Through Assemblies

Sample to browse a Dtk_MainDoc
Sample to browse a Dtk_Component
Sample to browse a Dtk_Component type Instance
Sample to browse a Dtk_Component type Prototype
Selection Set sample

Sample to browse a Dtk_MainDoc

//**********************************************************************************************
//  This file provides a sample implementation for writing the contents of a CAD document
//  using the Datakit API.
//**********************************************************************************************
 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
 
// Function declarations
extern Dtk_ErrorStatus WriteComponent(Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix = Dtk_transfo());
 
// Writes the contents of a CAD document.
// Returns a Dtk_ErrorStatus indicating success (dtkNoError) or failure of the operation.
Dtk_ErrorStatus WriteDocument(Dtk_MainDocPtr inDocument)
{
    // Retrieve the root component from the document.
    Dtk_ComponentPtr rootComponent = inDocument->RootComponent();
 
    // If the root component is valid, process it and its children.
    if (rootComponent.IsNotNULL())
    {
          // Initialize PDF output for the root component if PDF export is enabled.
        if (IsPdfDumpActivated())
        {
            PdfInitComponent(rootComponent);
        }
 
        // Recursively process the root component and its children.
        WriteComponent(rootComponent);
 
        // Finalize PDF output for the root component if PDF export is enabled.
        if (IsPdfDumpActivated())
        {
               // Finalize PDF output for the root component if PDF export is enabled.
            PdfEndComponent();
        }
        return dtkNoError;
    }
 
    // Return error if the document is invalid.
    return dtkErrorNullPointer;
}

Sample to browse a Dtk_Component

//**********************************************************************************************
//  This file provides a sample implementation for writing the contents of a CAD component
//  using the Datakit API.
//**********************************************************************************************
 
#include "datakit.h"
#include "WriteComponent.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
// Writes a CAD component and its children to output formats (XML and PDF).
// Returns a Dtk_ErrorStatus indicating success (dtkNoError) or failure of the operation.
Dtk_ErrorStatus WriteComponent(Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix)
{
    // Get the unit scale (e.g., 25.4 for inch) for the component.
    double unitFactor;
    inComponent->GetConceptionUnitScale(unitFactor);
 
    // Get the component name.
    Dtk_string componentName = inComponent->Name();
 
    // Get component attributes (activation, blanked status, color).
    Dtk_InfoPtr componentAttributes = inComponent->GetInfos();
    if (componentAttributes.IsNotNULL())
    {      
          // Get activation flag (1 if activated, 0 otherwise).
          int activationStatus = 1; 
          activationStatus = componentAttributes->GetActivationFlag();
 
          // Get blanked status (0: visible, 1: invisible, 2: construction geometry).
          int blankedStatus = 0;
          blankedStatus = componentAttributes->GetBlankedStatus();
          
          // Get color (RGB values).
          Dtk_RGB color = componentAttributes->GetColor();                 
    }
 
    // Get and save preview image if available.
    Dtk_PreviewPtr preview = inComponent->GetPreview();
    if (preview.IsNotNULL())
    {
        Dtk_Int32 size = preview->GetStreamSize();
        char *jpgImage = preview->GetStream();
        Dtk_string previewName = "ComponentPreview.jpg";
        FILE *jpg = previewName.OpenFile("wb");
        if (jpg)
        {
               // Write JPEG image data to file.
               fwrite(jpgImage, sizeof(char), size, jpg);
            fclose(jpg);
        }
    }
 
    if (IsXmlDumpActivated())
    {
          // initialize XML output for the component if XML export is enabled.
        XmlInitComponent(inComponent);
    }
 
    // Process the component based on its type.
    Dtk_Component::ComponentTypeEnum type = inComponent->ComponentType();
    switch (type)
    {
        // Instance: represents a prototype with a matrix placement.
        case Dtk_Component::InstanceComponentType:
        {
               // Write the component instance
            WriteInstance(inComponent);
            break;
        }
        // Prototype: check if already processed to avoid redundant work.
          // Use inComponent->GetID() to obtain its unique ID.
        case Dtk_Component::PrototypeComponentType:
        {
               // Write the prototype component with the given transformation matrix.
            WritePrototype(inComponent, inMatrix);
            break;
        }
        // Catalog: represents multiple possible configurations (scene, workspace, etc.).
        case Dtk_Component::CatalogComponentType:
        {
               // Get number of children and recursively write each child component.
               Dtk_Size_t numChildren = inComponent->GetNumChildren();
               if (numChildren > 0)
               {
                    // Get default component index in the catalog
                    Dtk_Int32 defaultComponentIndex = inComponent->GetDefaultChildInCatalog();
 
                    // Get activated component indices in the catalog
                    Dtk_tab<Dtk_Int32> activatedComponentIndices = inComponent->GetActivatedChildrenInCatalog();
 
                    // Get number of activated components in the catalog
                    Dtk_Size_t numActivatedComponents = activatedComponentIndices.size();
 
                    if (IsXmlDumpActivated())
                    {
                    // Write all non-activated and non-default children as XML dump entries (to provide a complete component tree)
                         for (Dtk_Size_t i = 0; i < numChildren; i++)
                         {
                              // Skip activated components
                              if( activatedComponentIndices.find( ( Dtk_Int32 )i ) >= 0 )
                              {
                                   continue;
                              }
                              
                              // Skip default component
                              if( defaultComponentIndex == ( Dtk_Int32 )i )
                              {
                                   continue;
                              }
 
                              // Write XML entry for non-activated and non-default child component
                              Dtk_ComponentPtr childComponent = inComponent->GetChild(i);
                              XmlInitComponent(childComponent);
                              XmlEndComponent();
                         }
                    }
 
                    // Write activated components or default component
                    if (numActivatedComponents > 0)
                    {
                         // Write all activated components
                         for ( Dtk_Size_t i = 0; i < numActivatedComponents; i++)
                         {
                              // Write the activated component
                              Dtk_ComponentPtr activatedComponent = inComponent->GetChild(activatedComponentIndices[i]);
                              WriteComponent(activatedComponent, inMatrix);
                         }
                    }
                    else
                    {
                         // Write the default component
                         Dtk_ComponentPtr defaultChildComponent = inComponent->GetChild(defaultComponentIndex);
                         WriteComponent(defaultChildComponent, inMatrix);
                    }
               }
 
            // If necessary, iterate over all children and select the desired one(s) to process based on their name.
               break;
          }
        // Virtual: component containing only children.
        case Dtk_Component::VirtualComponentType:
        {
               // Get number of child components and recursively write each child component.
            Dtk_Size_t numChildComponents = inComponent->GetNumChildren();
            for (Dtk_Size_t i = 0; i < numChildComponents; i++)
            {
                Dtk_ComponentPtr childComponent = inComponent->GetChild(i);
                WriteComponent(childComponent, inMatrix);
            }
            break;
        }
    }
 
    if (IsXmlDumpActivated())
    {
          // Finalize XML output for the component if XML export is enabled.
        XmlEndComponent();
    }
 
    return dtkNoError;
}

Sample to browse a Dtk_Component type Instance

//****************************************************************************************************
//  This file provides a sample implementation for writing the contents of a CAD component instance
//  using the Datakit API.
//****************************************************************************************************
 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
#include "WriteComponent.hpp"
 
// Global list to track processed components (to avoid redundant processing)
extern Dtk_tab<Dtk_ID> ProcessedComponents;
 
// Writes a CAD component instance
// Returns a Dtk_ErrorStatus indicating success (dtkNoError) or failure of the operation.
Dtk_ErrorStatus WriteInstance(Dtk_ComponentPtr inComponent)
{
     // Get the prototype name.
    Dtk_string prototypeName = inComponent->Name();
 
     // Get the instance name.
    Dtk_string instanceName = inComponent->InstanceName(); 
 
    // Get the prototype component (first child of instance) and its transformation matrix.
    Dtk_ComponentPtr prototype = inComponent->GetChild(0);
    Dtk_transfo matrix = inComponent->TransformationMatrix();
 
     // Get the ID of the prototype component.
    Dtk_ID childID = prototype->GetID();
 
     // Initialize PDF instance ID.
     Dtk_ID pdfInstanceID = 0;
 
     // Initialize PDF output for the instance if PDF export is enabled.
    if (IsPdfDumpActivated())
    {
        pdfInstanceID = PdfInitInstance(inComponent);
    }
 
    // Write the prototype component.
    // Note: The transformation matrix can be passed if needed for further processing.
    WriteComponent(prototype, Dtk_transfo());
 
    // Finalize PDF output for the instance if PDF export is enabled.
    if (IsPdfDumpActivated())
    {
        PdfEndInstance(pdfInstanceID, childID);
    }
 
    // Track the processed component by its ID to avoid redundant processing.
    if (ProcessedComponents.find(childID) < 0)
    {
        ProcessedComponents.push_back(childID);
    }
 
    return dtkNoError;
}

Sample to browse a Dtk_Component type Prototype

//****************************************************************************************************
//  This file provides a sample implementation for writing the contents of a CAD prototype component
//  using the Datakit API.
//****************************************************************************************************
 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
#include "../ThroughData/WriteNode.hpp"
#include "WriteComponent.hpp"
 
// Global variable for flattening assemblies (stores the current transformation matrix)
Dtk_transfo CurrentMatrix = Dtk_transfo();
 
// Global list to track processed components and avoid redundant processing
Dtk_tab<Dtk_ID> ProcessedComponents;
 
// Writes a prototype component, its children, and its construction tree.
void WritePrototype(Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix)
{
     // Get the component ID.
    Dtk_ID componentID = inComponent->GetID();
 
     // Check if the component has already been processed.
     // Only process the prototype if it hasn't been processed yet.
    Dtk_Int32 componentIndex = ProcessedComponents.find(componentID);
    if (componentIndex == -1)
    {
        Dtk_NodePtr rootNode;
 
          // Get the Datakit API instance.
        Dtk_API *myAPI = Dtk_API::GetAPI();
 
        // Recursively process all child components (instances, sub-assemblies, etc.).
        Dtk_Size_t numChildComponents = inComponent->GetNumChildren();
        for ( Dtk_Size_t i = 0; i < numChildComponents; i++)
        {
               // Get current child component.
            Dtk_ComponentPtr childComponent = inComponent->GetChild(i);
 
               // Recursively write the child component with the current transformation matrix.
            WriteComponent(childComponent, inMatrix);
        }
 
        // Read the construction tree for this prototype.
        Dtk_ErrorStatus errorStatus;
          if( inComponent->ComponentAvailability() == Dtk_Component::ComponentMissing )
          {
               errorStatus = dtkErrorFileNotExist;
          }
          else
          {
               errorStatus = myAPI->ReadComponent( inComponent, rootNode );
          }
 
        // If the construction tree is valid, process it.
        // A rootNode == NULL with err == dtkNoError means the component is empty.
        if (errorStatus == dtkNoError && rootNode.IsNotNULL())
        {
            // Set the current matrix for flattening assemblies.
            CurrentMatrix = inMatrix;
 
            // Recursively process the root node and its children.
            WriteNode(rootNode);
 
            // Write global data set and metadata to XML if XML export is enabled.
            if (IsXmlDumpActivated())
            {
                XmlWriteGlobalDataSet(inComponent->GetGlobalDataSet());
 
                Dtk_Size_t numMetaData = inComponent->GetNumMetaData();
                if (numMetaData)
                {
                    for ( Dtk_Size_t i = 0; i < numMetaData; i++)
                    {
                        XmlWriteMetaData(inComponent->GetMetaData(i));
                    }
                }
            }
        }
 
        // Write metadata to PDF if PDF export is enabled.
        if (IsPdfDumpActivated())
        {
            PdfWriteMetaData(inComponent);
        }
 
        // Finalize and free resources for the component.
        errorStatus = myAPI->EndComponent(inComponent);
    }
    else
    {
        // If the prototype has already been processed, handle the PDF instance case.
        // Use the unique ID returned by GetID() to map the component to your write ID.
        if (IsPdfDumpActivated())
        {
            PdfInstanceExistingPrototype(componentIndex);
        }
    }
}