MRPickPointManager.h

Go to the documentation of this file.

#pragma once
 
#include "MRViewerEventsListener.h"
#include "MRViewport.h"
#include "MRSurfacePointPicker.h"
#include "MRHistoryStore.h"
#include "MRViewer/MRGladGlfw.h"
#include "MRMesh/MRMeshFwd.h"
#include "MRMesh/MRObjectMeshHolder.h"
#include <MRMesh/MRphmap.h>
#include <unordered_map>
 
namespace MR
{
 
class MRVIEWER_CLASS PickPointManager : public MultiListener<
    MouseDownListener,
    MouseMoveListener>
{
public:
    using PickerPointCallBack = std::function<void( std::shared_ptr<VisualObject> obj, int index )>;
    using AllowCallBack = std::function<bool( const std::shared_ptr<VisualObject>& obj, int index )>;
 
    struct Params
    {
        int widgetContourCloseMod = GLFW_MOD_CONTROL;
 
        int widgetDeletePointMod = GLFW_MOD_SHIFT;
 
        bool writeHistory = true;
 
        std::string historyNameSuffix;
 
        bool startDraggingJustAddedPoint = true;
 
        SurfacePointWidget::Parameters surfacePointParams;
 
        Color ordinaryPointColor = Color::gray();
 
        Color lastPointColor = Color::green();
 
        Color closeContourPointColor = Color::transparent();
 
        Viewport::PickRenderObjectPredicate pickPredicate;
 
        AllowCallBack canAddPoint;
 
        PickerPointCallBack onPointAdd;
 
        PickerPointCallBack onPointMoveStart;
 
        PickerPointCallBack onPointMove;
 
        PickerPointCallBack onPointMoveFinish;
 
        AllowCallBack canRemovePoint;
 
        PickerPointCallBack onPointRemove;
    };
    struct Params {…};
    Params params;
 
    struct WidgetHistoryAction : HistoryAction {};
 
    using SurfaceContour = std::vector<std::shared_ptr<SurfacePointWidget>>;
    using SurfaceContours = std::unordered_map <std::shared_ptr<VisualObject>, SurfaceContour>;
 
    MRVIEWER_API PickPointManager();
 
    MRVIEWER_API ~PickPointManager();
 
    [[nodiscard]] const SurfaceContour& getSurfaceContour( const std::shared_ptr<VisualObject>& obj ) { return pickedPoints_[obj]; }
 
    [[nodiscard]] const SurfaceContours& getSurfaceContours() const { return pickedPoints_; }
 
    [[nodiscard]] MRVIEWER_API bool isClosedCountour( const std::shared_ptr<VisualObject>& obj ) const;
 
    [[nodiscard]] MRVIEWER_API size_t numPickPoints( const std::shared_ptr<VisualObject>& obj ) const;
 
    [[nodiscard]] MRVIEWER_API std::shared_ptr<SurfacePointWidget> getPointWidget( const std::shared_ptr<VisualObject>& obj, int index ) const;
 
    [[nodiscard]] MRVIEWER_API int getPointIndex( const std::shared_ptr<VisualObject>& obj, SurfacePointWidget& pointWidget ) const;
 
    [[nodiscard]] SurfacePointWidget* draggedPointWidget() const { return draggedPointWidget_; }
 
    MRVIEWER_API bool appendPoint( const std::shared_ptr<VisualObject>& obj, const PickedPoint& triPoint, bool startDragging = false );
 
    MRVIEWER_API bool insertPoint( const std::shared_ptr<VisualObject>& obj, int index, const PickedPoint& triPoint, bool startDragging = false );
 
    MRVIEWER_API bool removePoint( const std::shared_ptr<VisualObject>& obj, int pickedIndex );
 
    // if ( makeClosed ), and the contour is open add a special transparent point contour to the end of contour connected with given object.
    // A coordinated of this special transparent point will be equal to the firs point in contour, which will means that contour is closed.
    // if ( !makeClosed ), and the contour is closed remove last point of contour connected with given object.
    MRVIEWER_API bool closeContour( const std::shared_ptr<VisualObject>& obj, bool makeClosed = true );
 
    struct ObjectState
    {
        std::weak_ptr<VisualObject> objPtr;
        std::vector<PickedPoint> pickedPoints;
    };
    struct ObjectState {…};
    using FullState = std::vector<ObjectState>;
 
    MRVIEWER_API FullState getFullState() const;
 
    MRVIEWER_API void clear();
 
    MRVIEWER_API void setFullState( FullState s );
 
private:
    MRVIEWER_API bool onMouseDown_( MouseButton button, int modifier ) override;
    MRVIEWER_API bool onMouseMove_( int mouse_x, int mouse_y ) override;
 
    ObjAndPick pick_() const;
 
    void colorLast2Points_( const std::shared_ptr<VisualObject>& obj );
 
    // creates point widget for add to contour.
    [[nodiscard]] std::shared_ptr<SurfacePointWidget> createPickWidget_( const std::shared_ptr<VisualObject>& obj, const PickedPoint& pt );
 
    void clearNoHistory_();
 
    void swapStateNoHistory_( FullState& s );
 
    int insertPointNoHistory_( const std::shared_ptr<VisualObject>& obj, int index, const PickedPoint& point, bool startDragging );
 
    PickedPoint removePointNoHistory_( const std::shared_ptr<VisualObject>& obj, int index );
 
    template<class HistoryActionType, typename... Args>
    void appendHistory_( Args&&... args );
 
    void appendHistory_( std::shared_ptr<HistoryAction> action ) const;
 
    void setHoveredPointWidget_( SurfacePointWidget* newHoveredPoint );
 
    // whether the contour was closed before dragging of point #0, so we need to move the last point on end drag
    bool moveClosedPoint_ = false;
 
    // point widget currently under mouse and highlighted
    SurfacePointWidget* hoveredPointWidget_ = nullptr;
 
    // point widget currently dragged by mouse
    SurfacePointWidget* draggedPointWidget_ = nullptr;
 
    // data storage
    SurfaceContours pickedPoints_;
 
    // all spheres created in createPickWidget_ to quickly differentiate them from other features
    HashSet<const VisualObject*> myPickSpheres_;
 
    // for each object with pick points, holds connections to mesh/point changed event
    struct ConnectionHolder
    {
        boost::signals2::scoped_connection onMeshChanged;
        boost::signals2::scoped_connection onPointsChanged;
    };
    HashMap<std::shared_ptr<VisualObject>, ConnectionHolder> connectionHolders_;
 
    // History classes:
    class SetStateHistoryAction;
    class AddRemovePointHistoryAction;
    class MovePointHistoryAction;
};
class MRVIEWER_CLASS PickPointManager : public MultiListener< {…};
 
} //namespace MR