TriangularSurface.hpp

#ifndef __FIBER_GRID_TYPES_TRIANGULARSURFACE_HPP
#define __FIBER_GRID_TYPES_TRIANGULARSURFACE_HPP
 
#include "gridtypesDllApi.h"
#include "fish/fiber/grid/Grid.hpp"
#include "elementary/eagle/PhysicalSpace.hpp"
#include "fish/fiber/field/Cell.hpp"
#include "LineSet.hpp"
 
 
namespace Fiber
{
 
struct  gridtypes_API   TriangularSurface : RefPtr<Grid>
{
        typedef MemArray<1,Eagle::PhysicalSpace::point>         CoordsArray_t;
        typedef MultiArray<1,Eagle::PhysicalSpace::point>       CoordsArray_m_t;
 
        typedef MemArray<1, TriangleCell_t>                     CellArray_t;
        typedef MultiArray<1, TriangleCell>                     CellArray_m_t;
 
        typedef CellArray_t                                     ConnectivityArray_t;
        typedef CellArray_t                                     TriangleArray_t;
 
        typedef MemArray<1, Eagle::PhysicalSpace::bivector>     NormalVectorArray_t;
        typedef MultiArray<1, Eagle::PhysicalSpace::bivector>   NormalVectorArray_m_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  bool    addVerticesAndConnectivity(Grid&G,
                                           const RefPtr<CoordsArray_t>& Vertices,
                                           const RefPtr<CellArray_t>& Connectivity);
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<CreativeArrayBase> newVertexNormalCreator() const;
 
        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();
        }
 
 
static  TriangularSurface create(Grid&theGrid,
                                 const RefPtr<MemBase>&Vertices,
                                 const RefPtr<MemBase>&Triangles,
                                 bool DiscardableVertices,
                                 bool DiscardableTriangles);
 
 
 
static  TriangularSurface create(Grid&theGrid,
                                 const RefPtr<MemBase>&Vertices,
                                 const RefPtr<MemBase>&Triangles,
                                 bool Discardable = false)
        {
                return create(theGrid, Vertices, Triangles, Discardable, Discardable);
        }
 
 
        template<int N, class T>
        RefPtr<Fiber::MemBase> getTriangularFieldData(const std::string& fieldname,
                                                      RefPtr<FragmentID> fragID = NullPtr())
        {
        RefPtr<Fiber::Field> f = (*CellsAsVertices)(fieldname);
                if(!f)
                {
                        Verbose(0) << fieldname << ": NullPtr() in TriangularSurface::getTriangularFieldData [f]";
                        return NullPtr();
                }
 
        RefPtr<Fiber::MemArray<N,T> > mem = f->getData(fragID);
                if(!mem)
                {
                        Verbose(0) << fieldname << ": NullPtr() in TriangularSurface::getTriangularFieldData [mem]";
                        return NullPtr();
                }
 
                return mem;
        }
 
        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() );
 
static  RefPtr<CoordsArray_t>
                computeCircumCircleCenter(const RefPtr<CoordsArray_t>&Pts,
                                          const RefPtr<CellArray_t>  &Cells,
                                          const MemBase::Creator_t&Crec = NullPtr() );
 
static  RefPtr<CoordsArray_t>
                computeInCircleCenter(const RefPtr<CoordsArray_t>&Pts,
                                      const RefPtr<CellArray_t>  &Cells,
                                      const MemBase::Creator_t&Crec = NullPtr() );
 
static  bool containtedEdgeInArray( uint32_t A, uint32_t B, const std::vector< Edges::EdgeCell_t >& edges );
 
static  void addIfEdgeOfNotContained( const Edges::EdgeCell_t& edge, std::vector< Edges::EdgeCell_t >& edges );
 
static  RefPtr<LineSet::LinesetArray_t>
                computeOutLinesViaTriangles( const RefPtr<CoordsArray_t>&Pts,
                                             const RefPtr<CellArray_t>  &Cells,
                                             const MemBase::Creator_t&Crec = NullPtr() );
 
        LineSet OutLines(const RefPtr<Grid>&OutputGrid);
};
 
 
} // namespace Fiber
 
namespace std
{
        string to_string(const Fiber::TriangularSurface&);
}
 
 
#endif // __FIBER_GRID_TYPES_TRIANGULARSURFACE_HPP