FragmentSkeleton.hpp

#ifndef __FRAGMENT_SKELETON_HPP
#define __FRAGMENT_SKELETON_HPP

#include <grid/Grid.hpp>
#include <grid/CartesianChart.hpp>
#include <eagle/PhysicalSpace.hpp>
#include <aerie/BoundingBox.hpp>

#include "gridopDllApi.h"

namespace Fiber
{

struct gridop_API FragmentSkeleton
{
        typedef MemArray<1, std::string>        FragmentNamesMemArray_t;
        typedef MultiArray<1, std::string>      FragmentNamesArray_t;

        struct  gridop_API exception : ::std::exception
        {
                const char*what() const throw()
                {       return "FragmentSkeleton Exception";            }
        };

        struct  gridop_API NoVertices : exception
        {
                const char*what() const throw()
                {       return "FragmentSkeleton: No Vertices in Grid object";          }
        };

static  const char*MinFieldName();
static  const char*MaxFieldName();

static  SkeletonID ID(int VertexDims)
        {
                return SkeletonID(VertexDims, 2);
        } 

static  SkeletonID ID(const Grid&G)
        {
        RefPtr<Skeleton> Vertices = G.findVertices(); 
                if (!Vertices)
                        throw NoVertices();

        int     VertexDims = Vertices->Dims();
                return SkeletonID(VertexDims, 2);
        }


static  RefPtr<Skeleton> getFragments(const Grid&G)
        {
        RefPtr<Skeleton> Vertices = G.findVertices(); 
                if (!Vertices)
                        return NullPtr();

        int     VertexDims = Vertices->Dims(); 
                return G( SkeletonID(VertexDims, 2) );
        }

static  Skeleton& makeFragments(Grid&G)
        {
                return G[ ID(G) ];
        }



static  RefPtr<Representation> getFragmentsAsVertices(const Grid&G)
        {
        RefPtr<Skeleton> Vertices = G.findVertices(); 
                if (!Vertices)  return NullPtr();

        RefPtr<Skeleton> Fragments = getFragments(G); 
                if (!Fragments) return NullPtr();

                return (*Fragments)( Vertices );
        }

static  Representation&makeFragmentsAsVertices(Grid&G)
        {
        RefPtr<Skeleton> Vertices = G.findVertices(); 
                if (!Vertices) throw NoVertices(); 

        Skeleton& Fragments = makeFragments(G);

                return Fragments[ Vertices ];
        }

static  RefPtr<Field> makeFragmentNames(Grid&G)
        {
                return makeFragmentsAsVertices(G)[ FIBER_POSITIONS ]; 
        }

static  Representation&makeFragmentCoordinates(Grid&G, const RefPtr<Chart>&C)
        {
        Skeleton& Fragments = makeFragments(G);
                return Fragments[ C ];
        }

static  RefPtr<Field> makeFragmentCoordinatesCenter(Grid&G, const RefPtr<Chart>&C)
        {
                return makeFragmentCoordinates(G, C)[ FIBER_POSITIONS ];
        }

static  RefPtr<Field> makeFragmentCoordinatesMin(Grid&G, const RefPtr<Chart>&C)
        {
                return makeFragmentCoordinates(G, C)[ MaxFieldName() ];
        }

static  RefPtr<Field> makeFragmentCoordinatesMax(Grid&G, const RefPtr<Chart>&C)
        {
                return makeFragmentCoordinates(G, C)[ MaxFieldName() ];
        }

        RefPtr<Grid>        TheGrid;

        FragmentSkeleton(const RefPtr<Grid>&g)
        : TheGrid(g)
        {} 

        Skeleton& makeFragments() 
        {
                assert(TheGrid);
                return makeFragments(*TheGrid);
        }

        RefPtr<Field>   makeFragmentNames() const
        {
                assert(TheGrid);
                return makeFragmentNames(*TheGrid);
        } 

        std::string     getFragmentName(index_t i) const
        {
        RefPtr<Field> F = makeFragmentNames(); 
                assert(F);
        RefPtr<FragmentNamesMemArray_t> A = F->getData(); 
                assert(A);
                return (*A)[ i ];
        }
};

template <class Coordinates = Eagle::PhysicalSpace::point>
struct  FragmentCoordinates : public FragmentSkeleton
{
        typedef MemArray<1, Coordinates>        PointMemArray_t;
        typedef MultiArray<1, Coordinates>      PointArray_t;

        FragmentCoordinates(const RefPtr<Grid>&g)
        : FragmentSkeleton(g)
        {}

};

typedef FragmentCoordinates<Eagle::PhysicalSpace::point> 
        CartesianFragmentCoordinates;

struct  gridop_API CartesianFragments : public CartesianFragmentCoordinates
{
        typedef CartesianFragmentCoordinates Base_t;

        typedef MemArray<1, RefPtr<Eagle::BoundingBox> >   BoundingBoxMemArray_t;
        typedef MultiArray<1, RefPtr<Eagle::BoundingBox> > BoundingBoxArray_t;

        CartesianFragments(const RefPtr<Grid>&g)
        : Base_t(g)
        {}

        bool    buildFragmentCoordinates();

        Representation&makeFragmentCoordinates()
        {
        RefPtr<Chart>  myCartesian = TheGrid->makeChart( typeid(Fiber::CartesianChart3D) ); 
                return Base_t::makeFragmentCoordinates(*TheGrid, myCartesian);
        }

        std::pair<RefPtr<Field>, RefPtr<Field> >
                makeFragmentCoordinatesMinMax()
        {
        Representation&R = makeFragmentCoordinates(); 

                return std::pair<RefPtr<Field>, RefPtr<Field> >(
                        R[ MinFieldName() ], R[ MaxFieldName() ]
                        );
        }

        RefPtr<Eagle::BoundingBox> getBBox(index_t FragmentID); 

        RefPtr<FragmentID> getFragmentID(index_t I) const
        {
                assert( TheGrid );
        RefPtr<Representation> CartesianRep = TheGrid->getCartesianRepresentation(); 
                assert( CartesianRep ); 
                assert( CartesianRep->getPositions() );
                return CartesianRep->getPositions()->getFragmentID( getFragmentName(I) );
        }
};

} // namespace Fiber


#endif //  __FRAGMENT_SKELETON_HPP