MRPolyline.h

Go to the documentation of this file.

#pragma once
 
#include "MRPolylineTopology.h"
#include "MRSharedThreadSafeOwner.h"
#include "MRPlane3.h"
#include "MRLineSegm.h"
#include "MREdgePoint.h"
 
namespace MR
{


template<typename V>
struct Polyline
{
public:
    PolylineTopology topology;
    Vector<V, VertId> points;
 
    Polyline() = default;

    MRMESH_API Polyline( const Contour<V>& contour );

    MRMESH_API Polyline( const Contours<V>& contours );

    MRMESH_API Polyline( const std::vector<VertId> & comp2firstVert, Vector<V, VertId> ps );

    MRMESH_API EdgeId addFromPoints( const V * vs, size_t num, bool closed );

    MRMESH_API EdgeId addFromPoints( const V * vs, size_t num );

    MRMESH_API void addPart( const Polyline<V>& from,
        VertMap * outVmap = nullptr, WholeEdgeMap * outEmap = nullptr );

    MRMESH_API void addPartByMask( const Polyline<V>& from, const UndirectedEdgeBitSet& mask,
        VertMap* outVmap = nullptr, EdgeMap* outEmap = nullptr );

    MRMESH_API void pack( VertMap * outVmap = nullptr, WholeEdgeMap * outEmap = nullptr );

    [[nodiscard]] V orgPnt( EdgeId e ) const { return points[ topology.org( e ) ]; }

    [[nodiscard]] V destPnt( EdgeId e ) const { return points[ topology.dest( e ) ]; }

    [[nodiscard]] V edgePoint( EdgeId e, float f ) const { return f * destPnt( e ) + ( 1 - f ) * orgPnt( e ); }

    [[nodiscard]] V edgePoint( const EdgePoint & ep ) const { return edgePoint( ep.e, ep.a ); }

    [[nodiscard]] V edgeCenter( EdgeId e ) const { return edgePoint( e, 0.5f ); }

    [[nodiscard]] V edgeVector( EdgeId e ) const { return destPnt( e ) - orgPnt( e ); }

    [[nodiscard]] LineSegm<V> edgeSegment( EdgeId e ) const { return LineSegm<V>( orgPnt( e ), destPnt( e ) ); }

    [[nodiscard]] EdgePoint toEdgePoint( VertId v ) const { return EdgePoint( topology, v ); }

    [[nodiscard]] MRMESH_API EdgePoint toEdgePoint( EdgeId e, const V & p ) const;

    [[nodiscard]] float edgeLength( EdgeId e ) const { return edgeVector( e ).length(); }

    [[nodiscard]] float edgeLengthSq( EdgeId e ) const { return edgeVector( e ).lengthSq(); }

    [[nodiscard]] MRMESH_API Vector3f loopDirArea( EdgeId e ) const;

    [[nodiscard]] MRMESH_API float totalLength() const;

    [[nodiscard]] float averageEdgeLength() const { auto n = topology.computeNotLoneUndirectedEdges(); return n ? totalLength() / n : 0.0f; }

    MRMESH_API const AABBTreePolyline<V>& getAABBTree() const;

    [[nodiscard]] const AABBTreePolyline<V> * getAABBTreeNotCreate() const { return AABBTreeOwner_.get(); }

    [[nodiscard]] MRMESH_API Box<V> getBoundingBox() const;

    [[nodiscard]] MRMESH_API Box<V> computeBoundingBox( const AffineXf<V> * toWorld = nullptr ) const;

    [[nodiscard]] MRMESH_API V findCenterFromPoints() const;

    MRMESH_API void transform( const AffineXf<V> & xf );

    MRMESH_API EdgeId splitEdge( EdgeId e, const V & newVertPos );

    EdgeId splitEdge( EdgeId e ) { return splitEdge( e, edgeCenter( e ) ); }

    void invalidateCaches() { AABBTreeOwner_.reset(); };

    [[nodiscard]] MRMESH_API Contours<V> contours( std::vector<std::vector<VertId>>* vertMap = nullptr ) const;

    template<typename U>
    [[nodiscard]] Polyline<U> toPolyline() const;

    MRMESH_API EdgeId addFromEdgePath( const Mesh& mesh, const EdgePath& path );

    EdgeId addFromSurfacePath( const Mesh& mesh, const SurfacePath& path ) { return addFromGeneralSurfacePath( mesh, {}, path, {} ); }

    MRMESH_API EdgeId addFromGeneralSurfacePath( const Mesh& mesh, const MeshTriPoint & start, const SurfacePath& path, const MeshTriPoint & end );

    [[nodiscard]] MRMESH_API size_t heapBytes() const;
    template <class Q = V>
    [[nodiscard]] typename std::enable_if_t< std::is_same_v<Q, Vector3f> > mirror( const Plane3f& plane )
    {
        for ( auto& p : points )
        {
            p += 2.0f * ( plane.project( p ) - p );
        }
 
        invalidateCaches();
    }
 
private:
    mutable SharedThreadSafeOwner<AABBTreePolyline<V>> AABBTreeOwner_;
};
 
template<typename V>
template<typename U>
Polyline<U> Polyline<V>::toPolyline() const
{
    Polyline<U> res;
    res.topology = topology;
    res.points.reserve( points.size() );
    for ( size_t i = 0; i < points.size(); i++ )
    {
        res.points.push_back( U{ points[VertId( i )] } );
    }
    return res;
}
 
}