util_mesh_dtk.hpp

Go to the documentation of this file.

 
#ifndef _UTIL_MESH_DTK_HPP_
#define _UTIL_MESH_DTK_HPP_
 
#include "util_stl_dtk.hpp"
#include "util/util_ent_dtk.hpp"
#include "util/dtk_picture.hpp"
#include <cstdio>
#include "def/define.h"
#include "util/BaseTypes/dtk_dir.hpp"
#include "util/BaseTypes/dtk_matrix.hpp"
#include "util/BaseTypes/dtk_object.hpp"
#include "util/BaseTypes/dtk_pnt.hpp"
#include "util/BaseTypes/dtk_rgb.hpp"
#include "util/BaseTypes/dtk_string.hpp"
#include "util/BaseTypes/dtk_transfo.hpp"
#include "util/dtk_val.hpp"
#include "util/error_dtk.hpp"
#include "util/util_ptr_dtk.hpp"
 
class Dtk_material;
class Dtk_mesh;
class Dtk_mesh_face;
typedef Dtk_SmartPtr<Dtk_material>              Dtk_MaterialPtr;
typedef Dtk_SmartPtr<Dtk_mesh>                         Dtk_MeshPtr;
typedef Dtk_SmartPtr<Dtk_mesh_face>                    Dtk_mesh_facePtr;
 
/* Filtres */
 
#define DTK_MESH_XYZ                   1
#define DTK_MESH_NORMAL                2
#define DTK_MESH_RGB                   4
#define DTK_MESH_UV_TEXTURES           8    // textures
#define DTK_MESH_UV_BREP              16
#define DTK_MESH_DOUBLEPRECISION     32
// combinations
#define DTK_MESH_XYZ_NORMAL            3
#define DTK_MESH_XYZ_NORMAL_UVTEXTURES 11
#define DTK_MESH_XYZ_NORMAL_RGB        7
#define DTK_MESH_ALL                   31
 
/* Types de triangulation */
 
enum DTK_FACET_TYPE { DTK_UNKNOWN_FACET, DTK_TRIANGLES, DTK_TRIANGLE_STRIP, DTK_TRIANGLE_FAN, DTK_POLYGONS, DTK_MOCKUP };
 
enum DTK_MESH_CRV_TYPE  { DTK_MESH_UNKNOWN_CRV_TYPE, DTK_MESH_CIRCLE, DTK_MESH_LINE, DTK_MESH_OTHERCRV };
 
#define DTK_VALUE_M        1000.0
#define DTK_VALUE_CM       10.0
#define DTK_VALUE_MM       1.0
#define DTK_VALUE_INCH     25.4
#define DTK_VALUE_FEET     304.8
 
 
struct Dtk_bounding_box
{
    Dtk_pnt A;
    Dtk_pnt B;
    Dtk_pnt M;
};
 
typedef Dtk_bounding_box dtk_mesh_face_bb;
typedef Dtk_tab<dtk_mesh_face_bb> dtk_mesh_body_face_bb;
 
typedef Dtk_tab<dtk_mesh_body_face_bb> dtk_mesh_per_body_face_bb;
typedef Dtk_bounding_box dtk_mesh_body_bb;
 
typedef Dtk_tab<dtk_mesh_body_bb> dtk_mesh_bodies_bb;
typedef Dtk_bounding_box dtk_mesh_all_bodies_bb;
 
typedef Dtk_bounding_box dtk_mesh_crv_bb;
typedef Dtk_tab<dtk_mesh_crv_bb> dtk_mesh_per_crv_bb;
typedef Dtk_bounding_box dtk_mesh_all_crvs_bb;
 
 
class Dtk_material_value
{
public:
    Dtk_string NameProperties;
    Dtk_tab<Dtk_Val > PropertiesValue;
     void _Copy(const Dtk_material_value & s)
     {
          NameProperties = s.NameProperties;
          for(Dtk_Size_t i=0;i<s.PropertiesValue.size();i++)
          {
               PropertiesValue.push_back(Dtk_Val(s.PropertiesValue.at(i)));
          }
     }
    Dtk_material_value( void )
    {
    }
    ~Dtk_material_value()
    {
    }
};
 
class Dtk_rendering
{
public:
    Dtk_string name;
    Dtk_tab<Dtk_material_value> value;
     void _Copy(const Dtk_rendering * s)
     {
          if(s)
          {
               name = s->name;
               for(Dtk_Size_t i=0;i<s->value.size();i++)
               {
                    Dtk_material_value material_value;
                    material_value._Copy(s->value.at(i));
                    value.push_back(material_value);
               }
          }
     }
    Dtk_rendering( void )
    {
        value.clear();
    }
    ~Dtk_rendering()
    {
        value.clear();
    }
};
 
class Dtk_drw
{
public:
    Dtk_string name;
    Dtk_picture * picture;
    Dtk_string picturename;
    Dtk_tab<Dtk_material_value> value;
 
     void _Copy(const Dtk_drw * s)
     {
          if(s)
          {
               name = s->name;
               picturename = s->picturename;
               if(s->picture)
               {
                    picture = new Dtk_picture();
                    picture->_Copy(s->picture);
               }
               for(Dtk_Size_t i=0;i<s->value.size();i++)
               {
                    Dtk_material_value material_value;
                    material_value._Copy(s->value.at(i));
                    value.push_back(material_value);
               }
          }
     }
    Dtk_drw( void )
    {
        value.clear();
        picture = NULL;
    }
    ~Dtk_drw()
    {
        value.clear();
          delete picture;
        picture = NULL;
    }
};
 
class Dtk_drafting
{
public:
    Dtk_string name;
    Dtk_tab<Dtk_drw * > drw;
    Dtk_tab<Dtk_material_value> value;
 
     void _Copy(const Dtk_drafting * s)
     {
          if(s)
          {
               name = s->name;
               for(Dtk_Size_t i=0;i<s->drw.size();i++)
               {
                    Dtk_drw * curDrw = new Dtk_drw();
                    curDrw->_Copy(s->drw.at(i));
                    drw.push_back(curDrw);
               }
               for(Dtk_Size_t i=0;i<s->value.size();i++)
               {
                    Dtk_material_value material_value;
                    material_value._Copy(s->value.at(i));
                    value.push_back(material_value);
               }
          }
     }
    Dtk_drafting( void )
    {
        value.clear();
        drw.clear();
    }
    ~Dtk_drafting()
    {
        value.clear();
        for(Dtk_Size_t i=0;i<drw.size();i++)
        {
            delete drw.at(i);
            drw.at(i) = NULL;
        }
        drw.clear();
    }
};
 
 
class Dtk_analysis
{
public:
    Dtk_string name;
    Dtk_tab<Dtk_material_value> value;
 
     void _Copy(const Dtk_analysis * s)
     {
          if(s)
          {
               name = s->name;
               for(Dtk_Size_t i=0;i<s->value.size();i++)
               {
                    Dtk_material_value material_value;
                    material_value._Copy(s->value.at(i));
                    value.push_back(material_value);
               }
          }
     }
    Dtk_analysis( void )
    {
        value.clear();
    }
    ~Dtk_analysis()
    {
        for(Dtk_Size_t i=0;i<value.size();i++)
        {
            Dtk_material_value val = value.at(i);
            val.PropertiesValue.clear();
        }
        value.clear();
    }
};
 
class Dtk_composites
{
public:
    Dtk_string name;
    Dtk_tab<Dtk_material_value> value;
 
     void _Copy(const Dtk_composites * s)
     {
          if(s)
          {
               name = s->name;
               for(Dtk_Size_t i=0;i<s->value.size();i++)
               {
                    Dtk_material_value material_value;
                    material_value._Copy(s->value.at(i));
                    value.push_back(material_value);
               }
          }
     }
    Dtk_composites( void )
    {
        value.clear();
    }
    ~Dtk_composites()
    {
        value.clear();
    }
};
 
class Dtk_positioned
{
public:
    Dtk_string name;
    Dtk_tab<Dtk_material_value> value;
    Dtk_transfo * matrix;
 
     void _Copy(const Dtk_positioned * s)
     {
          if(s)
          {
               name = s->name;
               for(Dtk_Size_t i=0;i<s->value.size();i++)
               {
                    Dtk_material_value material_value;
                    material_value._Copy(s->value.at(i));
                    value.push_back(material_value);
               }
               if(s->matrix)
               {
                    matrix = new Dtk_transfo(s->matrix->getXdir(), s->matrix->getYdir(), s->matrix->getZdir(), s->matrix->getOrigin(), s->matrix->getScale());
               }
          }
     }
    Dtk_positioned( void )
    {
        matrix = NULL;
    }
    ~Dtk_positioned()
    {
        delete matrix;
        matrix = NULL;
    }
};
 
class Dtk_material:public Dtk_Object
{
protected:
    enum 
    {
        _typeID = DTK_TYPE_MATERIAL
    };
private:
    friend class Dtk_SmartPtr<Dtk_material>;
public:
    Dtk_string label;
 
    double ambient;             
    double diffuse;
    double specular;
    double refraction;
    double transparency;
    double reflectivity;
    double roughness;
    double  _Density;
 
     Dtk_Int32 _renderID;
     Dtk_Int32 _physicalID;
     Dtk_Int32 _identifier_library;
    bool repeat_u;
    bool repeat_v;
    Dtk_picture * picture;
    Dtk_string texture;
 
    Dtk_rendering  * rendering;
    Dtk_drafting   * drafting;
    Dtk_analysis   * analysis;
    Dtk_composites * composites;
    Dtk_positioned * positioned;
 
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
    { 
        if (inId == _typeID)
        {
            return 1; 
        }
        return Dtk_material::DtkDynamicType(inId); 
    }
    static Dtk_material * DtkDynamicCast(Dtk_Object * s)
    { 
        if(s->DtkDynamicType(_typeID)) 
            return static_cast<Dtk_material * >(s); 
        return NULL; 
    } 
 
     void _Copy(const Dtk_MaterialPtr & s)
     {
          if(s.IsNotNULL())
          {
               label = s->label;
               ambient = s->ambient;             
               diffuse = s->diffuse;
               specular = s->specular;
               refraction = s->refraction;
               transparency = s->transparency;
               reflectivity = s->reflectivity;
               roughness = s->roughness;
               _Density = s->_Density;
               _renderID = s->_renderID;
               repeat_u = s->repeat_u;
               repeat_v = s->repeat_v;
               texture = s->texture;
               _identifier_library = s->_identifier_library;
               if(s->picture)
               {
                    picture = new Dtk_picture();
                    picture->_Copy(s->picture);
               }
               if(s->rendering)
               {
                    rendering = new Dtk_rendering();
                    rendering->_Copy(s->rendering);
               }
               if(s->drafting)
               {
                    drafting = new Dtk_drafting();
                    drafting->_Copy(s->drafting);
               }
               if(s->analysis)
               {
                    analysis = new Dtk_analysis();
                    analysis->_Copy(s->analysis);
               }
               if(s->composites)
               {
                    composites = new Dtk_composites();
                    composites->_Copy(s->composites);
               }
               if(s->positioned)
               {
                    positioned = new Dtk_positioned();
                    positioned->_Copy(s->positioned);
               }
          }
     }
 
    //Constructor
    Dtk_material( void )
    {
        roughness = 0.0;
        refraction = 0.0;
        ambient = 0.0;             
        diffuse = 0.0;
        specular = 0.0;
        transparency = 0.0;
        reflectivity = 0.0;
        repeat_u = 0;
        repeat_v = 0;
        rendering = NULL;
        drafting = NULL;
        analysis = NULL;
        composites = NULL;
        positioned = NULL;
        picture = NULL;
        _Density = 0.0;
          _renderID = -1;
          _physicalID = -1;
          _identifier_library = 0;
    }
 
    // Destructor
    ~Dtk_material()
    {
        delete picture;
        picture = NULL;
        delete drafting;
        drafting = NULL;
        delete rendering;
        rendering = NULL;
        delete analysis;
        analysis = NULL;
        delete composites;
        composites = NULL;
        delete positioned;
        positioned = NULL;
    }
 
     inline Dtk_Double64 GetDensity() const {return _Density;}
     inline void SetDensity(const Dtk_Double64 inDensity) {_Density = inDensity;}
     inline Dtk_Int32 GetRenderID() const {return _renderID;}
     inline void SetRenderID(const Dtk_Int32 inRenderID) {_renderID = inRenderID;}
     inline Dtk_Int32 GetPhysicalMaterialID() const { return _physicalID; }
     inline void SetPhysicalMaterialID(const Dtk_Int32 inPhysicalID) { _physicalID = inPhysicalID; }
 
};
 
/* Class mesh */
 
class Dtk_mesh_vertex;
class Dtk_facet; 
class Dtk_mesh_face;
 
 
 
class Dtk_mesh:public Dtk_Entity
{
     private:
          friend class Dtk_SmartPtr<Dtk_mesh>;
     protected:
          enum {
               _typeID = DTK_TYPE_MESH
          };        
          int                            id;
        Dtk_bool                       back_face_culling;
          Dtk_bool                         HasTextureValues; 
        int                            vertex_format;
#ifdef NOCOMPRESSEDVERTICES
          Dtk_tab<Dtk_mesh_vertex *>     vertices;      // hide, and hide subclasses.
#else
          Dtk_tab<Dtk_UChar8> cvertices;
          Dtk_Size_t sizeonevertex,ofsVTX,ofsNRM,ofsRGB,ofsUV,ofsUVBrep;
          void C_GetVertex(Dtk_Size_t i,Dtk_pnt& out) const;
          void C_GetNormal(Dtk_Size_t i,Dtk_dir& out) const;
          void C_GetRGB(Dtk_Size_t i,Dtk_RGB& out) const;
          Dtk_Float32 C_GetU(Dtk_Size_t i) const;
          Dtk_Float32 C_GetV(Dtk_Size_t i) const;
          Dtk_Float32 C_GetUBrep(Dtk_Size_t i) const;
          Dtk_Float32 C_GetVBrep(Dtk_Size_t i) const;
          void C_SetVertex(Dtk_Size_t i,const Dtk_pnt& out);
          void C_SetNormal(Dtk_Size_t i,const Dtk_dir& out);
          void C_SetRGB(Dtk_Size_t i,const Dtk_RGB& out);
          void C_SetUV(Dtk_Size_t i,Dtk_Float32 u,Dtk_Float32 v);
          void C_SetUVBrep(Dtk_Size_t i,Dtk_Float32 u,Dtk_Float32 v);
          void C_ComputeOffsets();
#endif
          Dtk_StreamPtr _stream;
        Dtk_tab<Dtk_mesh_face *>       submeshes; 
        friend class Dtk_mesh_face;
        Dtk_bool check_params(const Dtk_pnt * inVertex, const Dtk_dir * inNormal, const Dtk_RGB * inColor, Dtk_Float32 inU, Dtk_Float32 inV);
        Dtk_bool check_params(const Dtk_tab<Dtk_pnt> * inVertices, const Dtk_tab<Dtk_dir> * inNormals, const Dtk_tab<Dtk_RGB> * inColors, const Dtk_tab<Dtk_Float32> * inU, const Dtk_tab<Dtk_Float32> * inV);
          void clean_up();
        inline virtual Dtk_Object* Clone() { return new Dtk_mesh(*this); }
public:
        Dtk_mesh(int inVertex_format = DTK_MESH_XYZ, Dtk_bool inBack_face_culling = true);
        Dtk_mesh(const Dtk_mesh &inMesh);
          Dtk_mesh& operator=(const Dtk_mesh &inMesh);
        ~Dtk_mesh();
    
     public:
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
          static Dtk_mesh* DtkDynamicCast(Dtk_Object *s);
 
          //void dump_vertices();
          static Dtk_MeshPtr Create(int inVertex_format = DTK_MESH_XYZ, Dtk_bool inBack_face_culling = true);
 
          static Dtk_MeshPtr Create(const Dtk_mesh &inToBeCopied);
 
        Dtk_bool check_format(int inFormat);
 
        int compute_round_normals();
 
        int compute_bb(Dtk_pnt * min, Dtk_pnt * max);
 
        int compute_bb_center(Dtk_pnt * i);
 
          int explode();
 
          int explode(Dtk_bool ExplodeTristrips, Dtk_bool ExplodeTrifans, Dtk_bool ExplodePolygons, Dtk_bool ExplodeMockups);
 
          int makestrips();
 
          int change_vertex_format(int inVertex_format);
 
        int transform(Dtk_matrix * inMatrix);
 
          int transform(Dtk_transfo * inMatrix);
 
        Dtk_mesh * transform2Cpy(Dtk_transfo * inMatrix);
 
        Dtk_bool is_backface_culled();
        int to_stl(Dtk_string inFilename,Dtk_bool inIsAciiMode=DTK_FALSE);
 
        Dtk_bool has_xyz();
        Dtk_bool has_normals();
        Dtk_bool has_colors();
        Dtk_bool has_texcoords();
 
        int add_vertex(const Dtk_pnt * inVertex,const  Dtk_dir * inNormal = NULL,const  Dtk_RGB * inColor = NULL, Dtk_Float32 inU = 0., Dtk_Float32 inV = 0., Dtk_Float32 inUBrep = 0., Dtk_Float32 inVBrep = 0.);    
        
          int reserve_vertex(Dtk_Size_t nb);
        int add_mesh_face(Dtk_mesh_face * inMesh_face);
 
        int set_vertex(Dtk_Size_t inPos, const Dtk_pnt * inVertex, const Dtk_dir * inNormal = NULL, const Dtk_RGB * inColor = NULL, Dtk_Float32 inU = 0., Dtk_Float32 inV = 0., Dtk_Float32 inUBrep = 0., Dtk_Float32 inVBrep = 0.);
 
        int set_normal(Dtk_Size_t inPos, const Dtk_dir * inNormal);
 
        int set_color(Dtk_Size_t inPos, const Dtk_RGB * inColor);
 
        int set_texcoords(Dtk_Size_t inPos, Dtk_Float32 inU, Dtk_Float32 inV);
 
          int get_texcoords(Dtk_Size_t inPos, Dtk_Float32 * outU, Dtk_Float32 * outV);
 
        Dtk_Size_t get_nb_vertices() const;
 
        int get_vertex(Dtk_Size_t inPos, Dtk_pnt * outVertex);
        
          Dtk_pnt get_vertex(Dtk_Size_t inPos);
 
        int get_normal(Dtk_Size_t inPos, Dtk_dir * outNormal,Dtk_mesh_face * inMeshFace = NULL);
 
          Dtk_dir get_normal(Dtk_Size_t inPos);
 
 
          Dtk_Float32 GetUTexture(Dtk_Size_t inPos) const;
          Dtk_Float32 GetVTexture(Dtk_Size_t inPos) const;
 
          Dtk_Float32 GetUBrep(Dtk_Size_t inPos) const;
          Dtk_Float32 GetVBrep(Dtk_Size_t inPos) const;
 
        int get_color(Dtk_Size_t inPos, Dtk_RGB * outColor);    
        
        Dtk_Size_t get_nb_mesh_face() const;
 
        Dtk_mesh_face* get_mesh_face(Dtk_Size_t inPos);
 
          Dtk_tab<Dtk_mesh_face *> & get_mesh_faces();
          Dtk_tab<Dtk_mesh_face *> const & get_mesh_faces() const;
 
        Dtk_Size_t get_nb_facets();
        
          void set_id(int inId);
 
        int get_id();
 
        void set_mesh_color(const Dtk_RGB & inColor);
        
        Dtk_RGB get_mesh_color();
 
        const Dtk_InfoPtr& get_Infos();
 
        void set_Infos(const Dtk_InfoPtr& inDtkInfosPtr);
 
        void set_material(Dtk_MaterialPtr inMat);
 
        Dtk_MaterialPtr get_material();
 
        int rescale_model(float ratio);
 
          void reduce();
 
          void merge(const Dtk_mesh* inMesh);
          void merge(const Dtk_SmartPtr<Dtk_mesh>& inMesh);
 
          void mergemove( Dtk_tab<Dtk_MeshPtr>& inArraymesh );
          void mergemove( Dtk_SmartPtr<Dtk_mesh>& inmesh );
          void mergemove( Dtk_mesh* inmesh );
          void reserve_submesh( Dtk_Size_t nb );
 
 
          void reducesubfaces();
 
          Dtk_tab<Dtk_mesh_face *>& get_mesh_face_array();
 
          enum type_detk get_type_detk() const;
          Dtk_ErrorStatus Transform(const Dtk_transfo&);
 
          Dtk_Size_t GetSize() const;
 
        Dtk_bool apply_render_infos(Dtk_RenderInfosPtr);
 
 
        Dtk_ErrorStatus Store(FILE* inFile, Dtk_Size_t inIo = 1);
        Dtk_ErrorStatus Store(const Dtk_string& inFile, Dtk_Size_t inIo = 1);
          void SetStream(Dtk_StreamPtr inStream);
          Dtk_StreamPtr GetStream() const;
};
 
/* Class mesh_vertex : vertex data */
 
class Dtk_mesh_vertex
{
protected:
     Dtk_Float32 vertex[3];
public:
     Dtk_mesh_vertex();
     Dtk_mesh_vertex(const Dtk_pnt * inVertex);
     virtual ~Dtk_mesh_vertex();
     virtual Dtk_pnt GetVertex() const;
     virtual Dtk_dir GetNormal() const;
     virtual Dtk_RGB GetRGB() const;
     virtual Dtk_Float32 GetU() const;
     virtual Dtk_Float32 GetV() const;
     virtual Dtk_Int32 SetVertex(const Dtk_pnt&);
     virtual Dtk_Int32 SetNormal(const Dtk_dir&);
     virtual Dtk_Int32 SetRGB(const Dtk_RGB&);
     virtual Dtk_Int32 SetU(Dtk_Float32);
     virtual Dtk_Int32 SetV(Dtk_Float32);
     virtual Dtk_Int32 transform(Dtk_transfo&);
     virtual Dtk_Size_t GetSize() const ;
};
 
class Dtk_mesh_vertex_norm:public Dtk_mesh_vertex
{
protected:
     Dtk_Float32 normal[3];
public:
     Dtk_mesh_vertex_norm();
     Dtk_mesh_vertex_norm(const Dtk_pnt * inVertex,const Dtk_dir * inNorm);
     Dtk_dir GetNormal() const;
     Dtk_Int32 SetNormal(const Dtk_dir&);
     Dtk_Int32 transform(Dtk_transfo&);
      Dtk_Size_t GetSize() const ;
};
 
class Dtk_mesh_vertex_norm_color:public Dtk_mesh_vertex_norm
{
protected:
     Dtk_RGB color;
public:
     Dtk_mesh_vertex_norm_color();
     Dtk_mesh_vertex_norm_color(const Dtk_pnt * inVertex,const Dtk_dir * inNorm,const Dtk_RGB* inRGB);
     Dtk_RGB GetRGB() const;
     Dtk_Int32 SetRGB(const Dtk_RGB&);
      Dtk_Size_t GetSize() const ;
};
 
class Dtk_mesh_vertex_norm_color_uv:public Dtk_mesh_vertex_norm_color
{
protected:
     Dtk_Float32 u,v;
public:
     Dtk_mesh_vertex_norm_color_uv();
     Dtk_mesh_vertex_norm_color_uv(const Dtk_pnt * inVertex,const Dtk_dir * inNorm,const Dtk_RGB* inRGB,Dtk_Float32 inU,Dtk_Float32 inV);
     Dtk_Float32 GetU() const;
     Dtk_Float32 GetV() const;
     Dtk_Int32 SetU(Dtk_Float32);
     Dtk_Int32 SetV(Dtk_Float32);
      Dtk_Size_t GetSize() const ;
};
 
 
/* --------------------------------------------- */
 
enum DTK_MESH_TYPE_FACE { DTK_MESH_UNKNOWN_TYPE_FACE, DTK_MESH_CYLINDER, DTK_MESH_PLANE, DTK_MESH_OTHERSRF };
class Dtk_mesh_circle_data;
 
class Dtk_mesh_face:public Dtk_Object
{
private:
     friend class Dtk_SmartPtr<Dtk_mesh_face>;
protected:
     enum {
          _typeID = DTK_TYPE_MESH_FACE
     };        
     Dtk_mesh * mesh;
// all types
     Dtk_tab<Dtk_UInt32> triangles;
    Dtk_tab<Dtk_tab<Dtk_UInt32> > polygons;
     Dtk_tab<Dtk_tab<Dtk_UInt32> > tristrips;
     Dtk_tab<Dtk_tab<Dtk_UInt32> > trifans;
     Dtk_tab<Dtk_tab<Dtk_tab<Dtk_UInt32> > > mockup;
     Dtk_tab<Dtk_tab<Dtk_UInt32> > polylines;
     Dtk_tab<Dtk_UInt32> points;
     Dtk_tab<Dtk_InfoPtr> subinfos;
// additionnal
    Dtk_InfoPtr _infos;
     friend class Dtk_mesh;
private:
     int explode_tristrips(Dtk_tab<Dtk_UInt32>* ret);
     int explode_trifans(Dtk_tab<Dtk_UInt32>* ret);
     int explode_polygons(Dtk_tab<Dtk_UInt32>* ret);
     int explode_mockups(Dtk_tab<Dtk_UInt32>* ret);
     int add_shapevertices(const Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals,const  Dtk_tab<Dtk_RGB> * inColors,const  Dtk_tab<Dtk_Float32> * inU, const Dtk_tab<Dtk_Float32> * inV);
 
     int _finddoublonstriangles();
// forbidden
     Dtk_mesh_face& operator=(const Dtk_mesh_face& inMesh);
public:
    Dtk_mesh_face(Dtk_mesh * inMesh);
 
     Dtk_mesh_face(const Dtk_mesh_face& inMeshface,Dtk_mesh* inMesh,Dtk_UInt32 shift=0);
     
    ~Dtk_mesh_face();
 
public:
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_mesh_face* DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_mesh_facePtr Create(const Dtk_mesh_face &inToBeCopied);
 
    int compute_round_normals();
 
    int compute_bb(Dtk_pnt * min, Dtk_pnt * max);
 
    int compute_bb_center(Dtk_pnt * i);
 
     int explode();
 
     int explode(Dtk_bool ExplodeTristrips, Dtk_bool ExplodeTrifans, Dtk_bool ExplodePolygons, Dtk_bool ExplodeMockups);
 
     int makestrips();
 
     Dtk_Size_t get_nb_facets();
 
     Dtk_Size_t get_nb_vertices(int inOnce=1);
 
     Dtk_mesh* get_mesh();
 
 
// triangles
 
     int add_triangles(Dtk_tab<Dtk_UInt32> * inIndices);
     int add_triangles(const Dtk_UInt32* inIndices,Dtk_Size_t nb);
 
     int add_triangles(const Dtk_tab<Dtk_UInt32> * inIndices,const Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
     
     Dtk_Size_t get_nbtriangles() const;
 
     const Dtk_UInt32* get_triangle_indices(Dtk_Size_t inI) const;
 
     Dtk_pnt get_triangle_vertex(Dtk_Size_t inI,Dtk_Size_t inV) const;
 
     Dtk_dir get_triangle_normal(Dtk_Size_t inI) const;
 
     void reverse_triangle(Dtk_Size_t inI);
 
// trianglestrip
     int add_triangle_strip(const Dtk_tab<Dtk_UInt32> * inIndices);
 
     int reserve_triangle_strip(Dtk_Size_t nb);
 
     int add_triangle_strip(const Dtk_tab<Dtk_UInt32> * inIndices,const Dtk_tab<Dtk_pnt> * inVertices,const Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
 
     Dtk_Size_t get_nbtriangle_strips() const;
 
     const Dtk_tab<Dtk_UInt32>* get_triangle_strip_indices(Dtk_Size_t inI) const;
 
// trianglefan
     int add_triangle_fan(const Dtk_tab<Dtk_UInt32> * inIndices);
 
     int add_triangle_fan(const Dtk_tab<Dtk_UInt32> * inIndices,const  Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
 
     Dtk_Size_t get_nbtriangle_fans() const;
 
     const Dtk_tab<Dtk_UInt32>* get_triangle_fan_indices(Dtk_Size_t inI) const;
 
// polygons
     int add_polygon(const Dtk_tab<Dtk_UInt32> * inIndices);
 
     int add_polygon(const Dtk_tab<Dtk_UInt32> * inIndices,const  Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
 
     Dtk_Size_t get_nbpolygons() const;
 
     const Dtk_tab<Dtk_UInt32>* get_polygon_indices(Dtk_Size_t inI) const;
 
 
     Dtk_dir get_polygon_normal(Dtk_Size_t inI) const;
 
// mockups
     int add_mockup(const Dtk_tab<Dtk_tab<Dtk_UInt32> > * inIndices);
 
     int add_mockup(const Dtk_tab<Dtk_tab<Dtk_UInt32> > * inIndices, const Dtk_tab<Dtk_pnt> * inVertices, const Dtk_tab<Dtk_dir> * inNormals = NULL, const Dtk_tab<Dtk_RGB> * inColors = NULL, const Dtk_tab<Dtk_Float32> * inU = NULL, const Dtk_tab<Dtk_Float32> * inV = NULL);
 
     int add_mockups(const Dtk_tab<Dtk_tab<Dtk_tab<Dtk_UInt32> > >* inIndices, const Dtk_tab<Dtk_pnt> * inVertices, const Dtk_tab<Dtk_dir> * inNormals = NULL, const Dtk_tab<Dtk_RGB> * inColors = NULL, const Dtk_tab<Dtk_Float32> * inU =NULL , const Dtk_tab<Dtk_Float32> * inV = NULL);
 
     Dtk_Size_t get_nbmockups() const;
 
     const Dtk_tab<Dtk_tab<Dtk_UInt32> >* get_mockup_indices(Dtk_Size_t inI) const;
 
     Dtk_dir get_mockup_normal(Dtk_Size_t inI) const;
 
// polylines
 
     int add_polyline(const Dtk_tab<Dtk_UInt32> * inIndices);
 
     int add_polyline(const Dtk_tab<Dtk_UInt32> * inIndices,const  Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
 
     void reserve_polylines(Dtk_Size_t nb);
     Dtk_Size_t get_nbpolylines() const;
 
     const Dtk_tab<Dtk_UInt32>* get_polyline_indices(Dtk_Size_t inI) const;
 
// points
 
     int add_point(Dtk_UInt32 inpnt);
     int add_points(const Dtk_tab<Dtk_UInt32> * pnts);
     int add_points(const Dtk_tab<Dtk_UInt32> * inIndices,const  Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
     Dtk_Size_t get_nbpoints() const;
     Dtk_UInt32 get_point_indice(Dtk_Size_t inI) const;
 
 
// subinfos
 
     int add_subinfo(Dtk_InfoPtr& ininf);
     Dtk_Size_t get_nbsubinfos() const;
     Dtk_InfoPtr& get_subinfo(Dtk_Size_t inI);
     const Dtk_InfoPtr& get_subinfo(Dtk_Size_t inI) const;
 
     void reduce();
 
   void merge(Dtk_mesh_face* inMeshface);
 
// additionnal infos
   Dtk_InfoPtr& info();
   const Dtk_InfoPtr& info() const;
 
     void set_id(int inId);
     int get_id();
 
     void set_face_color(const Dtk_RGB& inColor);
     Dtk_RGB get_face_color();
 
     int get_face_icolor();
     void set_face_icolor(int inColor);
 
     DTK_MESH_TYPE_FACE get_face_type();
     void set_face_type(DTK_MESH_TYPE_FACE inType);
 
     Dtk_mesh_circle_data get_mesh_circle_data();
     void set_mesh_circle_data(const Dtk_mesh_circle_data& inCircle);
 
     Dtk_dir get_face_normal();
     void set_face_normal(const Dtk_dir&);
 
     Dtk_string get_face_name();
     void set_face_name(const Dtk_string& inName);
 
     virtual Dtk_Size_t GetSize() const; 
 
    Dtk_ErrorStatus _Store(void*);
};
 
/*
 
class Dtk_facet
{
    protected:
 
        // indices 
        Dtk_tab<int>        indices;
        Dtk_mesh *            mesh;
 
        Dtk_Size_t                    numset;
 
        friend class Dtk_mesh;
        friend class Dtk_mesh_face;
 
        void set_numset(Dtk_Size_t);
        void set_mesh(Dtk_mesh* inMesh);
 
    public:
    
        Dtk_facet();
 
        Dtk_facet(Dtk_tab<int> * inIndices);
 
        ~Dtk_facet();
        
        void clean_up();
 
        virtual int compute_normal(Dtk_dir * outNormal) = 0;
 
        virtual Dtk_bool is_valid() = 0;
 
        Dtk_Size_t        add_indice(int inIndice);
        
        int        add_vertex(Dtk_pnt * inPnt, Dtk_dir * inNormal = NULL, Dtk_RGB * inColor = NULL, Dtk_Float32 inU = 0., Dtk_Float32 inV = 0.);        
 
        Dtk_Size_t            get_nb_vertices();
        
        int            get_vertex(Dtk_Size_t inIndice, Dtk_pnt* outPnt);
 
        int            get_normal(Dtk_Size_t inIndice, Dtk_dir* outNormal);
 
        int            get_color(Dtk_Size_t inIndice, Dtk_RGB* outColor);
 
        int            get_texcoords(Dtk_Size_t inIndice, double* ouU, double* outV);
 
        Dtk_Size_t            get_nb_indices();
 
        Dtk_tab<int>get_indices();
 
        int            get_indice(int inIndice);
 
        Dtk_mesh *    get_mesh();
};
 
*/
/*
 
// n points, n normales
class Dtk_triangle: public Dtk_facet
{
    public:
 
        Dtk_triangle();
        
        Dtk_triangle(Dtk_tab<int> * inIndices);
 
        ~Dtk_triangle();
 
        Dtk_bool is_valid();
 
        int compute_normal(Dtk_dir * outNormal);
};
 
*/
 
/*
 
class Dtk_planar_facet: public Dtk_facet
{
    friend class Dtk_mesh;
    public:
 
        Dtk_planar_facet();
        Dtk_planar_facet(Dtk_tab<int> *);
        ~Dtk_planar_facet();
 
        Dtk_bool is_valid();
        int compute_normal(Dtk_dir *);
 
        Dtk_triangle * to_strip();
        Dtk_triangle * to_triangles();
};
 
*/
 
 
class Dtk_mesh_circle_data;
 
 
class Dtk_mesh_curve
{
        int                    type;        // kind or crv
        DTK_MESH_CRV_TYPE      crv_type;    // crv type
        Dtk_tab<int>           indices;     // si type != 120
        Dtk_tab<Dtk_pnt>       vertices;    // si type == 120
        Dtk_RGB                color;
        unsigned long          id;
        int                    line_type;
        float                  thickness;
        Dtk_mesh_circle_data * circle_data;
 
    public:
 
        Dtk_mesh_curve();
        ~Dtk_mesh_curve();
 
        void    add_indice(int inIndice);
        int        get_indice(Dtk_Size_t inNum);
        int        pop_indice();
 
        void    add_vertex(Dtk_pnt inVertex);
        int        get_vertex(Dtk_Size_t inIndice, Dtk_pnt * outVertex);
        int        pop_vertex(Dtk_pnt*);
 
        Dtk_Size_t     get_nb_vertices();
        Dtk_Size_t     get_nb_indices();
 
        void            set_id(unsigned long inID);
        unsigned long    get_id();
 
        void set_type(int inType);
        int get_type();
        void set_crv_type(DTK_MESH_CRV_TYPE type);
        DTK_MESH_CRV_TYPE get_crv_type();
 
        void    set_color(int R, int G, int B);
        Dtk_RGB    get_color();
 
        void set_thickness(float inThickness);
 
        float get_thickness();
 
        void set_linetype(int inLineType);
 
        int get_linetype();
 
        void                    set_mesh_circle_data(Dtk_mesh_circle_data * inCircle);
        Dtk_mesh_circle_data *    get_mesh_circle_data();
        Dtk_mesh_curve * transform2Cpy(Dtk_transfo * inMatrix);
};
 
 
 
class Dtk_mesh_circle_data
{
    Dtk_dir axis;
    Dtk_pnt center;
    double    radius;
 
    public:
        Dtk_mesh_circle_data();
        ~Dtk_mesh_circle_data();
 
        void        set_axis(Dtk_dir inAxis);
        Dtk_dir        get_axis() const;
 
        void        set_center(Dtk_pnt inCenter);
        Dtk_pnt        get_center() const;
 
        void        set_radius(double inRadius);
        double        get_radius() const;
};
 
 
 
// new class Dtk_MeshPolyline
 
class Dtk_MeshPolyline :public Dtk_Object
{
private:
     friend class Dtk_SmartPtr<Dtk_MeshPolyline>;
     Dtk_tab<Dtk_UInt32> points;   // array of indice in vertex array from Dtk_MEsh of Polyline
     int  TopoID;
 
public:
     Dtk_MeshPolyline();
     virtual ~Dtk_MeshPolyline();
     void AddVertex(const Dtk_UInt32 ind);
     Dtk_UInt32 GetVertexInd(const Dtk_UInt32 ival);
     int GetTopoID() { return (TopoID); };
     void SetTopoID(const int ival);
     Dtk_Size_t GetNbVertex() { return (points.size()); };
 
     //downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_MeshPolyline * DtkDynamicCast(Dtk_Object * nObject);
 
 
};
 
typedef Dtk_SmartPtr<Dtk_MeshPolyline>                 Dtk_MeshPolylinePtr;
 
 
 
 
#endif