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 = wxT("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 update();

    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;

    virtual void OnDraw(wxDC& dc);

    // 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 OnKey(wxKeyEvent & e);
    void OnKeyDown(wxKeyEvent & e);
    void OnMouseLeave(wxMouseEvent & e);
    void OnMouseEnter(wxMouseEvent & e);
    void OnTimer(wxTimerEvent & e);
    void OnScrollWin(wxScrollWinEvent & 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 };

    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_EVENT_TABLE();
    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