LineSet.hpp

#ifndef __FIBER_GRID_TYPES_LINESET_HPP
#define __FIBER_GRID_TYPES_LINESET_HPP
 
#include "gridtypesDllApi.h"
#include <grid/Grid.hpp>
#include <eagle/PhysicalSpace.hpp>
#include "Edges.hpp"
 
#include <functional>
 
//#define VERBOSE
 
namespace Fiber
{
 
class   gridtypes_API   LineSet
{
public:
        typedef TypedArray<Eagle::PhysicalSpace::point>  CoordsArray_t;
        typedef MemArray<1, Eagle::PhysicalSpace::point> CoordsMemArray_t;
 
        typedef uint32_t LineIndex_t;
 
        typedef std::vector<LineSet::LineIndex_t> LineIndices_t;
 
        typedef MemArray<1, LineIndices_t>      LinesetArray_t;
 
        typedef MemArray<1, Eagle::tvector3>    TangentialVector_t;
 
 
 
static  SkeletonID PerLineSkeletonID()
        {
                return SkeletonID(1,2);
        }
 
static  SkeletonID ID()
        {
                return PerLineSkeletonID();
        }
 
static SkeletonID IDFragmented()
        {
                return SkeletonID(3,0);
        }
 
        RefPtr<Skeleton> Vertices,
                         Lineset;
 
        RefPtr<Representation>  CartesianVertices,
                                LinesAsVertices;
 
        RefPtr<Field>
                Coords,
                TangentialVectors,
                LineIndices;
 
 
 
static const char TangentialVectorFieldName[];
 
static const char NormalVectorFieldName[];
 
static  const char ArcLengthFieldName[];
 
        struct  gridtypes_API PredefinedFieldNames
        {
        static  const char
 
                ProperTime[],
 
                StepSize[],
 
                Velocity[],
 
                Speed[],
 
                Energy[],
 
                Curvature[],
 
                Torsion[];
        };
 
        PredefinedFieldNames    FieldNames;
 
 
 
        LineSet(const WeakPtr<Grid>&G = NullPtr() );
 
        LineSet(const RefPtr<Grid>&G,
                const RefPtr<CoordsArray_t>&Coords,
                const RefPtr<LinesetArray_t>&Lineset,
                const RefPtr<TangentialVector_t>&Tangents = NullPtr() );
 
        /*
          Alternative constructor to create a LineSet from a reference
          to a Grid object. Be cautious that when using the [] operator
          then an existing Grid will be reused from a Bundle and modified
          here. Using the newGrid() function is safer, but this function is
          convenient when operating in situation where it is ensured that
          the respective Grid does not exist or modifying it is not harmful.
          @code
              BundlePtr B;
              LineSet theLines(B[0.]["LineSet"], CoordsArray, LinesetArray );
           @endcode
         */
        LineSet(Grid&G,
                const RefPtr<CoordsArray_t>&Coords,
                const RefPtr<LinesetArray_t>&Lineset,
                const RefPtr<TangentialVector_t>&Tangents = NullPtr() )
        : LineSet(G.self(), Coords, Lineset, Tangents )
        {}
 
        bool    operator=(const WeakPtr<Grid>&G);
 
        LineSet&operator=(const LineSet&LS);
 
        ~LineSet();
 
        operator bool() const
        {
                return LineIndices.valid();
        }
 
        bool operator!() const
        {
                return !LineIndices;
        }
 
 
        RefPtr<CoordsArray_t> getCoords( const RefPtr<FragmentID>& f = NullPtr() ) const
        {
                if (!Coords)
                {
                        return NullPtr();
                }
                return Coords->getData( f );
        }
 
        RefPtr<MemCore::ChunkBase> getCoordsAsMemChunk() const
        {
                if (!Coords)
                        return NullPtr();
 
                return -(Coords->getData());
        }
 
        RefPtr<MemCore::ChunkBase> getTangentsAsMemChunk() const
        {
                if (!TangentialVectors)
                        return NullPtr();
 
                return -(TangentialVectors->getData());
        }
 
        RefPtr<LinesetArray_t>  getLineset( const RefPtr<FragmentID>& f = NullPtr() ) const
        {
                if (!LineIndices)
                {
                        Verbose(0) << "LineSet::getLineset() No LineIndices";
                        return NullPtr();
                }
 
                return LineIndices->getData( f );
        }
 
 
        template<int N, class T>
        RefPtr<Fiber::MemBase> extractDataFromField(const std::string& fieldname,
                                                    RefPtr<FragmentID> fragID = NullPtr())
        {
        RefPtr<Fiber::Field> f = (*LinesAsVertices)(fieldname);
                if(!f)
                {
                        f = (*CartesianVertices)(fieldname);
                        if (!f)
                        {
                                Verbose(0) << fieldname << ": NullPtr() in LineSet::extractDataFromField [f]";
                                return NullPtr();
                        }
                }
 
        RefPtr<Fiber::MemArray<N,T> > mem = f->getData(fragID);
                if (!mem)
                {
                        Verbose(0) << fieldname << ": NullPtr() in LineSet::extractDataFromField [mem]";
                        return NullPtr();
                }
 
                return mem;
        }
 
 
        index_t NumberOfLines(const RefPtr<FragmentID>&f ) const;
 
        index_t NumberOfLines() const;
 
        struct  NumberOfLinesIterator : FieldFragmentIterator
        {
                const LineSet& myLineSet;
                index_t numberOfLines;
 
                NumberOfLinesIterator( const LineSet& myLineSetP )
                :myLineSet(myLineSetP)
                , numberOfLines(0)
                        {}
 
                bool apply( const RefPtr<FragmentID>&f,
                            const MemCore::StrongPtr<Fiber::CreativeArrayBase>&DC )
                {
                        numberOfLines += myLineSet.NumberOfLines( f );
                        return true;
                }
        };
 
 
        /* Iterators */
 
        using CoordinateFragmentIterator =
                std::function<bool(const RefPtr<CoordsArray_t>&,
                                   const RefPtr<LinesetArray_t>&, const RefPtr<FragmentID>&LineFragmentID)>;
 
        using CoordinateFragmentIteratorWithVertexID =
                std::function<bool(const RefPtr<CoordsArray_t>&, const RefPtr<FragmentID>&VertexFragmentID,
                                   const RefPtr<LinesetArray_t>&, const RefPtr<FragmentID>&LineFragmentID)>;
 
        void    iterateCompatibleFragmentation(const CoordinateFragmentIterator&);
        void    iterateCompatibleFragmentation(const CoordinateFragmentIteratorWithVertexID&);
 
 
        using LineVertexIterator = std::function<bool(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                                                      const RefPtr<FragmentID>&VertexFragmentID,
                                                      const LineIndices_t&Line, const RefPtr<FragmentID>&LineFragmentID)>;
 
        void    iterateCompatibleFragmentation(const LineVertexIterator&);
 
 
 
 
 
 
 
 
        template<class T> struct FunctorPerFrag
        {
                bool exec( LineSet& myLineSet, const RefPtr<FragmentID>&f, const MemCore::StrongPtr<Fiber::CreativeArrayBase>&DC  )
                        {
                                return true;
                        }
        };
 
        template<class T>
                struct FunctorFragmentIterator : FieldFragmentIterator
        {
                LineSet& myLineSet;
                FunctorPerFrag<T>& Func;
 
                FunctorFragmentIterator( LineSet& myLineSetP, FunctorPerFrag<T>& FuncP  )
                : myLineSet(myLineSetP)
                , Func(FuncP)
                        {}
 
                bool apply( const RefPtr<FragmentID>&f,
                            const MemCore::StrongPtr<Fiber::CreativeArrayBase>&DC )
                        {
                                return Func.exec( myLineSet, f, DC);
                        }
        };
 
 
 
        struct TComputeTVectorDerivative{};
        struct TComputeScalarDerivative{};
        struct TComputeUnitTVectorDerivative{};
 
#ifdef  USE_DEPRECATED_LINESET_FUNCTIONS
 
        template <class Iterator>
        void    IterateLineSetFragment(Iterator&IC, const RefPtr<FragmentID>& f) const // would add lineset
        {
        RefPtr<LinesetArray_t> tmpLineSet = getLineset( f );
 
                if ( !tmpLineSet  )  // here hauts ihn
                {
                        return;
                }
 
        LinesetArray_t&LinesetArray = *tmpLineSet;
 
                if (!getCoords( f ) )
                {
                        Verbose(0) << "LineSet::IterateLineSetFragment() No Coords?!";
                        return;
                }
                // check
        CoordsArray_t&VertexArray   = *getCoords( f );
 
        const CreativeIterator<Eagle::PhysicalSpace::point>*V = VertexArray.creativeIterator();
        const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices = *V;
 
//      MemBase::Creator_t Crec;
//      RefPtr<MemArray<1, Eagle::tvector3> > TVecs = new MemArray<1, Eagle::tvector3>(V->count(), Crec );
 
                for(index_t line = 0; line < LinesetArray.count(); line++)
                {
                const LineIndices_t&Line = LinesetArray[ line ];
                        IC.apply(Vertices, Line);
                }
        }
 
        template<class Iterator>
        [[deprecated("Use iterateCompatibleFragmentation() instead.")]]
        void    Iterate(Iterator&IC) const
        {
/*
                if(!LineIndices)
                      return;
 
*/
                // do an iterations over vertexfragments here instead of just calling for one, MR
                ApplyOnVertexFragment(IC, NullPtr() );
 
                return;
                // iterate over line indizes
        }
 
        template <class Iterator>
        void    ApplyOnVertexFragment(Iterator&IC, const RefPtr<FragmentID>& f = NullPtr() ) const // would add lineset
        {
                // check for compatible line fragments here
                // call from operator
                IterateLineSetFragment(IC, f);
        }
 
        struct  [[deprecated("Use iterateCompatibleFragmentation() instead.")]] CurveIterator;
 
        struct  gridtypes_API CurveIterator
        {
                virtual ~CurveIterator();
 
                virtual void apply(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                                   const LineIndices_t&Line) = 0;
        };
 
        [[deprecated("Use iterateCompatibleFragmentation() instead.")]]
        void    IterateCurves(CurveIterator&IC) const;
 
#endif  // USE_DEPRECATED_LINESET_FUNCTIONS
 
 
static  void    ComputeCurveTangents(
                MultiArray<1, Eagle::tvector3>&Tangents,
                const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                const LineIndices_t&Line);
 
static RefPtr<TangentialVector_t>
        ComputeTangentialVectors(const CoordsArray_t&Vertices,
                                 const LinesetArray_t&LinesetArray);
 
 
        RefPtr<TangentialVector_t>
                getTangentialVectors(const RefPtr<FragmentID>&f = NullPtr(), const string&FieldName = TangentialVectorFieldName);
 
        RefPtr<TangentialVector_t>
                getNormalVectors(const string&FieldName = NormalVectorFieldName);
 
static RefPtr<TangentialVector_t>
        ComputeArcLength(const CoordsArray_t&Vertices,
                         const LinesetArray_t&LinesetArray);
 
        RefPtr<FieldID> ComputeTVectorDerivative    (const RefPtr<Grid>&theGrid, const string&F, const string&dF = "");
        RefPtr<FieldID> ComputeScalarDerivative     (const RefPtr<Grid>&theGrid, const string&F, const string&dF = "");
        RefPtr<FieldID> ComputeUnitTVectorDerivative(const RefPtr<Grid>&theGrid, const string&F, const string&dF = "");
 
 
 
struct  SetupStandardFieldIterator : FieldFragmentIterator
{
        LineSet& myLineSet;
 
        const RefPtr<Grid>&theGrid;
 
        SetupStandardFieldIterator( LineSet& myLineSetP, const RefPtr<Grid>&theGridP )
        :myLineSet(myLineSetP)
        , theGrid(theGridP)
        {}
 
        bool apply( const RefPtr<FragmentID>&f,
                    const MemCore::StrongPtr<Fiber::CreativeArrayBase>&DC );
 
};
 
 
        bool    setupStandardFields(const RefPtr<Grid>&theGrid);
 
        RefPtr<Field> getFieldOnLines(const string& field_name ) const;
 
static  uint32_t getNumberOfDistinctIndices( const LineSet::LinesetArray_t& lines );
 
 
        LineSet orient(bool CounterClockWise);
 
 
        /* convert fragmented line set to unfragmented */
static  std::string unfragment(const Grid&GridIn, Grid&GridOut);
 
 
};
 
 
class   gridtypes_API   LineSetWithEdges : public LineSet, public Edges
{
public:
        LineSetWithEdges(const WeakPtr<Grid>&G = NullPtr() );
        ~LineSetWithEdges();
};
 
} // namespace Fiber
 
#endif // __FIBER_GRID_TYPES_LINESET_HPP