MRFeatures.h

Go to the documentation of this file.

#pragma once
 
#include "MRMesh/MRAffineXf.h"
#include "MRMesh/MRCone3.h"
#include "MRMesh/MRCylinder3.h"
#include "MRMesh/MRPlane3.h"
#include "MRMesh/MRSphere.h"
#include "MRMesh/MRVector3.h"
 
#include <cassert>
#include <optional>
#include <variant>
 
namespace MR
{
 
class FeatureObject;
}
 
namespace MR::Features
{
 
namespace Primitives
{
    struct Plane;
    struct ConeSegment;


    using Sphere = Sphere3<float>;
 
    struct Plane
    {
        Vector3f center;

        Vector3f normal = Vector3f( 1, 0, 0 );

        [[nodiscard]] MRMESH_API ConeSegment intersectWithPlane( const Plane& other ) const;

        [[nodiscard]] MRMESH_API Sphere intersectWithLine( const ConeSegment& line ) const;
 
        friend bool operator==( const Plane&, const Plane& ) = default;
    };

    struct ConeSegment
    {

        Vector3f referencePoint;
        Vector3f dir;

        float positiveSideRadius = 0;
        float negativeSideRadius = 0;

        float positiveLength = 0;
        float negativeLength = 0;

        bool hollow = false;
 
        friend bool operator==( const ConeSegment&, const ConeSegment& ) = default;
 
        [[nodiscard]] bool isZeroRadius() const { return positiveSideRadius == 0 && negativeSideRadius == 0; }
        [[nodiscard]] bool isCircle() const { return positiveLength == -negativeLength && std::isfinite( positiveLength ); }

        [[nodiscard]] float length() const { return positiveLength + negativeLength; }

        [[nodiscard]] MRMESH_API Sphere centerPoint() const;

        [[nodiscard]] MRMESH_API ConeSegment extendToInfinity( bool negative ) const;
        [[nodiscard]] MRMESH_API ConeSegment extendToInfinity() const;

        [[nodiscard]] MRMESH_API ConeSegment untruncateCone() const;

        [[nodiscard]] MRMESH_API ConeSegment axis() const;

        [[nodiscard]] MRMESH_API Sphere basePoint( bool negative ) const;
        [[nodiscard]] MRMESH_API Plane basePlane( bool negative ) const;
        [[nodiscard]] MRMESH_API ConeSegment baseCircle( bool negative ) const;
    };
 
    using Variant = std::variant<Sphere, ConeSegment, Plane>;
}

 
[[nodiscard]] inline Primitives::Sphere toPrimitive( const Vector3f& point ) { return { point, 0 }; }
[[nodiscard]] inline Primitives::Sphere toPrimitive( const Sphere3f& sphere ) { return sphere; }
 
[[nodiscard]] MRMESH_API Primitives::ConeSegment toPrimitive( const Line3f& line );
[[nodiscard]] MRMESH_API Primitives::ConeSegment toPrimitive( const LineSegm3f& segm );
 
[[nodiscard]] inline Primitives::ConeSegment toPrimitive( const Cylinder3f& cyl )
{
    float halfLen = cyl.length / 2;
    return{
        .referencePoint = cyl.center(),
        .dir = cyl.direction().normalized(),
        .positiveSideRadius = cyl.radius, .negativeSideRadius = cyl.radius,
        .positiveLength = halfLen, .negativeLength = halfLen,
    };
}
[[nodiscard]] inline Primitives::ConeSegment toPrimitive( const Cone3f& cone )
{
    return{
        .referencePoint = cone.center(),
        .dir = cone.direction().normalized(),
        .positiveSideRadius = std::tan( cone.angle ) * cone.height, .negativeSideRadius = 0,
        .positiveLength = cone.height, .negativeLength = 0,
    };
}

[[nodiscard]] MRMESH_API Primitives::ConeSegment primitiveCircle( const Vector3f& point, const Vector3f& normal, float rad );
[[nodiscard]] MRMESH_API Primitives::ConeSegment primitiveCylinder( const Vector3f& a, const Vector3f& b, float rad );
[[nodiscard]] MRMESH_API Primitives::ConeSegment primitiveCone( const Vector3f& a, const Vector3f& b, float rad );

[[nodiscard]] MRMESH_API std::optional<Primitives::Variant> primitiveFromObject( const Object& object );
[[nodiscard]] MRMESH_API std::optional<Primitives::Variant> primitiveFromObjectWithWorldXf( const Object& object );
[[nodiscard]] MRMESH_API std::shared_ptr<FeatureObject> primitiveToObject( const Primitives::Variant& primitive, float infiniteExtent );

[[nodiscard]] MRMESH_API Primitives::Sphere      transformPrimitive( const AffineXf3f& xf, const Primitives::Sphere&      primitive );
[[nodiscard]] MRMESH_API Primitives::Plane       transformPrimitive( const AffineXf3f& xf, const Primitives::Plane&       primitive );
[[nodiscard]] MRMESH_API Primitives::ConeSegment transformPrimitive( const AffineXf3f& xf, const Primitives::ConeSegment& primitive );
[[nodiscard]] MRMESH_API Primitives::Variant     transformPrimitive( const AffineXf3f& xf, const Primitives::Variant&     primitive );

struct MeasureResult
{
    enum class Status
    {
        ok = 0,
        notImplemented,
        badFeaturePair,
        badRelativeLocation,
        notFinite,
    };
 
    struct BasicPart
    {
        Status status = Status::notImplemented;
        [[nodiscard]] operator bool() const { return status == Status::ok; }
    };
 
    struct Distance : BasicPart
    {
        float distance = 0;
 
        Vector3f closestPointA;
        Vector3f closestPointB;
 
        [[nodiscard]] Vector3f closestPointFor( bool b ) const { return b ? closestPointB : closestPointA; }
 
        [[nodiscard]] float distanceAlongAxis( int i ) const { return distanceAlongAxisAbs( i ) * ( distance < 0 ? -1 : 1 ); }
        [[nodiscard]] float distanceAlongAxisAbs( int i ) const { return std::abs( closestPointA[i] - closestPointB[i] ); }
    };

    Distance distance;

    Distance centerDistance;
 
    struct Angle : BasicPart
    {
        Vector3f pointA;
        Vector3f pointB;
        [[nodiscard]] Vector3f pointFor( bool b ) const { return b ? pointB : pointA; }
 
        Vector3f dirA; 
        Vector3f dirB; 
        [[nodiscard]] Vector3f dirFor( bool b ) const { return b ? dirB : dirA; }

        bool isSurfaceNormalA = false;
        bool isSurfaceNormalB = false;
 
        [[nodiscard]] bool isSurfaceNormalFor( bool b ) const { return b ? isSurfaceNormalB : isSurfaceNormalA; }
 
        [[nodiscard]] MRMESH_API float computeAngleInRadians() const;
    };
    Angle angle;

    std::vector<Primitives::Variant> intersections;

    MRMESH_API void swapObjects();
};

[[nodiscard]] MRMESH_API std::string_view toString( MeasureResult::Status status );

namespace Traits
{
 
template <typename T>
struct Unary {};
template <>
struct Unary<Primitives::Sphere>
{
    MRMESH_API std::string name( const Primitives::Sphere& prim ) const;
};
template <>
struct Unary<Primitives::ConeSegment>
{
    MRMESH_API std::string name( const Primitives::ConeSegment& prim ) const;
};
template <>
struct Unary<Primitives::Plane>
{
    MRMESH_API std::string name( const Primitives::Plane& prim ) const;
};
 
template <typename A, typename B>
struct Binary {};

template <typename A, typename B>
concept MeasureSupportedOneWay = requires( const Binary<A, B>& t, const A& a, const B& b )
{
    { t.measure( a, b ) } -> std::same_as<MeasureResult>;
};

template <>
struct Binary<Primitives::Sphere, Primitives::Sphere>
{
    MRMESH_API MeasureResult measure( const Primitives::Sphere& a, const Primitives::Sphere& b ) const;
};
template <>
struct Binary<Primitives::ConeSegment, Primitives::Sphere>
{
    MRMESH_API MeasureResult measure( const Primitives::ConeSegment& a, const Primitives::Sphere& b ) const;
};
template <>
struct Binary<Primitives::Plane, Primitives::Sphere>
{
    MRMESH_API MeasureResult measure( const Primitives::Plane& a, const Primitives::Sphere& b ) const;
};

template <>
struct Binary<Primitives::ConeSegment, Primitives::ConeSegment>
{
    MRMESH_API MeasureResult measure( const Primitives::ConeSegment& a, const Primitives::ConeSegment& b ) const;
};
template <>
struct Binary<Primitives::Plane, Primitives::ConeSegment>
{
    MRMESH_API MeasureResult measure( const Primitives::Plane& a, const Primitives::ConeSegment& b ) const;
};

template <>
struct Binary<Primitives::Plane, Primitives::Plane>
{
    MRMESH_API MeasureResult measure( const Primitives::Plane& a, const Primitives::Plane& b ) const;
};
 
}

template <typename T>
[[nodiscard]] std::string name( const T& primitive )
{
    return Traits::Unary<T>{}.name( primitive );
}

[[nodiscard]] MRMESH_API std::string name( const Primitives::Variant& var );

template <typename A, typename B>
concept MeasureSupported = Traits::MeasureSupportedOneWay<A, B> || Traits::MeasureSupportedOneWay<B, A>;

template <typename A, typename B>
requires MeasureSupported<A, B>
[[nodiscard]] MeasureResult measure( const A& a, const B& b )
{
    if constexpr ( Traits::MeasureSupportedOneWay<A, B> )
    {
        MeasureResult ret = Traits::Binary<A, B>{}.measure( a, b );
 
        for ( auto* dist : { &ret.distance, &ret.centerDistance } )
        {
            if ( *dist && ( !std::isfinite( dist->distance ) || !dist->closestPointA.isFinite() || !dist->closestPointB.isFinite() ) )
                dist->status = MeasureResult::Status::badRelativeLocation;

            if ( *dist )
            {
                assert( [&]{
                    float a = ( dist->closestPointB - dist->closestPointA ).length();
                    float b = std::abs( dist->distance );
                    return std::abs( a - b ) <= std::max( std::min( a, b ), 0.01f ) * 0.001f;
                }() );
            }
        }

        if ( ret.angle && ( !ret.angle.pointA.isFinite() || !ret.angle.pointB.isFinite() || !ret.angle.dirA.isFinite() || !ret.angle.dirB.isFinite() ) )
            ret.angle.status = MeasureResult::Status::badRelativeLocation;

        assert( ret.angle <= ( std::abs( 1 - ret.angle.dirA.length() ) < 0.0001f ) );
        assert( ret.angle <= ( std::abs( 1 - ret.angle.dirB.length() ) < 0.0001f ) );
 
        return ret;
    }
    else
    {
        static_assert( Traits::MeasureSupportedOneWay<B, A>, "This should never fail." );
        MeasureResult ret = ( measure )( b, a );
        ret.swapObjects();
        return ret;
    }
}

template <typename B>
[[nodiscard]] MeasureResult measure( const Primitives::Variant& a, const B& b )
{
    return std::visit( [&]( const auto& elem ){ return (measure)( elem, b ); }, a );
}

template <typename A>
[[nodiscard]] MeasureResult measure( const A& a, const Primitives::Variant& b )
{
    return std::visit( [&]( const auto& elem ){ return (measure)( a, elem ); }, b );
}

[[nodiscard]] MRMESH_API MeasureResult measure( const Primitives::Variant& a, const Primitives::Variant& b );
 
}