SrcPanoImage.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-

#ifndef _PANODATA_SRCPANOIMAGE_H
#define _PANODATA_SRCPANOIMAGE_H

// if this file is preprocessed for SWIG, we want to ignore
// all the header inclusions that follow:

#ifndef _HSI_IGNORE_SECTION

#include <hugin_shared.h>
#include <hugin_config.h>
#include <iostream>
#include <vector>
#include <vigra/diff2d.hxx>

#include <hugin_utils/utils.h>
#include <hugin_math/hugin_math.h>
#include "PanoramaVariable.h"
#include "ImageVariable.h"
#include "Mask.h"

#ifdef HUGIN_USE_EXIV2
#include <exiv2/exif.hpp>
#endif

#endif // _HSI_IGNORE_SECTION

namespace HuginBase {

class Panorama;

class IMPEX BaseSrcPanoImage
{
public:
    enum Projection {
        RECTILINEAR = 0,
        PANORAMIC = 1,
        CIRCULAR_FISHEYE = 2,
        FULL_FRAME_FISHEYE = 3,
        EQUIRECTANGULAR = 4,
        FISHEYE_ORTHOGRAPHIC = 8,
        FISHEYE_STEREOGRAPHIC = 10,
        FISHEYE_EQUISOLID = 21,
        FISHEYE_THOBY = 20
    };
    
    enum CropMode {
        NO_CROP=0,
        CROP_RECTANGLE=1,
        CROP_CIRCLE=2
    };

    enum VignettingCorrMode { 
        VIGCORR_NONE = 0,      
        VIGCORR_RADIAL = 1,    
        VIGCORR_FLATFIELD = 2, 
        VIGCORR_DIV = 4        
    };

    enum ResponseType {
        RESPONSE_EMOR=0,                 
        RESPONSE_LINEAR,                 
        RESPONSE_GAMMA,                  
        RESPONSE_FILE,                   
        RESPONSE_ICC                     
    };

    bool operator==(const BaseSrcPanoImage & other) const;    
    
    
public:
    BaseSrcPanoImage()
    {
        setDefaults();
    }
    
    virtual ~BaseSrcPanoImage() {};
    
    // property accessors
public:
    // get[variable name] functions. Return the value stored in the ImageVariable.
#define image_variable( name, type, default_value ) \
    type get##name() const { return m_##name.getData(); }
#include "image_variables.h"
#undef image_variable

    // get[variable name]IV functions. Return a const reference to the ImageVariable.
#define image_variable( name, type, default_value ) \
    const ImageVariable<type > & get##name##IV() const { return m_##name; }
#include "image_variables.h"
#undef image_variable

    // set[variable name] functions
#define image_variable( name, type, default_value ) \
    void set##name(type data) { m_##name.setData(data); }
#include "image_variables.h"
#undef image_variable

    /* The link[variable name] functions
     * Pass a pointer to another SrcPanoImg and the respective image variable
     * will be shared between the images. Afterwards, changing the variable with
     * set[variable name] on either image also sets the other image.
     */
#define image_variable( name, type, default_value ) \
    void link##name (BaseSrcPanoImage * target) \
    { m_##name.linkWith(&(target->m_##name)); }
#include "image_variables.h"
#undef image_variable

    /* The unlink[variable name] functions
     * Unlinking a variable makes it unique to this image. Then changing it will
     * not affect the other images.
     */
#define image_variable( name, type, default_value ) \
    void unlink##name () \
    { m_##name.removeLinks(); }
#include "image_variables.h"
#undef image_variable

    /* The [variable name]isLinked functions
     * Returns true if the variable has links, or false if it is independant.
     */
#define image_variable( name, type, default_value ) \
    bool name##isLinked () const \
    { return m_##name.isLinked(); }
#include "image_variables.h"
#undef image_variable

    /* The [variable name]isLinkedWith functions
     * Returns true if the variable is linked with the equivalent variable in
     * the specified image, false otherwise.
     */
#define image_variable( name, type, default_value ) \
    bool name##isLinkedWith (const BaseSrcPanoImage & image) const \
    { return m_##name.isLinkedWith(&(image.m_##name)); }
#include "image_variables.h"
#undef image_variable

protected:
    void setDefaults();

    // the image variables m_[variable name]
#define image_variable( name, type, default_value ) \
    ImageVariable<type > m_##name;
#include "image_variables.h"
#undef image_variable
};


class IMPEX SrcPanoImage : public BaseSrcPanoImage
{
public:
    SrcPanoImage()
    {
        setDefaults();
        successfullEXIFread=false;
    }
    
    virtual ~SrcPanoImage() {};
public:
    SrcPanoImage(const std::string &filename)
    {
        setDefaults();
        m_Filename = filename;
        double crop = 0;
        double fl = 0;
        successfullEXIFread=readEXIF(fl, crop, true, true);
    };
    const bool hasEXIFread() const {return successfullEXIFread;};
    
    
public:
    void resize(const vigra::Size2D & size);

    bool isInside(vigra::Point2D p, bool ignoreMasks=false) const;

    bool horizontalWarpNeeded();

    // Accessors
    // These are either:
    // #- extra ones that are derived from image varibles, or
    // #- replacements where we need extra processing.
public:
    bool getCorrectTCA() const;
    
    void setCropMode(CropMode val);

    bool isCircularCrop() const;

    void setSize(vigra::Size2D val);
    
    hugin_utils::FDiff2D getRadialDistortionCenter() const;
    
    hugin_utils::FDiff2D getRadialVigCorrCenter() const;
    
    // these are linked to ExposureValue, which is done with the above.
    // exposure value  is log2 of inverse exposure factor.
    double getExposure() const;
    void setExposure(const double & val);
    
    
    int getWidth() const
    { return getSize().width(); }
    
    int getHeight() const
    { return getSize().height(); }
        
    double getVar(const std::string & name) const;
    
    void setVar(const std::string & name, double val);
    
    VariableMap getVariableMap() const;
    
    const int getExifDateTime(struct tm* datetime) const;

    void unlinkRadialVigCorrCoeff ()
    {
        m_RadialVigCorrCoeff.removeLinks();
        m_VigCorrMode.removeLinks();
    }
    
    void unlinkRadialVigCorrCenterShift ()
    {
        m_RadialVigCorrCenterShift.removeLinks();
        m_VigCorrMode.removeLinks();
    }
    
    void unlinkEMoRParams ()
    {
        m_EMoRParams.removeLinks();
        m_ResponseType.removeLinks();
    }
    
    void linkRadialVigCorrCoeff (SrcPanoImage * target)
    {
        m_RadialVigCorrCoeff.linkWith(&(target->m_RadialVigCorrCoeff));
        m_VigCorrMode.linkWith(&(target->m_VigCorrMode));
    }

    void linkRadialVigCorrCenterShift (SrcPanoImage * target)
    {
        m_RadialVigCorrCenterShift.linkWith(&(target->m_RadialVigCorrCenterShift));
        m_VigCorrMode.linkWith(&(target->m_VigCorrMode));
    }
    
    void linkEMoRParams (SrcPanoImage * target)
    {
        m_EMoRParams.linkWith(&(target->m_EMoRParams));
        m_ResponseType.linkWith(&(target->m_ResponseType));
    }
    
    void linkStack (SrcPanoImage * target)
    { m_Stack.linkWith(&(target->m_Stack)); }
    
    bool readEXIF(double & focalLength, double & cropFactor, bool applyEXIF, bool applyExposureValue);
    bool readEXIF(double & focalLength, double & cropFactor, double & eV, bool applyEXIF, bool applyExposureValue);
    
    static double calcHFOV(SrcPanoImage::Projection proj, double fl, double crop, vigra::Size2D imageSize);
    
    static double calcFocalLength(SrcPanoImage::Projection proj, double hfov, double crop, vigra::Size2D imageSize);

    static double calcCropFactor(SrcPanoImage::Projection proj, double hfov, double focalLength, vigra::Size2D imageSize);

    void updateFocalLength(double newFocalLength);
    void updateCropFactor(double focalLength, double newCropFactor);

    bool readCropfactorFromDB();
    bool readProjectionFromDB();
    bool readDistortionFromDB();
    bool readVignettingFromDB();

    bool hasMasks() const;
    bool hasPositiveMasks() const;
    bool hasActiveMasks() const;
    void addMask(MaskPolygon newMask);
    void addActiveMask(MaskPolygon newMask);
    void clearActiveMasks();
    void changeMaskType(unsigned int index, HuginBase::MaskPolygon::MaskType newType);
    void deleteMask(unsigned int index);
    void deleteAllMasks();
    void printMaskLines(std::ostream &o, unsigned int newImgNr) const;
    bool isInsideMasks(vigra::Point2D p) const;

private:

    bool getExiv2Value(Exiv2::ExifData& exifData, std::string keyName, long & value);
    bool getExiv2Value(Exiv2::ExifData& exifData, std::string keyName, float & value);
    bool getExiv2Value(Exiv2::ExifData& exifData, std::string keyName, std::string & value);
    bool getExiv2Value(Exiv2::ExifData& exifData, uint16_t tagID, std::string groupName, std::string & value);

    bool trustExivOrientation();
    bool successfullEXIFread;
};

typedef std::vector<SrcPanoImage> ImageVector;

} // namespace

#endif // PANOIMAGE_H

---