MaskImageCtrl.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
/*  This is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This software is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this software. If not, see
 *  <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef _MaskImageCtrl_H
#define _MaskImageCtrl_H
 
#include <base_wx/wxImageCache.h>
#include <wx/overlay.h>
 
class MaskEditorPanel;
 
class MaskImageCtrl : public wxScrolledWindow
{
public:
    MaskImageCtrl()
        : m_maskEditState(NO_IMAGE), m_scaleFactor(1), m_fitToWindow(false), m_middleMouseScroll(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(MaskEditorPanel * parent);
 
    enum ImageRotation { ROT0=0, ROT90, ROT180, ROT270 };
 
    void setPreviewOnly() { m_previewOnly=true; };
    void setImage (const std::string & filename, HuginBase::MaskPolygonVector newMask, HuginBase::MaskPolygonVector masksToDraw, ImageRotation rot);
    void setNewMasks(HuginBase::MaskPolygonVector newMasks, HuginBase::MaskPolygonVector masksToDraw);
    void setCrop(HuginBase::SrcPanoImage::CropMode newCropMode,vigra::Rect2D newCropRect, bool isCentered, hugin_utils::FDiff2D center, bool isCircleCrop);
    vigra::Rect2D getCrop() { return m_cropRect; };
    void setActiveMask(unsigned int newMask, bool doUpdate=true);
    HuginBase::MaskPolygonVector getNewMask() const { return m_imageMask; };
    void selectAllMarkers();
 
    void OnMouseMove(wxMouseEvent& mouse);
    void OnLeftMouseDown(wxMouseEvent& mouse);
    void OnLeftMouseUp(wxMouseEvent& mouse);
    void OnLeftMouseDblClick(wxMouseEvent& mouse);
    void OnRightMouseDown(wxMouseEvent& mouse);
    void OnRightMouseUp(wxMouseEvent& mouse);
    void OnMiddleMouseDown(wxMouseEvent& mouse);
    void OnMiddleMouseUp(wxMouseEvent& mouse);
    void OnMouseWheel(wxMouseEvent& mouse);
    void OnKeyUp(wxKeyEvent &e);
    void OnChar(wxKeyEvent& e);
    void OnCaptureLost(wxMouseCaptureLostEvent &e);
    void OnKillFocus(wxFocusEvent &e);
    void OnScroll(wxScrollWinEvent &e);
 
    void startNewPolygon();
    wxSize DoGetBestSize() const override;
 
    void SetMaskMode(bool newMaskMode);
 
    void setScale(double factor);
 
    double getScale()
        { return m_fitToWindow ? 0 : m_scaleFactor; }
 
    ImageRotation getCurrentRotation() { return m_imgRotation; };
 
    void setDrawingActiveMasks(bool newDrawActiveMasks);
 
    void SetUserColourPolygonNegative(wxColour newColour) { m_colour_polygon_negative=newColour; };
    void SetUserColourPolygonPositive(wxColour newColour) { m_colour_polygon_positive=newColour; };
    void SetUserColourPointSelected(wxColour newColour) { m_colour_point_selected=newColour; };
    void SetUserColourPointUnselected(wxColour newColour) { m_colour_point_unselected=newColour; };
 
    void OnPaint(wxPaintEvent& e);
protected:
    void OnSize(wxSizeEvent & e);
    void OnSizeFinished(wxTimerEvent& e);
 
    double getScaleFactor() const;
    double calcAutoScaleFactor(wxSize size);
    void rescaleImage();
 
 private:
 
    //scaled bitmap
    wxBitmap m_bitmap;
    wxBitmap m_disabledBitmap;
    //filename of current editing file
    std::string m_imageFilename;
    // stores rotation of image
    ImageRotation m_imgRotation;
    // size of displayed (probably scaled) image
    wxSize m_imageSize;
    // size of real image
    wxSize m_realSize;
    // variables for crop
    HuginBase::SrcPanoImage::CropMode m_cropMode;
    vigra::Rect2D m_cropRect;
    bool m_cropCentered;
    bool m_cropCircle;
    hugin_utils::FDiff2D m_cropCenter;
    // draw active masks 
    bool m_showActiveMasks;
    // mask or crop mode
    bool m_maskMode;
    // timer to resize image only once at end of resize
    wxTimer m_resizeTimer;
 
    int scale(int x) const
        {  return (int) (x * getScaleFactor() + 0.5); }
 
    double scale(double x) const
        {  return x * getScaleFactor(); }
 
    int transform(int x) const
        {  return (int) ((x+HuginBase::maskOffset) * getScaleFactor() + 0.5); }
 
    double transform(double x) const
        {  return (x+HuginBase::maskOffset) * getScaleFactor(); }
 
    wxPoint transform(const hugin_utils::FDiff2D & p) const
        {
            wxPoint r;
            r.x = transform(p.x);
            r.y = transform(p.y);
            return r;
        };
 
    int invtransform(int x) const
        {  return (int) (x/getScaleFactor()-HuginBase::maskOffset + 0.5); };
 
    double invtransform(double x) const
        {  return (x/getScaleFactor()-HuginBase::maskOffset); };
 
    hugin_utils::FDiff2D invtransform(const wxPoint & p) const
        {
            hugin_utils::FDiff2D r;
            r.x = invtransform(p.x);
            r.y = invtransform(p.y);
            return r;
        };
    
    // 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;
        }
    }
 
    //draw the given polygon
    void DrawPolygon(wxDC &dc, HuginBase::MaskPolygon poly, bool isSelected, bool drawMarker);
    //draw a selection rectange, when called the second time the rectangle is deleted
    void DrawSelectionRectangle();
    // draws the crop rectangle and/or circle
    void DrawCrop(wxDC & dc);
    // find the polygon for which the point p is inside the polygon
    void FindPolygon(hugin_utils::FDiff2D p);
    // returns a set of points which are in the selection rectangle 
    bool SelectPointsInsideMouseRect(HuginBase::UIntSet &points,const bool considerSelectedOnly);
    // updates the crop
    void UpdateCrop(hugin_utils::FDiff2D delta);
 
    // where the cursor is 
    enum ClickPos
    {
        CLICK_OUTSIDE, CLICK_INSIDE, CLICK_LEFT, CLICK_RIGHT, CLICK_TOP, CLICK_BOTTOM, CLICK_CIRCLE
    };
    // test, where the curos is
    ClickPos GetClickPos(vigra::Point2D pos);
 
    enum MaskEditorState
    {
        NO_IMAGE=0, // no image selected
        NO_MASK, // image loaded, but none active mask
        NO_SELECTION, // active polygon, but no point selected
        POINTS_SELECTED, // points selected
        POINTS_MOVING, // dragging points
        POINTS_DELETING,  // remove points inside rect
        POINTS_ADDING,  // adding new points add mouse position
        POLYGON_SELECTING, // selecting an region to select another polygon
        REGION_SELECTING, // currently selecting an region
        NEW_POLYGON_STARTED, // modus is new polygon, but no point setted yet
        NEW_POLYGON_CREATING,  // currently creating new polygon
        CROP_SHOWING,  // only showing the crop
        CROP_MOVING,  // dragging crop
        CROP_CIRCLE_SCALING, // circular crop changing
        CROP_LEFT_MOVING, // dragging left border of crop
        CROP_RIGHT_MOVING, // dragging right border of crop
        CROP_TOP_MOVING,  // dragging top border of crop
        CROP_BOTTOM_MOVING // dragging bottom border of crop
    };
    MaskEditorState m_maskEditState;
 
    double m_scaleFactor;
    bool m_fitToWindow;
    bool m_previewOnly;
 
    MaskEditorPanel * m_editPanel;
    HuginBase::MaskPolygonVector m_imageMask;
    HuginBase::MaskPolygonVector m_masksToDraw;
    unsigned int m_activeMask;
    // the active masks, the one which is currently editing
    HuginBase::MaskPolygon m_editingMask;
    // all selected points
    HuginBase::UIntSet m_selectedPoints;
 
    ImageCache::EntryPtr m_img;
 
    // positions of mouse drag
    wxPoint m_dragStartPos;
    wxPoint m_currentPos;
    // variable for saving scrolling state
    bool m_middleMouseScroll;
    wxPoint m_scrollPos;
 
    // colours for different parts
    wxColor m_colour_polygon_negative;
    wxColor m_colour_polygon_positive;
    wxColor m_colour_point_selected;
    wxColor m_colour_point_unselected;
    wxColour m_color_selection;
    wxOverlay m_overlay;
    int m_oldScrollPosX, m_oldScrollPosY;
 
    DECLARE_DYNAMIC_CLASS(MaskImageCtrl)
};
 
class MaskImageCtrlXmlHandler : public wxXmlResourceHandler
{
    DECLARE_DYNAMIC_CLASS(MaskImageCtrlXmlHandler)
 
public:
    MaskImageCtrlXmlHandler();
    virtual wxObject *DoCreateResource();
    virtual bool CanHandle(wxXmlNode *node);
};
 
 
#endif // _MaskImageCtrl_H