PanoCommand.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _Hgn1_PANOCOMMAND_H
#define _Hgn1_PANOCOMMAND_H
 
 
#include "Command.h"
 
#include "panodata/Panorama.h"
#include <panodata/StandardImageVariableGroups.h>
 
namespace PanoCommand
{
    class WXIMPEX CombinedPanoCommand : public PanoCommand
    {
    public:
        CombinedPanoCommand(HuginBase::Panorama & pano, std::vector<PanoCommand*> & commands)
            : PanoCommand(pano), commands(commands) { setName("multiple commands");};
        ~CombinedPanoCommand();
        virtual bool processPanorama(HuginBase::Panorama & pano);
    private:
        std::vector<PanoCommand*> commands;
    };
 
    class WXIMPEX NewPanoCmd : public PanoCommand
    {
    public:
        explicit NewPanoCmd(HuginBase::Panorama & pano) : PanoCommand(pano) { m_clearDirty = true; };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "new panorama"; };
    };
 
    class WXIMPEX AddImagesCmd : public PanoCommand
    {
    public:
        AddImagesCmd(HuginBase::Panorama & pano, const std::vector<HuginBase::SrcPanoImage> & images)
            : PanoCommand(pano), imgs(images) { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "add images"; };
    private:
        std::vector<HuginBase::SrcPanoImage> imgs;
    };
 
    class WXIMPEX RemoveImageCmd : public PanoCommand
    {
    public:
        RemoveImageCmd(HuginBase::Panorama & p, unsigned int imgNr)
            : PanoCommand(p), imgNr(imgNr)
        { };
 
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "remove image"; };
    private:
        unsigned int imgNr;
    };
 
    class WXIMPEX RemoveImagesCmd : public PanoCommand
    {
    public:
        RemoveImagesCmd(HuginBase::Panorama & p, HuginBase::UIntSet imgs) : PanoCommand(p), imgNrs(imgs) {};
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "remove images"; };
    private:
        HuginBase::UIntSet imgNrs;
    };
 
    class WXIMPEX UpdateVariablesCmd : public PanoCommand
    {
    public:
        UpdateVariablesCmd(HuginBase::Panorama & p, const HuginBase::VariableMapVector & vars)
            : PanoCommand(p), vars(vars) {};
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update variables"; };
    private:
        HuginBase::VariableMapVector vars;
    };
 
    class WXIMPEX UpdateCPsCmd : public PanoCommand
    {
    public:
        UpdateCPsCmd(HuginBase::Panorama & p, const HuginBase::CPVector & cps, bool doUpdateCPError = true)
            : PanoCommand(p), cps(cps), updateCPError(doUpdateCPError)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update control points"; };
    private:
        HuginBase::CPVector cps;
        bool updateCPError;
    };
 
    class WXIMPEX UpdateVariablesCPCmd : public PanoCommand
    {
    public:
        UpdateVariablesCPCmd(HuginBase::Panorama & p, const HuginBase::VariableMapVector & vars, const HuginBase::CPVector& cps)
            : PanoCommand(p), vars(vars), cps(cps)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update variables and control points"; };
    private:
        HuginBase::VariableMapVector vars;
        HuginBase::CPVector cps;
    };
 
    class WXIMPEX UpdateVariablesCPSetCmd : public PanoCommand
    {
    public:
        UpdateVariablesCPSetCmd(HuginBase::Panorama & p, HuginBase::UIntSet imgs, const HuginBase::VariableMapVector & vars, const HuginBase::CPVector & cps)
            : PanoCommand(p), m_imgs(imgs), vars(vars), cps(cps)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update variables and control points"; };
    private:
        HuginBase::UIntSet m_imgs;
        HuginBase::VariableMapVector vars;
        HuginBase::CPVector cps;
    };
 
    class WXIMPEX UpdateImageVariablesCmd : public PanoCommand
    {
    public:
        UpdateImageVariablesCmd(HuginBase::Panorama & p, unsigned int ImgNr, const HuginBase::VariableMap & vars)
            : PanoCommand(p), imgNr(ImgNr), vars(vars)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update image variables"; };
    private:
        unsigned int imgNr;
        HuginBase::VariableMap vars;
    };
 
    class WXIMPEX UpdateImagesVariablesCmd : public PanoCommand
    {
    public:
        UpdateImagesVariablesCmd(HuginBase::Panorama & p, const HuginBase::UIntSet & change, const HuginBase::VariableMapVector & vars)
            : PanoCommand(p), change(change), vars(vars)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update image variables"; }
    private:
        HuginBase::UIntSet change;
        HuginBase::VariableMapVector vars;
    };
 
    class WXIMPEX UpdateVariablesByParseExpression : public PanoCommand
    {
    public:
        UpdateVariablesByParseExpression(HuginBase::Panorama & p, const std::string& expression)
            : PanoCommand(p), m_expression(expression)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update image variables by parsing expression"; }
    private:
        std::string m_expression;
    };
 
    class WXIMPEX UpdateOptimizeVectorCmd : public PanoCommand
    {
    public:
        UpdateOptimizeVectorCmd(HuginBase::Panorama &p, HuginBase::OptimizeVector optvec)
            : PanoCommand(p), m_optvec(optvec)
        { };
        virtual bool processPanorama(HuginBase::Panorama & pano);
        virtual std::string getName() const { return "update optimize vector"; }
    private:
        HuginBase::OptimizeVector m_optvec;
    };
 
    class WXIMPEX UpdateOptimizerSwitchCmd : public PanoCommand
    {
    public:
        UpdateOptimizerSwitchCmd(HuginBase::Panorama &p, int mode) : PanoCommand(p), m_mode(mode) { };
        virtual bool processPanorama(HuginBase::Panorama & pano);
        virtual std::string getName() const { return "update optimizer master switch"; }
    private:
        int m_mode;
    };
 
    class WXIMPEX UpdatePhotometricOptimizerSwitchCmd : public PanoCommand
    {
    public:
        UpdatePhotometricOptimizerSwitchCmd(HuginBase::Panorama &p, int mode) : PanoCommand(p), m_mode(mode) { };
        virtual bool processPanorama(HuginBase::Panorama & pano);
        virtual std::string getName() const { return "update photometric optimizer master switch"; }
    private:
        int m_mode;
    };
 
    class WXIMPEX SetVariableCmd : public PanoCommand
    {
    public:
        SetVariableCmd(HuginBase::Panorama & p, const HuginBase::UIntSet & images, const HuginBase::Variable & var)
            : PanoCommand(p), images(images), var(var)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "set image variable"; }
    private:
        HuginBase::UIntSet images;
        HuginBase::Variable var;
    };
 
    class WXIMPEX CenterPanoCmd : public PanoCommand
    {
    public:
        explicit CenterPanoCmd(HuginBase::Panorama & p) : PanoCommand(p) { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "center panorama"; }
    };
 
    class WXIMPEX StraightenPanoCmd : public PanoCommand
    {
    public:
        explicit StraightenPanoCmd(HuginBase::Panorama & p) : PanoCommand(p) { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "straighten panorama"; };
    };
 
    class WXIMPEX AddCtrlPointCmd : public PanoCommand
    {
    public:
        AddCtrlPointCmd(HuginBase::Panorama & p, const HuginBase::ControlPoint & cpoint)
            : PanoCommand(p), point(cpoint)
        {};
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "add control point"; };
    private:
        HuginBase::ControlPoint point;
    };
 
    class WXIMPEX AddCtrlPointsCmd : public PanoCommand
    {
    public:
        AddCtrlPointsCmd(HuginBase::Panorama & p, const HuginBase::CPVector & cpoints)
            : PanoCommand(p), cps(cpoints)
        { }
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "add control points"; };
    private:
        HuginBase::CPVector cps;
    };
 
    class WXIMPEX RemoveCtrlPointCmd : public PanoCommand
    {
    public:
        RemoveCtrlPointCmd(HuginBase::Panorama & p, unsigned int cpNr)
            : PanoCommand(p), pointNr(cpNr)
        { }
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "remove control point"; };
    private:
        unsigned int pointNr;
    };
 
    class WXIMPEX RemoveCtrlPointsCmd : public PanoCommand
    {
    public:
        RemoveCtrlPointsCmd(HuginBase::Panorama & p, const HuginBase::UIntSet & points)
            : PanoCommand(p), m_points(points)
        { }
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "remove control points"; };
    private:
        HuginBase::UIntSet m_points;
    };
 
    class WXIMPEX ChangeCtrlPointCmd : public PanoCommand
    {
    public:
        ChangeCtrlPointCmd(HuginBase::Panorama & p, unsigned int nr, HuginBase::ControlPoint point)
            : PanoCommand(p), pNr(nr), point(point)
        {};
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "change control point"; };
    private:
        unsigned int pNr;
        HuginBase::ControlPoint point;
    };
 
    class WXIMPEX SetActiveImagesCmd : public PanoCommand
    {
    public:
        SetActiveImagesCmd(HuginBase::Panorama & p, HuginBase::UIntSet & active)
            : PanoCommand(p), m_active(active)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "change active images"; };
    private:
        HuginBase::UIntSet m_active;
    };
 
    class WXIMPEX SwapImagesCmd : public PanoCommand
    {
    public:
        SwapImagesCmd(HuginBase::Panorama & p, unsigned int i1, unsigned int i2)
            : PanoCommand(p), m_i1(i1), m_i2(i2)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "swap images"; };
    private:
        unsigned int m_i1;
        unsigned int m_i2;
    };
 
    class WXIMPEX MoveImageCmd : public PanoCommand
    {
    public:
        MoveImageCmd(HuginBase::Panorama & p, size_t i1, size_t i2)
            : PanoCommand(p), m_i1(i1), m_i2(i2)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "move images"; };
    private:
        unsigned int m_i1;
        unsigned int m_i2;
    };
 
    class WXIMPEX MergePanoCmd : public PanoCommand
    {
    public:
        MergePanoCmd(HuginBase::Panorama & p, HuginBase::Panorama & p2)
            : PanoCommand(p), newPano(p2)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "merge panorama"; };
    private:
        HuginBase::Panorama newPano;
    };
 
    class WXIMPEX UpdateSrcImageCmd : public PanoCommand
    {
    public:
        UpdateSrcImageCmd(HuginBase::Panorama & p, unsigned i, HuginBase::SrcPanoImage img)
            : PanoCommand(p), img(img), imgNr(i)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const{ return "update source image"; };
    private:
        HuginBase::SrcPanoImage img;
        unsigned imgNr;
    };
 
    class WXIMPEX UpdateSrcImagesCmd : public PanoCommand
    {
    public:
        UpdateSrcImagesCmd(HuginBase::Panorama & p, HuginBase::UIntSet i, std::vector<HuginBase::SrcPanoImage> imgs)
            : PanoCommand(p), imgs(imgs), imgNrs(i)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update source images"; };
    private:
        std::vector<HuginBase::SrcPanoImage> imgs;
        HuginBase::UIntSet imgNrs;
    };
 
    class WXIMPEX SetPanoOptionsCmd : public PanoCommand
    {
    public:
        SetPanoOptionsCmd(HuginBase::Panorama & p, const HuginBase::PanoramaOptions & opts)
            : PanoCommand(p), options(opts)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "set panorama options"; };
    private:
        HuginBase::PanoramaOptions options;
    };
 
    class WXIMPEX LoadPTProjectCmd : public PanoCommand
    {
    public:
        LoadPTProjectCmd(HuginBase::Panorama & p, const std::string  & filename, const std::string & prefix = "");
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "load project"; };
    private:
        const std::string &filename;
        const std::string &prefix;
    };
 
    class WXIMPEX RotatePanoCmd : public PanoCommand
    {
    public:
        RotatePanoCmd(HuginBase::Panorama & p, double yaw, double pitch, double roll)
            : PanoCommand(p), y(yaw), p(pitch), r(roll)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "rotate panorama"; };
    private:
        double y, p, r;
    };
 
    class WXIMPEX TranslatePanoCmd : public PanoCommand
    {
    public:
        TranslatePanoCmd(HuginBase::Panorama & p, double TrX, double TrY, double TrZ)
            : PanoCommand(p), X(TrX), Y(TrY), Z(TrZ)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const{ return "translate panorama"; };
    private:
        double X, Y, Z;
    };
 
    class WXIMPEX UpdateFocalLengthCmd : public PanoCommand
    {
    public:
        UpdateFocalLengthCmd(HuginBase::Panorama & p, HuginBase::UIntSet imgs, double newFocalLength)
            : PanoCommand(p), imgNrs(imgs), m_focalLength(newFocalLength)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update focal length"; };
    private:
        HuginBase::UIntSet imgNrs;
        double m_focalLength;
    };
 
    class WXIMPEX UpdateCropFactorCmd : public PanoCommand
    {
    public:
        UpdateCropFactorCmd(HuginBase::Panorama & p, HuginBase::UIntSet imgs, double newCropFactor)
            : PanoCommand(p), imgNrs(imgs), m_cropFactor(newCropFactor)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update crop factor"; };
    private:
        HuginBase::UIntSet imgNrs;
        double m_cropFactor;
    };
 
    class WXIMPEX ChangePartNumberCmd : public PanoCommand
    {
    public:
        ChangePartNumberCmd(HuginBase::Panorama & p, HuginBase::UIntSet image_numbers, std::size_t new_part_number,
            std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> variables)
            : PanoCommand(p), image_numbers(image_numbers), new_part_number(new_part_number),variables(variables)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "Change part number"; };
    private:
        HuginBase::UIntSet image_numbers;
        std::size_t new_part_number;
        std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> variables;
    };
 
    class WXIMPEX ChangePartImagesLinkingCmd : public PanoCommand
    {
    public:
        ChangePartImagesLinkingCmd(HuginBase::Panorama & p,
            HuginBase::UIntSet image_numbers, std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> changeVariables,
            bool new_linked_state, std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> groupVariables)
            : PanoCommand(p), image_numbers(image_numbers), changeVariables(changeVariables),
            new_linked_state(new_linked_state), groupVariables(groupVariables)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "Change image variable links"; };
    private:
        HuginBase::UIntSet image_numbers;
        std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> changeVariables;
        bool new_linked_state;
        std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> groupVariables;
    };
 
    class WXIMPEX LinkLensVarsCmd : public PanoCommand
    {
    public:
        LinkLensVarsCmd(HuginBase::Panorama & p, std::size_t lens_number, std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> variables)
            : PanoCommand(p), lens_number(lens_number), variables(variables)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "Link lens variables"; };
    private:
        std::size_t lens_number;
        std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> variables;
    };
 
#define image_variable( name, type, default_value )\
    class WXIMPEX ChangeImage##name##Cmd : public PanoCommand\
                {\
    public:\
        ChangeImage##name##Cmd(HuginBase::Panorama & p,\
                               HuginBase::UIntSet image_numbers,\
                               type value)\
            :   PanoCommand(p),\
                image_numbers(image_numbers),\
                value(value)\
                        { };\
        virtual bool processPanorama(HuginBase::Panorama& pano);\
        virtual std::string getName() const { return "Change image's " #name; };\
    private:\
        HuginBase::UIntSet image_numbers;\
        type value;\
        };
#include <panodata/image_variables.h>
#undef image_variable
 
    class WXIMPEX NewPartCmd : public PanoCommand
    {
    public:
        NewPartCmd(HuginBase::Panorama & p, HuginBase::UIntSet image_numbers, std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> vars)
            : PanoCommand(p), image_numbers(image_numbers), vars(vars)
        { }
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "New Part"; };
    private:
        HuginBase::UIntSet image_numbers;
        std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> vars;
    };
 
    class WXIMPEX UpdateMaskForImgCmd : public PanoCommand
    {
    public:
        UpdateMaskForImgCmd(HuginBase::Panorama & p, unsigned int img, const HuginBase::MaskPolygonVector & mask)
            : PanoCommand(p), m_img(img), m_mask(mask)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update mask"; };
    private:
        unsigned int m_img;
        HuginBase::MaskPolygonVector m_mask;
    };
 
    class WXIMPEX UpdateWhiteBalance : public PanoCommand
    {
    public:
        UpdateWhiteBalance(HuginBase::Panorama & p, double redFactor, double blueFactor)
            : PanoCommand(p), m_red(redFactor), m_blue(blueFactor)
        { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "update global white balance"; };
    private:
        double m_red;
        double m_blue;
    };
 
    class WXIMPEX ResetToMeanExposure : public PanoCommand
    {
    public:
        explicit ResetToMeanExposure(HuginBase::Panorama & p) : PanoCommand(p) { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "set exposure to mean exposure"; };
    };
 
    class WXIMPEX DistributeImagesCmd : public PanoCommand
    {
    public:
        explicit DistributeImagesCmd(HuginBase::Panorama & p) : PanoCommand(p) { };
        virtual bool processPanorama(HuginBase::Panorama& pano);
        virtual std::string getName() const { return "distribute images"; };
    };
 
 
} // namespace PanoCommand
 
#endif // _PANOCOMMAND_H