PanoramaOptions.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _PANODATA_PANORAMAMEMENTO_H
#define _PANODATA_PANORAMAMEMENTO_H
 
#include <hugin_config.h>
#include <hugin_shared.h>
 
#include <string>
#include <vector>
 
#include <vigra/diff2d.hxx>
 
extern "C" {
 
    #ifdef __INTEL__
    #define __INTELMEMO__
    #undef __INTEL__
    #endif
 
    // Define __NO_SYSTEM__ in order to turn off including of windows.h in pano13/panorama.h
    #define __NO_SYSTEM__
    #include <pano13/panorama.h>
 
    #ifdef __INTELMEMO__
    #define __INTEL__
    #undef __INTELMEMO__
    #endif
 
    // remove stupid #defines from the evil windows.h
 
#ifdef DIFFERENCE
#undef DIFFERENCE
#endif
#ifdef min
#undef min
#endif
#ifdef max
#undef max
#endif
#ifdef MIN
#undef MIN
#endif
#ifdef MAX
#undef MAX
#endif
 
}
 
#include <vigra_ext/Interpolators.h>
 
namespace HuginBase {
 
class IMPEX PanoramaOptions
{
        
    public:
        enum ProjectionFormat {
            RECTILINEAR = 0,
            CYLINDRICAL = 1,
            EQUIRECTANGULAR = 2,
            FULL_FRAME_FISHEYE = 3,
            STEREOGRAPHIC = 4,
            MERCATOR = 5,
            TRANSVERSE_MERCATOR = 6,
            SINUSOIDAL = 7,
            LAMBERT = 8,
            LAMBERT_AZIMUTHAL = 9,
            ALBERS_EQUAL_AREA_CONIC = 10,
            MILLER_CYLINDRICAL = 11,
            PANINI = 12,
            ARCHITECTURAL = 13,
            ORTHOGRAPHIC = 14,
            EQUISOLID = 15,
            EQUI_PANINI = 16,
            BIPLANE = 17,
            TRIPLANE = 18,
            GENERAL_PANINI = 19,
            THOBY_PROJECTION = 20,
            HAMMER_AITOFF = 21,
        };
 
        enum PTStitcherAcceleration {
            NO_SPEEDUP,
            MAX_SPEEDUP,
            MEDIUM_SPEEDUP  // for projects with morphing.
        };
 
        enum FileFormat {
            JPEG = 0,
            JPEG_m,
            PNG,
            PNG_m,
            TIFF,
            TIFF_m,
            TIFF_mask,
            TIFF_multilayer,
            TIFF_multilayer_mask,
            PICT,
            PSD,
            PSD_m,
            PSD_mask,
            PAN,
            IVR,
            IVR_java,
            VRML,
            QTVR,
            HDR,
            HDR_m,
            EXR,
            EXR_m,
            FILEFORMAT_NULL
        };
 
        enum OutputMode {
            OUTPUT_LDR=0,
            OUTPUT_HDR
        };
 
        enum HDRMergeType {
            HDRMERGE_AVERAGE=0,
            HDRMERGE_DEGHOST=1
        };
 
        enum BlendingMechanism {
            NO_BLEND=0,
            PTBLENDER_BLEND=1,
            ENBLEND_BLEND=2,
            SMARTBLEND_BLEND=3,
            PTMASKER_BLEND=4,
            INTERNAL_BLEND=5
        };
 
        enum Remapper {
            NONA=0,
            PTMENDER
        };
 
        enum EdgeFillMode {
            NO_EDGE_FILL = 0,
            EDGE_FILL_SOLID = 1
        };
 
    public:
        PanoramaOptions()
        {
            reset();
        };
 
        virtual ~PanoramaOptions() {};
 
        virtual void reset()
        {
            m_projectionFormat = EQUIRECTANGULAR;
            m_hfov = 360;
            m_size = vigra::Size2D(3000, 1500);
            m_roi = vigra::Rect2D(m_size);
            tiff_saveROI = true;
            tiffCompression = "LZW";
            quality = 100;
            colorReferenceImage = 0;
            optimizeReferenceImage = 0;
            interpolator = vigra_ext::INTERP_CUBIC;
            // featherWidth = 10;
            outputFormat = TIFF_m;
            blendMode = ENBLEND_BLEND;
            hdrMergeMode = HDRMERGE_AVERAGE;
            remapper = NONA;
            remapUsingGPU = false;
            saveCoordImgs = false;
            huberSigma = 2;
            photometricHuberSigma = 2/255.0;
            outputMode = OUTPUT_LDR;
 
            outputLDRBlended = true;
            outputLDRLayers = false;
            outputLDRExposureRemapped = false;
            outputLDRExposureLayers = false;
            outputLDRExposureLayersFused = false;
            outputLDRStacks = false;
            outputLDRExposureBlended = false;
            outputHDRBlended = false;
            outputHDRLayers = false;
            outputHDRStacks = false;
 
            outputLayersCompression = "LZW";
            outputImageType = "tif";
            outputImageTypeCompression = "LZW";
            outputImageTypeHDR= "exr";
            outputImageTypeHDRCompression = "LZW";
 
            enblendOptions = "";
            enfuseOptions  = "";
            hdrmergeOptions = "";
            verdandiOptions = "";
 
            outputEMoRParams.resize(5,0.0f);
            outputExposureValue = 0.0;
            outputRangeCompression = 0.0;
            outputPixelType = "";
 
            panoProjectionFeaturesQuery(m_projectionFormat, &m_projFeatures);
            resetProjectionParameters();
 
            outputStacksMinOverlap = 0.7;
            outputLayersExposureDiff = 0.5;
 
            edgeFillMode = NO_EDGE_FILL;
            keepEdgeFillInput = false;
        }
 
    public:
        void printScriptLine(std::ostream & o,bool forPTOptimizer=false) const;
 
        static const std::string & getFormatName(FileFormat f);
 
        static FileFormat getFormatFromName(const std::string & name);
 
        const std::string & getOutputExtension() const;
 
    public:
        void setWidth(unsigned int w, bool keepView = true);
 
        void setHeight(unsigned int h);
 
        /* get panorama width */
        unsigned int getWidth() const
            { return m_size.x; }
 
        unsigned int getHeight() const
            {return m_size.y;}
 
        vigra::Size2D getSize() const
            { return m_size; }
 
        const vigra::Rect2D & getROI() const
            { return m_roi; }
 
        void setROI(const vigra::Rect2D & val)
            { m_roi = val & vigra::Rect2D(m_size); }
 
        void setProjection(ProjectionFormat f);
 
        void resetProjectionParameters();
 
        PanoramaOptions::ProjectionFormat getProjection() const
            { return m_projectionFormat; };
 
        const std::vector<double> & getProjectionParameters() const
            { return m_projectionParams; }
 
        void setProjectionParameters(const std::vector<double> & params);
 
        bool fovCalcSupported(ProjectionFormat f) const;
 
        void setHFOV(double h, bool keepView=true);
 
        double getHFOV() const
            { return m_hfov; }
        
        void setVFOV(double v);
        
        double getVFOV() const;
 
        double getMaxHFOV() const
            { return m_projFeatures.maxHFOV; }
 
        double getMaxVFOV() const
            { return m_projFeatures.maxVFOV; }
 
    public:
        //TODO: Write accessor methods; make instance variables private unless absolutely neccesary for backward-compatibility.
        
        FileFormat outputFormat;
 
        // jpeg options
        int quality;
 
        // TIFF options
        std::string tiffCompression;
        bool tiff_saveROI;
 
        unsigned int colorReferenceImage;
 
        // misc options
        vigra_ext::Interpolator interpolator;
 
        unsigned int optimizeReferenceImage;
        // unsigned int featherWidth;
 
        BlendingMechanism blendMode;
        HDRMergeType hdrMergeMode;
        Remapper remapper;
        bool remapUsingGPU;
 
        bool saveCoordImgs;
 
        double huberSigma;
 
        double photometricHuberSigma;
 
        // modes related to high dynamic range output
        OutputMode outputMode;
 
        bool outputLDRBlended;         
        bool outputLDRLayers;          
        bool outputLDRExposureRemapped;
        bool outputLDRExposureLayers;  
        bool outputLDRExposureLayersFused; 
        bool outputLDRStacks;          
        bool outputLDRExposureBlended; 
        bool outputHDRBlended;         
        bool outputHDRLayers;          
        bool outputHDRStacks;          
 
        std::string outputLayersCompression;
        std::string outputImageType;
        std::string outputImageTypeCompression;
        std::string outputImageTypeHDR;
        std::string outputImageTypeHDRCompression;
 
        std::string enblendOptions;
        std::string enfuseOptions;
        std::string hdrmergeOptions;
        std::string verdandiOptions;
 
        // select the exposure of the output images in LDR mode.
        double outputExposureValue;
        std::vector<float> outputEMoRParams;
        double outputRangeCompression;
 
        // choose pixel type for output images.
        std::string outputPixelType;
 
        // parameters for generating output layers and stacks
        double outputStacksMinOverlap;
        double outputLayersExposureDiff;
 
        // edge fill mode
        EdgeFillMode edgeFillMode;
        bool keepEdgeFillInput;
 
        pano_projection_features m_projFeatures;
 
    private:
        static const std::string fileformatNames[];
        static const std::string fileformatExt[];
        double m_hfov;
        double m_vfov;
    //    unsigned int m_width;
    //    unsigned int m_height;
        ProjectionFormat m_projectionFormat;
 
        std::vector<double> m_projectionParams;
        vigra::Size2D m_size;
        vigra::Rect2D m_roi;
};
 
 
} // namespace
#endif // _H