MRSurfaceContoursWidget.h

Go to the documentation of this file.

#pragma once
 
#include "MRViewer.h"
#include "MRViewerEventsListener.h"
#include "MRViewport.h"
#include "MRMesh/MRMeshFwd.h"
#include "MRSurfacePointPicker.h"
#include "MRMesh/MRObjectMeshHolder.h"
#include "MRHistoryStore.h"
#include "MRViewer/MRGladGlfw.h"
 
#include <unordered_map>
#include <unordered_set>
 
namespace MR
{
 
class MRVIEWER_CLASS SurfaceContoursWidget : public MultiListener<
    MouseDownListener,
    MouseMoveListener>
{
public:
 
    struct SurfaceContoursWidgetParams {
        // Modifier key for closing a contour (ordered vector of points) using the widget
        int widgetContourCloseMod = GLFW_MOD_CONTROL;
 
        // Modifier key for deleting a point using the widget
        int widgetDeletePointMod = GLFW_MOD_SHIFT;
 
        // Indicates whether to write history of the contours
        bool writeHistory = true;
 
        // specification of history actions
        std::string historySpecification = "surface contours widget";
 
        // Indicates whether to flash history on reset call
        bool filterHistoryonReset = true;
 
        // Parameters for configuring the surface point widget
        // Parameters affect to future points only
        SurfacePointWidget::Parameters surfacePointParams;
 
        // Color for ordinary points in the contour
        // Parameters affect to future points only
        MR::Color ordinaryPointColor = Color::gray();
 
        // Color for the last modified point in the contour
        // Parameters affect to future points only
        MR::Color lastPoitColor = Color::green();
 
        // Color for the special point used to close a contour. Better do not change it. 
        // Parameters affect to future points only
        MR::Color closeContourPointColor = Color::transparent();
 
        // Predicate to additionally filter objects that should be treated as pickable.
        Viewport::PickRenderObjectPredicate pickPredicate;
    };
 
    using PickerPointCallBack = std::function<void( std::shared_ptr<MR::VisualObject> )>;
    using PickerPointObjectChecker = std::function<bool( std::shared_ptr<MR::VisualObject> )>;
 
    using SurfaceContour = std::vector<std::shared_ptr<SurfacePointWidget>>;
    using SurfaceContours = std::unordered_map <std::shared_ptr<MR::VisualObject>, SurfaceContour>;
 
    // enable or disable widget
    MRVIEWER_API void enable( bool isEnabled );
 
    // create a widget and connect it. 
    // To create a widget, you need to provide 4 callbacks and one function that determines whether this object can be used to place points.
    // All callback takes a shared pointer to an MR::VisualObject as an argument.
    // onPointAdd: This callback is invoked when a point is added.
    // onPointMove : This callback is triggered when a point is being start  moved or dragge.
    // onPointMoveFinish : This callback is called when the movement of a point is completed.
    // onPointRemove : This callback is executed when a point is removed.
    // isObjectValidToPick : Must returh true or false. This callback is used to determine whether an object is valid for picking.
    MRVIEWER_API void create(
            PickerPointCallBack onPointAdd,
            PickerPointCallBack onPointMove,
            PickerPointCallBack onPointMoveFinish,
            PickerPointCallBack onPointRemove,
            PickerPointObjectChecker isObjectValidToPick
    );
 
    // clear temp internal variables.
    MRVIEWER_API void clear();
 
    // reset widget, clear internal variables and detach from signals.
    MRVIEWER_API void reset();
 
    // return contour for specific object, i.e. ordered vector of surface points
    [[nodiscard]] const SurfaceContour& getSurfaceContour( const std::shared_ptr<MR::VisualObject>& obj )
    {
        return pickedPoints_[obj];
    }
 
    // return all contours, i.e. per object umap of ordered surface points [vestor].
    [[nodiscard]] const SurfaceContours& getSurfaceContours() const
    {
        return pickedPoints_;
    }
 
    // chech is contour closed for particular object.
    [[nodiscard]] bool isClosedCountour( const std::shared_ptr<VisualObject>& obj );
 
    // Correctly selects the last point in the contours.
    // If obj == nullptr then the check will be in all circuits.
    // If specified, then only in the contour on specyfied object 
    void highlightLastPoint( const std::shared_ptr<VisualObject>& obj );
 
    // shared variables. which need getters and setters.
    MRVIEWER_API std::pair <std::shared_ptr<MR::VisualObject>, int > getActivePoint() const;
    MRVIEWER_API void setActivePoint( std::shared_ptr<MR::VisualObject> obj, int index );
 
    MRVIEWER_API std::shared_ptr<SurfacePointWidget> getActiveSurfacePoint() const;
 
    // Add a point to the end of non closed contour connected with obj.
    // With carefull it is possile to use it in CallBack.
    MRVIEWER_API bool appendPoint( const std::shared_ptr<VisualObject>& obj, const PickedPoint& triPoint );
 
    // Remove point with pickedIndex index from contour connected with obj.
    // With carefull it is possile to use it in CallBack.
    MRVIEWER_API bool removePoint( const std::shared_ptr<VisualObject>& obj, int pickedIndex );
 
    // Add a special transperent point contour to the end of contour connected with objectToCloseCoutour.
    // A coordinated of this special transperent point will be equal to the firs point in contour, 
    // which will means that contour is closed.
    MRVIEWER_API bool closeContour( const std::shared_ptr<VisualObject>& objectToCloseCoutour );
 
    // configuration params
    SurfaceContoursWidgetParams params;
private:
 
    MRVIEWER_API bool onMouseDown_( Viewer::MouseButton button, int modifier ) override;
    MRVIEWER_API bool onMouseMove_( int mouse_x, int mouse_y ) override;
 
    // creates point widget for add to contour.
    [[nodiscard]] std::shared_ptr<SurfacePointWidget> createPickWidget_( const std::shared_ptr<MR::VisualObject>& obj, const PickedPoint& pt );
 
    // SurfaceContoursWidget interlal variables 
    bool moveClosedPoint_ = false;
    bool activeChange_ = false;
    bool isPickerActive_ = false;
 
    // active point
    int activeIndex_{ 0 };
    std::shared_ptr<MR::VisualObject> activeObject_ = nullptr;
 
    // data storage
    SurfaceContours pickedPoints_;
 
    // picked points' cache
    std::unordered_set<const VisualObject*> surfacePointWidgetCache_;
 
    // connection storage
    struct SurfaceConnectionHolder
    {
        boost::signals2::scoped_connection onMeshChanged;
        boost::signals2::scoped_connection onPointsChanged;
    };
    std::unordered_map<std::shared_ptr<VisualObject>, SurfaceConnectionHolder> surfaceConnectionHolders_;
 
    // CallBack functions
    PickerPointCallBack onPointAdd_;
    PickerPointCallBack onPointMove_;
    PickerPointCallBack onPointMoveFinish_;
    PickerPointCallBack onPointRemove_;
    PickerPointObjectChecker isObjectValidToPick_;
 
    friend class AddPointActionPickerPoint;
    friend class RemovePointActionPickerPoint;
    friend class ChangePointActionPickerPoint;
    friend class SurfaceContoursWidgetClearAction;
};
 
 
// History classes;
class AddPointActionPickerPoint : public HistoryAction
{
public:
    AddPointActionPickerPoint( SurfaceContoursWidget& widget, const std::shared_ptr<MR::VisualObject>& obj, const PickedPoint& point ) :
        widget_{ widget },
        obj_{ obj },
        point_{ point }
    {};
 
    virtual std::string name() const override;
    virtual void action( Type actionType ) override;
    [[nodiscard]] virtual size_t heapBytes() const override;
private:
    SurfaceContoursWidget& widget_;
    const std::shared_ptr<MR::VisualObject> obj_;
    PickedPoint point_;
};
 
class RemovePointActionPickerPoint : public HistoryAction
{
public:
    RemovePointActionPickerPoint( SurfaceContoursWidget& widget, const std::shared_ptr<MR::VisualObject>& obj, const PickedPoint& point, int index ) :
        widget_{ widget },
        obj_{ obj },
        point_{ point },
        index_{ index }
    {};
 
    virtual std::string name() const override;
    virtual void action( Type actionType ) override;
    [[nodiscard]] virtual size_t heapBytes() const override;
private:
    SurfaceContoursWidget& widget_;
    const std::shared_ptr<MR::VisualObject> obj_;
    PickedPoint point_;
    int index_;
};
 
class ChangePointActionPickerPoint : public HistoryAction
{
public:
    ChangePointActionPickerPoint( SurfaceContoursWidget& widget, const std::shared_ptr<MR::VisualObject>& obj, const PickedPoint& point, int index ) :
        widget_{ widget },
        obj_{ obj },
        point_{ point },
        index_{ index }
    {};
 
    virtual std::string name() const override;
    virtual void action( Type ) override;
    [[nodiscard]] virtual size_t heapBytes() const override;
private:
    SurfaceContoursWidget& widget_;
    const std::shared_ptr<MR::VisualObject> obj_;
    PickedPoint point_;
    int index_;
};
 
class SurfaceContoursWidgetClearAction : public HistoryAction
{
public:
    SurfaceContoursWidgetClearAction( std::string name, SurfaceContoursWidget& widget );
 
public:
    // HistoryAction
    [[nodiscard]] std::string name() const override { return name_; }
 
    void action( Type type ) override;
 
    [[nodiscard]] size_t heapBytes() const override;
 
private:
    std::string name_;
    SurfaceContoursWidget& widget_;
 
    struct ObjectState
    {
        std::weak_ptr<VisualObject> objPtr;
        std::vector<PickedPoint> pickedPoints;
    };
    std::vector<ObjectState> states_;
    std::weak_ptr<VisualObject> activeObject_;
    int activeIndex_;
};
 
}