include/FCam/Frame.h

Go to the documentation of this file.

#ifndef FCAM_FRAME_H
#define FCAM_FRAME_H

#include <tr1/memory>
#ifndef FCAM_PLATFORM_OSX
#include <tr1/unordered_map>
#else
#include <map>
#endif

#include "Base.h"
#include "Device.h"
#include "Time.h"
#include "Image.h"
#include "TagValue.h"
#include "Shot.h"
#include "Event.h"

namespace FCam {

    class Action;
    class Lens;

#ifndef FCAM_PLATFORM_OSX // g++ 4.0.1 (OSX 10.5) has a bug in unordered_map
    typedef std::tr1::unordered_map<std::string, TagValue> TagMap;
#else
    typedef std::map<std::string, TagValue> TagMap;
#endif

    struct _Frame : public EventGenerator {
        _Frame();
    virtual ~_Frame();

        Image image;
        Time exposureStartTime;
        Time exposureEndTime;    
        Time processingDoneTime; 
        int exposure; 
        int frameTime; 
        float gain;    
        int whiteBalance;
        Histogram histogram;    
        SharpnessMap sharpness;   
        TagMap tags;

        // Derived frames should implement these to return a
        // platform-specific shot with \ref Shot(), and a basic Shot
        // using \ref baseShot().
        const Shot &shot() const { return baseShot(); }
        virtual const Shot &baseShot() const = 0;

        // Derived frames should implement these to return static
        // platform data necessary for interpreting this frame.
        virtual BayerPattern bayerPattern() const = 0;
        virtual unsigned short minRawValue() const {return 0;}
        virtual unsigned short maxRawValue() const = 0; 
        virtual void rawToRGBColorMatrix(int kelvin, float *matrix) const = 0;
        virtual const std::string &manufacturer() const = 0;
        virtual const std::string &model() const = 0;

        virtual void debug(const char *name="") const;
    };

    class Frame {
    protected:
        std::tr1::shared_ptr<_Frame> ptr;

    public:

        Frame(_Frame *f=NULL) : ptr(f) {}

    virtual ~Frame() {}

        bool valid() const {return (bool)ptr;}

        bool operator==(const Frame &other) const { return ptr == other.ptr; }

        Image image() const {return ptr->image;}
        
        Time exposureStartTime() const {return ptr->exposureStartTime;}
        
        Time exposureEndTime() const {return ptr->exposureEndTime;}    

        Time processingDoneTime() const {return ptr->processingDoneTime;}

        int exposure() const {return ptr->exposure;}

        int frameTime() const {return ptr->frameTime;}
        
        float gain() const {return ptr->gain;}
               
        int whiteBalance() const {return ptr->whiteBalance;}

        const Histogram &histogram() const {return ptr->histogram;}

        const SharpnessMap &sharpness() const {return ptr->sharpness;}

        const Shot &shot() const {
            return ptr->shot();
        }

        const TagMap &tags() const {
            return ptr->tags;
        }

        TagValue &operator[](const std::string &name) const {
            return ptr->tags[name];
        }

        void rawToRGBColorMatrix(float *matrix) const {
            return ptr->rawToRGBColorMatrix(ptr->whiteBalance, matrix);
        }
        
        virtual BayerPattern bayerPattern() const {
            return ptr->bayerPattern();
        }

        virtual unsigned short minRawValue() const {
            return ptr->minRawValue();
        }

        virtual unsigned short maxRawValue() const {
            return ptr->maxRawValue();
        }

        virtual void rawToRGBColorMatrix(int kelvin, float *matrix) const {
            return ptr->rawToRGBColorMatrix(kelvin, matrix);
        }

        virtual const std::string &manufacturer() const {
            return ptr->manufacturer();
        }

        virtual const std::string &model() const {
            return ptr->model();
        }

        operator EventGenerator*() {
            return static_cast<EventGenerator *>(ptr.get());
        }

        void debug(const char *name="") const {
            ptr->debug(name);
        }

    };

}

#define FCAM_FRAME_DEBUG(i) (i).debug(#i)

#endif