CatiaV5 Write Sample

//start_of_maincatiav5write
 
//This sample show you how to write layer data - Layers Names and Layer Filters -
Dtk_ErrorStatus WriteLayerData()
{
     //Keep in mind that layer data can only be set into CATPart context.
 
     //We will add 9 layers to the layer info set so we have to allocate the correct size
     Dtk_LayerInfosSetPtr layerInfoSet = Dtk_LayerInfosSet::Create( 9 );
     //we use a layer Idx to correctly handle the layers count
     Dtk_Size_t LayerIdx = 0;
     //1st layer - 888 -
     Dtk_Size_t Layer888Idx = LayerIdx++; layerInfoSet->SetLayerID( Layer888Idx, 888 ); layerInfoSet->SetLayerName( Layer888Idx, L"My First Layer" );
 
     //2nd layer - 111 -
     Dtk_Size_t Layer111Idx = LayerIdx++; layerInfoSet->SetLayerID( Layer111Idx, 111 ); layerInfoSet->SetLayerName( Layer111Idx, L"My Second Layer" );
 
     //3rd layer - 987 -
     Dtk_Size_t Layer987Idx = LayerIdx++; layerInfoSet->SetLayerID( Layer987Idx, 987 ); layerInfoSet->SetLayerName( Layer987Idx, L"My Third Layer" );
 
     //4th layer - 4 -
     Dtk_Size_t Layer4Idx = LayerIdx++;      layerInfoSet->SetLayerID( Layer4Idx, 4 );
 
     //5th layer - 5 -
     Dtk_Size_t Layer5Idx = LayerIdx++;      layerInfoSet->SetLayerID( Layer5Idx, 5 );
 
     //6th layer - 6 -
     Dtk_Size_t Layer6Idx = LayerIdx++;      layerInfoSet->SetLayerID( Layer6Idx, 6 );
 
     //7th layer - 10 -
     Dtk_Size_t Layer10Idx = LayerIdx++; layerInfoSet->SetLayerID( Layer10Idx, 10 );
 
     //8th layer - 11 -
     Dtk_Size_t Layer11Idx = LayerIdx++; layerInfoSet->SetLayerID( Layer11Idx, 11 );
 
     //9th layer - 12 -
     Dtk_Size_t Layer12Idx = LayerIdx++; layerInfoSet->SetLayerID( Layer12Idx, 12 );
 
 
     // 2 layer filters :
     //The first one gathers layers 4 - 5 - 6
     Dtk_LayerFilterInfosPtr filter4_5_6 = layerInfoSet->CreateLayerFilterInfos( "FILTER_4-5-6", "MyDescription", DTK_FALSE, DTK_FALSE );
     Dtk_tab<Dtk_Size_t> layers4_5_6;
     layers4_5_6.push_back( Layer4Idx ); layers4_5_6.push_back( Layer5Idx ); layers4_5_6.push_back( Layer6Idx );
     filter4_5_6->SelectLayers( layers4_5_6 );
 
     //The second one gathers layers 10 - 11 - 12
     Dtk_LayerFilterInfosPtr filter10_11_12 = layerInfoSet->CreateLayerFilterInfos( "FILTER_10-11-12" );
     Dtk_tab<Dtk_Size_t> layers10_11_12;
     layers10_11_12.push_back( Layer10Idx ); layers10_11_12.push_back( Layer11Idx ); layers10_11_12.push_back( Layer12Idx );
     filter10_11_12->SelectLayers( layers10_11_12 );
 
     //We send layer data to the writer
     return catiav5w::SetLayerData( layerInfoSet );
}
//This sample show you how to write a body with an unbounded surface and wireframe entity.
Dtk_ErrorStatus ProcessPart( const Dtk_string& inOutputFile, const Dtk_string& inReferenceName )
{
     Dtk_ErrorStatus err;
     // 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 
     err = catiav5w::InitPart( inOutputFile, inReferenceName, PartUUID );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
 
     // 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" );
     err = catiav5w::CreateNode( catiav5w::NodeTypeGeometricSet, MyCurveSetInfo );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     err = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_wireframe ) );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     err = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_point ) );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     // Close the group of entities
     err = catiav5w::CloseCurrentNode();
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
 
     Dtk_InfoPtr MyOpenShellInfo = Dtk_Info::create();
     MyOpenShellInfo->SetName( L"MyOpenShell" );
     MyOpenShellInfo->SetLayer( 123 );
     MyOpenShellInfo->SetColor( Dtk_RGB( 255, 255, 0 ) );
     MyOpenShellInfo->SetBlankedStatus( DTK_TRUE );
     err = catiav5w::CreateNode( catiav5w::NodeTypeGeometricSet, MyOpenShellInfo );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     Dtk_InfoPtr& body_openshellInfo = body_openshell->info();
     if( body_openshellInfo.IsNULL() )
     {
          body_openshellInfo = Dtk_Info::create();
     }
     body_openshellInfo->SetColor( Dtk_RGB( 0, 255, 0 ) );
     err = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_openshell ) );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     // Close the group of entities
     err = catiav5w::CloseCurrentNode();
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
 
     // 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 ) );
     err = catiav5w::CreateNode( catiav5w::NodeTypePartBody, MySolidInfo );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     // 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 ) );
     err = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_solid ) );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     // Close the group of entities
     err = catiav5w::CloseCurrentNode();
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     Dtk_InfoPtr MyOpenShellForMeshInfo = Dtk_Info::create();
     MyOpenShellForMeshInfo->SetName( L"MyOpenShellForMesh" );
     err = catiav5w::CreateNode( catiav5w::NodeTypeGeometricSet, MyOpenShellForMeshInfo );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     err = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( mesh ) );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     // Close the group of entities
     err = catiav5w::CloseCurrentNode();
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     Dtk_InfoPtr MyOpenShellForPlaneInfo = Dtk_Info::create();
     MyOpenShellForPlaneInfo->SetName( L"MyOpenShellForPlane" );
     err = catiav5w::CreateNode( catiav5w::NodeTypeGeometricSet, MyOpenShellForPlaneInfo );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     err = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_plane ) );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     // Close the group of entities
     err = catiav5w::CloseCurrentNode();
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     Dtk_InfoPtr MyOpenShellForInifiniteLineInfo = Dtk_Info::create();
     MyOpenShellForInifiniteLineInfo->SetName( L"MyOpenShellForInifiniteLine" );
     err = catiav5w::CreateNode( catiav5w::NodeTypeGeometricSet, MyOpenShellForInifiniteLineInfo );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     err = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( body_axis ) );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     // Close the group of entities
     err = catiav5w::CloseCurrentNode();
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     //Now we will create an AxisSystem
     Dtk_AxisSystemPtr TmpAxis = sampleWriter::CreateAxisSystem();
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     //we write it now
     err = catiav5w::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( TmpAxis ) );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     //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
     err = catiav5w::WriteNamedView( NamedView );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
 
     //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
     err = catiav5w::WriteNamedView( NamedView );
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     //Now we write layer data - Layers Names and Layer Filters -
     err = WriteLayerData();
     if( err != dtkNoError )
     {
          std::cout << "error : " << dtkTypeError( err ) << std::endl;
          return err;
     }
 
     // Close the current part
     err = catiav5w::EndPart();
 
     return err;
}
 
Dtk_ErrorStatus ProcessAsm( const Dtk_string &inResultDirectory )
{
     Dtk_string outputDirectory;
     outputDirectory = inResultDirectory + "CatiaV5/";
     outputDirectory.FixPathSeparator();
 
     Dtk_string CATPartFileName = outputDirectory + L"V5_sample.CATPart";
     Dtk_string V5FileName = inResultDirectory + L"CatiaV5/9.CATPart";
     Dtk_string CGRFileName = inResultDirectory + L"CGR/Engine.cgr";
     Dtk_string V4ModelFileName = inResultDirectory + L"CatiaV4/EngineComponent.model";
     Dtk_string SubProductFileName = outputDirectory + L"SubProduct.CATProduct";
     Dtk_string RootProductFileName = outputDirectory + L"RootProduct.CATProduct";
     CATPartFileName.FixPathSeparator();
     V5FileName.FixPathSeparator();
     CGRFileName.FixPathSeparator();
     V4ModelFileName.FixPathSeparator();
     SubProductFileName.FixPathSeparator();
     RootProductFileName.FixPathSeparator();
 
     Dtk_transfo TransformationMatrix;
 
     Dtk_ErrorStatus err;
 
     //The ProcessPart is an user implemented function to create a part
     err = 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 
          err = catiav5w::CreatePartDocId( CATPartFileName, L"PartFile", PartID );
 
          //   to an existing CATPart file 
          err = catiav5w::CreatePartDocId( V5FileName, L"V5File", V5ID );
 
          //...and to a CGR file
          err = catiav5w::CreateCGRDocId( CGRFileName, "CGRFile", CgrID );
 
          //...and finally to a CATIA V4 '.model' file
          err = 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...
          err = catiav5w::InitProduct( SubProductFileName, "SubProduct" );
 
          //we start a virtual component prototype
          err = catiav5w::InitVirtualComponent( "VirtualSubComponent1" );
          TransformationMatrix.setOrigin( 0, 0, 150 );
          err = catiav5w::AddInstance( PartID, L"PartInstance", TransformationMatrix, PartInstanceID );
          //we end the virtual component prototype
          err = catiav5w::EndVirtualComponent( VirtualSubComponent1ID );
 
          //we start another virtual component prototype
          err = catiav5w::InitVirtualComponent( "VirtualComponent1" );
          //we add the sub component instance...
          TransformationMatrix.setOrigin( 0.0, 0.0, 0.0 );
          err = catiav5w::AddVirtualComponentInstance( VirtualSubComponent1ID, L"VirtualSubComponent1_Instance1", TransformationMatrix, VirtualSubComponent1_Instance1ID );
          //we close the virtual component prototype
          err = catiav5w::EndVirtualComponent( VirtualSubComponent2ID );
          
          //we insert the created Part instance...
          TransformationMatrix.setOrigin( 0.0, 0.0, 0.0 );
          err = catiav5w::AddInstance( PartID, L"PartInstance", TransformationMatrix, PartInstanceID2 );
          //...a CGR instance
          TransformationMatrix.setOrigin( 0.0, 500.0, 0.0 );
          err = catiav5w::AddInstance( CgrID, L"CGRInstance", TransformationMatrix, CGRInstanceID );
          //...and a V4 instance
          TransformationMatrix.setOrigin( 0.0, -500.0, 0.0 );
          err = catiav5w::AddInstance( V4ID, L"V4Instance", TransformationMatrix, V4InstanceID );
          //...and an existing V5 instance
          TransformationMatrix.setOrigin( 0.0, -1000.0, 0.0 );
          err = catiav5w::AddInstance( V5ID, L"V5Instance", TransformationMatrix, V5InstanceID );
          //...and the main component instance
          TransformationMatrix.setOrigin( 0.0, 1000.0, 0.0 );
          err = catiav5w::AddVirtualComponentInstance( VirtualSubComponent2ID, L"VirtualComponent1_Instance1", TransformationMatrix, VirtualComponent1_Instance1ID );
 
          //we close the CATProduct context and retrieve the resulting DocID
          err = catiav5w::EndProduct( SubProductID );
     }
 
     //Now we create the RootProduct
     Dtk_ID RootProductID, PartInstance2ID, SubProductInstance1ID, SubProductInstance2ID;
     {
          //we create another CATProduct context
          err = catiav5w::InitProduct( RootProductFileName, "RootProduct" );
          //and we insert another time the a part instance - multinstancing management -
          TransformationMatrix.setOrigin( 0.0, 0.0, 50.0 );
          err = catiav5w::AddInstance( PartID, L"PartInstance2", TransformationMatrix, PartInstance2ID );
 
          //and two instances to the first CATProduct file
          TransformationMatrix.setOrigin( 1000.0, 0.0, 0.0 );
          err = catiav5w::AddInstance( SubProductID, L"SubProductInstance1", TransformationMatrix, SubProductInstance1ID );
          TransformationMatrix.setOrigin( -1000.0, 0.0, 0.0 );
 
          err = 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 ) );
          }
 
          {
               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...
          err = catiav5w::EndProduct( RootProductID );
     }
 
     cout << "=> " << RootProductFileName.c_str() << endl << "CatiaV5 Write end" << endl;
     return err;
}
 
 
int CatiaV5WriteSample( const Dtk_string &inResultDirectory )
{
     // First we initialize writing with name of files and protection fonction
     //First you have to initialize the CATIA V5 writer
     Dtk_string outputDirectory;
 
     cout << endl << "----------------------------------------------" << endl;
     cout << "CatiaV5 Write start" << endl;
 
     // Choosing output directory and file name
     outputDirectory = inResultDirectory + L"CatiaV5/";
     outputDirectory.FixPathSeparator();
     outputDirectory.mkdir();
 
     catiav5w::WriteOptions options;
     Dtk_ErrorStatus st = options.SetFileRelease( 19 );
     if( st != dtkNoError )
     {
          cout << "error : " << dtkTypeError( st ).c_str() << endl;
          return st;
     }
 
     st = catiav5w::InitWrite( outputDirectory + L"V5W_LogFile.log", NULL, options );
     if( st != dtkNoError )
     {
          cout << "error : " << dtkTypeError( st ).c_str() << endl;
          return st;
     }
 
     ProcessAsm( inResultDirectory );
 
     //...and the Main writter
     catiav5w::EndWrite();
 
     return dtkNoError;
}
//end_of_maincatiav5write