MRSurfaceManipulationWidget.h

Go to the documentation of this file.

#pragma once
#include "MRViewerFwd.h"
#include "MRViewerEventsListener.h"
#include "MRMesh/MRMeshFwd.h"
#include "MRMesh/MREnums.h"
#include "MRMesh/MRBitSet.h"
#include "MRViewer/MRViewport.h"
#include <chrono>
 
namespace MR
{
 
 
class MRVIEWER_CLASS SurfaceManipulationWidget :
    public MultiListener<MouseDownListener, MouseMoveListener, MouseUpListener,
                         PostDrawListener>
{
public:
    MRVIEWER_API SurfaceManipulationWidget();
    MRVIEWER_API virtual ~SurfaceManipulationWidget();
 
    enum class WorkMode
    {
        Add,
        Remove,
        Relax,
        Laplacian,
        Patch
    };
 
    enum class DeviationCalculationMethod
    {
        PointToPoint, 
        PointToPlane, 
        ExactDistance 
    };
 
 
    struct Settings
    {
        WorkMode workMode = WorkMode::Add;
        float radius = 1.f; 
        float relaxForce = 0.2f; 
        float editForce = 1.f; 
        float sharpness = 50.f; 
        float relaxForceAfterEdit = 0.25f; 
        EdgeWeights edgeWeights = EdgeWeights::Cotan; 
    };
 
    MRVIEWER_API void init( const std::shared_ptr<ObjectMesh>& objectMesh );
    MRVIEWER_API void reset();
    MRVIEWER_API void setFixedRegion( const FaceBitSet& region );
 
    MRVIEWER_API void setSettings( const Settings& settings );
    MRVIEWER_API const Settings& getSettings() { return settings_; }
 
    MRVIEWER_API float getMinRadius() { return minRadius_; }
 
    Palette& palette() { return *palette_; }
    MRVIEWER_API void updateTexture();
    MRVIEWER_API void updateUVs();
    MRVIEWER_API void enableDeviationVisualization( bool enable );
    MRVIEWER_API void setDeviationCalculationMethod( DeviationCalculationMethod method );
    MRVIEWER_API DeviationCalculationMethod deviationCalculationMethod() const { return deviationCalculationMethod_; }
    MRVIEWER_API bool sameValidVerticesAsInOriginMesh() const { return sameValidVerticesAsInOriginMesh_; }
    MRVIEWER_API Vector2f getMinMax();
 
    MRVIEWER_API void setIgnoreOcclusion( bool ignore ) { ignoreOcclusion_ = ignore; }
    MRVIEWER_API bool ignoreOcclusion() const { return ignoreOcclusion_; }
 
    void setEditOnlyCodirectedSurface( bool edit ) { editOnlyCodirectedSurface_ = edit; }
    bool isEditOnlyCodirectedSurface() const { return editOnlyCodirectedSurface_; }
protected:
    MRVIEWER_API bool onMouseDown_( MouseButton button, int modifiers ) override;
    MRVIEWER_API bool onMouseUp_( MouseButton button, int modifiers ) override;
    MRVIEWER_API bool onMouseMove_( int mouse_x, int mouse_y ) override;
    MRVIEWER_API void postDraw_() override;
 
    MRVIEWER_API virtual bool checkModifiers_( int modifiers ) const { return modifiers == 0; }
 
    MRVIEWER_API virtual void appendMeshDataChangeHistory_( ObjectMeshData&& newMeshData, const FaceBitSet& newFaces );
 
    void reallocData_( size_t size );
    void clearData_();
 
    void initConnections_();
    void resetConnections_();
 
    void changeSurface_();
    void updateUVmap_( bool set, bool wholeMesh = false );
    void updateRegion_( const Vector2f& mousePos );
    void invalidateMetricsCache_();
    void abortEdit_();
    void laplacianPickVert_( const PointOnFace& pick );
    void laplacianMoveVert_( const Vector2f& mousePos );
 
    void updateVizualizeSelection_();
 
    void updateRegionUVs_( const VertBitSet& region );
    void updateValueChanges_( const VertBitSet& region );
    void updateValueChangesPointToPoint_( const VertBitSet& region );
    void updateValueChangesPointToPlane_( const VertBitSet& region );
    void updateValueChangesExactDistance_( const VertBitSet& region );
    void createLastStableObjMesh_();
    void removeLastStableObjMesh_();
 
    void compressChangePointsAction_();
 
    void updateDistancesAndRegion_( const Mesh& mesh, const VertBitSet& start, VertScalars& distances, VertBitSet& region, const VertBitSet* untouchable );
 
    Settings settings_;
 
    std::shared_ptr<ObjectMesh> obj_;
    VertBitSet unchangeableVerts_;
    float minRadius_ = 1.f;
    Vector2f mousePos_; 
    VertBitSet activePickedVertices_; 
    VertBitSet singleEditingRegion_;  
    VertBitSet visualizationRegion_;  
    VertBitSet generalEditingRegion_; 
    VertScalars pointsShift_;
    VertScalars editingDistanceMap_;
    VertScalars visualizationDistanceMap_;
    VertBitSet changedRegion_;
    VertScalars valueChanges_;
    VertScalars lastStableValueChanges_;
    std::shared_ptr<Mesh> originalMesh_; 
    VertBitSet unknownSign_; 
    std::shared_ptr<ObjectMesh> lastStableObjMesh_;
    bool firstInit_ = true; 
    bool badRegion_ = false; 
 
    bool mousePressed_ = false;
 
    std::chrono::time_point<std::chrono::high_resolution_clock> timePoint_;
    boost::signals2::scoped_connection meshChangedConnection_;
    bool ownMeshChangedSignal_ = false;
 
    bool connectionsInitialized_ = false;
 
    VertId touchVertId_; 
    Vector3f touchVertIniPos_; 
    Vector2i storedDown_;
    std::unique_ptr<Laplacian> laplacian_;
 
    class SmartChangeMeshPointsAction;
    std::shared_ptr<SmartChangeMeshPointsAction> historyAction_;
 
    bool appendHistoryAction_ = false;
 
    std::shared_ptr<Palette> palette_;
    bool enableDeviationTexture_ = false;
    DeviationCalculationMethod deviationCalculationMethod_ = DeviationCalculationMethod::ExactDistance;
    bool sameValidVerticesAsInOriginMesh_ = true;
 
    bool ignoreOcclusion_ = false;
    bool editOnlyCodirectedSurface_ = true;
};
 
}