WriteNode.hpp File Reference

Go to the source code of this file.

Functions
void	WriteAxisSystem (Dtk_NodePtr inNode)
void	WriteBody (Dtk_NodePtr inNode)
void	WriteCamera (Dtk_NodePtr inNode)
void	WriteColorPalette (Dtk_NodePtr inNode)
void	WriteConstraints (Dtk_NodePtr inNode)
void	WriteDrawing (Dtk_NodePtr inNode)
void	WriteFdt (Dtk_NodePtr inNode)
void	WriteFeature (Dtk_NodePtr inNode)
void	WriteKinematics (Dtk_NodePtr inNode)
void	WriteLayerFilter (Dtk_NodePtr inNode)
void	WriteMesh (Dtk_NodePtr inNode)
void	WriteMetaData (Dtk_NodePtr inNode)
void	WriteModelDisplay (Dtk_NodePtr inNode)
Dtk_ErrorStatus	WriteNode (Dtk_NodePtr inNode)
void	WriteNodeConnector (Dtk_NodePtr inNode)

Function Documentation

WriteAxisSystem()

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));
          }
    }
 
 
}

WriteBody()

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 ));
            }
        }
    }
}

WriteCamera()

void WriteCamera

(

Dtk_NodePtr

inNode

)

{
    Dtk_CameraPtr TmpCamera = inNode->GetDtk_CameraPtr();
    if (TmpCamera.IsNotNULL())
    {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteCamera(TmpCamera);
          }
    }
}

WriteColorPalette()

void WriteColorPalette

(

Dtk_NodePtr

inNode

)

{
     Dtk_ColorInfosSetPtr TmpColorInfos = inNode->GetDtk_ColorInfosSetPtr();
     if (TmpColorInfos.IsNotNULL())
     {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteColorPalette(TmpColorInfos);
          }
     }
}

WriteConstraints()

void WriteConstraints

(

Dtk_NodePtr

inNode

)

{
     Dtk_ConstraintPtr TmpConstraint = inNode->GetDtk_ConstraintPtr();
     if( TmpConstraint.IsNotNULL() )
     {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteConstraint(TmpConstraint);
          }
     }
}

WriteDrawing()

void WriteDrawing

(

Dtk_NodePtr

inNode

)

{
 
     Dtk_DrawingPtr TmpDrawing = inNode->GetDtk_DrawingPtr();
     if (TmpDrawing.IsNotNULL())
     {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteDrawing(TmpDrawing);
          }
 
     }
}

WriteFdt()

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));
        }
    }
}

WriteFeature()

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);
          }
 
    }
}

WriteKinematics()

void WriteKinematics

(

Dtk_NodePtr

inNode

)

{
    Dtk_KinematicPtr TmpKinematics = inNode->GetDtk_KinematicPtr();
    if (TmpKinematics.IsNotNULL())
    {
          // Used to write an XML File 
          if (IsXmlDumpActivated())
          {
               XmlWriteKinematics(TmpKinematics);
          }
 
    }
}

WriteLayerFilter()

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);
          }
    }
 
}

WriteMesh()

void WriteMesh

(

Dtk_NodePtr

inNode

)

{
    Dtk_MeshPtr TmpMesh = inNode->GetDtk_MeshPtr();
    if (TmpMesh.IsNotNULL())
    {
        extern Dtk_transfo CurrentMatrix;
        TmpMesh->Transform(CurrentMatrix);
        WriteDtk_Mesh(TmpMesh);
    }
}

WriteMetaData()

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);
        }
    }
}

WriteModelDisplay()

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]);
    //         }                        
    //    }
 
}

WriteNode()

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;
}

WriteNodeConnector()

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]);
        }
    }
}