Frame.h

Go to the documentation of this file.

#ifndef FCAM_FRAME_H
#define FCAM_FRAME_H

#include "Base.h"
#include "Device.h"
#include "Time.h"
#include "Image.h"
#include <map>
#include <vector>
#include "Shot.h"
#include <set>
#include <tr1/memory>

namespace FCam {

    class Action;
    class Sensor;

    class Frame {
      public:

    typedef std::tr1::shared_ptr<Frame> Ptr;

    Image image;
    
    Time exposureStartTime;

    Time exposureEndTime;    

    Time processingDoneTime; 

    Sensor *sensor;

        int exposure; 

        int frameTime; 
    
        float gain;    
           

        Histogram histogram;     

        SharpnessMap sharpness;  

    ~Frame();

    const Shot &shot() const {
        return *request;
    }
    
    template<typename T>
        const typename T::Tags *tags(T *device) const {
        TagMap::const_iterator t = _tags.find(device);
        if (t == _tags.end()) return NULL;
        else return ((const typename T::Tags *)(t->second));
    }


    /* A device attached to a sensor can tag the frames coming out
     * of it. The first argument is the device attaching the tags,
     * and the second argument is a pointer to the tags themselves
     * (allocated on the heap). The frame takes ownership of the
     * tags. Template magic is used to require that a Device T
     * tags frames with an object of type (T::Tags *). T must
     * inherit from Device and T::Tags must inherit from
     * Device::Tags. */
    template<typename T>
        void addTags(T *d, typename T::Tags *t) {
        _tags[d] = (Device::Tags *)t;
    }

      protected:
    typedef std::map<Device *, Device::Tags *> TagMap;
    TagMap _tags;

    friend class Sensor;
    Frame();
    Shot *request;
    };

}

#endif

---