PDF Details Samples

Table of Contents

• Meshes Samples
  • Writing Simple mesh
  • Writing several meshes
  • Writing meshes with render
• B-rep Samples
  • Writing a Brep
  • Writing a Wire body
  • Writing a Body with visibility information
• Assemblies Samples
  • Writing a Simple assembly
  • Writing an assembly with part instances
  • Writing an assembly with assembly instances
  • Writing an assembly changing instances colors
  • Writing an assembly changing instances visibility
• Properties Samples
  • Writing MetaData
  • Writing Document properties
• Fdt Samples
  • Writing a simple FDT
  • Writing a Model view
  • Writing a Model view with associated fdt
  • Writing a Fdt associated with goemetry
  • Writing a Model view with section
  • Writing associated Fdts
• Other Samples
  • Writing Axis System
  • Writing points cloud
  • Writing Billboard
  • Writing Secured Pdf file
  • Writing multiple views

Meshes Samples

Writing Simple mesh

Here is an example to write a mesh.

//start_of_pdfw_onemesh
// ------------------------------------ PdfwSampleOneMesh_1_1 ---------------------------------------------
 
Dtk_ErrorStatus PdfwSampleOneMesh_1_1( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID meshID;
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
     Dtk_MeshPtr CubeMesh = sampleWriter::CreateMeshCube(); // create a simple red cube 
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( CubeMesh ), meshID ) );   // write the cube
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_onemesh

Writing several meshes

Here is an example to write several meshes with differents colors.

//start_of_pdfw_meshes
// ---------------------------------- PdfwSampleMeshes_1_2 -----------------------------------------------
 
template <typename T>
inline void Shift( T& mesh, double sh )
{
     Dtk_transfo t;
     t.addTranslate( Dtk_dir( sh, 0, 0 ) );
     mesh->Transform( t );
}
 
Dtk_ErrorStatus PdfwSampleMeshes_1_2( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID meshID;
 
     options.PointSize = 5.; // setting point size
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_MeshPtr CubeMesh = sampleWriter::CreateMeshCube(); // create a simple red cube 
     CubeMesh->info()->SetName( "ColoredCube" );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( CubeMesh ), meshID ) );   // write the cube
 
     Dtk_MeshPtr CubePervertexColorMesh = sampleWriter::CreateMeshCubeVertexColor(); // create a per vertex color cube 
     Shift( CubePervertexColorMesh, 3 );  // translate it not to be on previous geometry
     CubePervertexColorMesh->info() = Dtk_Info::create();
     CubePervertexColorMesh->info()->SetName( "VertexColoredCube" );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( CubePervertexColorMesh ), meshID ) );   // write the cube
 
     Dtk_MeshPtr TransparentCube = sampleWriter::CreateMeshCube();    // create a simple red cube 
     TransparentCube->info()->SetColor( Dtk_RGB( 0, 255, 0, 128 ) );   // set whole cube as green and transparent
     TransparentCube->info()->SetName( "TransparentCube" );
     Shift( TransparentCube, 6 );  // translate it not to be on previous geometry
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( TransparentCube ), meshID ) );   // write the cube
 
     Dtk_MeshPtr TransparentOneFaceCube = sampleWriter::CreateMeshCube();  // create a simple red cube 
     if( TransparentOneFaceCube->get_nb_mesh_face() == 6 )
     {
          if( TransparentOneFaceCube->get_mesh_face( 3 )->info().IsNULL() )
               TransparentOneFaceCube->get_mesh_face( 3 )->info() = Dtk_Info::create();
          TransparentOneFaceCube->get_mesh_face( 3 )->info()->SetColor( Dtk_RGB( 0, 0, 255, 128 ) ); // set face 3 as blue and transparent
     }
     Shift( TransparentOneFaceCube, 9 );  // translate it not to be on previous geometry
     TransparentCube->info()->SetName( "TransparentCubeColoredFace" );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( TransparentOneFaceCube ), meshID ) );   // write the cube
 
     Dtk_MeshPtr MeshWire = sampleWriter::CreateMeshWire();  // create wire mesh 
     Shift( MeshWire, 12 );  // translate it not to be on previous geometry
     MeshWire->info() = Dtk_Info::create();
     MeshWire->info()->SetName( "WireMesh" );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( MeshWire ), meshID ) );   // write the cube
 
     Dtk_MeshPtr MeshPoints = sampleWriter::CreateMeshPoints();  // create a mesh wich contain only orange points.
     Shift( MeshPoints, 15 );  // translate it not to be on previous geometry
     MeshPoints->info()->SetName( "PointMesh" );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( MeshPoints ), meshID ) );   // write the cube
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_meshes

Writing meshes with render

Here is an example to write several meshes with rendering information.

//start_of_pdfw_rendermesh
// ------------------------------------ PdfwSampleOneMeshRender_1_3 ---------------------------------------------
 
Dtk_ErrorStatus PdfwSampleOneMeshRender_1_3( const Dtk_string& inOutputFileName, const Dtk_string& inImageDirectory )
{
     Pdfw::WriteOptions options;
     Dtk_ID meshID;
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
     Dtk_MeshPtr meshCube = sampleWriter::CreateTexturedMeshCube( inImageDirectory );     // create a simple textured cube   
 
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( meshCube ), meshID ) ); // write the cube
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_rendermesh

B-rep Samples

Writing a Brep

Here is an example to write a Dtk_body.

//start_of_pdfw_body
// ---------------------------------- PdfwSampleBody_2_1 -----------------------------------------------
 
Dtk_ErrorStatus PdfwSampleBody_2_1( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID bodyID;
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl( 1, 2 );  // Create a Cylinder radius=1, height=2  (with a green face)
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinder ), bodyID ) );   // write the body
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_body

Writing a Wire body

Here is an example to write a Dtk_body with wire.

//start_of_pdfw_wirebody
// ---------------------------------- PdfwSampleWireBody_2_2 -----------------------------------------------
 
Dtk_ErrorStatus PdfwSampleWireBody_2_2( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID bodyID;
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_BodyPtr wire = sampleWriter::CreateCurves();
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( wire ), bodyID ) );   // write the body
 
     Dtk_BodyPtr wire2 = sampleWriter::CreateCurvesStyle();
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( wire2 ), bodyID ) );   // write the body
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
 
//end_of_pdfw_wirebody

Writing a Body with visibility information

Here is an example to write a Dtk_body with visibility information.

//start_of_pdfw_bodyvisibility
// ---------------------------------- PdfwSampleBodyVisibility_2_3 -----------------------------------------------
 
Dtk_ErrorStatus PdfwSampleBodyVisibility_2_3( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID bodyID;
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl( 1, 2 );
     cylinder->info()->SetName( "Cylinder.1" );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinder ), bodyID ) );   // write the 1st body
 
     Dtk_BodyPtr cylinder2 = sampleWriter::CreateCyl( 1, 2 );
     Shift( cylinder2, 3 );
     cylinder2->info()->SetName( "Cylinder.2" );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinder2 ), bodyID ) );   // write the 2nd body
 
     Dtk_BodyPtr cylinder3 = sampleWriter::CreateCyl( 1, 2 );
     Shift( cylinder3, 6 );
     cylinder3->info()->SetBlankedStatus( DTK_TRUE );
     cylinder3->info()->SetName( "Cylinder.3" );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinder3 ), bodyID ) );   // write the 3rd body
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_bodyvisibility

Assemblies Samples

Writing a Simple assembly

Here is an example to write an assembly with sub assembly.

//start_of_pdfw_asm
// ------------------------------------ PdfwSampleAssembly_3_1 ---------------------------------------------
 
Dtk_ErrorStatus PdfwSampleAssembly_3_1( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID axleNodeID, axleID, wheelsNodeID, wheelNodeID, wheel2NodeID, wheel1ID, wheel2ID;
     Dtk_InfoPtr info;
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_string nodeName = "Axle";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, axleNodeID ) ); // open Axle node
     Dtk_BodyPtr axle = sampleWriter::CreateCyl( 0.2, 5 );
     axle->info()->SetName( "axle" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( axle, Dtk_MeshPtr(), axleID ) ); // write the body
     CHECK_OK( Pdfw::EndNode() );  // close Axle
 
     nodeName = "Wheels";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, wheelsNodeID ) ); // open Wheels node
 
     nodeName = "Wheel";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, wheelNodeID ) ); // open Wheel node
     Dtk_BodyPtr wheel = sampleWriter::CreateCyl( 1, 1 );
     Shift( wheel, 2 );
     CHECK_OK( Pdfw::WriteBodyAndMesh( wheel, Dtk_MeshPtr(), wheel1ID ) ); // write the body
     CHECK_OK( Pdfw::EndNode() );  // close Wheel
 
     nodeName = "Wheel2";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, wheel2NodeID ) ); // open Wheel2 node
     Shift( wheel, 3 );
     CHECK_OK( Pdfw::WriteBodyAndMesh( wheel, Dtk_MeshPtr(), wheel2ID ) ); // write the body
     CHECK_OK( Pdfw::EndNode() );  // close Wheel2
 
     CHECK_OK( Pdfw::EndNode() );  // close Wheels
 
     CHECK_OK( Pdfw::EndWrite() );// Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_asm

Writing an assembly with part instances

Here is an example to write an assembly with part instances.

//start_of_pdfw_asm32
// -------------------------------- PdfwSamplePartInstances_3_2 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSamplePartInstances_3_2( const Dtk_string& inOutputFileName )
{
     Dtk_dir X( 1, 0, 0 );
     Dtk_dir Y( 0, 1, 0 );
     Dtk_dir Z( 0, 0, 1 );
     Pdfw::WriteOptions options;
     Dtk_ID axleNodeID, axleID, wheelsID, wheelNodeID, wheelID;
     Dtk_InfoPtr info;
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_string nodeName = "Axle";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, axleNodeID ) ); // open Axle Node
     Dtk_BodyPtr axle = sampleWriter::CreateCyl( 0.2, 5 );
     axle->info()->SetName( "axle" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( axle, Dtk_MeshPtr(), axleID ) );
     CHECK_OK( Pdfw::EndNode() );  // close Axle
 
     nodeName = "Wheels";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, wheelsID ) ); // open Wheels Node
     nodeName = "Wheel1";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo( X, Y, Z, Dtk_pnt( 0, 0, 5 ) ), info, wheelNodeID ) ); // open Wheel1 Node
     Pdfw::StorePrototype( wheelNodeID ); // Store Wheel node ID for future re-instanciation
     Dtk_BodyPtr wheel = sampleWriter::CreateCyl( 1, 1 );
     wheel->info()->SetName( "wheel" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( wheel, Dtk_MeshPtr(), wheelID ) ); // write the body
     CHECK_OK( Pdfw::EndNode() );  // close Wheel1
 
     nodeName = "Wheel2";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo( X, -Y, -Z, Dtk_pnt() ) ) ); // open Wheel2 node
     Pdfw::ReinstanciatePrototype( wheelNodeID ); // Re-instanciating Wheel node
     CHECK_OK( Pdfw::EndNode() );  // close Wheel2
 
     CHECK_OK( Pdfw::EndNode() ); // close Wheels
 
     CHECK_OK( Pdfw::EndWrite() ); // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_asm32

Writing an assembly with assembly instances

Here is an example to write an assembly with assembly instances.

//start_of_pdfw_asm33
// -------------------------------- PdfwSampleAsmInstances_3_3 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSampleAsmInstances_3_3( const Dtk_string& inOutputFileName )
{
     Dtk_dir X( 1, 0, 0 );
     Dtk_dir Y( 0, 1, 0 );
     Dtk_dir Z( 0, 0, 1 );
     Pdfw::WriteOptions options;
     Dtk_ID axlesNodeID, axlesNodeID2, axleNodeID, axleID, wheelsNodeID, wheelNodeID, wheelID;
     Dtk_InfoPtr info;
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_string nodeName = "Axles";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, axlesNodeID ) ); // open Axles Node, placement by default : identity matrix
     Pdfw::StorePrototype( axlesNodeID ); // Store Axles node ID for future re-instanciation
 
     nodeName = "Axle";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, axleNodeID ) ); // open Axle node
     Dtk_BodyPtr axle = sampleWriter::CreateCyl( 0.2, 5 );
     axle->info()->SetName( "axle" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( axle, Dtk_MeshPtr(), axleID ) );
     CHECK_OK( Pdfw::EndNode() );  // close Axle
 
     nodeName = "Wheels";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, wheelsNodeID ) ); // open Wheels node
     nodeName = "Wheel1";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo( X, Y, Z, Dtk_pnt( 0, 0, 5 ) ), info, wheelNodeID ) ); // open Wheel1 node
     Pdfw::StorePrototype( wheelNodeID ); // Store Wheel node ID for future re-instanciation
     Dtk_BodyPtr wheel = sampleWriter::CreateCyl( 1, 1 );
     wheel->info()->SetName( "wheel" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( wheel, Dtk_MeshPtr(), wheelID ) ); // write the body
     CHECK_OK( Pdfw::EndNode() );  // close Wheel
 
     nodeName = "Wheel2";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo( X, -Y, -Z, Dtk_pnt() ), info, wheelsNodeID ) ); // open Wheel2 node
     Pdfw::ReinstanciatePrototype( wheelNodeID ); // Re-instanciating Wheel node
     CHECK_OK( Pdfw::EndNode() );  // close Wheel2
 
     CHECK_OK( Pdfw::EndNode() );  // close Wheels
 
     CHECK_OK( Pdfw::EndNode() );  // close Axles
 
     nodeName = "Axles2";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo( X, Y, Z, Dtk_pnt( 10, 0, 0 ) ), info, axlesNodeID2 ) ); // Open Axles2 node
     Pdfw::ReinstanciatePrototype( axlesNodeID ); // Re-instanciating Axle node
     CHECK_OK( Pdfw::EndNode() );  // close Axles2
 
     CHECK_OK( Pdfw::EndWrite() ); // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_asm33

Writing an assembly changing instances colors

Here is an example to write an assembly changing instances colors.

//start_of_pdfw_asm34
// -------------------------------- PdfwSampleInstancesColors_3_4 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSampleInstancesColors_3_4( const Dtk_string& inOutputFileName )
{
     Dtk_dir X( 1, 0, 0 );
     Dtk_dir Y( 0, 1, 0 );
     Dtk_dir Z( 0, 0, 1 );
     Pdfw::WriteOptions options;
     Dtk_ID axlesNodeID, axlesNodeID2, axlesNodeID3, axlesNodeID4, axlesNodeID5, axleNodeID, axleID, wheelsNodeID, wheelNodeID, wheelID;
     Dtk_InfoPtr info;
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_string nodeName = "Axles";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, axlesNodeID ) ); // open Axles node, placement by default : identity matrix
     Pdfw::StorePrototype( axlesNodeID ); // Store Axles node ID for future re-instanciation
 
     nodeName = "Axle";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, axleNodeID ) ); // open Axle node
     Dtk_BodyPtr axle = sampleWriter::CreateCyl( 0.2, 5 );
     axle->info()->SetName( "axle" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( axle, Dtk_MeshPtr(), axleID ) ); // write the body
     CHECK_OK( Pdfw::EndNode() );  // close Axle
 
     nodeName = "Wheels";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, wheelsNodeID ) ); // open Wheels node
     nodeName = "Wheel1";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo( X, Y, Z, Dtk_pnt( 0, 0, 5 ) ), info, wheelNodeID ) ); // open wheel1 node
     Pdfw::StorePrototype( wheelNodeID ); // Store Wheel node ID for future re-instanciation
     Dtk_BodyPtr wheel = sampleWriter::CreateCyl( 1, 1 );
     wheel->info()->SetName( "wheel" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( wheel, Dtk_MeshPtr(), wheelID ) ); // write the body
     CHECK_OK( Pdfw::EndNode() );  // close Wheel1
 
     nodeName = "Wheel2";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo( X, -Y, -Z, Dtk_pnt() ), info, wheelsNodeID ) ); // open wheel2 node
     Pdfw::ReinstanciatePrototype( wheelNodeID ); // Re-instanciating Wheel node
     CHECK_OK( Pdfw::EndNode() );  // close wheel2
 
     CHECK_OK( Pdfw::EndNode() );  // close Wheels
 
     CHECK_OK( Pdfw::EndNode() );  // close Axles
 
     nodeName = "Axles2";
     Dtk_InfoPtr axle2Info = Dtk_Info::create();
 
     axle2Info->SetColor( Dtk_RGB( 255, 0, 0, 128 ) );// Give a RED color with transparency
     CHECK_OK( Pdfw::InitNode( nodeName,
                                     Dtk_transfo( X, Y, Z, Dtk_pnt( 5, 0, 0 ) ),
                                     axle2Info,
                                     Pdfw::keepsubcolor, // Keep mesh existing colors
                                     axlesNodeID2 ) ); // reinstance whole subassembly with matrix
     Pdfw::ReinstanciatePrototype( axlesNodeID ); // Re-instanciating Axles node
     CHECK_OK( Pdfw::EndNode() );  // close Axles2
 
     nodeName = "Axles3";
     Dtk_InfoPtr axle3Info = Dtk_Info::create();
     axle3Info->SetColor( Dtk_RGB( 0, 0, 255, 255 ) );// Give a BLUE opaque color
 
     CHECK_OK( Pdfw::InitNode( nodeName,
                                     Dtk_transfo( X, Y, Z, Dtk_pnt( 10, 0, 0 ) ),
                                     axle3Info,
                                     Pdfw::attributeoverwrite, // Overwrites existing colors/transparency
                                     axlesNodeID3 ) );
     Pdfw::ReinstanciatePrototype( axlesNodeID );
     CHECK_OK( Pdfw::EndNode() );  // close Axles3
 
     nodeName = "Axles4";
     Dtk_InfoPtr axle4Info = Dtk_Info::create();
     axle4Info->SetColor( Dtk_RGB( 255, 255, 0, 128 ) );// Give a YELLOW color with transparency
 
     CHECK_OK( Pdfw::InitNode( nodeName,
                                     Dtk_transfo( X, Y, Z, Dtk_pnt( 15, 0, 0 ) ),
                                     axle4Info,
                                     Pdfw::keepsubcolor | Pdfw::keepsubtransparency, // Keep mesh existing color / transparency
                                     axlesNodeID4 ) );
     Pdfw::ReinstanciatePrototype( axlesNodeID );
     CHECK_OK( Pdfw::EndNode() );  // close Axles4*
 
     nodeName = "Axles5";
     Dtk_InfoPtr axle5Info = Dtk_Info::create();
     axle5Info->SetColor( Dtk_RGB( 0, 255, 255 ) );// Give a BLUE GREEN color
 
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo( X, Y, Z, Dtk_pnt( 20, 0, 0 ) ), axle5Info, axlesNodeID5 ) );
     Pdfw::ReinstanciatePrototype( axlesNodeID );
     CHECK_OK( Pdfw::EndNode() );  // close Axles5
 
     CHECK_OK( Pdfw::EndWrite() ); // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_asm34

Writing an assembly changing instances visibility

Here is an example to write an assembly changing instances visibility.

//start_of_pdfw_asm35
// -------------------------------- PdfwSampleInstancesVisibility_3_5 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSampleInstancesVisibility_3_5( const Dtk_string& inOutputFileName )
{
     Dtk_dir X( 1, 0, 0 );
     Dtk_dir Y( 0, 1, 0 );
     Dtk_dir Z( 0, 0, 1 );
     Pdfw::WriteOptions options;
     Dtk_ID axleNodeID, axleID, wheelsNodeID, wheelNodeID, wheelID;
     Dtk_InfoPtr info;
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_string nodeName = "Axle";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, axleNodeID ) ); // open Axle node
     Dtk_BodyPtr axle = sampleWriter::CreateCyl( 0.2, 5 );
     axle->info()->SetName( "axle" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( axle, Dtk_MeshPtr(), axleID ) ); // write the body
     CHECK_OK( Pdfw::EndNode() );  // close Axle
 
     nodeName = "Wheels";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo(), info, wheelsNodeID ) ); // open Wheels node
     nodeName = "Wheel1";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo( X, Y, Z, Dtk_pnt( 0, 0, 5 ) ), info, wheelNodeID ) ); // open Wheel1 node
     Pdfw::StorePrototype( wheelNodeID ); // Store Wheel node ID for future re-instanciation
     Dtk_BodyPtr wheel = sampleWriter::CreateCyl( 1, 1 );
     wheel->info()->SetName( "wheel" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( wheel, Dtk_MeshPtr(), wheelID ) ); // write the body
     CHECK_OK( Pdfw::EndNode() );  // close Wheel1
 
     Dtk_InfoPtr wheelInfo = Dtk_Info::create();
     wheelInfo->SetBlankedStatus( 1 );
     nodeName = "Wheel2";
     CHECK_OK( Pdfw::InitNode( nodeName, Dtk_transfo( X, -Y, -Z, Dtk_pnt() ), wheelInfo, wheelsNodeID ) ); // open invisible Wheel2
     Pdfw::ReinstanciatePrototype( wheelNodeID ); // Re-instanciating Wheel node
     CHECK_OK( Pdfw::EndNode() );  // close Wheel2
 
     CHECK_OK( Pdfw::EndNode() );  // close Wheels
 
     CHECK_OK( Pdfw::EndWrite() ); // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_asm35

Properties Samples

Writing MetaData

Here is an example to write Dtk_MetaData.

//start_of_pdfw_meta41
// ------------------------------- PdfwSampleMetadatas_4_1 --------------------------------------------------
 
Dtk_ErrorStatus PdfwSampleMetadatas_4_1( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID axleID;
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_string nodeName = "Metadata";
     CHECK_OK( Pdfw::InitNode( nodeName ) );  // Metadata creation
 
     Dtk_tab<Dtk_MetaDataPtr> tabMetadata;
     tabMetadata.push_back( Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, "MyTitle", "MyValue" ) );
     CHECK_OK( Pdfw::AddNodeMetadata( tabMetadata ) ); // Adding metadata to node
     Dtk_BodyPtr axle = sampleWriter::CreateCyl( 0.2, 5 );
     axle->info()->SetName( "axle" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( axle, Dtk_MeshPtr(), axleID ) ); // write the body
 
     CHECK_OK( Pdfw::EndNode() );  // close Metadata
     CHECK_OK( Pdfw::EndWrite() ); // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_meta41

Writing Document properties

Here is an example to write properties on a document.

//start_of_pdfw_meta42
// ------------------------------- PdfwSampleDocumentProperties_4_2 --------------------------------------------------
 
Dtk_ErrorStatus PdfwSampleDocumentProperties_4_2( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Pdfw::PdfDocumentProperties docProperties;
     Dtk_tab<Dtk_MetaDataPtr> metadatas;
     Dtk_string application, pdfProducer, title, author, subject, keywords;
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     // We fill Pdfw::PdfDocumentProperties with information we want
     title = inOutputFileName.filename();
     docProperties.SetTitle( title ); // title
 
     author = "user";
     docProperties.SetAuthor( author ); // author
 
     subject = "Datakit PDF SDK demo";
     docProperties.SetSubject( subject ); // subject
 
     keywords = "Datakit;SDK;Demo";
     docProperties.SetKeywords( keywords ); // keywords
 
 
     application = "LibPdfWriteSample";
     docProperties.SetApplication( application ); // application
 
     pdfProducer = "DATAKIT API Version " + Dtk_API::GetAPI()->GetVersion();
     docProperties.SetPDFProducer( pdfProducer ); // producer
 
     metadatas.push_back( Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeFileProperty, "PartName", "SampleDocumentProperties_4_2" ) );  // custom metadata
 
     CHECK_OK( Pdfw::AddDocumentProperties( docProperties, metadatas ) ); // We add properties to the document
 
     CHECK_OK( Pdfw::EndWrite() ); // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_meta42

Fdt Samples

Writing a simple FDT

Here is an example to write a FDT type Datum.

//start_of_pdfw_fdt51
// --------------------------------PdfwSampleSimplePMI_5_1------------------------------------------------ -
 
 
Dtk_ErrorStatus PdfwSampleSimplePMI_5_1( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID axleID;
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl( 100, 150 );  // Create a Cylinder radius=1, height=2  (with a green face)
     cylinder->info()->SetName( "Body" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( cylinder, Dtk_MeshPtr(), axleID ) );   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( pmi ) ) ); // Add the PMI
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_fdt51

Writing a Model view

Here is an example to write a Model view.

//start_of_pdfw_fdt52
// -------------------------------- PdfwSampleSimpleModelview_5_2 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSampleSimpleModelview_5_2( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     options.CreateDefaultView = DTK_FALSE; // no default view needed
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl( 100, 150 );  // Create a Cylinder radius=100, height=150  (with a green face)
     cylinder->info()->SetName( "Body" );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinder ) ) );   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( pmi ) ) ); // Add the PMI
 
     Dtk_ModelDisplayPtr mvfit, mv2;
     mvfit = sampleWriter::CreateModelDisplayDesactivated();
     Dtk_tab<Dtk_ID> tabNodeIDs;
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( mvfit, tabNodeIDs ) );
 
     mv2 = sampleWriter::CreateModelDisplayActivated();
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( mv2, tabNodeIDs ) );
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_fdt52

Writing a Model view with associated fdt

Here is an example to write a Model view with associated fdt.

//start_of_pdfw_fdt53
// -------------------------------- PdfwSample_MV_association_5_3 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSample_MV_association_5_3( const Dtk_string& inOutputFileName )
{
 
     Pdfw::WriteOptions options;
     Dtk_ID cylID, datumID;
 
     options.CreateDefaultView = DTK_FALSE; // no default view needed
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl( 100, 150 );  // Create a Cylinder radius=100, height=150  (with a green face)
     cylinder->info()->SetName( "Body" );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinder ), cylID ) );   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( pmi ), datumID ) ); // Add the PMI
 
 
     Dtk_ModelDisplayPtr mv = sampleWriter::CreateModelDisplayActivated();
 
     Dtk_tab<Dtk_ID> tabNodeIDs;
     tabNodeIDs.push_back( cylID );
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( mv, tabNodeIDs ) ); // create the model display with visible nodes
 
     Dtk_ModelDisplayPtr mv2 = Dtk_ModelDisplay::Create( mv->GetCamera(), NULL, 0 );// create desactivated model display
     mv2->info() = Dtk_Info::create();
     mv2->info()->SetName( "PMIView" );
     tabNodeIDs.clear();
     tabNodeIDs.push_back( cylID );
     tabNodeIDs.push_back( datumID );
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( mv2, tabNodeIDs ) ); // create the model display with visible nodes
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_fdt53

Writing a Fdt associated with goemetry

Here is an example to write a Fdt associated with goemetry.

//start_of_pdfw_fdt54
// -------------------------------- PdfwSamplePMI_Geom_association_5_4 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSamplePMI_Geom_association_5_4( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID bodyID, datumID;
 
     options.CreateDefaultView = DTK_FALSE; // no default view needed
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl( 100, 150 );  // Create a Cylinder radius=100, height=150  (with a green face)
     cylinder->info()->SetName( "Body" );
     CHECK_OK( Pdfw::WriteBodyAndMesh( cylinder, Dtk_MeshPtr(), bodyID ) );   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( pmi ), datumID ) ); // Add the PMI
     CHECK_OK( Pdfw::CreateNodeConnectorHighlight( datumID, bodyID, 1 ) );  // Connect datum PMI on body, on face index 1
 
     Dtk_ModelDisplayPtr mv = sampleWriter::CreateModelDisplayActivated();
     mv->info()->SetName( "myView" );
     Dtk_tab<Dtk_ID>tabNodeIDs;
     tabNodeIDs.push_back( bodyID );
     tabNodeIDs.push_back( datumID );
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( mv, tabNodeIDs ) ); // Add ModelDisplay with visible nodes
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_fdt54

Writing a Model view with section

Here is an example to write a Model view with section plane.

//start_of_pdfw_fdt55
// -------------------------------- PdfwSampleModelview_section_5_5 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSampleModelview_section_5_5( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID bodyID, datumID, curveID;
 
     options.CreateDefaultView = DTK_FALSE; // no default view needed
     // setting cross section graphic properties
     options.CrossSection.CuttingPlaneColor = Dtk_RGB( 255, 255, 255 );
     options.CrossSection.CuttingPlaneOpacity = 0.9;
     options.CrossSection.IntersectionColor = Dtk_RGB( 155, 255, 0 );;
     options.CrossSection.AddSectionCap = false;
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl( 100, 150 );  // Create a Cylinder radius=100, height=150  (with a green face)
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinder ), bodyID ) );   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( pmi ), datumID ) ); // Add the PMI
 
     Dtk_ModelDisplayPtr mv1 = sampleWriter::CreateModelDisplayActivated(); // create first activated view
     Dtk_ModelDisplayPtr mv2 = sampleWriter::CreateModelDisplayWithSection();// create section view
     Dtk_tab<Dtk_ID>tabNodeIDs;
     tabNodeIDs.push_back( bodyID );
     tabNodeIDs.push_back( datumID );
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( mv1, tabNodeIDs ) ); // Add ModelDisplay
 
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( mv2, tabNodeIDs ) ); // Add ModelDisplay
 
     CHECK_OK( Pdfw::CreateNodeConnectorHighlight( datumID, bodyID, 1 ) );  // Connect datum PMI on body, on face index 1
 
     Dtk_EllipsePtr ellipse = Dtk_Ellipse::Create( Dtk_pnt(), Dtk_dir( 0., 0., 1. ), Dtk_dir( 1., 0., 0. ), 100 );
     ellipse->info() = Dtk_Info::create();
     ellipse->info()->SetName( "Curve" );
     ellipse->info()->SetBlankedStatus( DTK_TRUE );
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( ellipse ), curveID ) ); // Add the curve
     //for curve
     CHECK_OK( Pdfw::CreateNodeConnectorHighlight( datumID, curveID ) );  // Connect datum PMI on curve
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_fdt55

Writing associated Fdts

Here is an example to write associated Fdts.

//start_of_pdfw_fdt56
// -------------------------------- PdfwSamplePMI_PMI_association_5_6 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSamplePMI_PMI_association_5_6( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID bodyID, datumID;
     Dtk_tab<Dtk_ID> tabPMIIDs;
 
     // First we initialize writing with name of files
     options.CreateDefaultView = DTK_FALSE; // no default view needed
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl( 100, 150 );  // Create a Cylinder radius=100, height=150  (with a green face)
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinder ), bodyID ) );   // Add the body
 
     int i;
     for( i = 0; i < 10; i++ ) // create 10 PMI
     {
          Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
          Shift( pmi, 15 * i );
          CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( pmi ), datumID ) ); // Add the PMI
          tabPMIIDs.push_back( datumID );
     }
     Dtk_ModelDisplayPtr mv2 = sampleWriter::CreateModelDisplayActivated();
     mv2->info()->SetName( "SecondView" );
     Dtk_tab<Dtk_ID>tabNodeIDs;
     tabNodeIDs.push_back( bodyID );
     tabNodeIDs += tabPMIIDs;
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( mv2, tabNodeIDs ) ); // Add ModelDisplay with visible nodes
 
     CHECK_OK( Pdfw::CreateNodeConnectorHighlight( tabNodeIDs[ 5 ], tabNodeIDs[ 7 ] ) );  // Connect datum PMI on body, on face index 1
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_fdt56

Other Samples

Writing Axis System

Here is an example to write Axis System.

//start_of_pdfw_axis
 
// -------------------------------- PdfwSampleAxis_References_5_7 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSampleAxis_References_5_7( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID axisSysID, planeID, axisID;
     Dtk_tab<Dtk_ID> tabNodeIDs;
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     Dtk_AxisSystemPtr axis = sampleWriter::CreateAxisSystem();
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( axis ), axisSysID ) );
     tabNodeIDs.push_back( axisSysID );
 
     Dtk_BodyPtr refplane = sampleWriter::CreateInfinitePlane();
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( refplane ), planeID ) );
     tabNodeIDs.push_back( planeID );
 
     Dtk_BodyPtr refaxis = sampleWriter::CreateAxis();
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( refaxis ), axisID ) );
     tabNodeIDs.push_back( axisID );
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_axis

Writing points cloud

Here is an example to write points cloud.

//start_of_pdfw_cloud
// -------------------------------- PdfwSampleCloudPoint_6_1 -------------------------------------------------
 
Dtk_ErrorStatus PdfwSampleCloudPoint_6_1( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_tab<Dtk_pnt> tabPoints;
     Dtk_Size_t i, j;
     Dtk_transfo transfo;
     Dtk_ID pointID;
     Dtk_Double64 xPos = 0., yPos = 0., offset = 1.;
     Dtk_Size_t numPointX = 200, numPointY = 200;
     Dtk_tab<Dtk_RGB> tabColors;
     Dtk_tab<Dtk_dir> tabNormals;
 
     options.CreateDefaultView = DTK_FALSE; // no default view needed
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
 
     // generating cloud point
 
     for( i = 0; i < numPointX; i++ )
     {
          for( j = 0; j < numPointY; j++ )
          {
               tabPoints.push_back( Dtk_pnt( xPos, yPos, 0. ) );
               tabColors.push_back( Dtk_RGB( ( int )( std::rand() / double( RAND_MAX ) * 255 ),
                    ( int )( std::rand() / double( RAND_MAX ) * 255 ),
                                                    ( int )( std::rand() / double( RAND_MAX ) * 255 ) ) );
               yPos += offset;
          }
          yPos = 0.;
          xPos += offset;
     }
 
 
     CHECK_OK( Pdfw::WriteColoredPoints( tabPoints, tabNormals, tabColors, pointID ) ); // write the cloud point 
 
     Dtk_pnt from( 300, 300, 300 );
     Dtk_pnt to( numPointX / 2., numPointY / 2., 0 );
     Dtk_dir up( 0., 1., 0. );
     Dtk_CameraPtr cam = Dtk_Camera::Create( from, to, 200, 200, up );
     Dtk_ModelDisplayPtr mv1 = Dtk_ModelDisplay::Create( cam, NULL, 1 ); // create activated view
 
     mv1->info() = Dtk_Info::create();
     mv1->info()->SetName( "MainView" );
     Dtk_tab<Dtk_ID>tabNodeIDs;
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( mv1, tabNodeIDs ) ); // Add ModelDisplay
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
 
//end_of_pdfw_cloud

Writing Billboard

Here is an example to write a Billboard.

//start_of_pdfw_board
 
// ------------------------------------ PdfwSampleBillboard_7_1 ---------------------------------------------
 
Dtk_ErrorStatus PdfwSampleBillboard_7_1( const Dtk_string& inOutputFileName, const Dtk_string& inImageDirectory )
{
     Pdfw::WriteOptions options;
     Dtk_ID meshID;
     Dtk_LeaderPtr emptyLeader;
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
     Dtk_MeshPtr meshCube = sampleWriter::CreateMeshCube(); // create a simple red cube 
 
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( meshCube ), meshID ) ); // write the cube 
 
     // create a leader without terminator
     Dtk_tab<Dtk_pnt> leaderPoints;
     Dtk_pnt dtkLeaderEnd( 1., -1., 1. ), pictureOrigin( 2., -2, 2. );
     leaderPoints.push_back( dtkLeaderEnd );
     leaderPoints.push_back( pictureOrigin );
     Dtk_LeaderPtr leader = Dtk_Leader::Create( 0, 0, dtkLeaderEnd, Dtk_Leader::TerminatorTypeNone, leaderPoints );
 
     // write parallel to screen image with leader
     CHECK_OK( Pdfw::WriteParallelToScreenPicture( inImageDirectory + "logodtk.bmp", 20, 20, DTK_ANCHOR_TOP_RIGHT, false, true, Dtk_transfo(), leader ) );
     // write pin to screen image
     CHECK_OK( Pdfw::WritePinToScreenPicture( inImageDirectory + "logodtk.bmp", 20, 20, Dtk_pnt( 1., 100. ), DTK_ANCHOR_BOTTOM_LEFT, true, emptyLeader ) );
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
 
//end_of_pdfw_board

Writing Secured Pdf file

Here is an example to add a password into pdf document.

//start_of_pdfw_secure
// ------------------------------------ PdfwSampleSecuredPdf_8_1 ---------------------------------------------
 
Dtk_ErrorStatus PdfwSampleSecuredPdf_8_1( const Dtk_string& inOutputFileName )
{
     Pdfw::WriteOptions options;
     Dtk_ID meshID;
 
     // setting protection password
     options.OwnerPassword = "password";
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( inOutputFileName, "", NULL, options ) );
     Dtk_MeshPtr meshCube = sampleWriter::CreateMeshCube(); // create a simple red cube 
 
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( meshCube ), meshID ) ); // write the cube 
 
     CHECK_OK( Pdfw::EndWrite() );  // Write final file and free memory allocated
     cout << "=> " << inOutputFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_secure

Writing multiple views

Here is an example to add multiple views into pdf document.

//start_of_pdfw_multi
// ------------------------------------ PdfwSampleLayoutMultipleViews_9_1 ---------------------------------------------
 
Dtk_ErrorStatus PdfwCreateViews()
{
 
     // iso view
     Dtk_pnt from( 30, 30, 30 );
     Dtk_pnt to( 0, 0, 0 );
     Dtk_dir up( -0.57735, 0.57735, -0.57735 );
     Dtk_CameraPtr isoCam = Dtk_Camera::Create( from, to, 10, 10, up );
     Dtk_ModelDisplayPtr isoMd = Dtk_ModelDisplay::Create( isoCam, NULL, 1 ); // create first activated view
     Dtk_tab<Dtk_ID> tabNodeIDs;
     isoMd->info() = Dtk_Info::create();
     isoMd->info()->SetName( "Iso" );
 
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( isoMd, tabNodeIDs ) ); // Add ModelDisplay
 
                                                                                                  // top view
     from = Dtk_pnt( 0, 0, 300 );
     up = Dtk_dir( 0, 1, 0 );
     Dtk_CameraPtr topCam = Dtk_Camera::Create( from, to, 10, 10, up );
     Dtk_ModelDisplayPtr topMd = Dtk_ModelDisplay::Create( topCam, NULL, 0 ); // create first activated view
     topMd->info() = Dtk_Info::create();
     topMd->info()->SetName( "Top" );
 
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( topMd, tabNodeIDs ) ); // Add ModelDisplay
 
                                                                                                  // Front view
     from = Dtk_pnt( 0, -300, 0 );
     up = Dtk_dir( 0, 0, 1 );
     Dtk_CameraPtr frontCam = Dtk_Camera::Create( from, to, 10, 10, up );
     Dtk_ModelDisplayPtr frontMd = Dtk_ModelDisplay::Create( frontCam, NULL, 0 ); // create first activated view
     frontMd->info() = Dtk_Info::create();
     frontMd->info()->SetName( "Front" );
 
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( frontMd, tabNodeIDs ) ); // Add ModelDisplay
 
                                                                                                     // right view
     from = Dtk_pnt( 300, 0, 0 );
     up = Dtk_dir( 0, 0, 1 );
     Dtk_CameraPtr rightCam = Dtk_Camera::Create( from, to, 10, 10, up );
     Dtk_ModelDisplayPtr rightMd = Dtk_ModelDisplay::Create( rightCam, NULL, 0 ); // create first activated view
     rightMd->info() = Dtk_Info::create();
     rightMd->info()->SetName( "Right" );
 
     CHECK_OK( Pdfw::CreateModelDisplayWithVisibleNodes( rightMd, tabNodeIDs ) ); // Add ModelDisplay
 
     return dtkNoError;
}
 
 
Dtk_ErrorStatus PdfwCreate3DAnnotations( Dtk_Double64  annotBBox[ 4 ], const Dtk_UInt32 &artworkIndex )
{
     Dtk_Double64 margin = 3.0;
     Dtk_Double64 xPos = Pdfw::Layout::GetCurrentPageWidth() / 2.0, yPos = Pdfw::Layout::GetCurrentPageHeight() / 2.0;
     Dtk_Double64 width = ( Pdfw::Layout::GetCurrentPageWidth() / 2.0 ), height = ( Pdfw::Layout::GetCurrentPageHeight() / 2.0 );
 
     // first annotation 2d bbox (top right)
     annotBBox[ 0 ] = margin / 2. + xPos;
     annotBBox[ 1 ] = margin / 2. + yPos;
     annotBBox[ 2 ] = xPos + width - margin;
     annotBBox[ 3 ] = yPos + height - margin;
 
     CHECK_OK( Pdfw::Layout::Create3DAnnotation( artworkIndex, annotBBox, 0 ) );
 
     // second annotation 2d bbox (top left)
     xPos = 0.0;
     annotBBox[ 0 ] = margin + xPos;
     annotBBox[ 1 ] = margin / 2. + yPos;
     annotBBox[ 2 ] = xPos + width - margin / 2.;
     annotBBox[ 3 ] = yPos + height - margin;
     CHECK_OK( Pdfw::Layout::Create3DAnnotation( artworkIndex, annotBBox, 1 ) );
 
     // third annotation 2d bbox (bottom left)
     yPos = 0.0;
     annotBBox[ 0 ] = margin + xPos;
     annotBBox[ 1 ] = margin + yPos;
     annotBBox[ 2 ] = xPos + width - margin / 2.;
     annotBBox[ 3 ] = yPos + height - margin / 2.;
     CHECK_OK( Pdfw::Layout::Create3DAnnotation( artworkIndex, annotBBox, 2 ) );
 
     // fourth annotation 2d bbox (bottom right)
     xPos = Pdfw::Layout::GetCurrentPageWidth() / 2.0;
     annotBBox[ 0 ] = margin / 2. + xPos;
     annotBBox[ 1 ] = margin + yPos;
     annotBBox[ 2 ] = xPos + width - margin;
     annotBBox[ 3 ] = yPos + height - margin / 2.;
     CHECK_OK( Pdfw::Layout::Create3DAnnotation( artworkIndex, annotBBox, 3 ) );
 
     return dtkNoError;
}
 
void AssignFacesColors( Dtk_MeshPtr &meshCube )
{
     for( Dtk_Size_t i = 1; i < 6; i++ )
          meshCube->get_mesh_face( i )->info() = Dtk_Info::create();
     meshCube->get_mesh_face( 1 )->info()->SetColor( Dtk_RGB( 0, 255, 0 ) );
     meshCube->get_mesh_face( 2 )->info()->SetColor( Dtk_RGB( 0, 0, 255 ) );
     meshCube->get_mesh_face( 3 )->info()->SetColor( Dtk_RGB( 255, 255, 0 ) );
     meshCube->get_mesh_face( 4 )->info()->SetColor( Dtk_RGB( 255, 0, 255 ) );
     meshCube->get_mesh_face( 5 )->info()->SetColor( Dtk_RGB( 0, 255, 255 ) );
}
 
 
Dtk_ErrorStatus PdfwSampleLayoutMultipleViews_9_1( const Dtk_string &pdfFileName )
{
     Pdfw::WriteOptions                 options;
     Dtk_string                              artworkName, nodeName;
     Dtk_UInt32                              artworkIndex = 0;
     Dtk_Double64                       annotBBox[ 4 ];
     Dtk_transfo                             transfo;
     // We set the options of Writer
     options.Layout.CreateAutomaticLayout = DTK_FALSE;
     options.CreateDefaultView = DTK_FALSE;
     options.ShowToolbar = DTK_FALSE;
     options.ConvertRenderInfos = DTK_TRUE;
 
     // First we initialize writing with name of files
     CHECK_OK( Pdfw::InitWrite( pdfFileName, "", NULL, options ) );
 
     // We open a new grey page
     CHECK_OK( Pdfw::Layout::InitPage( Dtk_RGB( 200, 200, 200 ) ) );
 
     // Let's initialise the artwork
     artworkName = "myArtwork";
     CHECK_OK( Pdfw::Layout::Init3DArtwork( artworkName, &options ) );
 
     // add the render
     Dtk_RenderInfosPtr            renderInfos = NULL;
     //RenderInfos Sample
     Dtk_MeshPtr meshCube = sampleWriter::CreateMeshCube(); // create a simple red cube 
 
     // assigning faces colors
     AssignFacesColors( meshCube );
 
     // let's write the mesh cube 
     CHECK_OK( Pdfw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( meshCube ) ) );
 
     // end of artwork
     CHECK_OK( Pdfw::Layout::End3DArtwork( artworkIndex ) );
 
     // create the wiews
     PdfwCreateViews();
 
     // create the annotations 
     PdfwCreate3DAnnotations( annotBBox, artworkIndex );
 
     // close the page
     CHECK_OK( Pdfw::Layout::EndPage() );
     // Finally closing pdf file
     CHECK_OK( Pdfw::EndWrite() );
 
     cout << "=> " << pdfFileName.c_str() << endl;
     return dtkNoError;
}
//end_of_pdfw_multi