WriteParasolid.cpp File Reference

Functions
Dtk_string	PswGetLastOutputFile ()
const Dtk_tab< char > &	PswGetLastStream ()
static Dtk_ID	PswGetOrWritePrototype (Dtk_ComponentPtr inPrototype)
static void	PswWriteComponent (Dtk_ComponentPtr inComponent, Dtk_ID inParentAssemblyId)
void	PswWriteDocument (Dtk_MainDocPtr inDocument)
Dtk_ErrorStatus	PswWriteEnd ()
Dtk_ErrorStatus	PswWriteInit (const Dtk_string &inInputFile, const Dtk_string &inOutputFolder)
Dtk_ErrorStatus	PswWriteInitMemory ()
void	PswWriteNode (Dtk_NodePtr inNode, Dtk_tab< Dtk_ID > &outIds)

Variables
static Dtk_string	g_lastOutputFile
static Dtk_tab< char >	g_lastStream
static map< Dtk_ID, Dtk_ID >	g_prototypeCache

Function Documentation

PswGetLastOutputFile()

Dtk_string PswGetLastOutputFile

(

)

{
     return g_lastOutputFile;
}

PswGetLastStream()

const Dtk_tab<char>& PswGetLastStream

(

)

{
     return g_lastStream;
}

PswGetOrWritePrototype()

static Dtk_ID PswGetOrWritePrototype ( Dtk_ComponentPtr  inPrototype )

static

{
     if( inPrototype.IsNULL() )
          return 0;
 
     Dtk_ID compId = inPrototype->GetID();
 
     // Return cached entity ID if already written.
     auto it = g_prototypeCache.find( compId );
     if( it != g_prototypeCache.end() )
          return it->second;
 
     Dtk_API* api = Dtk_API::GetAPI();
     Dtk_Size_t numChildren = inPrototype->GetNumChildren();
     bool hasSubComponents = ( numChildren > 0 );
 
     // --- Handle sub-components (children are instances of sub-prototypes) ---
     Dtk_ID assemblyId = 0;
     if( hasSubComponents )
     {
          // Create a Parasolid sub-assembly to hold all sub-instances.
          psw_CreateEmptyAssembly( assemblyId );
 
          for( Dtk_Size_t i = 0; i < numChildren; ++i )
               PswWriteComponent( inPrototype->GetChild( i ), assemblyId );
     }
 
     // --- Read and write the geometric content of this prototype ---
     Dtk_NodePtr rootNode;
     Dtk_ErrorStatus err = dtkNoError;
 
     if( inPrototype->IsAvailabilityFlaggedAs( Dtk_Component::ComponentMissing ) )
     {
          err = dtkErrorFileNotExist;
          cout << "Warning: component file missing for '"
               << inPrototype->Name().c_str() << "'" << endl;
     }
     else
     {
          err = api->ReadComponent( inPrototype, rootNode );
     }
 
     Dtk_tab<Dtk_ID> bodyIds;
     if( err == dtkNoError && rootNode.IsNotNULL() )
     {
          PswWriteNode( rootNode, bodyIds );
     }
     else if( err != dtkNoError && err != dtkErrorFileNotExist )
     {
          cout << "Warning: ReadComponent failed: " << dtkTypeError( err ).c_str() << endl;
     }
 
     // Always close the component after ReadComponent (even on error).
     if( err != dtkErrorFileNotExist )
          api->EndComponent( inPrototype );
 
     // --- Build the resulting Parasolid entity ---
     Dtk_ID entityId = 0;
     Dtk_string name = inPrototype->Name();
 
     if( hasSubComponents )
     {
          // Add body instances to the prototype's sub-assembly (identity placement).
          if( bodyIds.size() > 0 )
          {
               Dtk_transfoPtr identity = Dtk_transfo::Create();
               for( Dtk_Size_t i = 0; i < bodyIds.size(); ++i )
               {
                    Dtk_ID instId = 0;
                    psw_CreateInstance( assemblyId, bodyIds[ i ], identity, instId );
               }
          }
          // Set the prototype name on the sub-assembly.
          if( name.len() > 0 )
          {
               Dtk_InfoPtr info = Dtk_Info::Create();
               info->SetName( name );
               psw_CreateAttribut( assemblyId, info );
          }
          psw_LinkAttribut( assemblyId );
          entityId = assemblyId;
     }
     else
     {
          if( bodyIds.size() == 1 )
          {
               // Single body: use it directly as the entity.
               entityId = bodyIds[ 0 ];
               if( name.len() > 0 )
               {
                    Dtk_InfoPtr info = Dtk_Info::Create();
                    info->SetName( name );
                    psw_CreateAttribut( entityId, info );
               }
          }
          else if( bodyIds.size() > 1 )
          {
               // Multiple bodies: wrap them in a sub-assembly.
               psw_CreateEmptyAssembly( assemblyId );
               Dtk_transfoPtr identity = Dtk_transfo::Create();
               for( Dtk_Size_t i = 0; i < bodyIds.size(); ++i )
               {
                    Dtk_ID instId = 0;
                    psw_CreateInstance( assemblyId, bodyIds[ i ], identity, instId );
               }
               if( name.len() > 0 )
               {
                    Dtk_InfoPtr info = Dtk_Info::Create();
                    info->SetName( name );
                    psw_CreateAttribut( assemblyId, info );
               }
               psw_LinkAttribut( assemblyId );
               entityId = assemblyId;
          }
          // If bodyIds is empty: component has no geometry (e.g. skeleton), entityId stays 0.
     }
 
     // Cache the result.
     if( entityId != 0 )
          g_prototypeCache[ compId ] = entityId;
 
     return entityId;
}

PswWriteComponent()

static void PswWriteComponent ( Dtk_ComponentPtr  inComponent, Dtk_ID  inParentAssemblyId  )

static

{
     if( inComponent.IsNULL() )
          return;
 
     Dtk_Component::ComponentTypeEnum type = inComponent->ComponentType();
 
     switch( type )
     {
          // Instance: a reference to a prototype with a placement matrix.
          case Dtk_Component::InstanceComponentType:
          {
               // The prototype is always child[0] of an instance.
               Dtk_ComponentPtr prototype = inComponent->GetChild( 0 );
 
               Dtk_ID protoEntityId = PswGetOrWritePrototype( prototype );
               if( protoEntityId == 0 )
                    break;
 
               // Build the placement matrix from the instance.
               Dtk_transfoPtr matrix = Dtk_transfo::Create( inComponent->TransformationMatrix() );
 
               Dtk_ID instanceId = 0;
               psw_CreateInstance( inParentAssemblyId, protoEntityId, matrix, instanceId );
 
               // Optionally set the instance name.
               Dtk_string instanceName = inComponent->InstanceName();
               if( instanceName.is_NULL() )
                    instanceName = inComponent->Name();
               if( instanceName.len() > 0 )
               {
                    Dtk_InfoPtr info = Dtk_Info::Create();
                    info->SetName( instanceName );
                    psw_CreateAttribut( instanceId, info );
               }
               break;
          }
 
          // Prototype encountered directly (rare at top level): write and instantiate.
          case Dtk_Component::PrototypeComponentType:
          {
 
               Dtk_ID entityId = PswGetOrWritePrototype( inComponent );
               if( entityId == 0 )
                    break;
               Dtk_transfoPtr identity = Dtk_transfo::Create();
               Dtk_ID instanceId = 0;
               psw_CreateInstance( inParentAssemblyId, entityId, identity, instanceId );
               break;
          }
 
          // Catalog: multiple configurations; use the default one.
          case Dtk_Component::CatalogComponentType:
          {
               // 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();
 
               // 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 ] );
                         PswWriteComponent( activatedComponent, inParentAssemblyId );
                    }
               }
               else
               {
                    // Write the default component
                    Dtk_ComponentPtr defaultChildComponent = inComponent->GetChild( defaultComponentIndex );
                    PswWriteComponent( defaultChildComponent, inParentAssemblyId );
               }
               break;
          }
 
          // Virtual: a grouping node with no geometry of its own.
          case Dtk_Component::VirtualComponentType:
          {
               Dtk_Size_t n = inComponent->GetNumChildren();
               for( Dtk_Size_t i = 0; i < n; ++i )
                    PswWriteComponent( inComponent->GetChild( i ), inParentAssemblyId );
               break;
          }
     }
}

PswWriteDocument()

void PswWriteDocument

(

Dtk_MainDocPtr

inDocument

)

{
     g_prototypeCache.clear();
 
     Dtk_ComponentPtr rootComponent = inDocument->RootComponent();
     if( rootComponent.IsNULL() )
     {
          cout << "Warning: document has no root component." << endl;
          return;
     }
 
     // Always create a top-level Parasolid assembly to hold the entire document.
     Dtk_ID rootAssemblyId = 0;
     psw_CreateEmptyAssembly( rootAssemblyId );
 
     // Set the document/root name on the assembly.
     Dtk_string docName = rootComponent->Name();
     if( docName.len() > 0 )
     {
          Dtk_InfoPtr info = Dtk_Info::Create();
          info->SetName( docName );
          psw_CreateAttribut( rootAssemblyId, info );
     }
 
     // Recursively traverse the component tree and fill the root assembly.
     PswWriteComponent( rootComponent, rootAssemblyId );
 
     // Finalise the root assembly (must be called once all instances are added).
     psw_LinkAttribut( rootAssemblyId );
 
     g_prototypeCache.clear();
}

PswWriteEnd()

Dtk_ErrorStatus PswWriteEnd

(

)

{
     Dtk_tab<Dtk_ID> emptyIds; // Root assembly is implicit when the tab is empty.
     Dtk_ErrorStatus err = psw_EndFile( emptyIds );
     if( err != dtkNoError )
          cout << "Warning: psw_EndFile failed: " << dtkTypeError( err ).c_str() << endl;
     return err;
}

PswWriteInit()

Dtk_ErrorStatus PswWriteInit	(	const Dtk_string &	inInputFile,
		const Dtk_string &	inOutputFolder
	)

{
     g_prototypeCache.clear();
     g_lastStream.clear();
 
     Dtk_string outputFile;
     if( inOutputFolder.len() > 0 )
          outputFile = inOutputFolder + inInputFile.filename() + inInputFile.extension() + L"_psw.x_t";
     else
          outputFile = inInputFile + L"_psw.x_t";
 
     // Persist the output path so callers can retrieve it via PswGetLastOutputFile().
     g_lastOutputFile = outputFile;
 
     const Dtk_bool muteMode = DTK_TRUE; // Suppress the psw internal log file.
     Dtk_ErrorStatus err = psw_InitFile( outputFile, muteMode );
 
     if( err == dtkNoError )
          cout << "Creating Parasolid file: " << outputFile.c_str() << endl;
     else
          cout << "Warning: psw_InitFile failed: " << dtkTypeError( err ).c_str() << endl;
 
     return err;
}

PswWriteInitMemory()

Dtk_ErrorStatus PswWriteInitMemory

(

)

{
     g_prototypeCache.clear();
     g_lastStream.clear();
     g_lastOutputFile = Dtk_string();   // no output file in memory mode
 
     const Dtk_bool muteMode = DTK_TRUE;
     Dtk_ErrorStatus err = psw_InitFile( g_lastStream, muteMode );
 
     if( err == dtkNoError )
          cout << "Parasolid writer: using in-memory stream (no .x_t file)." << endl;
     else
          cout << "Warning: psw_InitFile (memory) failed: " << dtkTypeError( err ).c_str() << endl;
 
     return err;
}

PswWriteNode()

void PswWriteNode	(	Dtk_NodePtr	inNode,
		Dtk_tab< Dtk_ID > &	outIds
	)

{
     if( inNode.IsNULL() )
          return;
 
     int blanked = inNode->GetInfos()->GetBlankedStatus();
     // Skip invisible nodes (blanked == 1); keep visible (0) and construction (2).
     if( blanked == 1 )
     {
          // Invisible body nodes may still have visible children – recurse anyway.
          Dtk_Size_t n = inNode->GetNumChildren();
          for( Dtk_Size_t i = 0; i < n; ++i )
               PswWriteNode( inNode->GetChild( i ), outIds );
          return;
     }
 
     Dtk_Node::FullType nodeType = inNode->GetNodeFullType();
 
     switch( nodeType.PrimaryType() )
     {
          case Dtk_Node::BodyType:
          {
               // Skip infinite geometry (datum planes, axes, …)
               if( inNode->GetInfos()->GetInfiniteGeometryFlag() != 0 )
                    break;
 
 
               // Write B-Rep body data directly when available and visible
               Dtk_BodyPtr body = inNode->GetDtk_BodyPtr();
 
               // Write the body only if it is not blanked 
               if( body.IsNotNULL() && blanked == 0 )
               {
                    // Write the body only if it has solids or surfaces 
                    if(  inNode->NodeHasSolids() || inNode->NodeHasSurfaces()  )
                         WriteBodyForParasolid( body, outIds );
                    else //better to handle on your own the wire or point body (Parasolid modeler is not intend to handle such body)
                         cout << "Warning: skipping body node '" << inNode->Name().c_str() << "' because it has no solids or surfaces." << endl;
               }
               break;
          }
 
          case Dtk_Node::MeshType:
          {
               // Write faceted (mesh) data directly when no B-Rep is available and visible
               Dtk_MeshPtr mesh = inNode->GetDtk_MeshPtr();
               if( mesh.IsNotNULL() && blanked == 0 )
               {
                    Dtk_tab<Dtk_ID> meshIds;
                    Dtk_ErrorStatus err = psw_WriteMesh( mesh, meshIds );
                    if( err == dtkNoError )
                    {
                         for( Dtk_Size_t i = 0; i < meshIds.size(); ++i )
                              outIds.push_back( meshIds[ i ] );
                    }
                    else
                    {
                         cout << "Warning: psw_WriteMesh failed: " << dtkTypeError( err ).c_str() << endl;
                    }
               }
               break;
          }
 
          default:
               break;
     }
 
     // Recurse into child nodes.
     Dtk_Size_t n = inNode->GetNumChildren();
     for( Dtk_Size_t i = 0; i < n; ++i )
          PswWriteNode( inNode->GetChild( i ), outIds );
}

Variable Documentation

g_lastOutputFile

Dtk_string g_lastOutputFile

static

g_lastStream

Dtk_tab<char> g_lastStream

static

g_prototypeCache

map<Dtk_ID, Dtk_ID> g_prototypeCache

static