MRFeatureObject.h

Go to the documentation of this file.

#pragma once
#include "MRMesh/MRVisualObject.h"
#include "MRMeshFwd.h"
 
#include "MRVector3.h"
 
#include <cassert>
#include <variant>
 
namespace MR
{
 
 
using FeaturesPropertyTypesVariant = std::variant<float, Vector3f>;
 
class FeatureObject;
 
enum class FeaturePropertyKind
{
    position, 
    linearDimension, 
    direction, 
    angle, 
    other,
};
 
struct FeatureObjectSharedProperty
{
    std::string propertyName;
    FeaturePropertyKind kind;
    std::function<FeaturesPropertyTypesVariant( const FeatureObject* objectToInvoke, ViewportId id )> getter;
    std::function<void( const FeaturesPropertyTypesVariant&, FeatureObject* objectToInvoke, ViewportId id )> setter;
 
    template <typename T, typename C, typename SetterFunc>
    FeatureObjectSharedProperty(
        std::string name,
        FeaturePropertyKind kind,
        T( C::* m_getter )( ViewportId ) const,
        SetterFunc m_setter
    )
        : propertyName( std::move( name ) ),
        kind( kind ),
        getter( [m_getter] ( const FeatureObject* objectToInvoke, ViewportId id ) -> FeaturesPropertyTypesVariant
        {
            return std::invoke( m_getter, dynamic_cast< const C* >( objectToInvoke ), id );
        } )
    {
        if constexpr ( ( std::is_same_v<SetterFunc, void ( C::* )( const T&, ViewportId )> )
            || ( std::is_same_v<SetterFunc, void ( C::* )( T, ViewportId )> ) )
        {
            setter = [m_setter] ( const FeaturesPropertyTypesVariant& v, FeatureObject* objectToInvoke, ViewportId id )
            {
                assert( std::holds_alternative<T>( v ) );
                if ( std::holds_alternative<T>( v ) )
                {
                    std::invoke( m_setter, dynamic_cast< C* > ( objectToInvoke ), std::get<T>( v ), id );
                }
            };
        }
        else
        {
            static_assert( dependent_false<T>, "Setter function signature unsupported" );
        }
    }
};
 
struct FeatureObjectProjectPointResult {
    Vector3f point;
    std::optional<Vector3f> normal;
};
 
enum class MRMESH_CLASS FeatureVisualizePropertyType
{
    Subfeatures,
    DetailsOnNameTag, 
    _count [[maybe_unused]],
};
template <> struct IsVisualizeMaskEnum<FeatureVisualizePropertyType> : std::true_type {};
 
class MRMESH_CLASS FeatureObject : public VisualObject
{
public:
    constexpr static const char* StaticTypeName() noexcept { return "FeatureObject"; }
    virtual const char* typeName() const override { return StaticTypeName(); }
 
    constexpr static const char* StaticClassName() noexcept { return "Feature"; }
    virtual std::string className() const override { return StaticClassName(); }
 
    constexpr static const char* StaticClassNameInPlural() noexcept { return "Features"; }
    virtual std::string classNameInPlural() const override { return StaticClassNameInPlural(); }
 
    virtual const std::vector<FeatureObjectSharedProperty>& getAllSharedProperties() const = 0;
 
    [[nodiscard]] MRMESH_API bool supportsVisualizeProperty( AnyVisualizeMaskEnum type ) const override;
    MRMESH_API AllVisualizeProperties getAllVisualizeProperties() const override;
    MRMESH_API const ViewportMask& getVisualizePropertyMask( AnyVisualizeMaskEnum type ) const override;
 
    MRMESH_API void serializeFields_( Json::Value& root ) const override;
    MRMESH_API void deserializeFields_( const Json::Value& root ) override;
 
 
    [[nodiscard]] virtual FeatureObjectProjectPointResult projectPoint( const Vector3f& point, ViewportId id = {} ) const = 0;
    [[nodiscard]] MRMESH_API std::optional<Vector3f> getNormal( const Vector3f& point ) const;
 
    MRMESH_API void setXf( const AffineXf3f& xf, ViewportId id = {} ) override;
    MRMESH_API void resetXf( ViewportId id = {} ) override;
 
    [[nodiscard]] MRMESH_API virtual Vector3f getBasePoint( ViewportId id = {} ) const;
 
    [[nodiscard]] Matrix3f getRotationMatrix( ViewportId id = {}, bool* isDef = nullptr ) const { return r_.get( id, isDef ); }
    [[nodiscard]] Matrix3f getScaleShearMatrix( ViewportId id = {}, bool* isDef = nullptr ) const { return s_.get( id, isDef ); }
 
    MRMESH_API const Color& getDecorationsColor( bool selected, ViewportId viewportId = {}, bool* isDef = nullptr ) const;
    MRMESH_API virtual void setDecorationsColor( const Color& color, bool selected, ViewportId viewportId = {} );
    MRMESH_API virtual const ViewportProperty<Color>& getDecorationsColorForAllViewports( bool selected ) const;
    MRMESH_API virtual void setDecorationsColorForAllViewports( ViewportProperty<Color> val, bool selected );
 
    [[nodiscard]] MRMESH_API virtual float getPointSize() const;
    [[nodiscard]] MRMESH_API virtual float getLineWidth() const;
    MRMESH_API virtual void setPointSize( float pointSize );
    MRMESH_API virtual void setLineWidth( float lineWidth );
 
    [[nodiscard]] MRMESH_API virtual float getSubfeaturePointSize() const;
    [[nodiscard]] MRMESH_API virtual float getSubfeatureLineWidth() const;
    MRMESH_API virtual void setSubfeaturePointSize( float pointSize );
    MRMESH_API virtual void setSubfeatureLineWidth( float lineWidth );
 
    [[nodiscard]] MRMESH_API virtual float getMainFeatureAlpha() const;
    [[nodiscard]] MRMESH_API virtual float getSubfeatureAlphaPoints() const;
    [[nodiscard]] MRMESH_API virtual float getSubfeatureAlphaLines() const;
    [[nodiscard]] MRMESH_API virtual float getSubfeatureAlphaMesh() const;
    MRMESH_API virtual void setMainFeatureAlpha( float alpha );
    MRMESH_API virtual void setSubfeatureAlphaPoints( float alpha );
    MRMESH_API virtual void setSubfeatureAlphaLines( float alpha );
    MRMESH_API virtual void setSubfeatureAlphaMesh( float alpha );
 
protected:
    MRMESH_API FeatureObject( int numDimensions );
 
    MRMESH_API void setAllVisualizeProperties_( const AllVisualizeProperties& properties, std::size_t& pos ) override;
 
    ViewportMask subfeatureVisibility_ = ViewportMask::all();
    ViewportMask detailsOnNameTag_ = ViewportMask::all();
 
    ViewportProperty<Matrix3f> r_; 
    ViewportProperty<Matrix3f> s_; 
 
    std::array<ViewportProperty<Color>, 2> decorationsColor_;
 
 
    float pointSize_ = 10;
    float lineWidth_ = 2;
 
    float subPointSize_ = 6;
    float subLineWidth_ = 1;
 
    float mainFeatureAlpha_ = 1;
    float subAlphaPoints_ = 1;
    float subAlphaLines_ = 1;
    float subAlphaMesh_ = 0.5f;
};
 
}