Full samples source code

/* ------------------------------------------------------------------------- */
/*                           Datakit JtWriter samples                        */
/*                    this file allow to write several JT files              */
/*            see main function for each case, on the end of this file       */
#include "testwriters.h"
#include "datakit.h"    // DATAKIT header needed
#include "jw/jtw.h"     // JtWrite header needed
#include "tess/tess.h"  // tessellation header needed for example from 2.
 
#include "SampleWriter/testcreatemesh.hpp"   // common datakit mesh creation
#include "SampleWriter/testcreatecube.hpp"   // common datakit bodies creation
#include "SampleWriter/testcreatefdt.hpp"  // common datakit pmi creation
 
 
 
 
//start_of_jtwsample11
 
// ------------------------------------ SampleOneMesh_1_1 ---------------------------------------------
 
Dtk_ErrorStatus JtwSampleOneMesh_1_1(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus);
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
     Dtk_MeshPtr CubeMesh = sampleWriter::CreateMeshCube(); // create a simple red cube 
     CHECK_OK(jtWriter.AddMesh(CubeMesh));   // write the cube
     CHECK_OK(jtWriter.CloseLastInstance()); // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError; // Automatic Finish while J released
}
//end_of_jtwsample11
 
// ---------------------------------- SampleMeshes_1_2 -----------------------------------------------
 
//start_of_jtwsample12
template <typename T>
inline void Shift(T& inoutMesh, double inShiftAmount)
{
     Dtk_transfo translation;
     translation.addTranslate(Dtk_dir(inShiftAmount, 0, 0));
     inoutMesh->Transform(translation);
}
 
Dtk_ErrorStatus JtwSampleMeshes_1_2(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus);
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_MeshPtr CubeMesh = sampleWriter::CreateMeshCube(); // create a simple red cube 
     CHECK_OK(jtWriter.AddMesh(CubeMesh));   // write the cube (A)
 
     Dtk_MeshPtr CubePervertexColorMesh = sampleWriter::CreateMeshCubeVertexColor(); // create a per vertex color cube 
     Shift(CubePervertexColorMesh, 3);  // translate it not to be on previous geometry 
     CHECK_OK(jtWriter.AddMesh(CubePervertexColorMesh)); // (B)
 
     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
     Shift(TransparentCube, 6);  // translate it not to be on previous geometry
     CHECK_OK(jtWriter.AddMesh(TransparentCube)); // (C)
 
     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  (D)
     CHECK_OK(jtWriter.AddMesh(TransparentOneFaceCube));
 
     Dtk_MeshPtr MeshWire = sampleWriter::CreateMeshWire();  // create wire mesh 
     Shift(MeshWire, 12);  // translate it not to be on previous geometry
     CHECK_OK(jtWriter.AddMesh(MeshWire));  // (E)
 
     Dtk_MeshPtr MeshPoints = sampleWriter::CreateMeshPoints();  // create a mesh wich contain only orange points.
     Shift(MeshPoints, 15);  // translate it not to be on previous geometry
     CHECK_OK(jtWriter.AddMesh(MeshPoints));  // (F)
 
     CHECK_OK(jtWriter.CloseLastInstance()); // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError; // Automatic Finish while J released
}
//end_of_jtwsample12
 
// ---------------------------------- SampleTextures_1_3 -----------------------------------------------
//start_of_jtwsample13
inline void AddVertex( Dtk_MeshPtr inoutMesh, const Dtk_pnt& inPosition, const Dtk_dir& inNormal, float inTexU, float inTexV )
{
     inoutMesh->add_vertex( &inPosition, &inNormal, NULL, inTexU, inTexV );
}
 
Dtk_MeshPtr CreateTextureMesh()
{
     Dtk_MeshPtr mesh = Dtk_mesh::Create( DTK_MESH_XYZ | DTK_MESH_NORMAL | DTK_MESH_UV_TEXTURES );
     Dtk_mesh_face* mf = new Dtk_mesh_face( mesh.operator->() );
     mesh->add_mesh_face( mf );
     AddVertex( mesh, Dtk_pnt( 0, 0, 0 ), Dtk_dir( 0, 0, 1 ), 0, 0 );
     AddVertex( mesh, Dtk_pnt( 10, 0, 0 ), Dtk_dir( 0, 0, 1 ), 1, 0 );
     AddVertex( mesh, Dtk_pnt( 10, 10, 0 ), Dtk_dir( 0, 0, 1 ), 1, 1 );
     AddVertex( mesh, Dtk_pnt( 0, 10, 0 ), Dtk_dir( 0, 0, 1 ), 0, 1 );
     Dtk_tab<Dtk_ID> inds;
     inds.push_back( 0 ); inds.push_back( 1 ); inds.push_back( 2 );
     inds.push_back( 0 ); inds.push_back( 2 ); inds.push_back( 3 );
     mf->add_triangles(&inds );
// texture
     Dtk_picture picture;
     picture.MetricHeight() = picture.MetricWidth() = 256;
     picture.PixelWidth() = 256;
     picture.PixelHeight() = 256;
     picture.FileType() = DTK_PICTURE_RGB24;
     picture.File().resize( 256 * 256 * 3 );
     size_t i, size = picture.File().size();
     for( i = 0; i < size; i++ ) // make "random" pixels
          picture.File()[ i ] = ( i * i + i / 256 ) % 256;
     Dtk_TextureInfosPtr texture = Dtk_TextureInfos::Create( Dtk_TextureInfos::StoredUVMapping );
     texture->SetTextureImage( &picture );
     Dtk_RenderInfosPtr render = Dtk_RenderInfos::Create( "uselessname", NULL, texture );
     mf->info() = Dtk_Info::Create();
     mf->info()->AddRenderInfos( render );
     return mesh;
}
 
Dtk_ErrorStatus JtwSampleTextures_1_3( const Dtk_string& inOutputFileName )
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter( inOutputFileName, errorStatus );
     CHECK_OK( errorStatus );
     CHECK_OK( jtWriter.OpenInstance( "RootNode" ) );  // Rootnode creation
     Dtk_MeshPtr TextureMesh = CreateTextureMesh();    // create a simple red cube 
     CHECK_OK( jtWriter.AddMesh( TextureMesh ) ); // write the cube
     CHECK_OK( jtWriter.CloseLastInstance() );    // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError; // Automatic Finish while J released
}
//end_of_jtwsample13
 
// ---------------------------------- SampleBody_2_1 -----------------------------------------------
//start_of_jtwsample21
Dtk_ErrorStatus JtwSampleBody_2_1(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(1, 2);  // Create a Cylinder radius=1, height=2  (with a green face)
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample21
// --------------------------------- SampleBodyLOD_2_2 ------------------------------------------------
//start_of_jtwsample22
Dtk_ErrorStatus JtwSampleBodyLOD_2_2(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(1, 2);  // Create a Cylinder radius=1, height=2  (with a green face)
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body, tessellated as default tess_InitTesselation value
 
     Dtk_BodyPtr cylinder2 = sampleWriter::CreateCyl(1, 2);  // Create another Cylinder radius=1, height=2  (with a green face)
     Shift(cylinder2, 3);  // shift the cylinder, see exemple above
     Dtk_tab<Dtk_Float32> lods;  // create a LOD array
     lods.push_back(0.001f); lods.push_back(-1);  // Highest LOD : linear tol = 0.001, angular automatic
     lods.push_back(0.01f); lods.push_back(-1);   // Medium LOD  : linear tol = 0.01, angular automatic
     lods.push_back(0.1f); lods.push_back(-1);    // Lower LOD  : linear tol = 0.1, angular automatic
     CHECK_OK(jtWriter.AddBody(cylinder2, lods));  // add the body, will tessellate automaticly for LODS.
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample22
 
// ---------------------------------- SampleWireBody_2_3 -----------------------------------------------
//start_of_jtwsample23
Dtk_ErrorStatus JtwSampleWireBody_2_3(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
     
     Dtk_BodyPtr wire = sampleWriter::CreateCurves();
     CHECK_OK(jtWriter.AddBody(wire));
 
     Dtk_BodyPtr wire2 = sampleWriter::CreateCurvesStyle();
     CHECK_OK(jtWriter.AddBody(wire2));
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample23
 
// ---------------------------------- SampleBodyVisibility_2_4 -----------------------------------------------
//start_of_jtwsample24
Dtk_ErrorStatus JtwSampleBodyVisibility_2_4(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(1, 2);
     CHECK_OK(jtWriter.AddBody(cylinder));
 
     Dtk_BodyPtr cylinder2 = sampleWriter::CreateCyl(1, 2);
     Shift(cylinder2, 3);
     CHECK_OK(jtWriter.AddBody(cylinder2));
 
     Dtk_BodyPtr cylinder3 = sampleWriter::CreateCyl(1, 2);
     Shift(cylinder3, 6);
     cylinder3->info()->SetBlankedStatus(DTK_TRUE);
     CHECK_OK(jtWriter.AddBody(cylinder3));
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample24
 
// ---------------------------------- SampleLightmap_2_5 -----------------------------------------------
//start_of_jtwsample25
void SetLightMapOnOneFace( Dtk_BodyPtr& inoutBody, const Dtk_RGB& inAmbient, const Dtk_RGB& inDiffuse,
                                 const Dtk_RGB& inSpecular, float inShininess )
{
     size_t idx, nb = inoutBody->GetNumTopologicalEntities( DTK_TYPE_UNKNOWN );
     for( idx = 0; idx < nb; idx++ )
     {// fetch first face, then abort
          Dtk_TopologicalEntityPtr topo = inoutBody->GetPtr( (Dtk_ID)idx );
          if( topo.IsNULL() || topo->get_type_detk() != DTK_TYPE_FACE )
               continue;
          Dtk_FacePtr face = Dtk_FacePtr::DtkDynamicCast( topo );
          Dtk_LightMapPtr lightmap = Dtk_LightMap::Create( inAmbient, inDiffuse, inSpecular );
          lightmap->SetShininessRatio( inShininess );
          Dtk_RenderInfosPtr render = Dtk_RenderInfos::Create( "uselessname", lightmap, NULL );
          face->info()->AddRenderInfos( render );
          break;
     }
}
 
Dtk_ErrorStatus JtwSampleLightmap_2_5( const Dtk_string& inOutputFileName )
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter( inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep );   // Specify allowing BREP Writing 
     CHECK_OK( errorStatus );
     CHECK_OK( jtWriter.OpenInstance( "RootNode" ) );  // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl( 1, 2 );
     SetLightMapOnOneFace( cylinder, Dtk_RGB( 50, 50, 50 ), Dtk_RGB( 255, 0, 0 ), Dtk_RGB( 0, 0, 255 ), 0 );
     CHECK_OK( jtWriter.AddBody( cylinder ) );
 
     Dtk_BodyPtr cylinder2 = sampleWriter::CreateCyl( 1, 2 );
     Shift( cylinder2, 3 );
     SetLightMapOnOneFace( cylinder2, Dtk_RGB( 50, 50, 50 ), Dtk_RGB( 255, 0, 0 ), Dtk_RGB( 0, 0, 0 ), 0.5 );
     CHECK_OK( jtWriter.AddBody( cylinder2 ) );
 
     Dtk_BodyPtr cylinder3 = sampleWriter::CreateCyl( 1, 2 );
     Shift( cylinder3, 6 );
     SetLightMapOnOneFace( cylinder3, Dtk_RGB( 100, 50, 30 ), Dtk_RGB( 255, 0, 0 ), Dtk_RGB( 255, 255, 255 ), 1 );
     CHECK_OK( jtWriter.AddBody( cylinder3 ) );
 
     CHECK_OK( jtWriter.CloseLastInstance() );  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample25
 
 
// --------------------------------- SampleLossyCompression_2_6 ------------------------------------------------
//start_of_jtwsample26
Dtk_ErrorStatus SampleLossyCompression_2_6( const Dtk_string& inOutputFileName )
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter( inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep );   // Specify allowing BREP Writing 
     CHECK_OK( errorStatus );
     CHECK_OK( jtWriter.OpenInstance( "RootNode" ) );  // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl( 1, 2 );  // Create a Cylinder radius=1, height=2  (with a green face)
     CHECK_OK( jtWriter.AddBody( cylinder ) );   // Add the body, tessellated as default tess_InitTesselation value
 
     Dtk_BodyPtr cylinder2 = sampleWriter::CreateCyl( 1, 2 );  // Create another Cylinder radius=1, height=2  (with a green face)
     Shift( cylinder2, 3 );  // shift the cylinder, see exemple above
     Dtk_tab<Dtk_Float32> lods;  // create a LOD array
     lods.push_back( 0.001f ); lods.push_back( -1 );  // Highest LOD : linear tol = 0.001, angular automatic
     lods.push_back( 0.01f ); lods.push_back( -1 );   // Medium LOD  : linear tol = 0.01, angular automatic
     lods.push_back( 0.1f ); lods.push_back( -1 );    // Lower LOD  : linear tol = 0.1, angular automatic
     CHECK_OK( jtWriter.AddBody( cylinder2, lods , 0.01f ) );  // add the body, will tessellate automaticly for LODS, and a Lossy factor of 0.01
 
     CHECK_OK( jtWriter.CloseLastInstance() );  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample26
 
 
// ------------------------------------ SampleAssembly_3_1 ---------------------------------------------
//start_of_jtwsample31
Dtk_ErrorStatus JtwSampleAssembly_3_1(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     CHECK_OK(jtWriter.OpenInstance("Axle")); // open
     Dtk_BodyPtr axle = sampleWriter::CreateCyl(0.2, 5);
     CHECK_OK(jtWriter.AddBody(axle));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axle
 
     CHECK_OK(jtWriter.OpenInstance("Wheels")); // open
 
     CHECK_OK(jtWriter.OpenInstance("Wheel")); // open
     Dtk_BodyPtr wheel = sampleWriter::CreateCyl(1, 1);
     Shift(wheel, 2);
     CHECK_OK(jtWriter.AddBody(wheel));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheel
 
     CHECK_OK(jtWriter.OpenInstance("Wheel2")); // open
     Shift(wheel, 3);
     CHECK_OK(jtWriter.AddBody(wheel));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheel
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheels
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close RootNode
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample31
// -------------------------------- SamplePartInstances_3_2 -------------------------------------------------
//start_of_jtwsample32
Dtk_ErrorStatus JtwSamplePartInstances_3_2(const Dtk_string& inOutputFileName)
{
     Dtk_dir X(1, 0, 0);
     Dtk_dir Y(0, 1, 0);
     Dtk_dir Z(0, 0, 1);
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     CHECK_OK(jtWriter.OpenInstance("Axle")); // open
     Dtk_BodyPtr axle = sampleWriter::CreateCyl(0.2, 5);
     CHECK_OK(jtWriter.AddBody(axle));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axle
 
     CHECK_OK(jtWriter.OpenInstance("Wheels")); // open
     Dtk_Int64 id_of_wheel = 1;
          CHECK_OK(jtWriter.OpenInstance("Wheel", id_of_wheel, Dtk_transfo(X, Y, Z, Dtk_pnt(0, 0, 5)))); // open instance
          Dtk_BodyPtr wheel = sampleWriter::CreateCyl(1, 1);
          CHECK_OK(jtWriter.AddBody(wheel));
          CHECK_OK(jtWriter.CloseLastInstance());  // close Wheel
 
          CHECK_OK(jtWriter.OpenInstance("Wheel2", id_of_wheel, Dtk_transfo(X, -Y, -Z, Dtk_pnt()))); // open reinstance
          CHECK_OK(jtWriter.CloseLastInstance());  // reinstancied : must close Wheel immediatly.
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheels
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close RootNode
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample32
// -------------------------------- SampleAsmInstances_3_3 -------------------------------------------------
//start_of_jtwsample33
Dtk_ErrorStatus JtwSampleAsmInstances_3_3(const Dtk_string& inOutputFileName)
{
     Dtk_dir X(1, 0, 0);
     Dtk_dir Y(0, 1, 0);
     Dtk_dir Z(0, 0, 1);
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_Int64 id_of_axles = 2;
     CHECK_OK(jtWriter.OpenInstance("Axles", id_of_axles)); // open Axles, give an ID for future reinstance, placement by default : identity matrix
 
     CHECK_OK(jtWriter.OpenInstance("Axle")); // open
     Dtk_BodyPtr axle = sampleWriter::CreateCyl(0.2, 5);
     CHECK_OK(jtWriter.AddBody(axle));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axle
 
          CHECK_OK(jtWriter.OpenInstance("Wheels")); // open
               Dtk_Int64 id_of_wheel = 1;
               CHECK_OK(jtWriter.OpenInstance("Wheel", id_of_wheel, Dtk_transfo(X, Y, Z, Dtk_pnt(0, 0, 5)))); // open instance
               Dtk_BodyPtr wheel = sampleWriter::CreateCyl(1, 1);
               CHECK_OK(jtWriter.AddBody(wheel));
               CHECK_OK(jtWriter.CloseLastInstance());  // close Wheel
 
               CHECK_OK(jtWriter.OpenInstance("Wheel2", id_of_wheel, Dtk_transfo(X, -Y, -Z, Dtk_pnt()))); // open reinstance
               CHECK_OK(jtWriter.CloseLastInstance());  // reinstancied : must close Wheel immediatly.
 
          CHECK_OK(jtWriter.CloseLastInstance());  // close Wheels
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axles
 
     CHECK_OK(jtWriter.OpenInstance("Axles2", 2, Dtk_transfo(X, Y, Z, Dtk_pnt(10, 0, 0)))); // reinstance whole subassembly with matrix
     CHECK_OK(jtWriter.CloseLastInstance());  // reinstancied : must close Wheel immediatly.
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close RootNode
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample33
 
// -------------------------------- SampleInstancesColors_3_4 -------------------------------------------------
//start_of_jtwsample34
Dtk_ErrorStatus JtwSampleInstancesColors_3_4(const Dtk_string& inOutputFileName)
{
     Dtk_dir X(1, 0, 0);
     Dtk_dir Y(0, 1, 0);
     Dtk_dir Z(0, 0, 1);
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_Int64 id_of_axles = 2;
     CHECK_OK(jtWriter.OpenInstance("Axles", id_of_axles)); // open Axles, give an ID for future reinstance, placement by default : identity matrix
 
          CHECK_OK(jtWriter.OpenInstance("Axle")); // open
          Dtk_BodyPtr axle = sampleWriter::CreateCyl(0.2, 5);
          CHECK_OK(jtWriter.AddBody(axle));
          CHECK_OK(jtWriter.CloseLastInstance());  // close Axle
 
          CHECK_OK(jtWriter.OpenInstance("Wheels")); // open
          Dtk_Int64 id_of_wheel = 1;
          CHECK_OK(jtWriter.OpenInstance("Wheel", id_of_wheel, Dtk_transfo(X, Y, Z, Dtk_pnt(0, 0, 5)))); // open instance
          Dtk_BodyPtr wheel = sampleWriter::CreateCyl(1, 1);
          CHECK_OK(jtWriter.AddBody(wheel));
          CHECK_OK(jtWriter.CloseLastInstance());  // close Wheel
 
     CHECK_OK(jtWriter.OpenInstance("Wheel2", id_of_wheel, Dtk_transfo(X, -Y, -Z, Dtk_pnt()))); // open reinstance
     CHECK_OK(jtWriter.CloseLastInstance());  // reinstancied : must close Wheel immediatly.
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheels
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axles
 
     CHECK_OK(jtWriter.OpenInstance("Axles2", id_of_axles, Dtk_transfo(X, Y, Z, Dtk_pnt(5, 0, 0))));
     CHECK_OK(jtWriter.LastInstance_SetInstanceColor(Dtk_RGB(255, 0, 0, 128), Dtk_Jtw_Interface::keepsubcolor));
           // Give a RED color with transparence, with keepsubcolor strategy : only uncolored faces are filled
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axles2
 
     CHECK_OK(jtWriter.OpenInstance("Axles3", id_of_axles, Dtk_transfo(X, Y, Z, Dtk_pnt(10, 0, 0))));
     CHECK_OK(jtWriter.LastInstance_SetInstanceColor(Dtk_RGB(0, 0, 255), Dtk_Jtw_Interface::overwritecolor));
          // Give a BLUE color, with overwrite color strategy : all faces are filled
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axles2
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close RootNode
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample34
// -------------------------------- SampleInstancesVisibily_3_5 -------------------------------------------------
//start_of_jtwsample35
Dtk_ErrorStatus JtwSampleInstancesVisibily_3_5(const Dtk_string& inOutputFileName)
{
     Dtk_dir X(1, 0, 0);
     Dtk_dir Y(0, 1, 0);
     Dtk_dir Z(0, 0, 1);
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     CHECK_OK(jtWriter.OpenInstance("Axle")); // open
     Dtk_BodyPtr axle = sampleWriter::CreateCyl(0.2, 5);
     CHECK_OK(jtWriter.AddBody(axle));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axle
 
     CHECK_OK(jtWriter.OpenInstance("Wheels")); // open
     Dtk_Int64 id_of_wheel = 1;
     CHECK_OK(jtWriter.OpenInstance("Wheel", id_of_wheel, Dtk_transfo(X, Y, Z, Dtk_pnt(0, 0, 5)))); // open instance
     Dtk_BodyPtr wheel = sampleWriter::CreateCyl(1, 1);
     CHECK_OK(jtWriter.AddBody(wheel));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheel
 
     CHECK_OK(jtWriter.OpenInstance("Wheel2", id_of_wheel, Dtk_transfo(X, -Y, -Z, Dtk_pnt())));
     CHECK_OK(jtWriter.LastInstance_SetInvisible());  // Set as invisible
     CHECK_OK(jtWriter.CloseLastInstance());    // reinstancied : must close Wheel immediatly.
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheels
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close RootNode
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample35
// -------------------------------- SampleMultipleFilesPerPart_3_6 -------------------------------------------------
//start_of_jtwsample36
Dtk_ErrorStatus JtwSampleMultipleFilesPerPart_3_6(const Dtk_string& inOutputFileName)
{
     Dtk_dir X(1, 0, 0);
     Dtk_dir Y(0, 1, 0);
     Dtk_dir Z(0, 0, 1);
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_Int64 id_of_axles = 2;
     CHECK_OK(jtWriter.OpenInstance("Axles", id_of_axles)); // open Axles, give an ID for future reinstance, placement by default : identity matrix
 
     CHECK_OK(jtWriter.OpenInstance("Axle",Dtk_transfo(), "assembly/axle.jt"));// open instance in a new file.
     Dtk_BodyPtr axle = sampleWriter::CreateCyl(0.2, 5);
     CHECK_OK(jtWriter.AddBody(axle));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axle
 
     CHECK_OK(jtWriter.OpenInstance("Wheels")); // open
     Dtk_Int64 id_of_wheel = 1;
     CHECK_OK(jtWriter.OpenInstance("Wheel", id_of_wheel, Dtk_transfo(X, Y, Z, Dtk_pnt(0, 0, 5)), "assembly/wheel.jt"));
     Dtk_BodyPtr wheel = sampleWriter::CreateCyl(1, 1);
     CHECK_OK(jtWriter.AddBody(wheel));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheel
 
     CHECK_OK(jtWriter.OpenInstance("Wheel2", id_of_wheel, Dtk_transfo(X, -Y, -Z, Dtk_pnt()))); // open reinstance
     CHECK_OK(jtWriter.CloseLastInstance());  // reinstancied : must close Wheel immediatly.
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheels
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axles
 
     CHECK_OK(jtWriter.OpenInstance("Axles2", 2, Dtk_transfo(X, Y, Z, Dtk_pnt(10, 0, 0)))); // reinstance whole subassembly with matrix
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axles2
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close RootNode
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample36
 
// -------------------------------- SampleMultipleFilesShattered_3_7 -------------------------------------------------
//start_of_jtwsample37
Dtk_ErrorStatus JtwSampleMultipleFilesShattered_3_7(const Dtk_string& inOutputFileName)
{
     Dtk_dir X(1, 0, 0);
     Dtk_dir Y(0, 1, 0);
     Dtk_dir Z(0, 0, 1);
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_Int64 id_of_axles = 2;
     CHECK_OK(jtWriter.OpenInstance("Axles", id_of_axles, Dtk_transfo(), "shattered_axles.jt")); // open Axles, give an ID for future reinstance, open instance in a new file.
 
     CHECK_OK(jtWriter.OpenInstance("Axle", Dtk_transfo(), "shattered_axle.jt")); // open instance in a new file.
 
     Dtk_BodyPtr axle = sampleWriter::CreateCyl(0.2, 5);
     CHECK_OK(jtWriter.AddBody(axle));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axle
 
     CHECK_OK(jtWriter.OpenInstance("Wheels", Dtk_transfo(), "shattered_wheels.jt")); // open instance in a new file.
     Dtk_Int64 id_of_wheel = 1;
     CHECK_OK(jtWriter.OpenInstance("Wheel", id_of_wheel, Dtk_transfo(X, Y, Z, Dtk_pnt(0, 0, 5)), "shattered_wheel.jt")); // open instance in a new file.
     Dtk_BodyPtr wheel = sampleWriter::CreateCyl(1, 1);
     CHECK_OK(jtWriter.AddBody(wheel));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheel
 
     CHECK_OK(jtWriter.OpenInstance("Wheel2", id_of_wheel, Dtk_transfo(X, -Y, -Z, Dtk_pnt()))); // open reinstance
     CHECK_OK(jtWriter.CloseLastInstance());  // reinstancied : must close Wheel immediatly."
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheels
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axles
 
     CHECK_OK(jtWriter.OpenInstance("Axles2", 2, Dtk_transfo(X, Y, Z, Dtk_pnt(10, 0, 0)))); // reinstance whole subassembly with matrix
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axles2
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close RootNode
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample37
 
// ------------------------------------ SampleVersion_4_1 ---------------------------------------------
//start_of_jtwsample41
Dtk_ErrorStatus JtwSampleVersion_4_1(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep, Dtk_Jtw_Interface::version80);  // set version 8.0
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
     Dtk_MeshPtr CubeMesh = sampleWriter::CreateMeshCube(); // create a simple red cube 
     CHECK_OK(jtWriter.AddMesh(CubeMesh));   // write the cube
     CHECK_OK(jtWriter.CloseLastInstance()); // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample41
// ------------------------------------ SampleUnits_4_2 ---------------------------------------------
//start_of_jtwsample42
Dtk_ErrorStatus JtwSampleUnits_4_2(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep, Dtk_Jtw_Interface::version95, Dtk_Jtw_Interface::inches); 
               // set units as inches
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
     Dtk_MeshPtr CubeMesh = sampleWriter::CreateMeshCube(); // create a simple red cube 
     CHECK_OK(jtWriter.AddMesh(CubeMesh));   // write the cube
     CHECK_OK(jtWriter.CloseLastInstance()); // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample42
 
// ------------------------------- SampleMetadatas_4_3 --------------------------------------------------
//start_of_jtwsample43
Dtk_ErrorStatus JtwSampleMetadatas_4_3(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_MetaDataPtr meta = Dtk_MetaData::CreateMetaData(Dtk_MetaData::TypeProperty, "MyTitle", "MyValue");
     CHECK_OK(jtWriter.AddMetaData(meta));
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(1, 2);  // Create a Cylinder radius=1, height=2  (with a green face)
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample43
 
// -------------------------------- SampleLayers_4_4 -------------------------------------------------
 
//start_of_jtwsample44
Dtk_ErrorStatus JtwSampleLayers_4_4(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     CHECK_OK(jtWriter.OpenInstance("Cyl1"));
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(1, 2);
     cylinder->info()->SetLayer(3);
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
     CHECK_OK(jtWriter.CloseLastInstance());
 
     CHECK_OK(jtWriter.OpenInstance("Cyl2"));
     Dtk_BodyPtr cylinder2 = sampleWriter::CreateCyl(1, 2);
     cylinder2->info()->SetLayer(5);
     Shift(cylinder2, 3);
     CHECK_OK(jtWriter.AddBody(cylinder2));   // Add the body
     CHECK_OK(jtWriter.CloseLastInstance());
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample44
 
// -------------------------------- SampleLayerNames_4_5 -------------------------------------------------
//start_of_jtwsample45
Dtk_LayerInfosSetPtr CreateLayerInfosSet()
{
     Dtk_LayerInfosSetPtr lay = Dtk_LayerInfosSet::Create();
     lay->AddLayer( Dtk_LayerInfosSet::Layer( 3, L"LayerThree" ) ); // first layer has ID 3
     lay->AddLayer( Dtk_LayerInfosSet::Layer( 5, L"LayerFive" ) ); // second layer has ID 5
     return lay;
}
 
Dtk_ErrorStatus JtwSampleLayerNames_4_5(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_LayerInfosSetPtr lay = CreateLayerInfosSet();
     CHECK_OK(jtWriter.AddLayerInfosSet(lay));
 
     CHECK_OK(jtWriter.OpenInstance("Cyl1"));
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(1, 2);
     cylinder->info()->SetLayer(3);
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
     CHECK_OK(jtWriter.CloseLastInstance());
 
     CHECK_OK(jtWriter.OpenInstance("Cyl2"));
     Dtk_BodyPtr cylinder2 = sampleWriter::CreateCyl(1, 2);
     cylinder2->info()->SetLayer(5);
     Shift(cylinder2, 3);
     CHECK_OK(jtWriter.AddBody(cylinder2));   // Add the body
     CHECK_OK(jtWriter.CloseLastInstance());
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample45
// -------------------------------- SampleSimplePMI_5_1 -------------------------------------------------
 
//start_of_jtwsample51
Dtk_ErrorStatus JtwSampleSimplePMI_5_1(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(100, 150);  // Create a Cylinder radius=1, height=2  (with a green face)
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK(jtWriter.AddPMI(pmi)); // Add the PMI
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample51
// -------------------------------- SampleSimpleModelview_5_2 -------------------------------------------------
//start_of_jtwsample52
Dtk_ErrorStatus JtwSampleSimpleModelview_5_2(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(100, 150);  // Create a Cylinder radius=100, height=150  (with a green face)
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK(jtWriter.AddPMI(pmi)); // Add the PMI
 
     Dtk_pnt from(0, 0, 100);
     Dtk_pnt to(0, 0, 0);
     Dtk_dir up(0, 1, 0);
     Dtk_CameraPtr cam = Dtk_Camera::Create(from, to, 100, 100, up);  // semiwidth = 100
     Dtk_ModelDisplayPtr mvfit = Dtk_ModelDisplay::Create(cam, NULL, 1);
     mvfit->info() = Dtk_Info::Create();
     mvfit->info()->SetName("FitView");
     CHECK_OK(jtWriter.AddModelView(mvfit));
 
     from = Dtk_pnt(300, 300, 300);
     up = Dtk_dir(-0.57735, 0.57735, -0.57735);
     cam = Dtk_Camera::Create(from, to, 250, 250, up);
     Dtk_ModelDisplayPtr mv2 = Dtk_ModelDisplay::Create(cam, NULL, 1);
     mv2->info() = Dtk_Info::Create();
     mv2->info()->SetName("SecondView");
     CHECK_OK(jtWriter.AddModelView(mv2));
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample52
// -------------------------------- SamplePMI_MV_association_5_3 -------------------------------------------------
//start_of_jtwsample53
Dtk_ErrorStatus JtwSamplePMI_MV_association_5_3(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(100, 150);  // Create a Cylinder radius=100, height=150  (with a green face)
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK(jtWriter.AddPMI(pmi, 5)); // Add the PMI, set ID = 5
 
     Dtk_pnt from(300, 300, 300);
     Dtk_pnt to(0, 0, 0);
     Dtk_dir up(-0.57735, 0.57735, -0.57735);
     Dtk_CameraPtr cam = Dtk_Camera::Create(from, to, 250, 250, up);
     Dtk_ModelDisplayPtr mv2 = Dtk_ModelDisplay::Create(cam, NULL, 1);
     mv2->info() = Dtk_Info::Create();
     mv2->info()->SetName("SecondView");
     CHECK_OK(jtWriter.AddModelView(mv2, 8)); // Add Modelview, set ID = 8
 
     CHECK_OK(jtWriter.ConnectPMI_ModelView(5, 8));  // Connect PMI 5 into Modelview 8
     
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample53
// -------------------------------- SamplePMI_Geom_association_5_4 -------------------------------------------------
//start_of_jtwsample54
Dtk_ErrorStatus JtwSamplePMI_Geom_association_5_4(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(100, 150);  // Create a Cylinder radius=100, height=150  (with a green face)
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK(jtWriter.AddPMI(pmi, 5)); // Add the PMI, set ID = 5
 
     Dtk_pnt from(300, 300, 300);
     Dtk_pnt to(0, 0, 0);
     Dtk_dir up(-0.57735, 0.57735, -0.57735);
     Dtk_CameraPtr cam = Dtk_Camera::Create(from, to, 150, 150, up);
     Dtk_ModelDisplayPtr mv2 = Dtk_ModelDisplay::Create(cam, NULL, 1);
     mv2->info() = Dtk_Info::Create();
     mv2->info()->SetName("SecondView");
     CHECK_OK(jtWriter.AddModelView(mv2, 8)); // Add Modelview, set ID = 8
 
     CHECK_OK(jtWriter.ConnectPMI_ModelView(5, 8));  // Connect PMI 5 into Modelview 8
 
     CHECK_OK(jtWriter.ConnectPMI_Geom(5, 2, DTK_TYPE_FACE));  // Connect PMI 5 on body, on face ID= 2
     CHECK_OK(jtWriter.ConnectPMI_Geom(5, 15, DTK_TYPE_EDGE));  // Connect PMI 5 on body, on edge ID= 15
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample54
// -------------------------------- SampleModelview_sections_5_5 -------------------------------------------------
//start_of_jtwsample55
Dtk_EntityPtr MakeMultiSection()
{
     Dtk_BodyPtr body = Dtk_Body::Create();
     Dtk_ShellPtr shell = Dtk_Shell::Create(body);
     body->AddOpenShell(shell);
     Dtk_FacePtr face1 = Dtk_Face::Create(body);
     Dtk_PlaneSurfacePtr section1 = Dtk_PlaneSurface::Create(Dtk_pnt(), Dtk_dir(1, 0, 0), Dtk_dir(0, 1, 0));
     section1->info() = Dtk_Info::Create();
     section1->info()->SetColor(Dtk_RGB(128, 0, 0));  // red
     face1->SetGeom(Dtk_SurfacePtr::DtkDynamicCast(section1));
     shell->AddFace(face1, DTK_TRUE);
     Dtk_FacePtr face2 = Dtk_Face::Create(body);
     Dtk_PlaneSurfacePtr section2 = Dtk_PlaneSurface::Create(Dtk_pnt(), Dtk_dir(0, 1, 0), Dtk_dir(1, 0, 0));
     section2->info() = Dtk_Info::Create();
     section2->info()->SetColor(Dtk_RGB(0, 0, 128));  // blue
     face2->SetGeom(Dtk_SurfacePtr::DtkDynamicCast(section2));
     shell->AddFace(face2, DTK_TRUE);
     return Dtk_EntityPtr::DtkDynamicCast(body);
}
 
Dtk_ErrorStatus JtwSampleModelview_sections_5_5(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(100, 150);  // Create a Cylinder radius=100, height=150  (with a green face)
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK(jtWriter.AddPMI(pmi, 5)); // Add the PMI, set ID = 5
 
     Dtk_pnt from(300, 300, 300);
     Dtk_pnt to(0, 0, 0);
     Dtk_dir up(-0.57735, 0.57735, -0.57735);
     Dtk_CameraPtr cam = Dtk_Camera::Create(from, to, 150, 150, up);
     Dtk_PlaneSurfacePtr section = Dtk_PlaneSurface::Create(Dtk_pnt(), Dtk_dir(1, 0, 0), Dtk_dir(0, 1, 0));  // (A)
     //Dtk_EntityPtr section = MakeMultiSection();  // (B)
     Dtk_ModelDisplayPtr mv2 = Dtk_ModelDisplay::Create(cam, Dtk_EntityPtr::DtkDynamicCast(section), 1);
 
     mv2->info() = Dtk_Info::Create();
     mv2->info()->SetName("SecondView");
     CHECK_OK(jtWriter.AddModelView(mv2, 8)); // Add Modelview, set ID = 8
 
     CHECK_OK(jtWriter.ConnectPMI_ModelView(5, 8));  // Connect PMI 5 into Modelview 8
 
     CHECK_OK(jtWriter.ConnectPMI_Geom(5, 2, DTK_TYPE_FACE));  // Connect PMI 5 on body, on face ID= 2
     CHECK_OK(jtWriter.ConnectPMI_Geom(5, 15, DTK_TYPE_EDGE));  // Connect PMI 5 on body, on edge ID= 15
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample55
// -------------------------------- SamplePMI_PMI_association_5_6 -------------------------------------------------
//start_of_jtwsample56
Dtk_ErrorStatus JtwSamplePMI_PMI_association_5_6(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(100, 150);  // Create a Cylinder radius=100, height=150  (with a green face)
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
 
     int pmiIdx;
     for (pmiIdx = 0; pmiIdx < 10; pmiIdx++) // create 10 PMI
     {
          Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
          if( pmi.IsNotNULL() && pmi->Sub2DEntity().IsNotNULL() && pmi->Sub2DEntity()->get_type_detk() == DTK_TYPE_SYMBOL)
          {    // changing letter inside PMI (datum feature symbol), or JT2Go recognize as same PMI with semantic informations, and example fails.
               Dtk_SymbolPtr symb = Dtk_SymbolPtr::DtkDynamicCast( pmi->Sub2DEntity() );
               if (symb.IsNotNULL() && symb->Texts().GetNumTexts() > 0 && symb->Texts()[0].Text().len()>0)
                    symb->Texts()[ 0 ].Text()[ 0 ] = (wchar_t)('A' + pmiIdx);
          }
          Shift(pmi, 15 * pmiIdx);
          CHECK_OK(jtWriter.AddPMI(pmi, 5 + pmiIdx)); // Add the PMI, set ID = 5
     }
     Dtk_pnt from(300, 300, 300);
     Dtk_pnt to(0, 0, 0);
     Dtk_dir up(-0.57735, 0.57735, -0.57735);
     Dtk_CameraPtr cam = Dtk_Camera::Create(from, to, 150, 150, up);
     Dtk_ModelDisplayPtr mv2 = Dtk_ModelDisplay::Create(cam, NULL, 1);
     mv2->info() = Dtk_Info::Create();
     mv2->info()->SetName("SecondView");
     CHECK_OK(jtWriter.AddModelView(mv2, 30)); // Add Modelview, set ID = 8
 
     for (pmiIdx = 0; pmiIdx < 10; pmiIdx++) // link the 10 PMIto ModelView
     {
          CHECK_OK(jtWriter.ConnectPMI_ModelView(5 + pmiIdx, 30));
     }
 
     CHECK_OK(jtWriter.ConnectPMI_PMI(6, 8));  // Associate PMI 6 to PMI 8
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample56
 
// -------------------------------- SampleAxis_References_5_7 -------------------------------------------------
//start_of_jtwsample57
Dtk_BodyPtr MakeReferencePlane()
{
     Dtk_BodyPtr body = Dtk_Body::Create();
     body->info() = Dtk_Info::Create();
     body->info()->SetName("MyReferencePlane");
     body->info()->SetInfiniteGeometryFlag(1);  // mandatory
     body->info()->SetColor(Dtk_RGB(128, 0, 0));  // color red
     Dtk_ShellPtr shell = Dtk_Shell::Create(body);
     body->AddOpenShell(shell);
     Dtk_FacePtr face1 = Dtk_Face::Create(body);
     Dtk_PlaneSurfacePtr plane = Dtk_PlaneSurface::Create(Dtk_pnt(), Dtk_dir(1, 0, 0), Dtk_dir(0, 1, 0));
     double box[4] = { -200,200,-200,200 };   // trim of the plane
     plane->SetTrimUVBox(box);
     face1->SetGeom(Dtk_SurfacePtr::DtkDynamicCast(plane));
     shell->AddFace(face1, DTK_TRUE);
     return body;
}
 
Dtk_BodyPtr MakeReferenceAxis()
{
     Dtk_BodyPtr body = Dtk_Body::Create();
     body->info() = Dtk_Info::Create();
     body->info()->SetName("MyReferenceAxis");
     body->info()->SetInfiniteGeometryFlag(1);  // mandatory
     body->info()->SetColor(Dtk_RGB(0, 128, 0));  // color green
     Dtk_ShellPtr shell = Dtk_Shell::Create(body);
     body->AddOpenShell(shell);
     Dtk_tab<Dtk_CurvePtr> tabwire;
     Dtk_LinePtr L = Dtk_Line::Create(Dtk_pnt(100, 100, 0), Dtk_dir(0, 0, 1));
     L->SetTrimmingParameters(0.0, 200.0);
     tabwire.push_back(Dtk_CurvePtr::DtkDynamicCast(L));
     shell->AddWire(tabwire);
     return body;
}
 
Dtk_BodyPtr MakeReferencePoint()
{
     Dtk_BodyPtr body = Dtk_Body::Create();
     body->info() = Dtk_Info::Create();
     body->info()->SetName("MyReferencePoint");
     body->info()->SetInfiniteGeometryFlag(1);  // mandatory
     body->info()->SetColor(Dtk_RGB(0, 0, 128));  // color blue
     Dtk_ShellPtr shell = Dtk_Shell::Create(body);
     body->AddOpenShell(shell);
     Dtk_tab<Dtk_PointPtr> tabpoints;
     Dtk_PointPtr point = Dtk_Point::Create(Dtk_pnt(120, 120, 0));
     tabpoints.push_back(point);
     shell->AddWire(tabpoints);
     return body;
}
 
Dtk_ErrorStatus JtwSampleAxis_References_5_7(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(100, 150);  // Create a Cylinder radius=100, height=150  (with a green face)
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
 
     Dtk_pnt from(300, 300, 300);
     Dtk_pnt to(0, 0, 0);
     Dtk_dir up(-0.57735, 0.57735, -0.57735);
     Dtk_CameraPtr cam = Dtk_Camera::Create(from, to, 250, 250, up);
     Dtk_ModelDisplayPtr mv2 = Dtk_ModelDisplay::Create(cam, NULL, 1);
     mv2->info() = Dtk_Info::Create();
     mv2->info()->SetName("SecondView");
     CHECK_OK(jtWriter.AddModelView(mv2, 8)); // Add Modelview, set ID = 8
 
     Dtk_AxisSystemPtr axis = Dtk_AxisSystem::Create();
     axis->SetMatrix(Dtk_transfo(Dtk_dir(1, 0, 0), Dtk_dir(0, 1, 0), Dtk_dir(0, 0, 1), Dtk_pnt(100, 100, 0))); // X,Y,Z, O
     axis->SetName("MyAxisSystem"); // give a name
     CHECK_OK(jtWriter.AddAxisSystem(axis, 50));  // give ID 50
     CHECK_OK(jtWriter.ConnectPMI_ModelView(50, 8));  // Connect AxisSystem 50 to Modelview 8
 
     Dtk_BodyPtr refplane = MakeReferencePlane();
     CHECK_OK(jtWriter.AddReferenceGeometry(refplane, 60));  // give ID 60
     CHECK_OK(jtWriter.ConnectPMI_ModelView(60, 8));  // Connect Referenceplane 50 to Modelview 8
 
     Dtk_BodyPtr refaxis = MakeReferenceAxis();
     CHECK_OK(jtWriter.AddReferenceGeometry(refaxis, 70));  // give ID 70
     CHECK_OK(jtWriter.ConnectPMI_ModelView(70, 8));  // Connect Referenceplane 60 to Modelview 8
 
     Dtk_BodyPtr refpoint = MakeReferencePoint();
     CHECK_OK(jtWriter.AddReferenceGeometry(refpoint, 80));  // give ID 80
     CHECK_OK(jtWriter.ConnectPMI_ModelView(80, 8));  // Connect Referenceplane 70 to Modelview 8
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample57
// -------------------------------- SamplePMI_Geom_one_association_5_8 -------------------------------------------------
//start_of_jtwsample58
Dtk_ErrorStatus JtwSamplePMI_Geom_one_association_5_8(const Dtk_string& inOutputFileName)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_BodyPtr cylinder = sampleWriter::CreateCyl(100, 150);  // Create a Cylinder radius=100, height=150  (with a green face)
     cylinder->info()->SetId(10);
     CHECK_OK(jtWriter.AddBody(cylinder));   // Add the body
 
     Dtk_BodyPtr cylinder2 = sampleWriter::CreateCyl(100, 150);  // Create a Cylinder radius=100, height=150  (with a green face)
     Shift(cylinder2, 250);
     cylinder2->info()->SetId(11);
     CHECK_OK(jtWriter.AddBody(cylinder2));   // Add the body
 
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();  // Create an FDT (PMI)
     CHECK_OK(jtWriter.AddPMI(pmi, 5)); // Add the PMI, set ID = 5
 
     Dtk_pnt from(300, 300, 300);
     Dtk_pnt to(0, 0, 0);
     Dtk_dir up(-0.57735, 0.57735, -0.57735);
     Dtk_CameraPtr cam = Dtk_Camera::Create(from, to, 250, 250, up);
     Dtk_ModelDisplayPtr mv2 = Dtk_ModelDisplay::Create(cam, NULL, 1);
     mv2->info() = Dtk_Info::Create();
     mv2->info()->SetName("SecondView");
     CHECK_OK(jtWriter.AddModelView(mv2, 8)); // Add Modelview, set ID = 8
 
     CHECK_OK(jtWriter.ConnectPMI_ModelView(5, 8));  // Connect PMI 5 into Modelview 8
 
     CHECK_OK(jtWriter.ConnectPMI_Geom(5, 2, DTK_TYPE_FACE, Dtk_tab<Dtk_Int64>(), 10));  // Connect PMI 5 on body 10, on face ID= 2
     CHECK_OK(jtWriter.ConnectPMI_Geom(5, 15, DTK_TYPE_EDGE, Dtk_tab<Dtk_Int64>(), 11));  // Connect PMI 5 on body 11, on edge ID= 15
 
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample58
// -------------------------------- SampleModelViewAsm_6_1 -------------------------------------------------
//start_of_jtwsample61
Dtk_ModelDisplayPtr CreateModelDisplay(const Dtk_string& inName)
{
     Dtk_pnt from(300, 300, 300);
     Dtk_pnt to(0, 0, 0);
     Dtk_dir up(-0.57735, 0.57735, -0.57735);
     Dtk_CameraPtr cam = Dtk_Camera::Create(from, to, 5, 5, up);
     Dtk_ModelDisplayPtr mv = Dtk_ModelDisplay::Create(cam, NULL, 1);
     mv->info() = Dtk_Info::Create();
     mv->info()->SetName(inName);
     return mv;
}
 
Dtk_ErrorStatus JtwSampleModelViewAsm_6_1(const Dtk_string& inOutputFileName)
{
     Dtk_dir X(1, 0, 0);
     Dtk_dir Y(0, 1, 0);
     Dtk_dir Z(0, 0, 1);
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode")); // Rootnode creation
 
     Dtk_Int64 id_of_axles = 2;
     CHECK_OK(jtWriter.OpenInstance("Axles", id_of_axles)); // open Axles, give an ID for future reinstance, placement by default : identity matrix
 
     CHECK_OK(jtWriter.OpenInstance("Axle")); // open
     Dtk_BodyPtr axle = sampleWriter::CreateCyl(0.2, 5);
     CHECK_OK(jtWriter.AddBody(axle));
     CHECK_OK(jtWriter.AddModelView(CreateModelDisplay("AxleMV"), 8));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axle
 
     CHECK_OK(jtWriter.OpenInstance("Wheels")); // open
     Dtk_Int64 id_of_wheel = 1;
     CHECK_OK(jtWriter.OpenInstance("Wheel", id_of_wheel, Dtk_transfo(X, Y, Z, Dtk_pnt(0, 0, 5)))); // open instance
     Dtk_BodyPtr wheel = sampleWriter::CreateCyl(1, 1);
     CHECK_OK(jtWriter.AddBody(wheel));
     CHECK_OK(jtWriter.AddModelView(CreateModelDisplay("WheelMV"), 8));
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheel
 
     CHECK_OK(jtWriter.OpenInstance("Wheel2", id_of_wheel, Dtk_transfo(X, -Y, -Z, Dtk_pnt()))); // open reinstance
     CHECK_OK(jtWriter.CloseLastInstance());  // reinstancied : must close Wheel immediatly.
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Wheels
 
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axles
 
     CHECK_OK(jtWriter.OpenInstance("Axles2", id_of_axles, Dtk_transfo(X, Y, Z, Dtk_pnt(5, 0, 0)))); // reinstance whole subassembly with matrix
     CHECK_OK(jtWriter.CloseLastInstance());  // close Axles2
 
     CHECK_OK(jtWriter.AddModelView(CreateModelDisplay("RootMV"), 8));
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample61
// -------------------------------- SampleModelViewTarget_6_2 ; 6.3 ; 6.4  -------------------------------------------------
//start_of_jtwsample62
Dtk_tab<Dtk_Int64> Makeroute(Dtk_Int64 inRouteIds[], int inCount)
{
     Dtk_tab<Dtk_Int64> res;
     for (int routeIdx = 0; routeIdx < inCount; routeIdx++)
          res.push_back(inRouteIds[routeIdx]);
     return res;
}
 
Dtk_FdtPtr CreateFdtDatumAt(const Dtk_pnt& inPosition)
{
     Dtk_FdtPtr pmi = sampleWriter::CreateFdtDatum();
     double scale = 0.1;
     Dtk_transfo rescale(Dtk_dir(scale, 0, 0), Dtk_dir(0, scale, 0), Dtk_dir(0, 0, scale), scale * Dtk_pnt(-50., -100., -50.));
     pmi->Transform(rescale);
     Dtk_transfo shift;
     shift.addTranslate(inPosition);
     pmi->Transform(shift);
     return pmi;
}
 
Dtk_ErrorStatus MakePmiOnRoot(Dtk_Jtw_Interface& inoutJtWriter, int inOption)
{
     Dtk_pnt from(300, 300, 300);
     Dtk_pnt to(3, 0, 3);
     Dtk_dir up(-0.57735, 0.57735, -0.57735);
     Dtk_CameraPtr cam = Dtk_Camera::Create(from, to, 5, 5, up);
     Dtk_ModelDisplayPtr mv2 = Dtk_ModelDisplay::Create(cam, NULL, 1);
     mv2->info() = Dtk_Info::Create();
     mv2->info()->SetName("View");
     CHECK_OK(inoutJtWriter.AddModelView(mv2, 8)); // Add Modelview, set ID = 8
 
     if (inOption == 1)  // 6.2. Add instances by addition
     {
          Dtk_Int64 r1[] = { 1,11,2,13,4,14 };   // target one specific wheel
          Dtk_Int64 r2[] = { 1,16 };  // target one specific axle subassembly
          CHECK_OK(inoutJtWriter.ConnectModelView_Instance(8, Makeroute(r1, 6)));
          CHECK_OK(inoutJtWriter.ConnectModelView_Instance(8, Makeroute(r2, 2)));
     }
     if (inOption == 2) // 6.3. Remove instances (subtraction)
     {
          Dtk_Int64 r1[] = { 1,11,2,13,4,14 };   // target one specific wheel
          CHECK_OK(inoutJtWriter.ConnectModelView_Instance(8, Makeroute(r1, 6), 1)); // last parameter hide = 1
     }
     if (inOption == 3) // 6.4. Target PMI on assembly geometry
     {
          Dtk_FdtPtr pmi = CreateFdtDatumAt(Dtk_pnt(0, 1, 0));
          CHECK_OK(inoutJtWriter.AddPMI(pmi, 5)); // Add the PMI, set ID = 5
          CHECK_OK(inoutJtWriter.ConnectPMI_ModelView(5, 8));  // set PMI into Modelview
          Dtk_Int64 r1[] = { 1,11,2,13,4,15,5 };   // target one specific wheel
          CHECK_OK(inoutJtWriter.ConnectPMI_Geom(5, 3, DTK_TYPE_FACE, Makeroute(r1, 7)));
          Dtk_Int64 r2[] = { 1,16,2,12, 3 };   // target one specific axle
          CHECK_OK(inoutJtWriter.ConnectPMI_Geom(5, 2, DTK_TYPE_FACE, Makeroute(r2, 5)));
     }
     if( inOption == 4 )  // 6.2. Add instances by addition, and shift for exploded view
     {
          Dtk_Int64 rsub[] = { 1,16 };  // target one specific axle subassembly
          Dtk_Int64 rw1[] = { 1,11,2,13,4,14 };   // target the first wheel of the other axle subassembly
          Dtk_Int64 rw2[] = { 1,11,2,13,4,15 };   // target the second wheel of the other axle subassembly
          Dtk_Int64 ra[] = { 1,11,2,12 };            // target the axle of the other axle subassembly
          Dtk_dir X( 1, 0, 0 );
          Dtk_dir Y( 0, 1, 0 );
          Dtk_dir Z( 0, 0, 1 );
          Dtk_transfo newplacementwheel1( X, Y, Z, Dtk_pnt( 0, 0, 8 ) );
          Dtk_transfo newplacementwheel2( X, -Y, -Z, Dtk_pnt( 0, 0, -3 ) );
          CHECK_OK( inoutJtWriter.ConnectModelView_Instance( 8, Makeroute( rsub, 2 ) ) );
          CHECK_OK( inoutJtWriter.ConnectModelView_Instance( 8, Makeroute( ra, 4 ) ) );
          CHECK_OK( inoutJtWriter.ConnectModelView_Instance( 8, Makeroute( rw1, 6 ), 0, 0, &newplacementwheel1 ) );
          CHECK_OK( inoutJtWriter.ConnectModelView_Instance( 8, Makeroute( rw2, 6 ), 0, 0, &newplacementwheel2 ) );
     }
     return dtkNoError;
}
 
Dtk_ErrorStatus JtwSampleModelViewTarget_6_2(const Dtk_string& inOutputFileName, int inOption)
{
     Dtk_dir X(1, 0, 0);
     Dtk_dir Y(0, 1, 0);
     Dtk_dir Z(0, 0, 1);
     Dtk_ErrorStatus errorStatus;
     Dtk_Jtw_Interface jtWriter(inOutputFileName, errorStatus, Dtk_Jtw_Interface::xtbrep);     // Specify allowing BREP Writing 
     CHECK_OK(errorStatus);
     CHECK_OK(jtWriter.OpenInstance("RootNode", 1));   // Rootnode creation
          CHECK_OK(jtWriter.OpenInstance("Axles", 2));
          CHECK_OK(jtWriter.LastInstance_SetInstanceID(11));
               CHECK_OK(jtWriter.OpenInstance("Axle", 3));
               CHECK_OK(jtWriter.LastInstance_SetInstanceID(12));
                    Dtk_BodyPtr axle = sampleWriter::CreateCyl(0.2, 5);
                    CHECK_OK(jtWriter.AddBody(axle));
               CHECK_OK(jtWriter.CloseLastInstance());  // close Axle
               CHECK_OK(jtWriter.OpenInstance("Wheels", 4));
               CHECK_OK(jtWriter.LastInstance_SetInstanceID(13));
                    CHECK_OK(jtWriter.OpenInstance("Wheel", 5, Dtk_transfo(X, Y, Z, Dtk_pnt(0, 0, 5))));
                    CHECK_OK(jtWriter.LastInstance_SetInstanceID(14));
                         Dtk_BodyPtr wheel = sampleWriter::CreateCyl(1, 1);
                    CHECK_OK(jtWriter.AddBody(wheel));
                    CHECK_OK(jtWriter.CloseLastInstance());  // close Wheel
                    CHECK_OK(jtWriter.OpenInstance("Wheel2", 5, Dtk_transfo(X, -Y, -Z, Dtk_pnt())));
                    CHECK_OK(jtWriter.LastInstance_SetInstanceID(15));
                    CHECK_OK(jtWriter.CloseLastInstance());  // reinstancied : must close Wheel2 immediatly.
               CHECK_OK(jtWriter.CloseLastInstance());  // close Wheels
          CHECK_OK(jtWriter.CloseLastInstance());  // close Axles
          CHECK_OK(jtWriter.OpenInstance("Axles2", 2, Dtk_transfo(X, Y, Z, Dtk_pnt(6, 0, 0))));
          CHECK_OK(jtWriter.LastInstance_SetInstanceID(16));
          CHECK_OK(jtWriter.CloseLastInstance());  // close Axles2
          MakePmiOnRoot(jtWriter, inOption);
     CHECK_OK(jtWriter.CloseLastInstance());  // Rootnode closing.
     std::cout << "=> " << inOutputFileName.c_str() << std::endl;
     return dtkNoError;// Automatic Finish while J released
}
//end_of_jtwsample62
 
// -------------------------------- main -------------------------------------------------
 
//start_of_jtwtests
DtkErrorStatus AllJtWTests(const Dtk_string &inResultDirectory)
{
     Dtk_ErrorStatus errorStatus;
     Dtk_string outputDirectory, inOutputFileName;
     // Choosing output directory and file name
     outputDirectory = inResultDirectory + L"Jt/";
     outputDirectory.FixPathSeparator();
     outputDirectory.mkdir();
 
     // samples meshes
     inOutputFileName = outputDirectory + L"JTW_1_1_SampleMesh.jt";
     errorStatus = JtwSampleOneMesh_1_1( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_1_2_SampleMeshes.jt";
     errorStatus = JtwSampleMeshes_1_2( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_1_3_SampleTextures.jt";
     errorStatus = JtwSampleTextures_1_3( inOutputFileName );
 
     inOutputFileName = outputDirectory + L"JTW_2_1_SampleBody.jt";
     errorStatus = JtwSampleBody_2_1( inOutputFileName);
     inOutputFileName = outputDirectory + L"JTW_2_2_SampleBodyLOD.jt";
     errorStatus = JtwSampleBodyLOD_2_2( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_2_3_SampleWireBody.jt";
     errorStatus = JtwSampleWireBody_2_3( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_2_4_SampleBodyVisibility.jt";
     errorStatus = JtwSampleBodyVisibility_2_4( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_2_5_SampleLightmap.jt";
     errorStatus = JtwSampleLightmap_2_5( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_2_6_SampleLossy.jt";
     errorStatus = SampleLossyCompression_2_6( inOutputFileName );
 
     inOutputFileName = outputDirectory + L"JTW_3_1_SampleAssembly.jt";
     errorStatus = JtwSampleAssembly_3_1( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_3_2_SamplePartInstances.jt";
     errorStatus = JtwSamplePartInstances_3_2( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_3_3_SampleAsmInstances.jt";
     errorStatus = JtwSampleAsmInstances_3_3( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_3_4_SampleInstancesColors.jt";
     errorStatus = JtwSampleInstancesColors_3_4( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_3_5_SampleInstancesVisibily.jt";
     errorStatus = JtwSampleInstancesVisibily_3_5( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_3_6_SampleMultipleFilesPerPart.jt";
     errorStatus = JtwSampleMultipleFilesPerPart_3_6( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_3_7_SampleMultipleFilesShattered.jt";
     errorStatus = JtwSampleMultipleFilesShattered_3_7( inOutputFileName );
 
     inOutputFileName = outputDirectory + L"JTW_4_1_SampleVersion.jt";
     errorStatus = JtwSampleVersion_4_1( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_4_2_SampleUnits.jt";
     errorStatus = JtwSampleUnits_4_2( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_4_3_SampleMetadatas.jt";
     errorStatus = JtwSampleMetadatas_4_3( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_4_4_SampleLayers.jt";
     errorStatus = JtwSampleLayers_4_4( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_4_5_SampleLayerNames.jt";
     errorStatus = JtwSampleLayerNames_4_5( inOutputFileName );
 
     inOutputFileName = outputDirectory + L"JTW_5_1_SampleSimplePMI.jt";
     errorStatus = JtwSampleSimplePMI_5_1( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_5_2_SampleSimpleModelview.jt";
     errorStatus = JtwSampleSimpleModelview_5_2( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_5_3_SamplePMI_MV_association.jt";
     errorStatus = JtwSamplePMI_MV_association_5_3( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_5_4_SamplePMI_Geom_association.jt";
     errorStatus = JtwSamplePMI_Geom_association_5_4( inOutputFileName);
     inOutputFileName = outputDirectory + L"JTW_5_5_SampleModelview_sections.jt";
     errorStatus = JtwSampleModelview_sections_5_5( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_5_6_SamplePMI_PMI_association.jt";
     errorStatus = JtwSamplePMI_PMI_association_5_6( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_5_7_SampleAxis_References.jt";
     errorStatus = JtwSampleAxis_References_5_7( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_5_8_SamplePMI_Geom_one_association.jt";
     errorStatus = JtwSamplePMI_Geom_one_association_5_8( inOutputFileName );
 
     inOutputFileName = outputDirectory + L"JTW_6_1_SampleModelViewAsm.jt";
     errorStatus = JtwSampleModelViewAsm_6_1( inOutputFileName );
     inOutputFileName = outputDirectory + L"JTW_6_2_SampleModelViewTarget.jt";
     errorStatus = JtwSampleModelViewTarget_6_2( inOutputFileName, 1);
     inOutputFileName = outputDirectory + L"JTW_6_3_SampleModelViewRemove.jt";
     errorStatus = JtwSampleModelViewTarget_6_2( inOutputFileName, 2);
     inOutputFileName = outputDirectory + L"JTW_6_4_SampleAsmPMITarget.jt";
     errorStatus = JtwSampleModelViewTarget_6_2( inOutputFileName, 3);
     inOutputFileName = outputDirectory + L"JTW_6_5_SampleAsmExplodedView.jt";
     errorStatus = JtwSampleModelViewTarget_6_2( inOutputFileName, 4 );
 
     return errorStatus;
}
//end_of_jtwtests
 
//start_of_jtwmain
DtkErrorStatus JtWriteSample(const Dtk_string &inResultDirectory)
{
     std::cout << std::endl << "----------------------------------------------" << std::endl;
     std::cout << "Jt Write start" << std::endl;
 
     tess_InitTesselation("./", 0.005); // Init Tessellation : working directory and default tolerance (needed for writing bodies)
     tess_ComputeBoundariesFromMesh(0); // Disable wire creation on mesh during Brep tessellation.
 
     DtkErrorStatus errorStatus = AllJtWTests(inResultDirectory);  // all tests.
 
     tess_EndTesselation();  // End of tessellation
     std::cout << "Jt Write end" << std::endl;
 
     
     return errorStatus;
}
//end_of_jtwmain