Sample to browse a Dtk_Node

 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "WriteNode.hpp"
 
#include "util/util_xml_dtk.hpp"
 
 
 
 
 
 
//This function is a sample on how to write node
//Dtk_node can be an Body, Mesh , Drawing, Fdt, AxisPlacement and/or have children (recursive function)
//It represent construction tree for Model
Dtk_ErrorStatus WriteNode( Dtk_NodePtr inNode )
{
 
     FILE * xmlDumpFile = Dtk_DumpXMLNamespace::Dtk_DumpXml_GetFile();
 
 
     //GetName
     Dtk_string NodeName = inNode->Name();
 
     // You can Get Preview if you want to handle it
     Dtk_PreviewPtr TmpPreview = inNode->GetPreview();
     if( TmpPreview.IsNotNULL() )
     {
          Dtk_Int32 size = TmpPreview->GetStreamSize();
          char *jpgimage = TmpPreview->GetStream();
          Dtk_string Preview_name = "NodePreview.jpg";
          FILE *jpg = Preview_name.OpenFile( "wb" );
          if( jpg )
          {
               fwrite( jpgimage, sizeof( char ), size, jpg );
               fclose( jpg );
          }
     }
 
 
     //See Dtk_InfoPtr methods for others attributes in infos (color, layer...)
     if( xmlDumpFile )
     {
          Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NodePtr_Init( xmlDumpFile, inNode );
     }
     if(IsPdfDumpActivated())
     {
          Dtk_ID pdfID;
          pdfID =  PdfInitNode(inNode);
     }
 
     //Get The node Blanked Status
     // -1 = undefined, 0 = Visible, 1=Invisible, 2=Construction Geometry
     int NodeBlankedStatus = inNode->GetInfos()->GetBlankedStatus();
 
     Dtk_Node::FullType NodeType = inNode->GetNodeFullType();
 
     //In this sample we read and treat only visible node - change this test if you want to read invisible and/or construction node
     if( NodeBlankedStatus == 0 )
     {
          //You have many types for Node Data : 
          // BodyType for 3D geometry (solid and wireframe)
          // MeshType for 3D tessellated geometry
          // FdtType for FDT
          // DrawingType for 2D
          // KinematicsType for Kinematics
          // AxisSystemType for AxisPlacement
          // LayerInfosSetType for LayerInfos
          // MetaDataType for Additional informations
          // CameraType for Camera 
          // ModelDisplayType for ModelDisplay
          // VirtualType just for containing children
          switch( NodeType.PrimaryType() )
          {
               case Dtk_Node::BodyType:
               {
                    WriteBody( inNode );
                    break;
               }
               case Dtk_Node::FdtType:
               {
                    WriteFdt( inNode );
                    break;
               }
               case Dtk_Node::DrawingType:
               {
                    WriteDrawing( inNode );
                    break;
               }
               case Dtk_Node::MeshType:
               {
                    WriteMesh( inNode );
                    break;
               }
               case Dtk_Node::AxisSystemType:
               {
                    WriteAxisSystem( inNode );
                    break;
               }
               case Dtk_Node::KinematicsType:
               {
                    WriteKinematics( inNode );
                    break;
               }
               case Dtk_Node::LayerInfosSetType:
               {
                    WriteLayerFilter( inNode );
                    break;
               }
               case Dtk_Node::ColorInfosSetType:
               {
                    WriteColorPalette(inNode);
                    break;
               }
               case Dtk_Node::MetaDataType:
               {
                    WriteMetaData( inNode );
                    break;
               }
               case Dtk_Node::CameraType:
               {
                    WriteCamera( inNode );
                    break;
               }
               case Dtk_Node::ModelDisplayType:
               {
                    WriteModelDisplay( inNode );
                    break;
               }
               case Dtk_Node::ConstraintType:
               {
                    WriteConstraints( inNode );
                    break;
               }
               default:
               {
                    break;
               }
          }
     }
 
     //Treat recursive TreeNode for Visible and Construction node
     // NodeBlankedStatus : -1 = undefined, 0 = Visible, 1=Invisible, 2=Construction Geometry
     //remove this test if you want to treat invisible entities
     if( NodeBlankedStatus != 1 || NodeType.PrimaryType() == Dtk_Node::BodyType )
          //invisible body can have visible children
     {
 
          Dtk_Size_t i, NumChildren;
          NumChildren = inNode->GetNumChildren();
          for( i = 0; i < NumChildren; i++ )
          {
               WriteNode( inNode->GetChild( i ) );
          }
     }
 
 
     // Write Feature associated if you want to handle it
     WriteFeature( inNode );
 
     //Write NodeConnector if you want to handle it
     WriteNodeConnector( inNode );
 
 
     if( xmlDumpFile )
     {
          Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NodePtr_End( xmlDumpFile );
     }
     if(IsPdfDumpActivated())
     {
          PdfEndNode();
     }
 
     return dtkNoError;
}

Sample to browse a Dtk_NodeConnector

 
#include "datakit.h"
#include "util/util_xml_dtk.hpp"
 
void WriteNodeConnector(Dtk_NodePtr inNode)
{
    FILE * xmlDumpFile = Dtk_DumpXMLNamespace::Dtk_DumpXml_GetFile();
    Dtk_tab< Dtk_NodeConnectorPtr > AssociatedEntities;
    inNode->GetAssociatedEntities(AssociatedEntities);
    Dtk_Size_t i, NumAssoc = AssociatedEntities.size();
    for (i = 0; i < NumAssoc; i++)
    {
        if (xmlDumpFile)
        {
            Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NodeConnector(xmlDumpFile, AssociatedEntities[i]);
        }
    }
}
 
 
 

Sample to browse a Dtk_AxisSystem

 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
extern Dtk_bool     toDumpPDF;
 
void WriteAxisSystem(Dtk_NodePtr inNode)
{
     enum type_detk subtype;
     subtype = inNode->GetNodeSubType();
    // subtype can be DTK_TYPE_VIEW or DTK_TYPE_AXIS_SYSTEM
 
    Dtk_AxisSystemPtr TmpAxis = inNode->GetDtk_AxisSystemPtr();
    if (TmpAxis.IsNotNULL() )
    {
        Dtk_string SystemName = TmpAxis->get_info()->GetName();
 
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteAxisSystem(TmpAxis);
          }
          // Used to write a Pdf File 
          if (IsPdfDumpActivated())
          {
               PdfWriteEntity(Dtk_EntityPtr::DtkDynamicCast(TmpAxis));
          }
    }
 
 
}

Sample to browse a Dtk_Body

 
#include "datakit.h"
#include "tess/tess.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
using namespace std;
 
int GetTesselationStatus();
void WriteDtk_Mesh(const Dtk_MeshPtr& inMeshToWrite);
 
extern Dtk_transfo CurrentMatrix;
 
void WriteBody(Dtk_NodePtr inNode)
{
    // Get if the node represent infinite geometry
    // 1 = Infinite, 0 = Finite
    int NodeInfiniteGeometry = inNode->GetInfos()->GetInfiniteGeometryFlag();
    if (NodeInfiniteGeometry == 0)
    {
        //Calling both methods GetDtk_MeshPtr() and GetDtk_BodyPtr() on BodyNode will give you the same result
        //Choose the one you need in order to avoid duplicated data
        const Dtk_BodyPtr TmpBody = inNode->GetDtk_BodyPtr();
        if (TmpBody.IsNotNULL())
        {
               // Used to write an XML File 
               if (IsXmlDumpActivated())
               {
                    XmlWriteBody(TmpBody);
               }
        }
 
        // Some CAD formats store also faceted data besides B-Rep. 
        // So you can get faceted data corresponding to the body using the following method
          const Dtk_MeshPtr TmpFacetedBody = inNode->GetDtk_MeshPtr();
        if (TmpFacetedBody.IsNotNULL())
        {
            TmpFacetedBody->Transform(CurrentMatrix);
            WriteDtk_Mesh(TmpFacetedBody);
        }
 
 
        // If there is no mesh data associated to the current body, you can tessellate (and if init of tessellation engine is successful)
        if (TmpFacetedBody.IsNULL() && TmpBody.IsNotNULL() && GetTesselationStatus() == dtkNoError)
        {
            Dtk_tab<Dtk_MeshPtr> meshes;
            Dtk_tab<Dtk_Int32> isclosed;
               // Change this variable to true if you want to tessellate wireframe contained in the body
               bool tesselWireframe = true; 
 
            int err_tess = tess_BodyToMeshes(TmpBody, meshes, isclosed, tesselWireframe );
               if( inNode->Name().len() > 0 )
                    cout << "NodeName = " << inNode->Name().c_str() << ";";
               cout << "err_tess = " << dtkTypeError( err_tess ).c_str() << endl ;
            if (err_tess == 0)
            {
                Dtk_Size_t i, nbmeshes = meshes.size();
                for (i = 0; i < nbmeshes; i++)
                {
                    meshes[i]->Transform(CurrentMatrix);
                    WriteDtk_Mesh(meshes[i]);
                }
            }
 
            if (IsPdfDumpActivated() && TmpBody->HasWire())
            {// handling wire / points
                    PdfWriteEntity( Dtk_EntityPtr::DtkDynamicCast( TmpBody ));
            }
        }
    }
}

Sample to browse a Dtk_Camera

 
#include "datakit.h"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
void WriteCamera(Dtk_NodePtr inNode)
{
    Dtk_CameraPtr TmpCamera = inNode->GetDtk_CameraPtr();
    if (TmpCamera.IsNotNULL())
    {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteCamera(TmpCamera);
          }
    }
}

Sample to browse a Dtk_ColorInfosSet

 
#include "datakit.h"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
void WriteColorPalette(Dtk_NodePtr inNode)
{
     Dtk_ColorInfosSetPtr TmpColorInfos = inNode->GetDtk_ColorInfosSetPtr();
     if (TmpColorInfos.IsNotNULL())
     {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteColorPalette(TmpColorInfos);
          }
     }
}

Sample to browse a Dtk_ConstraintPtr

 
#include "datakit.h"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
void WriteConstraints( Dtk_NodePtr inNode )
{
     Dtk_ConstraintPtr TmpConstraint = inNode->GetDtk_ConstraintPtr();
     if( TmpConstraint.IsNotNULL() )
     {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteConstraint(TmpConstraint);
          }
     }
}
 
 
 

Sample to browse a Dtk_Drawing

#include "datakit.h"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
void WriteDrawing(Dtk_NodePtr inNode)
{
 
     Dtk_DrawingPtr TmpDrawing = inNode->GetDtk_DrawingPtr();
     if (TmpDrawing.IsNotNULL())
     {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteDrawing(TmpDrawing);
          }
 
     }
}

Sample to browse a Dtk_Fdt

 
 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
void WriteFdt(Dtk_NodePtr inNode)
{
    enum type_detk subtype;
    subtype = inNode->GetNodeSubType();
    // subtype can be DTK_TYPE_MEASURE or DTK_TYPE_FDT
 
    Dtk_FdtPtr TmpFdt = inNode->GetDtk_FdtPtr();
    if (TmpFdt.IsNotNULL())
    {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteFdt(TmpFdt);
          }
        // Used to write an PDF File 
        if (IsPdfDumpActivated())
        {
               PdfWriteEntity(Dtk_EntityPtr::DtkDynamicCast(TmpFdt));
        }
    }
}

Sample to browse a Dtk_Feature

 
#include "datakit.h"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
Dtk_bool toDumpFeatures;
 
void ActivateFeatureDump(Dtk_bool inDumpFeature)
{
     toDumpFeatures = inDumpFeature;
}
 
 
void WriteFeature(Dtk_NodePtr inNode)
{
     if (toDumpFeatures == DTK_FALSE)
          return;
 
    // Get the Feature associated to the current node, if exists,
    // otherwise a NULL pointer is returned
    Dtk_FeaturePtr TmpFeature = inNode->GetDtk_FeaturePtr();
    if (TmpFeature.IsNotNULL())
    {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteFeature(TmpFeature);
          }
 
    }
}
 
 
 

Sample to browse a Dtk_LayerInfosSet

 
#include "datakit.h"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
void WriteLayerFilter(Dtk_NodePtr inNode)
{
    Dtk_LayerInfosSetPtr TmpLayerInfosSet = inNode->GetDtk_LayerInfosSetPtr();
    if (TmpLayerInfosSet.IsNotNULL())
    {
        Dtk_Size_t NumLayerFilters = TmpLayerInfosSet->GetNumLayerFilters();
        Dtk_Size_t CurrentLayer, DefaultLayerFilter;
        TmpLayerInfosSet->GetCurrentLayer( CurrentLayer );
        TmpLayerInfosSet->GetDefaultLayerFilter(DefaultLayerFilter);
 
          auto const& layers = TmpLayerInfosSet->GetLayers();
        for ( Dtk_LayerInfosSet::Layer layer : layers )
        {
            Dtk_string LayerName = layer.GetName();
            Dtk_ID LayerID = layer.GetID();
               DTK_UNUSED( LayerName );
               DTK_UNUSED( LayerID );
        }
        for ( Dtk_Size_t i = 0; i < NumLayerFilters; i++)
        {
            Dtk_LayerFilterInfosPtr TmpLayerFilter = TmpLayerInfosSet->GetLayerFilterByPos(i);
            Dtk_tab< Dtk_Size_t > SelectedLayers;
            TmpLayerFilter->GetSelectedLayers(SelectedLayers);
            Dtk_string LayerFilterName;
            TmpLayerFilter->GetName(LayerFilterName);
        }
          if (IsXmlDumpActivated())
          {
               XmlWriteLayerFilter(TmpLayerInfosSet);
          }
    }
 
}

Sample to browse a Dtk_mesh

 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
 
 
void WriteDtk_Mesh(const Dtk_MeshPtr& inMeshToWrite)
{
    // convert triangles-strip, fans, polygons into simple triangles
    inMeshToWrite->explode();
 
    // Used to write a PDF File 
    if (IsPdfDumpActivated())
    {
           PdfWriteEntity(Dtk_EntityPtr::DtkDynamicCast(inMeshToWrite));
    }
 
     // Used to write an XML File 
     if (IsXmlDumpActivated())
     {
          XmlWriteMesh(inMeshToWrite);
     }
 
    Dtk_RGB rgb = inMeshToWrite->get_mesh_color();   // mesh global color.
 
    // vertices :
    Dtk_Size_t nbvertices = inMeshToWrite->get_nb_vertices();
    Dtk_Size_t i, j;
    for (i = 0; i < nbvertices; i++)
    {
        Dtk_pnt pnt;
        Dtk_dir dir;
        Dtk_RGB color;
        float u, v;
        u = v = 0.0;
        inMeshToWrite->get_vertex(i, &pnt);  //  coordinates of the vertices
        if (inMeshToWrite->has_normals())
            inMeshToWrite->get_normal(i, &dir);  // vertex normal (if enabled)
        if (inMeshToWrite->has_colors())
            inMeshToWrite->get_color(i, &color);  // vertex color (if enabled)
        if (inMeshToWrite->has_texcoords())
        {
            u = inMeshToWrite->GetUTexture(i);  // vertex u,v texture coordinate (if enabled)
            v = inMeshToWrite->GetVTexture(i);
        }
    }
    // mesh_faces
    Dtk_Size_t k, m, nbmeshfaces = inMeshToWrite->get_nb_mesh_face();
    for (i = 0; i < nbmeshfaces; i++)
    {
        Dtk_mesh_face* mf = inMeshToWrite->get_mesh_face(i);
        Dtk_Size_t nbtriangles = mf->get_nbtriangles();
        Dtk_Int32 trianglesindices[3];
        for (j = 0; j < nbtriangles; j++)
        {
            const Dtk_UInt32* tri = mf->get_triangle_indices(j);
            trianglesindices[0] = tri[0];
            trianglesindices[1] = tri[1];
            trianglesindices[2] = tri[2];
            // id of vertex in vertices table you read in the first step of this function
        }
 
        //face boundaries
        Dtk_Size_t nbpolyline = mf->get_nbpolylines();
        for (j = 0; j < nbpolyline; j++)
        {
            const Dtk_tab<Dtk_UInt32> *pnt;
            pnt = mf->get_polyline_indices(j);
            Dtk_Size_t nbvertex = pnt->size();
            for (k = 0; k < nbvertex; k++)
            {
                m = (*pnt)[k];  // id of vertex in vertices table
                Dtk_pnt pt = inMeshToWrite->get_vertex(m);
            }
        }
    }
}
 
void WriteMesh(Dtk_NodePtr inNode)
{
    Dtk_MeshPtr TmpMesh = inNode->GetDtk_MeshPtr();
    if (TmpMesh.IsNotNULL())
    {
        extern Dtk_transfo CurrentMatrix;
        TmpMesh->Transform(CurrentMatrix);
        WriteDtk_Mesh(TmpMesh);
    }
}

Sample to browse a Dtk_MetaData

 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
 
#include "util/util_xml_dtk.hpp"
 
 
void WriteMetaData(Dtk_NodePtr inNode)
{
    FILE * xmlDumpFile = Dtk_DumpXMLNamespace::Dtk_DumpXml_GetFile();
    enum type_detk subtype;
    subtype = inNode->GetNodeSubType();
    // subtype can be DTK_TYPE_PUBLICATION, DTK_TYPE_MEASURE or DTK_TYPE_METADATA
    Dtk_MetaDataPtr TmpMetaData = inNode->GetDtk_MetaDataPtr();
    if (TmpMetaData.IsNotNULL())
    {
        if (xmlDumpFile)
        {
            Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr(xmlDumpFile, TmpMetaData);
        }
        if (IsPdfDumpActivated())
        {
            Dtk_tab<Dtk_MetaDataPtr> tabMetadata;
            tabMetadata.push_back(TmpMetaData);
               PdfWriteMetaData(tabMetadata);
        }
    }
}
 

Sample to browse a Dtk_ModelDisplay

 
#include "datakit.h"
#include "util/util_xml_dtk.hpp"
 
void WriteModelDisplay(Dtk_NodePtr inNode)
{
    FILE * xmlDumpFile = Dtk_DumpXMLNamespace::Dtk_DumpXml_GetFile();
 
    Dtk_ModelDisplayPtr TmpModelDisplay = inNode->GetDtk_ModelDisplayPtr();
    if (TmpModelDisplay.IsNotNULL())
    {
        if (xmlDumpFile)
        {
            Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ModelDisplayPtr(xmlDumpFile, TmpModelDisplay);
        }
    }
 
    //To get the entities attached to this model display use the connector
    Dtk_tab< Dtk_NodeConnectorPtr > AssociatedEntities;
    inNode->GetAssociatedEntities(AssociatedEntities);
 
    // Already done in WriteNode
    //    Dtk_Size_t i, NumAssoc = AssociatedEntities.size();
    //    for ( i = 0; i < NumAssoc; i++ )
    //    {
    //         if (xmlDumpFile)
    //         {   
    //              Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NodeConnector(xmlDumpFile,AssociatedEntities[i]);
    //         }                        
    //    }
 
}
 
 
 

Sample to browse a Dtk_Preview

#include "datakit.h"
 
// Writes the image stream of a Dtk_Preview to a file on disk.
void WritePreview( const Dtk_PreviewPtr& inPreview, const Dtk_string& inName )
{
     if( inPreview.IsNULL() )
          return;
 
     Dtk_Int32 size = inPreview->GetStreamSize();
     char* imageData = inPreview->GetStream();
 
     if( size <= 0 || imageData == nullptr )
          return;
 
     Dtk_string previewExt;
 
     switch( inPreview->GetType() )
     {
          case PREVIEW_TYPE_DETK_JPG:
               previewExt = "jpg";
               break;
          case PREVIEW_TYPE_DETK_BMP:
               previewExt = "bmp";
               break;
          case PREVIEW_TYPE_DETK_PNG:
               previewExt = "png";
               break;
          case PREVIEW_TYPE_DETK_CGM:
               previewExt = "cgm";
               break;
          case PREVIEW_TYPE_DETK_GIF:
               previewExt = "gif";
               break;
          case PREVIEW_TYPE_DETK_TIFF:
               previewExt = "tiff";
               break;
          case PREVIEW_TYPE_DETK_ICO:
               previewExt = "ico";
               break;
          case PREVIEW_TYPE_DETK_EMF:
               previewExt = "emf";
               break;
          case PREVIEW_TYPE_DETK_UNKNOWN:
          default:
               previewExt = "jpg"; // Default to jpg if type is unknown
               break;
     }
 
     Dtk_string previewName = inName + "_Preview." + previewExt;
     FILE* previewPtr = previewName.OpenFile( "wb" );
     if( previewPtr )
     {
          fwrite( imageData, sizeof( char ), size, previewPtr );
          fclose( previewPtr );
          //std::cout << "Writing Preview " << previewName.c_str() << std::endl;
     }
}