MRPolyline.h

Go to the documentation of this file.

#pragma once
 
#include "MRPolylineTopology.h"
#include "MRUniqueThreadSafeOwner.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 Contours2f& contours );
 
    MRMESH_API Polyline( const Contours3f& 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 float totalLength() const;
 
    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;
 
    // computes average position of all valid polyline vertices
    [[nodiscard]] MRMESH_API V findCenterFromPoints() const;
 
    MRMESH_API void transform( const AffineXf<V> & xf );
 
    MRMESH_API EdgeId splitEdge( EdgeId e, const V & newVertPos );
 
    // same, but split given edge on two equal parts
    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;
 
    [[nodiscard]] MRMESH_API Contours2f contours2( 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 UniqueThreadSafeOwner<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;
}
 
} // namespace MR