Get Started

Enable the readers you need
Start Dtk_API
Open a Dtk_MainDoc from any format

Enable the readers you need

//*********************************************************************************************************************
//  This file demonstrates how to enable Datakit readers for various CAD and neutral formats.
//  It also shows how to set the schema directory required for certain readers (UG NX, SolidWorks, Solid Edge, CADDS).
//*********************************************************************************************************************
 
#include "datakit.h"
 
// If you want to link with libraries using PsKernel, uncomment the following line:
// #define USE_PSKERNEL
 
// Enables all supported readers in the Datakit API.
void EnableReaders()
{
     // Supported formats and their extensions:
     //   Acis:        .sat
     //   Catiav4:     .model (2D/3D), .session, .dlv
     //   Catiav5:     .CATDrawing, .CATPart, .CATProduct
     //   Cgr:         .cgr
     //   Dwg:         .dwg
     //   Iges:        .igs, .iges
     //   Inventor:    .ipt, .iam
     //   Jt:          .jt
     //   Parasolid:   .x_t, .x_b, .xmt
     //   Proe:        .prt, .asm
     //   Solid Edge:   .par, .asm
     //   Solidworks:  .sldprt, .sldasm
     //   Step:        .step, .stp
     //   UG NX:       .prt (2D/3D)
     //   Vda:         .vda
     //   ZW3D:        .z3prt, .z3asm, .z3
 
    // Enable the readers you want to use.
    _3dmReader::Enable();
    AcisReader::Enable();
#ifndef Linux
#ifndef ARM64
    CaddsReader::Enable();
#endif
#endif
    CatiaV4Reader::Enable();
    CatiaV5Reader::Enable();
    CatiaV6Reader::Enable();
    CerconReader::Enable();
    CerecReader::Enable();
    CgmReader::Enable();
    CgrReader::Enable();
    CreoviewReader::Enable();
    DcmReader::Enable();
    DwgDtkReader::Enable();
    F3dReader::Enable();
    FbxReader::Enable();
    GltfReader::Enable();
    IfcReader::Enable();
    IgesReader::Enable();
    InvReader::Enable();
    JtReader::Enable();
    LavaReader::Enable();
    NavisReader::Enable();
    ObjReader::Enable();
    PlmXmlReader::Enable();
    ProCeraReader::Enable();
    ProeReader::Enable();
#ifdef USE_PSKERNEL
    XmtReader::Enable();
#else
    PsReader::Enable();
#endif
    QifReader::Enable();
    RevitReader::Enable();
    SmgReader::Enable();
    StlReader::Enable();
    StepReader::Enable();
    SolidEdgeReader::Enable();
    SwReader::Enable();
    UgReader::Enable();
    VdaReader::Enable();
    Zw3dReader::Enable();
}
 
// Sets the Schema directory required for readers based on PsKernel (UG NX, SolidWorks, Solid Edge) or CADDS.
// Returns the status of the operation.
Dtk_ErrorStatus SetSchemaDirectory(Dtk_API *inOutMyApi)
{
    Dtk_ErrorStatus schemaStatus;
 
     // Define the schema directory path.
    Dtk_string schemaDirectory = "./Schema";
 
#ifndef Linux
    char tmpFullPathSchemaDir[_MAX_PATH];
 
    if (_fullpath(tmpFullPathSchemaDir, schemaDirectory.c_str(), _MAX_PATH) != NULL)
        schemaStatus = inOutMyApi->SetSchemaDir(tmpFullPathSchemaDir);
    else
        schemaStatus = inOutMyApi->SetSchemaDir(schemaDirectory);
#else 
    schemaStatus = inOutMyApi->SetSchemaDir(schemaDirectory);
#endif 
 
#ifdef USE_PSKERNEL
    if (schemaStatus != dtkNoError)
    {
        std::cout << "Schema directory error (required for readers based on PsKernel or CADDS): "
                  << dtkTypeError(schemaStatus).c_str() << std::endl;
    }
#endif
 
    return schemaStatus;
}

Start Dtk_API

//********************************************************************************************
//  This sample reads input files via the Datakit API and creates PDF and XML output files
//  in the same directory as the input files.
//  It can optionally generate an XML dump of features from the input files.
//********************************************************************************************
 
#include <time.h>
#include "datakit.h"
 
#include "../../TesselationEngine/TesselationEngine.hpp"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
#ifdef Linux
#include <unistd.h>
#endif
 
// Function declarations
extern void EnableReaders();
extern void ActivateApiOptions(Dtk_API *inoutMyApi);
extern void ActivateFeatureDump(Dtk_bool inDumpFeature);
extern Dtk_ErrorStatus SetSchemaDirectory(Dtk_API *inoutMyApi);
extern Dtk_ErrorStatus ProcessCADFile(const Dtk_string& inInputFile, const Dtk_string& inOutputFolder);
 
// Entry point for processing files via Datakit API.
// Reads input files and generates PDF and XML output files.
// Arguments: list of input files to process.
int LaunchAPISample(int argc, char **argv)
{
    ////////// Project Options //////////
      
    // Activate/Deactivate 3D PDF file creation (geometry, PMI, assembly, materials, etc.)
    // This option requires Datakit tessellation.
    ActivatePdfDump(DTK_TRUE);
 
    // Activate/Deactivate dumping of DTK classes to XML file.
    ActivateXmlDump(DTK_TRUE);
 
    // Activate/Deactivate dumping of features (only for CatiaV5, Proe, UG NX).
    ActivateFeatureDump(DTK_FALSE);
 
    ////////// End Project Options //////
 
    // Enable the readers you want to use.
    EnableReaders();
 
    // Set working directory for Dtk_API.
#ifndef Linux
    wchar_t temporaryWorkingDirectory[1024];
    wchar_t *retwc;
    retwc = _wgetcwd(temporaryWorkingDirectory, 1024);
#else
    char temporaryWorkingDirectory[1024];
    getcwd(temporaryWorkingDirectory, 1024);
#endif
 
     std::cout << "Starting DATAKIT API..." << std::endl;
 
     // Start DATAKIT API with the working directory.
     Dtk_ErrorStatus errorStatus = dtkNoError;
    Dtk_API *myApi = Dtk_API::StartAPI(temporaryWorkingDirectory, errorStatus);
    if (myApi == NULL)
    {
          // Report error if API fails to start.
        std::cout << "Can't start DATAKIT API (error code: " << errorStatus << ")" << std::endl;
        return dtkErrorAPINotStarted;
    }
     else
     {
          // Report successful API start.
          std::cout << "DATAKIT API started successfully." << std::endl << std::endl;
     }
 
    // Activate additional API options.
    ActivateApiOptions(myApi);
 
    // Initialize tessellation library if PDF export is enabled.
    if (IsPdfDumpActivated() == DTK_TRUE)
    {
        InitTesselation();
    }
 
    // Set Schema directory (required for some readers).
    SetSchemaDirectory(myApi);
 
    // Supported extensions: sat, prt, asm, igs, iges, jt, vda, CATDrawing, CATPart, CATProduct,
    // cgr, model, x_t, x_b, xmt, par, sldprt, step, stp, ipt, iam, dwg, and more.
     // Integration is identical for all supported file types.
 
    // Process each input file.
    for (int i = 1; i < argc; i++)
    {
        Dtk_string inputFile = argv[i];
 
          // Start measuring processing time.
        time_t startTime;
        time(&startTime);
 
          // Process the current file.
        Dtk_ErrorStatus curError = ProcessCADFile(inputFile, "");
 
          // Stop measuring processing time.
        time_t stopTime;
        time(&stopTime);
 
        if (curError)
        {
               // Report any errors encountered during processing.
            std::cout << "Error processing file: " << inputFile.c_str()
                      << " (" << dtkTypeError(curError).c_str() << ")" << std::endl;
        }
        else
        {
               // Report successful processing time.
            double elapsedTime = difftime(stopTime, startTime);
            std::cout << "File: " << inputFile.c_str()
                      << " successfully processed in " << elapsedTime << " s" << std::endl << std::endl;
        }
    }
 
    // Close tessellation kernel if PDF export is enabled.
    if (IsPdfDumpActivated() == DTK_TRUE)
    {
        EndTesselation();
    }
 
    // Stop DATAKIT API at the end.
    Dtk_API::StopAPI(myApi);
 
    std::cout << "Stopping DATAKIT API" << std::endl;
 
    return 0;
}

Open a Dtk_MainDoc from any format

//********************************************************************************************
//  This sample reads input files via the Datakit API and creates PDF and XML output files
//  in the same directory as the input files.
//  It can optionally generate an XML dump of features from the input files.
//********************************************************************************************
 
#include "datakit.h"
 
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
#include "../ThroughAssemblies/WriteComponent.hpp"
 
// Global variable to track processed components (see WriteComponent.hpp)
extern Dtk_tab<Dtk_ID> ProcessedComponents;
 
// Processes a CAD file: it reads the file, writes PDF/XML outputs, and handles logging.
// Returns a Dtk_ErrorStatus indicating success (dtkNoError) or failure of the operation.
Dtk_ErrorStatus ProcessCADFile(const Dtk_string& inInputFile, const Dtk_string& inOutputFolder)
{
     // Clear the list of processed components before starting.
    ProcessedComponents.clear();
 
    // Get the current Datakit API instance.
    Dtk_API* myApi = Dtk_API::GetAPI();
 
    std::cout << "Processing file: " << inInputFile.c_str() << std::endl;
 
    // Retrieve and display the file version.
    Dtk_string fileVersion;
     Dtk_ErrorStatus stError = myApi->GetFileVersion(inInputFile, fileVersion);
 
     if( fileVersion.is_not_NULL() )
     {
          // Display the file version.
          std::cout << "File version: " << fileVersion.c_str() << std::endl;
     }
 
    if (stError != dtkNoError)
    {
          // Report error if unable to get file version.
        std::cout << "Unable to get file version (error code:  " << dtkTypeError(stError).c_str() << ")" << std::endl;
        return stError;
    }
 
    // Set log file for the reader (inventory, missing files in assembly, etc.).
     Dtk_string logFilePath = inInputFile.filename() + Dtk_string("-dtk.log");
    myApi->SetLogFile( logFilePath );
 
     // Initialize XML writing if XML export is enabled.
     Dtk_ErrorStatus stErrorXml = dtkNoError;
    if (IsXmlDumpActivated())
    {
        stErrorXml = XmlWriteInit(inInputFile, inOutputFolder);
    }
 
     // Initialize PDF writing if PDF export is enabled.
     Dtk_ErrorStatus stErrorPdf = dtkNoError;
    if (IsPdfDumpActivated())
    {
        stErrorPdf = PdfInitWrite(inInputFile, inOutputFolder);
    }
 
    // Open the input file and obtain the corresponding document.
     Dtk_MainDocPtr tmpDoc;
    Dtk_ErrorStatus err = myApi->OpenDocument(inInputFile, tmpDoc);
 
     // If successful, write the document (see WriteDocument.cpp)
    if (err == dtkNoError && tmpDoc.IsNotNULL())
    {
        WriteDocument(tmpDoc);
    }
    else
    {
          // Report error if unable to open the document.
        std::cout << "Error with OpenDocument (error code: " << err << " " << dtkTypeError(err).c_str() << ")" << std::endl;
    }
 
    // Close the opened document.
    err = myApi->EndDocument(tmpDoc);
 
     // Finalize XML writing if XML export is enabled.
    if (IsXmlDumpActivated())
    {
        XmlWriteEnd();
    }
 
     // Finalize PDF writing if PDF export is enabled.
    if (IsPdfDumpActivated())
    {
        PdfEndWrite(inInputFile);
    }
 
    return err;
}