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 <memcore/Persistencer.hpp>
//#include <memcore/AlzheimerCreator.hpp>

//#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();
        } 

        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  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() ); 

        bool    operator=(const WeakPtr<Grid>&G); 

        LineSet&operator=(const LineSet&LS);

        ~LineSet(); 

        operator bool() const
        {
                return LineIndices;
        } 

        bool operator!() const
        {
                return !LineIndices;
        } 


        RefPtr<CoordsArray_t> getCoords( const RefPtr<FragmentID>& f = NullPtr() ) const
        {
                if (!Coords)
                {
                        puts("LineSet::getCoords() No Coords");
                        return NullPtr();
                }
                return Coords->getData( f );
        } 
        
        RefPtr<MemCore::ChunkBase> getCoordsAsMemChunk() const
        {
                if (!Coords)
                        return NullPtr();

                return (Coords->getData())->getChunk();
        } 

        RefPtr<MemCore::ChunkBase> getTangentsAsMemChunk() const
        {
                if (!TangentialVectors)
                        return NullPtr();

                return (TangentialVectors->getData())->getChunk();
        } 
        
        RefPtr<LinesetArray_t>  getLineset( const RefPtr<FragmentID>& f = NullPtr() ) const
        {
#ifdef VERBOSE
                puts("LineSet::getLineset() enter"); 
                if(!f) puts("LineSet::getLineset() no fragment!");
#endif 
                if (!LineIndices)
                {
                        puts("LineSet::getLineset() No LineIndices");
                        return NullPtr();
                } 
                
                return LineIndices->getData( f );
        } 

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

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

        template <class Iterator>
        void    IterateLineSetFragment(Iterator&IC, const RefPtr<FragmentID>& f) const // would add lineset
        {
#ifdef VERBOSE
                puts("LineSet::IterateLineSetFragment() >>>> enter");fflush(stdout); 
                if(!f) puts("LineSet::IterateLineSetFragment() no fragment!");
#endif  

                RefPtr<LinesetArray_t> tmpLineSet = getLineset( f ); 

//              tmpLineSet.speak();

                if ( !tmpLineSet  )  // here hauts ihn
                {
                        puts("LineSet::IterateLineSetFragment() No LineSet!");fflush(stdout); 
                        if(f)
                                std::cout << "          in " << f->Name() << std::endl;
                        return;
                } 
        LinesetArray_t&LinesetArray = *tmpLineSet; 

                if (!getCoords( f ) ) 
                {               
                        puts("LineSet""IterateLineSetFragment() No Coords?!");fflush(stdout);
                        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>
        void Iterate(Iterator&IC)
        {
#ifdef VERBOSE
                puts("LineSet::Iterate() enter");
#endif
/*
                if(!LineIndices)
                      return; 
                
*/
                return;
                // iterate over line indizes
        } 

        template <class Iterator>
        void    ApplyOnVertexFragment(Iterator&IC, const RefPtr<FragmentID>& f = NullPtr() ) const // would add lineset
        {
                puts("LineSet::IterateVertexFragment() >>>> enter <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");

                // check for compatible line fragments here

                // call from operator  
                IterateLineSetFragment(IC, f);
        }

        struct  gridtypes_API CurveIterator
        {
                virtual ~CurveIterator();

                virtual void apply(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                                   const LineIndices_t&Line) = 0;
        };

        void    IterateCurves(CurveIterator&IC) const;


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


class   gridtypes_API   LineSetWithEdges : public LineSet, public Edges
{
public:
        LineSetWithEdges(const WeakPtr<Grid>&G = NullPtr() );
        ~LineSetWithEdges();
};

} // namespace Fiber

#endif // __FIBER_GRID_TYPES_LINESET_HPP