PerspectiveImageCtrl.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 PerspectiveImageCtrl_H
#define PerspectiveImageCtrl_H

#include <base_wx/wxImageCache.h>
#include <panoinc.h>
#include <lcms2.h>

const int PerspectiveOffset = 200;
const int maxSelectionDistance = 10;
const int polygonPointSize = 3;

class PerspectiveImageCtrl : public wxScrolledWindow
{
public:
    // simple struct for lines
    class Line
    {
        public:
            hugin_utils::FDiff2D start, end;
            // constructor for fast creation
            Line() : start(hugin_utils::FDiff2D()), end(hugin_utils::FDiff2D()) {};
            Line(const hugin_utils::FDiff2D& p1, const hugin_utils::FDiff2D& p2)
            {
                start = p1;
                end = p2;
            };
            // swap start and end point
            void Mirror()
            {
                hugin_utils::FDiff2D temp = start;
                start = end;
                end = temp;
            };
    };

    bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL, const wxString& name = "panel");

    enum ImageRotation { ROT0 = 0, ROT90, ROT180, ROT270 };

    void setOriginalMode();
    bool IsOriginalShown() const { return !m_showRemappedImage; };
    void SetRemappedMode(const HuginBase::Panorama& pano);
    void setImage(const std::string& filename, ImageRotation rot);
    void ChangeRotation(ImageRotation newRot);

    void OnMouseMove(wxMouseEvent& mouse);
    void OnLeftMouseDown(wxMouseEvent& mouse);
    void OnLeftMouseUp(wxMouseEvent& mouse);
    void OnRightMouseUp(wxMouseEvent& mouse);
    void OnMiddleMouseDown(wxMouseEvent& mouse);
    void OnMiddleMouseUp(wxMouseEvent& mouse);
    void OnCaptureLost(wxMouseCaptureLostEvent& e);
    void OnKillFocus(wxFocusEvent& e);

    void setScale(double factor);
    double getScale() const;

    ImageRotation getCurrentRotation() { return m_imgRotation; };
    void SetLineColour(wxColour newColour);

    void OnPaint(wxPaintEvent& e);
    void SetRectMode(bool newMode);
    HuginBase::CPVector GetControlPoints(const unsigned int index);

    ImageCache::EntryPtr getCachedImage() { return m_img; };
    void AddLines(const HuginBase::CPVector& lines);
protected:
    void OnSize(wxSizeEvent& e);

    double getScaleFactor() const;
    double calcAutoScaleFactor(wxSize size);
    void rescaleImage();
    void UpdateVirtualSize();

private:
    HuginBase::ControlPoint GetCP(const unsigned int index, const hugin_utils::FDiff2D& p1, const hugin_utils::FDiff2D& p2);
    void ClipPos(hugin_utils::FDiff2D& pos);
    int GetNearestRectanglePoint(const hugin_utils::FDiff2D& p);
    int GetNearestRectangleLine(const hugin_utils::FDiff2D& p);
    bool IsInsideRect(const hugin_utils::FDiff2D& p);
    int GetNearestLinePoint(const hugin_utils::FDiff2D& p, bool& isStart);
    int GetNearestLine(const hugin_utils::FDiff2D& p);
    void GenerateRemappedImage(const unsigned int newWidth, const unsigned int newHeight);
    //draw the given polygon
    void DrawRect(wxDC& dc, const std::vector<hugin_utils::FDiff2D>& rect);
    // draw lines
    void DrawLines(wxDC& dc, const std::vector<Line>& lines);

    //scaled bitmap
    wxBitmap m_bitmap;
    wxBitmap m_remappedImg;

    //filename of current editing file
    std::string m_imageFilename;
    // stores rotation of image
    ImageRotation m_imgRotation{ ROT0 };
    // size of displayed (probably scaled) image
    wxSize m_imageSize;
    // size of real image
    wxSize m_realSize;
    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 + PerspectiveOffset) * getScaleFactor() + 0.5);
    };
    double transform(double x) const
    {
        return (x + PerspectiveOffset) * 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() - PerspectiveOffset + 0.5);
    };
    double invtransform(double x) const
    {
        return (x / getScaleFactor() - PerspectiveOffset);
    };
    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;
        }
    }

    enum PerspectiveEditorState
    {
        NO_IMAGE = 0, // no image selected
        SHOW_IMAGE, // image loaded and rectangle
        POINT_MOVING, // dragging points of the rectangle
        SEGMENT_MOVING, // dragging line of the rectangle
        RECT_MOVING, // dragging the whole rectangle
        LINE_CREATE, // create a new line
        LINE_POINT_MOVING,  // dragging one point of the line
        LINE_MOVING  // dragging one line
    };
    PerspectiveEditorState m_editorState{ NO_IMAGE };

    double m_scaleFactor{ 1.0 };
    bool m_fitToWindow{ false };
    bool m_showRemappedImage{ false };
    bool m_showRect{ true };

    ImageCache::EntryPtr m_img;
    HuginBase::Panorama m_pano;

    // positions of mouse drag
    wxPoint m_dragStartPos;
    wxPoint m_currentPos;
    int m_movingPoint{ -1 };
    // variable for saving scrolling state
    bool m_middleMouseScroll{ false };
    wxPoint m_scrollPos;

    // colours for different parts
    wxColor m_colour_selected;
    // coordinates of the rectangle
    std::vector<hugin_utils::FDiff2D> m_rectPoints, m_rectPointsStartDrag;
    std::vector<Line> m_lines, m_currentLine;
    Line m_lineStartDrag;

    DECLARE_DYNAMIC_CLASS(PerspectiveImageCtrl)
};

#endif // PerspectiveImageCtrl_H