TriangularSurface.hpp

#ifndef __FIBER_GRID_TYPES_TRIANGULARSURFACE_HPP
#define __FIBER_GRID_TYPES_TRIANGULARSURFACE_HPP

#include "gridtypesDllApi.h"
#include <grid/Grid.hpp>
#include <eagle/PhysicalSpace.hpp>
#include <field/Cell.hpp>
#include "Edges.hpp"


namespace Fiber
{

struct  gridtypes_API   TriangularSurface : RefPtr<Grid>
{
        typedef MemArray<1,Eagle::PhysicalSpace::point>         CoordsArray_t; 
        typedef MemArray<1, TriangleCell>                       CellArray_t; 
        typedef CellArray_t                                     ConnectivityArray_t; 

        typedef MemArray<1, Eagle::PhysicalSpace::bivector>     NormalVectorArray_t; 

        RefPtr<Field>           CoordField,

                                VertexNormalField,

                                CellField; 

        RefPtr<Representation>  CartesianVertices,
                                CellsAsVertices; 

        TriangularSurface(const RefPtr<Grid>& = NullPtr() );

        TriangularSurface&operator=(const RefPtr<Grid>&); 
//      TriangularSurface&operator=(const TriangularSurface&); 

        ~TriangularSurface();


static   Eagle::PhysicalSpace::bivector NormalVector(const TriangleCell&T, 
                                                     const MultiArray<1, Eagle::PhysicalSpace::point>&Vertices);

static  RefPtr<NormalVectorArray_t>
                computeVertexNormals(const RefPtr<CoordsArray_t>&Pts,
                                     const RefPtr<CellArray_t>  &Cells,
                                     const MemBase::Creator_t&Crec = NullPtr() );


static  SkeletonID ID()
        {
                return SkeletonID(2,1);
        } 

static  RefPtr<Skeleton> getFaceSkeleton(const RefPtr<Grid>&G, bool CreateIfNotFound);

static  const char NormalVectorFieldName[]; 

        RefPtr<Field>   getVertexNormalField(const string&FieldName = NormalVectorFieldName); 

        RefPtr<NormalVectorArray_t> getVertexNormals(const string&FieldName = NormalVectorFieldName)
        {
        RefPtr<Field>   F = getVertexNormalField(NormalVectorFieldName); 
                if (!F)
                        return NullPtr(); 

                return  F->getData();   
        }

        RefPtr<CoordsArray_t> getCoords() const
        {
                if (!CoordField)
                        return NullPtr();

                return CoordField->getData();
        }

        RefPtr<CellArray_t> getCells() const
        {
                if (!CellField)
                        return NullPtr();

                return CellField->getData();
        }

        RefPtr<CoordsArray_t> getNormals(const string&FieldName = NormalVectorFieldName)
        {
        RefPtr<Field>   N = getVertexNormalField( FieldName ); 
                if (!N)
                        return NullPtr(); 

                return N->getData();
        } 

        RefPtr<Field>   getTriangleBaryCenters();

static  RefPtr<CoordsArray_t>
                computeBaryCenters(const RefPtr<CoordsArray_t>&Pts,
                                   const RefPtr<CellArray_t>  &Cells,
                                   const MemBase::Creator_t&Crec = NullPtr() );

};

class   gridtypes_API   TriangularSurfaceWithEdges : public TriangularSurface, public Edges
{
public:
        typedef MemArray<1, TriangleCell> EdgesPerFaceArray_t;

        typedef MemArray<1, EdgeCell_t>   EdgesArray_t;

static  RefPtr<Representation>  getEdgesPerFace(const RefPtr<Grid>&, bool CreateIfNotFound); 

static  RefPtr<Representation>  getFacesPerEdge(const RefPtr<Grid>&G, bool CreateIfNotFound);

        TriangularSurfaceWithEdges(const RefPtr<Grid>& = NullPtr() ); 

        ~TriangularSurfaceWithEdges();
};


} // namespace Fiber

#endif // __FIBER_GRID_TYPES_TRIANGULARSURFACE_HPP