Function primitiveToObject

source/MRMesh/MRFeatures.cpp:230–343

}

std::shared_ptr<FeatureObject> primitiveToObject( const Primitives::Variant& primitive, float infiniteExtent )
{
    return std::visit( overloaded{
        []( const Primitives::Sphere& sphere ) -> std::shared_ptr<FeatureObject>
        {
            if ( sphere.radius == 0 )
            {
                auto newPoint = std::make_shared<PointObject>();
                newPoint->setLocalPoint( sphere.center );
                return newPoint;
            }
            else
            {
                auto newSphere = std::make_shared<SphereObject>();
                newSphere->setCenter( sphere.center );
                newSphere->setRadius( sphere.radius );
                return newSphere;
            }
        },
        [infiniteExtent]( const Primitives::Plane& plane ) -> std::shared_ptr<FeatureObject>
        {
            auto newPlane = std::make_shared<PlaneObject>();
            newPlane->setCenter( plane.center );
            newPlane->setNormal( plane.normal );
            newPlane->setSize( infiniteExtent );
            return newPlane;
        },
        [infiniteExtent]( const Primitives::ConeSegment& cone ) -> std::shared_ptr<FeatureObject>
        {
            if ( cone.isCircle() )
            {
                if ( cone.isZeroRadius() )
                    return primitiveToObject( cone.basePoint( false ), infiniteExtent ); // This isn't really valid, but let's support it.

                auto newCircle = std::make_shared<CircleObject>();
                newCircle->setCenter( cone.basePoint( false ).center );
                newCircle->setNormal( cone.dir );
                newCircle->setRadius( cone.positiveSideRadius );
                return newCircle;
            }

            bool posFinite = std::isfinite( cone.positiveLength );
            bool negFinite = std::isfinite( cone.negativeLength );

            if ( cone.isZeroRadius() )
            {
                auto newLine = std::make_shared<LineObject>();
                newLine->setDirection( cone.dir );

                if ( posFinite == negFinite )
                {
                    // Finite or fully infinite.
                    newLine->setCenter( cone.centerPoint().center );
                    newLine->setLength( posFinite ? cone.length() : infiniteExtent );
                }
                else
                {
                    // Half-infinite.