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