CPEditorPanel.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _CPEDITORPANEL_H
#define _CPEDITORPANEL_H
 
 
//-----------------------------------------------------------------------------
// Headers
//-----------------------------------------------------------------------------
 
#include <vector>
#include <set>
#include <functional>
#include <utility>
#include <string>
 
// Celeste files
#include "Celeste.h"
#include "CelesteGlobals.h"
#include "Utilities.h"
 
#include <panodata/Panorama.h>
 
#include "CPImagesComboBox.h"
 
#include "CPImageCtrl.h"
#include <panotools/PanoToolsInterface.h>
 
namespace vigra {
    class Diff2D;
}
 
namespace vigra_ext{
    struct CorrelationResult;
}
 
class CPEditorPanel : public wxPanel, public HuginBase::PanoramaObserver
{
public:
    CPEditorPanel();
 
    bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL, const wxString& name = "panel");
 
    void Init(HuginBase::Panorama * pano);
 
    virtual ~CPEditorPanel();
 
    void setLeftImage(unsigned int imgNr);
    void setRightImage(unsigned int imgNr);
 
    void SetPano(HuginBase::Panorama * panorama)
        { m_pano = panorama; };
 
    void panoramaChanged(HuginBase::Panorama &pano);
    void panoramaImagesChanged(HuginBase::Panorama &pano, const HuginBase::UIntSet & imgNr);
 
 
    void SelectGlobalPoint(unsigned int globalNr);
 
    void ShowControlPoint(unsigned int cpNr);
 
    void ClearSelection();
 
private:
 
    void UpdateDisplay(bool newImages);
 
    void EnablePointEdit(bool state);
 
    void SelectLocalPoint(unsigned int LVpointNr, bool scrollLeft = true, bool scrollRight = true);
 
    bool globalPNr2LocalPNr(unsigned int & localNr, unsigned int globalNr) const;
    unsigned int localPNr2GlobalPNr(unsigned int localNr) const;
 
    // function called when a new point has been selected or changed
    // in one of your images
    void NewPointChange(hugin_utils::FDiff2D p, bool left);
//    void CreateNewPointRight(wxPoint p);
 
    void CreateNewPoint();
 
//    bool FindTemplate(unsigned int tmplImgNr, const wxRect &region, unsigned int dstImgNr, vigra_ext::CorrelationResult & res);
 
    bool PointFineTune(unsigned int tmplImgNr,
                       const vigra::Diff2D &tmplPoint,
                       int tmplWidth,
                       unsigned int subjImgNr,
                       const hugin_utils::FDiff2D &subjPoint,
                       int searchWidth,
                       vigra_ext::CorrelationResult & tunedPos);
 
    const float getVerticalCPBias();
    // event handler functions
    void OnCPEvent(CPEvent &ev);
    void OnLeftChoiceChange(wxCommandEvent & e);
    void OnRightChoiceChange(wxCommandEvent & e);
    void OnCPListSelect(wxListEvent & e);
    void OnCPListDeselect(wxListEvent & e);
    void OnAddButton(wxCommandEvent & e);
    void OnZoom(wxCommandEvent & e);
    void OnTextPointChange(wxCommandEvent &e);
    void OnKey(wxKeyEvent & e);
    void OnDeleteButton(wxCommandEvent & e);
    void OnPrevImg(wxCommandEvent & e);
    void OnNextImg(wxCommandEvent & e);
 
    void OnColumnWidthChange( wxListEvent & e );
    void OnColumnHeaderClick(wxListEvent & e);
 
    void OnFineTuneButton(wxCommandEvent & e);
    void OnActionButton(wxCommandEvent& e);
    void OnCreateCPButton(wxCommandEvent& e);
    void OnCelesteButton(wxCommandEvent & e);
    void OnCleanCPButton(wxCommandEvent& e);
    void OnShowLinesCheckbox(wxCommandEvent& e);
 
    void OnActionSelectCreate(wxCommandEvent& e);
    void OnActionSelectCeleste(wxCommandEvent& e);
    void OnActionSelectCleanCP(wxCommandEvent& e);
    void OnActionContextMenu(wxContextMenuEvent& e);
 
    void FineTuneSelectedPoint(bool left);
    void FineTuneNewPoint(bool left);
    // local fine tune
    hugin_utils::FDiff2D LocalFineTunePoint(unsigned int srcNr,
                               const vigra::Diff2D & srcPnt,
                               hugin_utils::FDiff2D & movedSrcPnt,
                               unsigned int moveNr,
                               const hugin_utils::FDiff2D & movePnt);
 
    hugin_utils::FDiff2D EstimatePoint(const hugin_utils::FDiff2D & p, bool left);
 
 
    enum CPCreationState { NO_POINT,  
                           LEFT_POINT, 
                           RIGHT_POINT, 
                           RIGHT_POINT_RETRY, 
                           LEFT_POINT_RETRY,  
                           BOTH_POINTS_SELECTED 
    };
    // used to change the point selection state
    void changeState(CPCreationState newState);
 
    void estimateAndAddOtherPoint(const hugin_utils::FDiff2D & p,
                                  bool left,
                                  CPImageCtrl * thisImg,
                                  unsigned int thisImgNr,
                                  CPCreationState THIS_POINT,
                                  CPCreationState THIS_POINT_RETRY,
                                  CPImageCtrl * otherImg,
                                  unsigned int otherImgNr,
                                  CPCreationState OTHER_POINT,
                                  CPCreationState OTHER_POINT_RETRY);
 
    CPImageCtrl::ImageRotation GetRot(double yaw, double roll, double pitch);
    void UpdateTransforms();
    void SortList();
 
    CPCreationState cpCreationState;
 
    enum CPTabActionButtonMode
    {
        CPTAB_ACTION_CREATE_CP = 0,
        CPTAB_ACTION_CELESTE = 1,
        CPTAB_ACTION_CLEAN_CP = 2
    };
    CPTabActionButtonMode m_cpActionButtonMode;
    wxMenu* m_cpActionContextMenu;
    wxString m_currentCPDetector;
    // GUI controls
    CPImagesComboBox *m_leftChoice;
    CPImagesComboBox *m_rightChoice;
    CPImageCtrl *m_leftImg, *m_rightImg;
    wxListCtrl *m_cpList;
 
    wxTextCtrl *m_x1Text, *m_y1Text, *m_x2Text, *m_y2Text, *m_errorText;
    wxChoice *m_cpModeChoice;
    wxChoice* m_zoomChoice;
    wxButton *m_addButton;
    wxButton *m_delButton;
    wxButton* m_actionButton;
    wxButton* m_finetuneButton;
    wxButton* m_nextImgButton;
    wxButton* m_prevImgButton;
    wxCheckBox *m_autoAddCB;
    wxCheckBox *m_fineTuneCB;
    wxCheckBox *m_estimateCB;
    wxCheckBox *m_showLinesCB;
    wxPanel *m_cp_ctrls;
 
    // my data
    HuginBase::Panorama * m_pano;
    // the current images
    unsigned int m_leftImageNr;
    unsigned int m_rightImageNr;
    std::string m_leftFile;
    std::string m_rightFile;
    bool m_listenToPageChange;
    double m_detailZoomFactor;
    // store transformation for drawing line control points
    HuginBase::PTools::Transform m_leftTransform;
    HuginBase::PTools::Transform m_leftInvTransform;
    HuginBase::PTools::Transform m_rightTransform;
    HuginBase::PTools::Transform m_rightInvTransform;
    // store transformation for drawing the magnifier
    HuginBase::PTools::Transform m_leftTransformMag;
    HuginBase::PTools::Transform m_leftInvTransformMag;
    HuginBase::PTools::Transform m_rightTransformMag;
    HuginBase::PTools::Transform m_rightInvTransformMag;
 
    unsigned int m_selectedPoint;
 
    // contains the control points shown currently.
    HuginBase::CPointVector currentPoints;
    // this set contains all points that are mirrored (point 1 in right window,
    // point 2 in left window), in local point numbers
    std::set<unsigned int> mirroredPoints;
    size_t m_countCP;
    // store current sorting column
    long m_sortCol = -1;
    bool m_sortAscending = true;
 
    CPImageCtrl::ImageRotation m_leftRot;
    CPImageCtrl::ImageRotation m_rightRot;
 
    enum CPScrollHint
    {
        CP_SCROLL_BOTH=0,
        CP_SCROLL_LEFT,
        CP_SCROLL_RIGHT
    } ;
    CPScrollHint m_scrollHint;
 
    DECLARE_DYNAMIC_CLASS(CPEditorPanel)
 
};
 
vigra_ext::CorrelationResult PointFineTuneProjectionAware(const HuginBase::SrcPanoImage& templ, const vigra::UInt8RGBImage& templImg,
    vigra::Diff2D templPos, int templSize,
    const HuginBase::SrcPanoImage& search, const vigra::UInt8RGBImage& searchImg,
    vigra::Diff2D searchPos, int sWidth);
 
class CPEditorPanelXmlHandler : public wxXmlResourceHandler
{
    DECLARE_DYNAMIC_CLASS(CPEditorPanelXmlHandler)
 
public:
    CPEditorPanelXmlHandler();
    virtual wxObject *DoCreateResource();
    virtual bool CanHandle(wxXmlNode *node);
};
 
#endif // _CPEDITORPANEL_H