MRSurfaceManipulationWidget.h

Go to the documentation of this file.

#pragma once
#include "MRViewerFwd.h"
#include "MRViewerEventsListener.h"
#include "MRMesh/MREnums.h"
#include "MRMesh/MRBitSet.h"
#include "MRMesh/MRVector2.h"
#include <cfloat>
 
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; 
        VertexMass vmass = VertexMass::NeiArea; 
        bool laplacianBasedAddRemove = false; 
        bool subdivideGrooves = false; 
    };

    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 sameOriginalMeshTopology() const { return sameOriginalMeshTopology_; }

    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 initLaplacian_( RememberShape rs ); 
    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 subdivideAfterAddRemove_();
 
    void updateDistancesAndRegion_( const Mesh& mesh, const std::vector<MeshTriPoint>& start, VertScalars& distances, VertBitSet& region, const VertBitSet* untouchable );
 
    Settings settings_;
 
    std::shared_ptr<ObjectMesh> obj_;
    VertBitSet unchangeableVerts_;
    float minRadius_ = 1.f;
    Vector2f mousePos_; 
    std::vector<MeshTriPoint> pointsUnderMouse_; 
    VertBitSet singleEditingRegion_;  
    VertBitSet visualizationRegion_;  
    VertBitSet generalEditingRegion_; 
    VertScalars pointsShift_;
    VertScalars editingDistanceMap_;
    VertScalars visualizationDistanceMap_;
    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;
 
    boost::signals2::scoped_connection meshChangedConnection_;
    bool ownMeshChangedSignal_ = false;
 
    bool connectionsInitialized_ = false;

    VertId touchVertId_; 
    Vector3f touchVertIniPos_; 
    Vector2i storedDown_;
    std::unique_ptr<Laplacian> laplacian_;

    VertBitSet pickedVerts_;
 
    struct PickedVertData
    {
        Vector3f target; 
        float minMouseDistSq = FLT_MAX; 
    };

    HashMap<VertId, PickedVertData> pickedVertsToData_;

    std::shared_ptr<VersatileChangeMeshPointsAction> historyAction_;

    bool appendHistoryAction_ = false;
 
    std::shared_ptr<Palette> palette_;
    bool enableDeviationTexture_ = false;
    DeviationCalculationMethod deviationCalculationMethod_ = DeviationCalculationMethod::ExactDistance;
    bool sameOriginalMeshTopology_ = true;

    bool ignoreOcclusion_ = false;
    bool editOnlyCodirectedSurface_ = true;
};
 
}