PolylineSlicer.h

#pragma once
#include <NDEVR/Model.h>
#include <NDEVR/Translator.h>
#include <NDEVR/ProgressInfo.h>
#include <NDEVR/Plane.h>
#include <NDEVR/DesignObjectResourceCache.h>
#include <NDEVR/Polyline.h>
namespace NDEVR
{
    class Model;
    class Geometry;
    class PolylineSliceIterator;
    template<uint01 t_dims, class t_type> class RTree;

    struct SlicerArgs
    {
        Model linework_root;                                    
        Buffer<Model> models_to_slice;                          
        PolylineSliceIterator* slicer = nullptr;                
        LogPtr log = nullptr;                                   
        DesignObjectResourceCache resource_cache;               
        fltp08 point_distance = Constant<fltp08>::Invalid;      
        const void* lock = nullptr;                             
    };

    struct SlicePlane
    {
        Buffer<Buffer<uint04>> segments;                        
        Buffer<Vertex<3, fltp04>> polyline_vertices;            
        Buffer<Vertex<3, fltp04>> point_vertices;               
        Buffer<RGBColor> point_colors;                          
        Dictionary<String, Buffer<fltp04>> properties;          
        Plane<3, fltp08> plane;                                 
        Vertex<3, fltp04> center_point = Constant<Vertex<3, fltp04>>::Invalid; 
        TranslatedString name;                                  
        TranslatedString group;                                 
    };

    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*/ };
    };

    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; 
    };

    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 slice_vertical_orthogonal = false;                 
        bool slice_orthogonal = false;                          
        bool slice_vertical_parallel = false;                   
        bool slice_horizontal_parallel = false;                 
    };

    struct PolylineSliceCache
    {
        PolylineSliceCache(LogPtr pipe)
            : log(_t("Polyline Slice"), pipe)
        {}
        Matrix<fltp08> slice_transform;                         
        Buffer<SlicePlane> planes;                              
        Buffer<Triangle<3, fltp08>> triangles;                  
        Buffer<Vertex<3, fltp08>> points;                       
        Buffer<RGBColor> point_colors;                          
        RTree<3, fltp08>* point_tree = nullptr;                 
        RTree<3, fltp08>* tri_tree = nullptr;                   
        PolylineSliceIterator* slice_plane;                     
        DesignObjectResourceCache resource_cache;               
        Bounds<3, fltp08> bounds = Constant<Bounds<3, fltp08>>::Min; 
        mutable ProgressInfo log;                               
        NDEVR_DESIGN_API ~PolylineSliceCache();
    };

    class PolylineSlicer
    {
    public:
        static void CreateActiveLinework(SlicerArgs& args);

        static constexpr StringView SliceTypeName() { return "polyline_slice"; }
    protected:
        static void SliceIntoLineSegments(uint04 slice_index, PolylineSliceCache& args);

        static void SliceIntoNearPoints(uint04 slice_index, PolylineSliceCache& args, fltp08 point_distance);

        static void PrepareTriCache(const Matrix<fltp08>& transform, const Geometry& geo, PolylineSliceCache& params);

        static void PreparePointCache(const Matrix<fltp08>& transform, const Model& model, PolylineSliceCache& params);

        static void FinishSegmenting(const Matrix<fltp08>& transform, Model& model, uint04 slice_index, PolylineSliceCache& params);

        static void AddVertices(Geometry& geo, const SlicePlane& plane, const Matrix<fltp08>& mat);
    };
}