TriangularSurfaceWithEdges.hpp

#ifndef __FIBER_GRID_TYPES_TRIANGULARSURFACEWITHEDGES_HPP
#define __FIBER_GRID_TYPES_TRIANGULARSURFACEWITHEDGES_HPP
 
#include "gridtypesDllApi.h"
#include <grid/Grid.hpp>
#include <eagle/PhysicalSpace.hpp>
#include <field/Cell.hpp>
#include "Edges.hpp"
 
#include "LineSet.hpp"
#include "TriangularSurface.hpp"
 
namespace Fiber
{
 
class   gridtypes_API   TriangularSurfaceWithEdges : public TriangularSurface, public Edges
{
public:
        typedef MemArray<1, TriangleCell> EdgesPerFaceArray_t; 
 
        typedef MemArray<1, TriangleCell> EdgesPerTriangleArray_t;
 
        typedef MemArray<1, EdgeCell_t>   EdgesArray_t; 
        typedef MultiArray<1, EdgeCell_t> EdgesArray_m_t;
static  RefPtr<Representation>  getEdgesPerFace(const RefPtr<Grid>&, bool CreateIfNotFound); 
 
        RefPtr<Representation>  getEdgesPerFace(bool CreateIfNotFound) const
        {
                return getEdgesPerFace( *this, CreateIfNotFound);
        }
 
        RefPtr<EdgesPerFaceArray_t> getEdgesPerFaceArray() const
        {
                if (RefPtr<Representation> R = getEdgesPerFace(false) )
                {
                        if (RefPtr<Field> Pos = R->Positions())
                                return Pos->getData();
                } 
                return NullPtr();
        }
 
static  RefPtr<Representation>  getFacesPerEdge(const RefPtr<Grid>&G, bool CreateIfNotFound); 
 
static  RefPtr<TriangularSurfaceWithEdges::EdgesArray_t> getTrianglesPerEdgeArray(const RefPtr<Grid>&G, bool CreateIfNotFound) ;
 
static  RefPtr<MemArray<1,Edges::TriangleCell_t> > getTrianglesPerTriangleArray(const RefPtr<Grid>&G, bool CreateIfNotFound);
 
static  RefPtr<Representation>  getTrianglesPerEdge(const RefPtr<Grid>&G, bool CreateIfNotFound)
        {
                return getFacesPerEdge(G, CreateIfNotFound);
        } 
 
static  RefPtr<Edges::EdgesPerVertexMemArray_t>  getTrianglesPerVertexArray(const RefPtr<Grid>&G, bool CreateIfNotFound);
/*
        Adding 
*/
static bool addTrianglesPerEdgeArray(const RefPtr<Grid>&G, const RefPtr<EdgesArray_t>&Data);
 
static bool addTrianglesPerTriangleArray (const RefPtr<Grid>&G,  RefPtr<TriangularSurfaceWithEdges::CellArray_t>&Data);
 
static bool addEdgesPerFaceArray(const RefPtr<Grid>&G, const RefPtr<EdgesPerFaceArray_t>&Data); 
 
static bool addTrianglesPerVertexArray(const RefPtr<Grid>&G, const RefPtr<Edges::EdgesPerVertexMemArray_t>&Data);
 
static TriangularSurfaceWithEdges create(const TriangularSurface&T);
 
/* 
        Create edges per vertex
        @author doeby
*/
static RefPtr<Edges::EdgesPerVertexMemArray_t >
        createEdgesPerVertex(const TriangularSurfaceWithEdges&T, bool storeThem); 
 
static RefPtr<Edges::EdgesPerVertexMemArray_t > 
        createEdgesPerVertex(const TriangularSurface&T, bool storeThem);
 
/* 
        Create edges per vertex
        @author doeby
*/
static RefPtr<TriangularSurfaceWithEdges::EdgesArray_t>
        createTrianglesPerEdge(const TriangularSurfaceWithEdges&T, bool storeThem); 
 
static RefPtr<TriangularSurfaceWithEdges::EdgesArray_t> 
        createTrianglesPerEdge(const TriangularSurface&T, bool storeThem);
 
 
/* 
        Create triangles per triangle
        @author doeby
*/
 
static RefPtr<MemArray<1,Edges::TriangleCell_t> >
        createTrianglesPerTriangle(const TriangularSurfaceWithEdges&T,bool storeThem);
 
 
static RefPtr<MemArray<1,Edges::TriangleCell_t> >
        createTrianglesPerTriangle(const TriangularSurface&T,bool storeThem);
 
/*
        Create triangles per vertex
        @author doeby
*/
static RefPtr<Edges::EdgesPerVertexMemArray_t>
        createTrianglesPerVertex(const TriangularSurfaceWithEdges&T, bool storeThem); 
 
static RefPtr<Edges::EdgesPerVertexMemArray_t> 
        createTrianglesPerVertex(const TriangularSurface&T, 
                               bool storeThem);
 
 
        TriangularSurfaceWithEdges(const RefPtr<Grid>& = NullPtr() ); 
 
        ~TriangularSurfaceWithEdges(); 
 
        LineSet OutLines(const RefPtr<Grid>&OutputGrid);
 
/*
static  RefPtr<LineSet::LinesetArray_t>
                computeOutLines( const RefPtr<CoordsArray_t>&Pts,
                                 const RefPtr<CellArray_t>  &Cells,
                                 const MemBase::Creator_t&Crec = NullPtr() );
*/
};
 
 
} // namespace Fiber
 
#endif // __FIBER_GRID_TYPES_TRIANGULARSURFACE_HPP