testlibcatiav5write.cpp File Reference

Functions
Dtk_ErrorStatus	CatiaV5WriteSample (const Dtk_string &inResultDirectory, const Dtk_string &inInputFilesDirectory)
Dtk_ErrorStatus	ProcessAsm (const Dtk_string &inResultDirectory, const Dtk_string &inInputFilesDirectory)
	Writes a CATProduct assembly: one sub-product referencing a CATPart and one instanced directly from an existing V5 file. More...
Dtk_ErrorStatus	ProcessPart (const Dtk_string &inOutputFile, const Dtk_string &inReferenceName)
std::wstring	resolvePath (const std::wstring &inRelativePath)
Dtk_ErrorStatus	WriteBodyMaterial (const Dtk_InfoPtr &inNodeInfo)
Dtk_ErrorStatus	WriteLayerData ()

Function Documentation

CatiaV5WriteSample()

Dtk_ErrorStatus CatiaV5WriteSample	(	const Dtk_string &	inResultDirectory,
		const Dtk_string &	inInputFilesDirectory
	)

{
     // First we initialize writing with name of files and protection fonction
     //First you have to initialize the CATIA V5 writer
     Dtk_string outputDirectory;
 
     std::cout << std::endl << "----------------------------------------------" << std::endl;
     std::cout << "CatiaV5 Write start" << std::endl;
 
     // Choosing output directory and file name
     outputDirectory = inResultDirectory + L"CatiaV5/";
     outputDirectory.FixPathSeparator();
     outputDirectory.mkdir();
 
     catiav5w::WriteOptions options;
     Dtk_ErrorStatus errorStatus = options.SetFileRelease( 20 );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     errorStatus = catiav5w::InitWrite( outputDirectory + L"V5W_LogFile.log", NULL, options );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     ProcessAsm( inResultDirectory, inInputFilesDirectory );
 
     //...and the Main writter
     catiav5w::EndWrite();
 
     return dtkNoError;
}

ProcessAsm()

Dtk_ErrorStatus ProcessAsm	(	const Dtk_string &	inResultDirectory,
		const Dtk_string &	inInputFilesDirectory
	)

Writes a CATProduct assembly: one sub-product referencing a CATPart and one instanced directly from an existing V5 file.

{
     Dtk_string outputDirectory;
     outputDirectory = inResultDirectory + "CatiaV5/";
     outputDirectory.FixPathSeparator();
 
     Dtk_string CATPartFileName = outputDirectory + L"V5_sample.CATPart";
     Dtk_string SubProductFileName = outputDirectory + L"SubProduct.CATProduct";
     Dtk_string RootProductFileName = outputDirectory + L"RootProduct.CATProduct";
 
     Dtk_string V5FileName = inInputFilesDirectory + L"CatiaV5/9.CATPart";
     //
     //Catia V5 does not support the paths L"../Input Files/Models/"
     std::wstring tempDirectoryFixed = resolvePath( inInputFilesDirectory.w_str() );
     Dtk_string outputDirectoryFixed = tempDirectoryFixed.c_str();
 
     outputDirectoryFixed.replace( L'\\', L'/' );
     Dtk_string CGRFileName = outputDirectoryFixed + L"CGR/Engine.cgr";
     Dtk_string V4ModelFileName = outputDirectoryFixed + L"CatiaV4/EngineComponent.model";
 
     CATPartFileName.FixPathSeparator();
     V5FileName.FixPathSeparator();
     CGRFileName.FixPathSeparator();
     V4ModelFileName.FixPathSeparator();
     SubProductFileName.FixPathSeparator();
     RootProductFileName.FixPathSeparator();
 
     Dtk_transfo TransformationMatrix;
 
     Dtk_ErrorStatus errorStatus;
 
     //The ProcessPart is an user implemented function to create a part
     errorStatus = ProcessPart( CATPartFileName, L"testPart" );
 
     //Reference creation to external files - V4 / CGR / existing v5 file -
     Dtk_ID PartID, V5ID, V4ID, CgrID;
     {
          //We create Document References to the CATPart file we create 
          errorStatus = catiav5w::CreatePartDocId( CATPartFileName, L"PartFile", PartID );
 
          //   to an existing CATPart file 
          errorStatus = catiav5w::CreatePartDocId( V5FileName, L"V5File", V5ID );
 
          //...and to a CGR file
          errorStatus = catiav5w::CreateCGRDocId( CGRFileName, "CGRFile", CgrID );
 
          //...and finally to a CATIA V4 '.model' file
          errorStatus = catiav5w::CreateV4ModelDocId( V4ModelFileName, "V4File", V4ID );
     }
 
     //We create the SubProduct 
     Dtk_ID SubProductID, VirtualSubComponent1ID, VirtualSubComponent2ID, PartInstanceID, VirtualSubComponent1_Instance1ID;
     Dtk_ID PartInstanceID2, CGRInstanceID, V4InstanceID, V5InstanceID, VirtualComponent1_Instance1ID;
     {
          //we init a CATProduct context...
          errorStatus = catiav5w::InitProduct( SubProductFileName, "SubProduct" );
 
          //we start a virtual component prototype
          errorStatus = catiav5w::InitVirtualComponent( "VirtualSubComponent1" );
          TransformationMatrix.setOrigin( 0, 0, 150 );
          errorStatus = catiav5w::AddInstance( PartID, L"PartInstance", TransformationMatrix, PartInstanceID );
          //we end the virtual component prototype
          errorStatus = catiav5w::EndVirtualComponent( VirtualSubComponent1ID );
 
          //we start another virtual component prototype
          errorStatus = catiav5w::InitVirtualComponent( "VirtualComponent1" );
          //we add the sub component instance...
          TransformationMatrix.setOrigin( 0.0, 0.0, 0.0 );
          errorStatus = catiav5w::AddVirtualComponentInstance( VirtualSubComponent1ID, L"VirtualSubComponent1_Instance1", TransformationMatrix, VirtualSubComponent1_Instance1ID );
          //we close the virtual component prototype
          errorStatus = catiav5w::EndVirtualComponent( VirtualSubComponent2ID );
          
          //we insert the created Part instance...
          TransformationMatrix.setOrigin( 0.0, 0.0, 0.0 );
          errorStatus = catiav5w::AddInstance( PartID, L"PartInstance", TransformationMatrix, PartInstanceID2 );
          //...a CGR instance
          TransformationMatrix.setOrigin( 0.0, 500.0, 0.0 );
          errorStatus = catiav5w::AddInstance( CgrID, L"CGRInstance", TransformationMatrix, CGRInstanceID );
          //...and a V4 instance
          TransformationMatrix.setOrigin( 0.0, -500.0, 0.0 );
          errorStatus = catiav5w::AddInstance( V4ID, L"V4Instance", TransformationMatrix, V4InstanceID );
          //...and an existing V5 instance
          TransformationMatrix.setOrigin( 0.0, -1000.0, 0.0 );
          errorStatus = catiav5w::AddInstance( V5ID, L"V5Instance", TransformationMatrix, V5InstanceID );
          //...and the main component instance
          TransformationMatrix.setOrigin( 0.0, 1000.0, 0.0 );
          errorStatus = catiav5w::AddVirtualComponentInstance( VirtualSubComponent2ID, L"VirtualComponent1_Instance1", TransformationMatrix, VirtualComponent1_Instance1ID );
 
          //we close the CATProduct context and retrieve the resulting DocID
          errorStatus = catiav5w::EndProduct( SubProductID );
     }
 
     //Now we create the RootProduct
     Dtk_ID RootProductID, PartInstance2ID, SubProductInstance1ID, SubProductInstance2ID;
     {
          //we create another CATProduct context
          errorStatus = catiav5w::InitProduct( RootProductFileName, "RootProduct" );
          //and we insert another time the a part instance - multinstancing management -
          TransformationMatrix.setOrigin( 0.0, 0.0, 50.0 );
          errorStatus = catiav5w::AddInstance( PartID, L"PartInstance2", TransformationMatrix, PartInstance2ID );
 
          //and two instances to the first CATProduct file
          TransformationMatrix.setOrigin( 1000.0, 0.0, 0.0 );
          errorStatus = catiav5w::AddInstance( SubProductID, L"SubProductInstance1", TransformationMatrix, SubProductInstance1ID );
          TransformationMatrix.setOrigin( -1000.0, 0.0, 0.0 );
 
          errorStatus = catiav5w::AddInstance( SubProductID, L"SubProductInstance2", TransformationMatrix, SubProductInstance2ID );
 
          //Now we create an instance PathID to handle override
          //We want to override SubProductInstance2/VirtualComponent1_Instance1/VirtualSubComponent1_Instance1/PartInstance
          {
               catiav5w::PathID Path1;
               Path1.push_back( SubProductInstance2ID );
               Path1.push_back( VirtualComponent1_Instance1ID );
               Path1.push_back( VirtualSubComponent1_Instance1ID );
               Path1.push_back( PartInstanceID );
 
               //We override Blanked status and color
               catiav5w::OverrideBlankedStatusWithPathID( Path1, DTK_TRUE );
               catiav5w::OverrideInstanceColorWithPathID( Path1, Dtk_RGB( 0, 0, 255 ) );
          }
 
          ////No we want to override SubProductInstance1/CGRInstance
          {
               catiav5w::PathID Path2;
               Path2.push_back( SubProductInstance1ID );
               Path2.push_back( CGRInstanceID );
 
               //We override Color and Alpha
               catiav5w::OverrideInstanceColorWithPathID( Path2, Dtk_RGB( 0, 255, 255 ) );
               catiav5w::OverrideInstanceAlphaWithPathID( Path2, 65 );
          }
          //finally we close the second CATProduct...
          errorStatus = catiav5w::EndProduct( RootProductID );
     }
 
     std::cout << "=> " << RootProductFileName.c_str() << std::endl << "CatiaV5 Write end" << std::endl;
     return errorStatus;
}

ProcessPart()

Dtk_ErrorStatus ProcessPart	(	const Dtk_string &	inOutputFile,
		const Dtk_string &	inReferenceName
	)

{
     Dtk_ErrorStatus errorStatus;
     // We construct a body with a solid
     Dtk_BodyPtr body_solid = sampleWriter::CreateCube();
 
     // We construct a body with an Open Shell
     Dtk_BodyPtr body_openshell = sampleWriter::CreateOpenShell();
 
     // We construct a body with Wireframe
     Dtk_BodyPtr body_wireframe = sampleWriter::CreateCurves();
 
     // We construct a body with a Point
     Dtk_BodyPtr body_point = sampleWriter::CreatePoint();
 
     // We construct a body with an Infinite Plane
     Dtk_BodyPtr body_plane = sampleWriter::CreateInfinitePlane();
 
     // We construct a body with an Infinite Line / Axis
     Dtk_BodyPtr body_axis = sampleWriter::CreateAxis();
 
     // We construct a mesh
     Dtk_MeshPtr mesh = sampleWriter::CreateMeshCylinder( 20 );
 
     Dtk_UUID PartUUID;
     //You init the Part writer 
     errorStatus = catiav5w::InitPart( inOutputFile, inReferenceName, PartUUID );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
 
     // We create a new group of entities with a name (you must create at least one group)
     // This sample make a surfacic group use to construct a solid
     Dtk_InfoPtr MyCurveSetInfo = Dtk_Info::Create();
     MyCurveSetInfo->SetName( L"MyCurveSet" );
     errorStatus = catiav5w::CreateNode( catiav5w::NodeTypeGeometricSet, MyCurveSetInfo );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     ////Writing Wire entities
     errorStatus = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_wireframe ) );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     errorStatus = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_point ) );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     // Close the group of entities
     errorStatus = catiav5w::CloseCurrentNode();
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
 
     Dtk_InfoPtr MyOpenShellInfo = Dtk_Info::Create();
     MyOpenShellInfo->SetName( L"MyOpenShell" );
     MyOpenShellInfo->SetLayer( 123 );
     MyOpenShellInfo->SetColor( Dtk_RGB( 255, 255, 0 ) );
     MyOpenShellInfo->SetBlankedStatus( DTK_TRUE );
     errorStatus = catiav5w::CreateNode( catiav5w::NodeTypeGeometricSet, MyOpenShellInfo );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     ////Writing OpenShell entity
     Dtk_InfoPtr& body_openshellInfo = body_openshell->info();
     if( body_openshellInfo.IsNULL() )
     {
          body_openshellInfo = Dtk_Info::Create();
     }
     body_openshellInfo->SetColor( Dtk_RGB( 0, 255, 0 ) );
     errorStatus = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_openshell ) );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     // Close the group of entities
     errorStatus = catiav5w::CloseCurrentNode();
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
 
     // We create a solid group with a name 
     Dtk_InfoPtr MySolidInfo = Dtk_Info::Create();
     MySolidInfo->SetName( L"My Solid" );
     MySolidInfo->SetLayer( 12 );
     MySolidInfo->SetColor( Dtk_RGB( 255, 0, 255 ) );
 
     //The material is assigned on the node info so it applies to the whole PartBody
     errorStatus = WriteBodyMaterial( MySolidInfo );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     errorStatus = catiav5w::CreateNode( catiav5w::NodeTypePartBody, MySolidInfo );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     // And we write body in the catiav5 file
     Dtk_InfoPtr& body_solidInfo = body_solid->info();
     if( body_solidInfo.IsNULL() )
     {
          body_solidInfo = Dtk_Info::Create();
     }
     body_solidInfo->SetColor( Dtk_RGB( 255, 0, 0 ) );
     errorStatus = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_solid ) );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     // Close the group of entities
     errorStatus = catiav5w::CloseCurrentNode();
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     Dtk_InfoPtr MyOpenShellForMeshInfo = Dtk_Info::Create();
     MyOpenShellForMeshInfo->SetName( L"MyOpenShellForMesh" );
     errorStatus = catiav5w::CreateNode( catiav5w::NodeTypeGeometricSet, MyOpenShellForMeshInfo );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     ////Writing Mesh entity
     errorStatus = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( mesh ) );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     // Close the group of entities
     errorStatus = catiav5w::CloseCurrentNode();
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     Dtk_InfoPtr MyOpenShellForPlaneInfo = Dtk_Info::Create();
     MyOpenShellForPlaneInfo->SetName( L"MyOpenShellForPlane" );
     errorStatus = catiav5w::CreateNode( catiav5w::NodeTypeGeometricSet, MyOpenShellForPlaneInfo );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     ////Writing Plane entity
     errorStatus = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_plane ) );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     // Close the group of entities
     errorStatus = catiav5w::CloseCurrentNode();
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     Dtk_InfoPtr MyOpenShellForInifiniteLineInfo = Dtk_Info::Create();
     MyOpenShellForInifiniteLineInfo->SetName( L"MyOpenShellForInifiniteLine" );
     errorStatus = catiav5w::CreateNode( catiav5w::NodeTypeGeometricSet, MyOpenShellForInifiniteLineInfo );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     ////Writing Plane entity
     errorStatus = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_axis ) );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     // Close the group of entities
     errorStatus = catiav5w::CloseCurrentNode();
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     //Now we will create an AxisSystem
     Dtk_AxisSystemPtr TmpAxis = sampleWriter::CreateAxisSystem();
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     //we write it now
     errorStatus = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( TmpAxis ) );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     //We create a default Named View - Camera -
     //For that we firstly create a camera
     Dtk_CameraPtr Cam = Dtk_Camera::Create(
          Dtk_pnt( 200, 100, 100 ),     //Origin Point
          Dtk_pnt( 0, 100, 100 ),       //Target Point
          100., 100.,                        //SemiWidth / SemiHeight
          Dtk_dir( 0, 1, 0 ) );         //Up Vector - can be reprocessed by CatiaV5 if needed -
 
     //We create the model display from the camera
     //We don't put any clipping entity - not used by V5 write -
     //The 3rd parameter set the Named View as the default one - used at the V5 file opening -
     Dtk_ModelDisplayPtr NamedView = Dtk_ModelDisplay::Create( Cam, NULL, DTK_TRUE );
     //We don't need any name because the default Named View name is hardcoded
     //Finally we write the NamedView
     errorStatus = catiav5w::WriteNamedView( NamedView );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
 
     //Now we create another named view
     Cam = Dtk_Camera::Create( Dtk_pnt( 100, 100, 100 ), Dtk_pnt( 0, 0, 0 ), 100., 100., Dtk_dir( 0, 1, 0 ) );
     //Not set as default => will appear in the 'Named Views' Dialog Box into Catia V5
     NamedView = Dtk_ModelDisplay::Create( Cam, NULL, DTK_FALSE );
     NamedView->info() = Dtk_Info::Create();
     //We put the Named view name
     NamedView->info()->SetName( L"MyNamedView" );
     //Finally we write the NamedView
     errorStatus = catiav5w::WriteNamedView( NamedView );
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     //Now we write layer data - Layers Names and Layer Filters -
     errorStatus = WriteLayerData();
     if( errorStatus != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( errorStatus ).c_str() << std::endl;
          return errorStatus;
     }
 
     // Close the current part
     errorStatus = catiav5w::EndPart();
 
     return errorStatus;
}

resolvePath()

std::wstring resolvePath

(

const std::wstring &

inRelativePath

)

{
#ifdef _MSC_VER
     wchar_t buffer[ MAX_PATH ];
     DWORD len = GetFullPathNameW( inRelativePath.c_str(), MAX_PATH, buffer, nullptr );
     return std::wstring( buffer, len );
#else
     // --- Linux/macOS : std::string ---
     // Simply convert the wstring to a plain string
     // (assumes UTF-8 if the source file is encoded in UTF-8)
     std::string utf8( inRelativePath.begin(), inRelativePath.end() );
 
     char buffer[ PATH_MAX ];
     if( realpath( utf8.c_str(), buffer ) != nullptr )
     {
          // Convert back to a simple wstring
          return std::wstring( buffer, buffer + strlen( buffer ) );
     }
     else
     {
          return inRelativePath; // path does not exist
     }
#endif
}

WriteBodyMaterial()

Dtk_ErrorStatus WriteBodyMaterial

(

const Dtk_InfoPtr &

inNodeInfo

)

{
     //CATIA requires at least the Lighting data to be set for the material to be considered valid; otherwise the material will render as gray
     catiav5w::Material material( L"BlueMaterial" );
     material.m_Lighting.SetAmbientData( Dtk_RGB( 40, 40, 255 ), 0.6 );
     material.m_Lighting.SetDiffuseData( Dtk_RGB( 80, 80, 255 ), 1.0 );
     material.m_Lighting.SetSpecularData( Dtk_RGB( 255, 255, 255 ), 0.9 );
     material.m_Lighting.SetTransparencyData( Dtk_RGB( 0, 0, 0 ), 0. );
     material.m_Lighting.SetReflectivityCoefficient( 0.4 );
 
     //...and its physical aspect - used for mass properties computation -
     material.m_Analysis.SetDensity( 7850. ); //kg/m3 - Steel -
 
     //We add the material to the CATPart context...
     catiav5w::MaterialId materialId;
     Dtk_ErrorStatus errorStatus = catiav5w::AddMaterial( material, materialId );
     if( errorStatus != dtkNoError )
     {
          return errorStatus;
     }
 
     //...and we assign it to the node through its Info
     return inNodeInfo->SetRenderInfosId( materialId );
}

WriteLayerData()

Dtk_ErrorStatus WriteLayerData

(

)

{
     //Keep in mind that layer data can only be set into CATPart context.
     auto layerInfoSet = sampleWriter::layer::CreateSetWithFilters();
 
     //We send layer data to the writer
     return catiav5w::SetLayerData( layerInfoSet );
}