PolylineSlicer.h

Go to the documentation of this file.

#pragma once
#include <NDEVR/RTree.h>
#include <NDEVR/Model.h>
namespace NDEVR
{
    class Model;
    class Geometry;
    class PolylineSliceIterator;
    class ProgressInfo;
    /**--------------------------------------------------------------------------------------------------
    \brief Arguments for performing a Geometry slice operation
    **/
    struct SlicerArgs
    {
        Model linework_root;
        Buffer<Model> models_to_slice; 
        PolylineSliceIterator* slicer = nullptr;
        ProgressInfo* log = nullptr;
        const void* lock = nullptr;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Represents a single plane to slice the data across
    **/
    struct SlicePlane
    {
        Buffer<Buffer<uint04>> segments;
        Buffer<Vertex<3, fltp04>> polyline_vertices;
        Dictionary<String, Buffer<fltp04>> properties;
        Plane<3, fltp08> plane;
        Vertex<3, fltp04> center_point = Constant<Vertex<3, fltp04>>::Invalid;
        String name;
        String group;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Arguments for performing a Geometry slice operation
    **/
    class PolylineSliceIterator
    {
    public:
        virtual Buffer<SlicePlane> slicePlanes(const Matrix<fltp08>& transform, const Bounds<3, fltp08>& bounds) = 0;
        virtual void cleanupSlicePlanes(const Matrix<fltp08>&, Buffer<SlicePlane>&) { /*Do nothing*/ };
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Slices object into evenly spaced cross sections
    **/
    class GriddedSliceIterator : public PolylineSliceIterator
    {
        Buffer<SlicePlane> slicePlanes(const Matrix<fltp08>& trans, const Bounds<3, fltp08>& bounds) override;
    public:
        Matrix<fltp08> transform = Matrix<fltp08>(1.0);
        Vector<3, fltp08> spacing = Constant<Vector<3, fltp08>>::Invalid;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Slices object evenly along a specified polyline
    **/
    class PathSliceIterator : public PolylineSliceIterator
    {
        Buffer<SlicePlane> slicePlanes(const Matrix<fltp08>& trans, const Bounds<3, fltp08>& bounds) override;
        void cleanupSlicePlanes(const Matrix<fltp08>&, Buffer<SlicePlane>&) override;
    protected:
        Polyline<3, fltp08> makeCenterlinePath(const Polyline<3, fltp08>& path);
    public:
        Matrix<fltp08> transform = Matrix<fltp08>(1.0);
        Polyline<3, fltp08> path;
        fltp08 spacing = Constant<fltp08>::Invalid;
        Vector<2, fltp08> max_hv_distance = Vector<2, fltp08>(10, 30);
        bool include_main_line = false;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Internal class for storing Polyline slice data
    **/
    struct PolylineSliceCache
    {
        Matrix<fltp08> slice_transform;
        Buffer<SlicePlane> planes;
        Buffer<Triangle<3, fltp08>> triangles;
        RTree<3, fltp08> tree;
        PolylineSliceIterator* slice_plane;
        Bounds<3, fltp08> bounds = Constant<Bounds<3, fltp08>>::Min;
        ProgressInfo* log;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Logic for slicing one or more Model/Geometry objects into polyline Model/Geometry objects based
        on set criteria
    **/
    class PolylineSlicer
    {
    public:
        static void CreateActiveLinework(SlicerArgs& args);
        static constexpr const char* SliceTypeName() { return "polyline_slice"; }
    protected:
        static void SliceIntoLineSegments(uint04 slice_index, PolylineSliceCache& args);
        static void PrepareCache(const Matrix<fltp08>& transform, const Geometry& geo, PolylineSliceCache& params);
        static void FinishSegmenting(const Matrix<fltp08>& transform, Model& model, uint04 slice_index, const PolylineSliceCache& params);
        static void AddVertices(Geometry& geo, const SlicePlane& plane, const Matrix<fltp08>& mat);
    };
}