CPImageCtrl.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _CPIMAGECTRL_H
#define _CPIMAGECTRL_H
 
#include <string>
#include <vector>
 
#include <panotools/PanoToolsInterface.h>
#include <base_wx/wxImageCache.h>
#include <wx/overlay.h>
 
class CPEditorPanel;
class CPImageCtrl;
 
class CPEvent : public wxCommandEvent
{
    DECLARE_DYNAMIC_CLASS(CPEvent)
 
    enum CPEventMode { NONE, NEW_POINT_CHANGED, NEW_LINE_ADDED, POINT_SELECTED, POINT_CHANGED, RIGHT_CLICK, SCROLLED, DELETE_REGION_SELECTED, CANCELED };
 
public:
    CPEvent( );
    CPEvent(wxWindow* win, CPEventMode mode);
    CPEvent(wxWindow* win, hugin_utils::FDiff2D & p);
    CPEvent(wxWindow *win, unsigned int cpNr);
    CPEvent(wxWindow* win, unsigned int cpNr, const hugin_utils::FDiff2D & p);
    CPEvent(wxWindow* win, const hugin_utils::FDiff2D & p1, const hugin_utils::FDiff2D & p2);
    CPEvent(wxWindow* win, CPEventMode mode, const hugin_utils::FDiff2D & p);
    CPEvent(wxWindow* win, CPEventMode mode, const HuginBase::ControlPoint cp);
    CPEvent(wxWindow* win, CPEventMode mode, size_t cpNr, const HuginBase::ControlPoint cp);
 
    virtual wxEvent* Clone() const;
 
    CPEventMode getMode()
        { return mode; };
 
    const wxRect & getRect()
        { return region; }
 
    const hugin_utils::FDiff2D & getPoint()
        { return point; }
 
    unsigned int getPointNr()
        { return pointNr; }
 
    const HuginBase::ControlPoint& getControlPoint() 
        { return m_cp; };
private:
    CPEventMode mode;
    wxRect region;
    hugin_utils::FDiff2D point;
    HuginBase::ControlPoint m_cp;
    int pointNr;
};
 
wxDECLARE_EVENT(EVT_CPEVENT, CPEvent);
 
class DisplayedControlPoint
{
public:
    DisplayedControlPoint() { m_mirrored=false; m_control=NULL; m_line=false; };
    DisplayedControlPoint(const HuginBase::ControlPoint& cp, CPImageCtrl* control, bool mirrored);
    void SetColour(wxColour pointColour, wxColour textColour);
    void SetLabel(wxString newLabel);
    void SetControl(CPImageCtrl* control);
    void Draw(wxDC& dc, const wxRect& visibleRect, bool selected, bool newPoint=false);
    const bool isOccupiedLabel(const wxPoint mousePos) const;
    const bool isOccupiedPos(const hugin_utils::FDiff2D &p) const;
    void CheckSelection(const wxPoint mousePos, const hugin_utils::FDiff2D& p);
    const bool IsMirrored() const { return m_mirrored; };
    const wxString GetLabel() const { return m_label; };
    void UpdateControlPointX(double x);
    void UpdateControlPointY(double y);
    void UpdateControlPoint(hugin_utils::FDiff2D newPoint);
    void ShiftControlPoint(hugin_utils::FDiff2D shift);
    void StartLineControlPoint(hugin_utils::FDiff2D newPoint);
    hugin_utils::FDiff2D GetPos() const;
    const HuginBase::ControlPoint GetControlPoint() const { return m_cp; };
    bool operator==(const DisplayedControlPoint other);
private:
    wxRect DrawTextMag(wxDC& dc, wxPoint p, hugin_utils::FDiff2D pointInput, bool drawMag, wxColour pointColour, wxColour textColour);
    void DrawLine(wxDC& dc);
    void DrawLineSegment(wxDC& dc);
    bool IsDrawingLine() const;
    HuginBase::ControlPoint m_cp;
    bool m_mirrored;
    CPImageCtrl* m_control;
    wxColour m_pointColour;
    wxColour m_textColour;
    wxString m_label;
    wxRect m_labelPos;
    wxRect m_labelPos2;
    bool m_line;
};
 
class CPImageCtrl : public wxScrolledWindow
{
public:
    enum EditorState {NO_IMAGE=0, NO_SELECTION, KNOWN_POINT_SELECTED, NEW_POINT_SELECTED, NEW_LINE_CREATING, SELECT_DELETE_REGION};
    
    CPImageCtrl()
        : scaleFactor(1),fitToWindow(false)
        { }
 
    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(CPEditorPanel * parent);
 
 
    ~CPImageCtrl();
 
    enum ImageRotation { ROT0=0, ROT90, ROT180, ROT270 };
 
    void setImage (const std::string & filename, ImageRotation rot);
    void setSameImage(bool sameImage);
    void setTransforms(HuginBase::PTools::Transform* firstTrans, HuginBase::PTools::Transform* firstInvTrans, HuginBase::PTools::Transform* secondInvTrans);
    void setMagTransforms(HuginBase::PTools::Transform* magTrans, HuginBase::PTools::Transform* magInvTrans);
    HuginBase::PTools::Transform* getFirstTrans() const { return m_firstTrans; };
    HuginBase::PTools::Transform* getFirstInvTrans() const { return m_firstInvTrans; };
    HuginBase::PTools::Transform* getSecondInvTrans() const { return m_secondInvTrans; };
 
    void setCtrlPoint(const HuginBase::ControlPoint& cp, const bool mirrored);
    void clearCtrlPointList();
 
    void clearNewPoint();
 
    void setNewPoint(const hugin_utils::FDiff2D & p);
 
    void selectPoint(unsigned int, bool scrollTo = true);
 
    void deselect();
 
    void mousePressLMBEvent(wxMouseEvent& mouse);
    void mouseReleaseLMBEvent(wxMouseEvent& mouse);
    void mousePressRMBEvent(wxMouseEvent& mouse);
    void mouseReleaseRMBEvent(wxMouseEvent& mouse);
    void mouseMoveEvent(wxMouseEvent& mouse);
    void mousePressMMBEvent(wxMouseEvent& mouse);
    void mouseReleaseMMBEvent(wxMouseEvent& mouse);
 
    wxSize DoGetBestSize() const;
//    virtual wxSize GetBestSize() const
//        { return DoGetBestSize(); }
 
    void setScale(double factor);
 
    double getScale()
        { return fitToWindow ? 0 : scaleFactor; }
 
    void showPosition(hugin_utils::FDiff2D point, bool warpPointer=false);
 
    void showSearchArea(bool show=true);
 
    void showTemplateArea(bool show=true);
 
    hugin_utils::FDiff2D getNewPoint();
 
    void ScrollDelta(const wxPoint & delta);
 
    wxPoint MaxScrollDelta(wxPoint delta);
 
    int scale(int x) const
        {  return (int) (x * getScaleFactor() + 0.5); }
 
    double scale(double x) const
        {  return x * getScaleFactor(); }
 
    hugin_utils::FDiff2D scale(const hugin_utils::FDiff2D & p) const
        {
            hugin_utils::FDiff2D r;
            r.x = scale(p.x);
            r.y = scale(p.y);
            return r;
        }
 
    wxPoint scale(const wxPoint & p) const
        {
            wxPoint r;
            r.x = scale(p.x);
            r.y = scale(p.y);
            return r;
        }
 
    int invScale(int x) const
        {  return (int) (x / getScaleFactor() + 0.5); }
 
    double invScale(double x) const
        {  return x / getScaleFactor(); }
 
    hugin_utils::FDiff2D invScale(const hugin_utils::FDiff2D & p) const
        {
            hugin_utils::FDiff2D r;
            r.x = invScale(p.x);
            r.y = invScale(p.y);
            return r;
        }
 
    wxPoint invScale(const wxPoint & p) const
        {
            wxPoint r;
            r.x = invScale(p.x);
            r.y = invScale(p.y);
            return r;
        }
 
    wxPoint roundP(const hugin_utils::FDiff2D & p) const
        {
            return wxPoint(hugin_utils::roundi(p.x), hugin_utils::roundi(p.y));
        }
 
    // rotate coordinate to fit possibly rotated image display
    // useful for drawing something on the rotated display
    template <class T>
    T applyRot(const T & p) const
    {
        switch (m_imgRotation) {
            case ROT0:
                return p;
                break;
            case ROT90:
                return T(m_realSize.GetHeight()-1 - p.y, p.x);
                break;
            case ROT180:
                return T(m_realSize.GetWidth()-1 - p.x, m_realSize.GetHeight()-1 - p.y);
                break;
            case ROT270:
                return T(p.y, m_realSize.GetWidth()-1 - p.x);
                break;
            default:
                return p;
                break;
        }
    }
 
    // rotate coordinate to fit possibly rotated image display
    // useful for converting rotated display coordinates to image coordinates
    template <class T>
    T applyRotInv(const T & p) const
    {
        switch (m_imgRotation) {
            case ROT90:
                return T(p.y, m_realSize.GetHeight()-1 - p.x);
                break;
            case ROT180:
                return T(m_realSize.GetWidth()-1 - p.x, m_realSize.GetHeight()-1 - p.y);
                break;
            case ROT270:
                return T(m_realSize.GetWidth()-1 - p.y, p.x);
                break;
            case ROT0:
            default:
                return p;
                break;
        }
    }
    // some helper function for DisplayedControlPoint 
    const bool GetMouseInWindow() const { return m_mouseInWindow; };
    const bool GetForceMagnifier() const { return m_forceMagnifier; };
    HuginBase::ImageCache::ImageCacheRGB8Ptr GetImg();
    wxBitmap& GetMagBitmap(hugin_utils::FDiff2D point);
    const wxSize GetRealImageSize() const { return m_realSize; };
    const wxSize GetBitmapSize() const;
 
    // setting/getting option if line cp should be shown as separate line
    void ShowLines(bool isShown);
    bool IsShowingLines() const;
protected:
    // display the image when loading finishes
    void OnImageLoaded(ImageCache::EntryPtr entry, std::string filename, bool load_small);
    void OnSize(wxSizeEvent & e);
    void OnSizeFinished(wxTimerEvent & e);
    void OnKey(wxKeyEvent & e);
    void OnKeyDown(wxKeyEvent & e);
    void OnMouseLeave(wxMouseEvent & e);
    void OnMouseEnter(wxMouseEvent & e);
    void OnTimer(wxTimerEvent & e);
    void OnScrollWin(wxScrollWinEvent & e);
    void OnPaint(wxPaintEvent& e);
 
    bool emit(CPEvent & ev);
 
    double getScaleFactor() const;
 
    double calcAutoScaleFactor(wxSize size);
 
    // rescale image
    void rescaleImage();
 
private:
    wxBitmap bitmap;
    std::string imageFilename;
    // size of displayed (probably scaled) image
    wxSize imageSize;
    // size of real image
    wxSize m_realSize;
    // for drawing overlay
    wxOverlay m_overlay;
    // cache mag image
    wxBitmap m_magImg;
    hugin_utils::FDiff2D m_magImgCenter;
    // should line cp shown as line
    bool m_showLines { true };
    // timer for resizing only once at end of resizing
    wxTimer m_resizeTimer;
 
    std::vector<DisplayedControlPoint> m_points;
 
    wxCursor * m_CPSelectCursor;
    wxCursor * m_ScrollCursor;
 
    // this is only valid during MOVE_POINT
    unsigned int selectedPointNr;
    // valid during MOVE_POINT and CREATE_POINT
    DisplayedControlPoint m_selectedPoint;
    hugin_utils::FDiff2D newPoint;
    bool m_sameImage;
 
    // only valid during SELECT_DELETE_REGION
    hugin_utils::FDiff2D rectStartPos;
    // draw a selection rectangle from pos1 to pos2
    void DrawSelectionRectangle(hugin_utils::FDiff2D pos1,hugin_utils::FDiff2D pos2);
 
    EditorState editState;
    // store pointer to transformation object to draw line control points
    HuginBase::PTools::Transform* m_firstTrans;
    HuginBase::PTools::Transform* m_firstInvTrans;
    HuginBase::PTools::Transform* m_secondInvTrans;
    // store pointer to transformation for drawing the magnifier
    HuginBase::PTools::Transform* m_magTrans;
    HuginBase::PTools::Transform* m_magInvTrans;
 
    // colors for the different points
    std::vector<wxColour> pointColors;
    std::vector<wxColour> textColours;
    double scaleFactor;
    bool fitToWindow;
 
    bool m_showSearchArea;
    int m_searchRectWidth;
 
    hugin_utils::FDiff2D m_mousePos;
    wxPoint m_mouseScrollPos;
 
    bool m_showTemplateArea;
    int m_templateRectWidth;
 
    EditorState isOccupied(wxPoint mousePos, const hugin_utils::FDiff2D & point, unsigned int & pointNr) const;
 
    CPEditorPanel * m_editPanel;
 
    ImageRotation m_imgRotation;
 
    ImageCache::EntryPtr m_img;
    ImageCache::RequestPtr m_imgRequest;
 
    bool m_mouseInWindow;
    bool m_forceMagnifier;
    wxTimer m_timer;
 
    DECLARE_DYNAMIC_CLASS(CPImageCtrl)
};
 
class CPImageCtrlXmlHandler : public wxXmlResourceHandler
{
    DECLARE_DYNAMIC_CLASS(CPImageCtrlXmlHandler)
 
public:
    CPImageCtrlXmlHandler();
    virtual wxObject *DoCreateResource();
    virtual bool CanHandle(wxXmlNode *node);
};
 
 
#endif // _CPIMAGECTRL_H