DATAKIT API  V2025.4
Macros | Functions
testwriters.h File Reference

Go to the source code of this file.

Macros

#define CHECK_OK(X)   {Dtk_ErrorStatus res;if ((res=X)!=dtkNoError) {printf("error : %s\n", dtkTypeError(res).c_str());return res;}}
 
#define PRINT_ERROR(inStatus)
 

Functions

int _3dxmlWriteSample (const Dtk_string &inResultDirectory)
 
int _3mfWriteSample (const Dtk_string &inResultDirectory)
 
int CatiaV5WriteSample (const Dtk_string &inResultDirectory)
 
int CgrWriteSample (const Dtk_string &inResultDirectory)
 
int ColladaWriteSample (const Dtk_string &inResultDirectory)
 
int FbxWriteSample (const Dtk_string &inResultDirectory)
 
int GltfWriteSample (const Dtk_string &inResultDirectory)
 
int IfcWriteSample (const Dtk_string &inResultDirectory)
 
int IgesWriteSample (const Dtk_string &inResultDirectory)
 
int JtWriteSample (const Dtk_string &inResultDirectory)
 
int ObjWriteSample (const Dtk_string &inResultDirectory)
 
int ParasolidWriteSample (const Dtk_string &inResultDirectory)
 
int PdfWriteSample (const Dtk_string &inResultDirectory)
 
int PlmxmlWriteSample (const Dtk_string &inResultDirectory)
 
int SatWriteSample (const Dtk_string &inResultDirectory)
 
int StepWriteSample (const Dtk_string &inResultDirectory)
 
int SwWriteSample (Dtk_API *inDtkAPI, const Dtk_string &inResultDirectory)
 
int UgWriteSample (const Dtk_string &inResultDirectory)
 

Macro Definition Documentation

◆ CHECK_OK

#define CHECK_OK (   X)    {Dtk_ErrorStatus res;if ((res=X)!=dtkNoError) {printf("error : %s\n", dtkTypeError(res).c_str());return res;}}

◆ PRINT_ERROR

#define PRINT_ERROR (   inStatus)
Value:
{ \
if ( ( inStatus ) != dtkNoError) \
std::cout << __FUNCTION__ << " encountered an error at line " << __LINE__ << " : " << dtkTypeError(inStatus).c_str() << std::endl; \
}

Function Documentation

◆ _3dxmlWriteSample()

int _3dxmlWriteSample ( const Dtk_string &  inResultDirectory)
229 {
230  Dtk_MeshPtr CubeMesh;
231  Dtk_MeshPtr CylinderMesh;
232  Dtk_string outputFileName, outputDirectory;
233 
234  cout << endl << "----------------------------------------------" << endl;
235  cout << "3dxml Write start" << endl;
236 
237  // Choosing output directory and file name
238  outputDirectory = inResultDirectory + L"CatiaV6/";
239  outputDirectory.FixPathSeparator();
240  outputDirectory.mkdir();
241  outputFileName = outputDirectory + L"sample.3dxml";
242 
243  // Cube Sample
244  CubeMesh = sampleWriter::CreateMeshCube();
245 
246  // Cylinder Sample
247  CylinderMesh = sampleWriter::CreateMeshCylinder( 30 );
248 
249  // CREATING HIERARCHY
250 
251  // Root
252  // |
253  // | __Node(Node_1)
254  // | |
255  // | |
256  // | CylinderMesh(Node_2)
257  // |
258  // | __CubeWireMesh(Node_3)
259  // |
260  // |
261  // | __CylinderMesh(Node_4)
262 
263  _3dxmlw::WriteOptions Options;//no option for the moment
264  Dtk_string inLogFile;//no config for the moment
265  DtkErrorStatus errorSt = _3dxmlw::InitWrite( outputFileName, inLogFile, Options );
266 
267  if( errorSt == dtkNoError )
268  {
269  WriteEntity( CubeMesh, CylinderMesh );
270  }
271  else
272  cout << "error : " << dtkTypeError( errorSt ).c_str() << endl;
273 
274  _3dxmlw::EndWrite();
275 
276  if( errorSt == dtkNoError )
277  cout << "=> " << outputFileName.c_str() << endl << "3dxml Write end" << endl;
278 
279  return errorSt;
280 }

◆ _3mfWriteSample()

int _3mfWriteSample ( const Dtk_string &  inResultDirectory)
17 {
18  Dtk_ErrorStatus err = dtkNoError;
19  Dtk_MeshPtr cubeMesh = NULL;
20  Dtk_MeshPtr cylinderMesh = NULL;
21  Dtk_string outputFileName, outputDirectory;
22 
23  cout << endl << "----------------------------------------------" << endl;
24  cout << "3mf Write start" << endl;
25 
26  // Choosing output directory and file name
27  outputDirectory = inResultDirectory + L"3mf/";
28  outputDirectory.FixPathSeparator();
29  outputDirectory.mkdir();
30  outputFileName = outputDirectory + L"sample.3mf";
31 
32  // Cube Sample
33  cubeMesh = sampleWriter::CreateMeshCube();
34  sampleWriter::FillFacesColors( cubeMesh );
35 
36  // Cylinder Sample
37  cylinderMesh = sampleWriter::CreateMeshCylinder( 30 );
38 
39  // First we initialize writing
40  Dtk_3MFWriter::WriteOptions options;
41  Dtk_3MFWriter *_3mfw = new Dtk_3MFWriter();
42  err = _3mfw->InitWrite( outputFileName, Dtk_string( "test3mfw.log" ), options );
43 
44  if( err != dtkNoError )
45  cout << "error : " << dtkTypeError( err ).c_str() << endl;
46 
47 
48  // Lets write a small part composed by one cube and one cylinder
49 
50  // Let write the cube
51  cubeMesh->info() = Dtk_Info::create();
52  cubeMesh->info()->SetName( "Cube" );
53 
54  if( err == dtkNoError )
55  err = _3mfw->WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cubeMesh ) );
56 
57  // Let write the cylinder
58  cylinderMesh->info() = Dtk_Info::create();
59  cylinderMesh->info()->SetName( "Cylinder" );
60 
61  if( err == dtkNoError )
62  err = _3mfw->WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinderMesh ) );
63 
64  // We finish process and free memory allocated for writing
65  _3mfw->EndWrite();
66  if( err == dtkNoError )
67  cout << "=> " << outputFileName.c_str() << endl << "3mf Write end" << endl;
68  delete _3mfw;
69  return err;
70 }

◆ CatiaV5WriteSample()

int CatiaV5WriteSample ( const Dtk_string &  inResultDirectory)
484 {
485  // First we initialize writing with name of files and protection fonction
486  //First you have to initialize the CATIA V5 writer
487  Dtk_string outputDirectory;
488 
489  cout << endl << "----------------------------------------------" << endl;
490  cout << "CatiaV5 Write start" << endl;
491 
492  // Choosing output directory and file name
493  outputDirectory = inResultDirectory + L"CatiaV5/";
494  outputDirectory.FixPathSeparator();
495  outputDirectory.mkdir();
496 
497  catiav5w::WriteOptions options;
498  Dtk_ErrorStatus st = options.SetFileRelease( 19 );
499  if( st != dtkNoError )
500  {
501  cout << "error : " << dtkTypeError( st ).c_str() << endl;
502  return st;
503  }
504 
505  st = catiav5w::InitWrite( outputDirectory + L"V5W_LogFile.log", NULL, options );
506  if( st != dtkNoError )
507  {
508  cout << "error : " << dtkTypeError( st ).c_str() << endl;
509  return st;
510  }
511 
512  ProcessAsm( inResultDirectory );
513 
514  //...and the Main writter
515  catiav5w::EndWrite();
516 
517  return dtkNoError;
518 }

◆ CgrWriteSample()

int CgrWriteSample ( const Dtk_string &  inResultDirectory)
18 {
19  int status;
20  Dtk_MeshPtr CubeMesh;
21  Dtk_MeshPtr CylinderMesh;
22  Dtk_MeshPtr WireMesh;
23  Dtk_AxisSystemPtr TmpAxis;
24  Dtk_mesh_asm_node * mesh_asm = NULL;
25  Dtk_mesh_asm_node * mesh_asm_1 = NULL;
26  Dtk_mesh_asm_node * mesh_asm_2 = NULL;
27  Dtk_mesh_asm_node * mesh_asm_3 = NULL;
28  Dtk_mesh_asm_node * mesh_asm_4 = NULL;
29  Dtk_string outputFileName, outputDirectory;
30 
31  cout << endl << "----------------------------------------------" << endl;
32  cout << "Cgr Write start" << endl;
33 
34  // Choosing output directory and file name
35  outputDirectory = inResultDirectory + L"Cgr/";
36  outputDirectory.FixPathSeparator();
37  outputDirectory.mkdir();
38  outputFileName = outputDirectory + L"sample.cgr";
39 
40  // Axis System
41  TmpAxis = sampleWriter::CreateAxisSystem();
42 
43  // Cube Sample
44  CubeMesh = sampleWriter::CreateMeshCube();
45 
46  // Cylinder Sample
47  CylinderMesh = sampleWriter::CreateMeshCylinder( 30 );
48 
49  // Wire Sample
50  WireMesh = sampleWriter::CreateMeshWire();
51 
52  // PART5 : CREATING HIERARCHY
53 
54  // CREATE ROOT ASM NODE
55  mesh_asm = new Dtk_mesh_asm_node();
56 
57  mesh_asm->set_id( 0 ); // id of node
58  Dtk_transfo * transfo1 = new Dtk_transfo(); // transformation matrix
59  //apply scale
60  transfo1->setXdir( Dtk_dir( 0.8, 0.0, 0.0 ) );
61  transfo1->setYdir( Dtk_dir( 0.0, 0.8, 0.0 ) );
62  transfo1->setZdir( Dtk_dir( 0.0, 0.0, 0.8 ) );
63  transfo1->setOrigin( Dtk_pnt( 0.0, 0.0, 0.8 ) );
64  transfo1->setScale( 1.0 );
65 
66  // CREATE ASM 1
67  mesh_asm_1 = new Dtk_mesh_asm_node(); //create new node
68  mesh_asm_1->set_id( 1 ); // id of node
69  mesh_asm->add_asm_instance( mesh_asm_1, transfo1 ); // add mesh_asm_1 node in mesh_asm
70 
71  //WRITE AXIS SYSTEM
72  mesh_asm->add_axis_system(TmpAxis); // add axis system in mesh_asm
73 
74  //WRITE CUBE MESH
75  mesh_asm->add_mesh( CubeMesh );
76 
77  //WRITE CUBE MESH
78  mesh_asm_2 = new Dtk_mesh_asm_node(); //create new node
79  mesh_asm_2->set_id( 2 ); // id of node
80  Dtk_transfo * transfo2 = new Dtk_transfo();
81  transfo2->setOrigin( Dtk_pnt( -4, -4, -4 ) );
82  mesh_asm->add_asm_instance( mesh_asm_2, transfo2 ); // add mesh_asm_2 node in mesh_asm
83  mesh_asm_2->add_mesh( CubeMesh ); // add mesh in instance mesh_asm_2
84 
85  //WRITE WIRE MESH
86  mesh_asm_3 = new Dtk_mesh_asm_node(); //create new node
87  mesh_asm_3->set_id( 3 ); // id of node
88  mesh_asm_2->add_asm_instance( mesh_asm_3, transfo2 ); // add mesh_asm_3 node in mesh_asm_2
89  mesh_asm_3->add_mesh( WireMesh ); // add wireframe in instance mesh_asm_3
90 
91  //WRITE CYLINDER MESH
92  mesh_asm_4 = new Dtk_mesh_asm_node(); //create new node
93  mesh_asm_4->set_id( 4 ); // id of node
94  Dtk_transfo * transfo3 = new Dtk_transfo();
95  transfo3->setOrigin( Dtk_pnt( -6., -7., -6. ) );
96  mesh_asm_1->add_asm_instance( mesh_asm_4, transfo3 ); // add mesh_asm_4 node in mesh_asm_1
97  Dtk_RGB rgb = Dtk_RGB( 0, 0, 255 );
98  mesh_asm_4->set_color( rgb ); // set color in instance mesh_asm_2
99  mesh_asm_4->add_mesh( CylinderMesh ); // add mesh in instance mesh_asm_4
100 
101 
102  WriteOptions options;
103 
104  //initialize writing
105  options.SetFileRelease( 14 );
106 
107  //CGR write start here
108  // First we initialize writing with name of files and protection fonction if needed (3rd parameter)
109  status = cgrw_InitWrite( outputFileName, outputDirectory + L"testcgrw.log", NULL, L"", options );
110  if( status != 0 )
111  {
112  cgrw_EndWrite();
113  delete mesh_asm;
114  cout << "error : " << dtkTypeError( status ).c_str() << endl;
115  return status;
116  }
117  // Then we write for the mesh assembly constructed
118  cgrw_WriteMeshAsm( mesh_asm );
119 
120  // And free memory allocated for writing
121  cgrw_EndWrite();
122 
123  cout << "=> " << outputFileName.c_str() << endl << "Cgr Write end" << endl;
124 
125  delete mesh_asm;
126 
127  return 0;
128 }

◆ ColladaWriteSample()

int ColladaWriteSample ( const Dtk_string &  inResultDirectory)
17 {
18  Dtk_ErrorStatus err = dtkNoError;
19  int status;
20  Dtk_MeshPtr cubeMesh = NULL;
21  Dtk_MeshPtr cubeMeshVC = NULL;
22  Dtk_MeshPtr cylinderMesh = NULL;
23  Dtk_MeshPtr wireMesh = NULL;
24  Dtk_ModelDisplayPtr modelDisplay = NULL;
25  Dtk_RenderInfosPtr renderInfos = NULL;
26  Dtk_string outputFileName, outputDirectory;
27  Dtk_string nodeName;
28  Dtk_tab<Dtk_MetaDataPtr> tabMetadata;
29  Dtk_tab<Dtk_ID> tabNodesView1;
30  Dtk_tab<Dtk_ID> tabNodesView2;
31  Dtk_tab<Dtk_ID> tabNodesView3;
32  Dtk_tab< Dtk_tab <Dtk_ID> > tabNodesViews;
33  Dtk_ID nodeID = 0;
34  Dtk_bool reinstanciate = DTK_TRUE;
35  Dtk_InfoPtr info;
36 
37  cout << endl << "----------------------------------------------" << endl;
38  cout << "Collada Write start" << endl;
39 
40  // Choosing output directory and file name
41  outputDirectory = inResultDirectory + L"Collada/";
42  outputDirectory.FixPathSeparator();
43  outputDirectory.mkdir();
44  outputFileName = outputDirectory + L"sample.dae";
45 
46  // Cube Sample
47  cubeMesh = sampleWriter::CreateMeshCube();
48  sampleWriter::FillFacesColors( cubeMesh );
49 
50  // Cylinder Sample
51  cylinderMesh = sampleWriter::CreateMeshCylinder( 30 );
52 
53  //RenderInfos Sample
54  renderInfos = sampleWriter::CreateCubeRenderInfos();
55 
56  // First we initialize writing
57  Colladaw::WriteOptions options;
58  options.ConvertRenderInfos = 1;
59 
60  status = Colladaw::InitWrite( outputFileName, Dtk_string( "testcolladaw.log" ), options );
61 
62  if( status != 0 )
63  {
64  err = Colladaw::EndWrite();
65  cout << "error : " << dtkTypeError( status ).c_str() << endl;
66  return status;
67  }
68 
69  // Lets write a small assembly composed by one cube and one cylinder
70 
71  // let a matrix moving the cube on the left
72  Dtk_transfo cubetransfo;
73  cubetransfo.addTranslate( Dtk_dir( -10, 0, 0 ) );
74 
75  // let a matrix moving the cylinder
76  Dtk_transfo cyltransfo;
77  cyltransfo.addTranslate( Dtk_dir( 10, 0, 0 ) );
78 
79  // let a matrix moving the first instance
80  Dtk_transfo transfo;
81  transfo.addTranslate( Dtk_dir( 100, 100, 100 ) );
82  transfo.setXdir( 0.0, 1.0, 0.0 );
83  transfo.setYdir( 0.0, 0.0, 1.0 );
84  transfo.setZdir( 1.0, 0.0, 0.0 );
85 
86  // Rootnode creation
87  if( err == dtkNoError )
88  {
89  nodeName = "RootNode";
90  err = Colladaw::InitNode( nodeName );
91  }
92  // Facetted data node creation
93  if( err == dtkNoError )
94  {
95  nodeName = "Facetted data";
96  info = Dtk_Info::create();
97  err = Colladaw::InitNode( nodeName, Dtk_transfo(), info, nodeID );
98  }
99 
100  // from this node, create a Child for the cube, giving its matrix, and naming it "Cube"
101  if( err == dtkNoError )
102  {
103  nodeName = "Cube";
104  err = Colladaw::InitNode( nodeName, cubetransfo );
105  }
106  cubeMesh->info() = Dtk_Info::create();
107  cubeMesh->info()->AddRenderInfos( renderInfos );
108  // Write the mesh cube
109  if( err == dtkNoError )
110  Colladaw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cubeMesh ) );
111  // Close the mesh cube node
112  if( err == dtkNoError )
113  err = Colladaw::EndNode();
114 
115  // From root node again, create a Child for the cylinder, giving its matrix, and naming it "Cylinder"
116  if( err == dtkNoError )
117  {
118  nodeName = "Cylinder";
119  err = Colladaw::InitNode( nodeName, cyltransfo );
120  }
121  // Write the mesh cylinder
122  if( err == dtkNoError )
123  err = Colladaw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinderMesh ) );
124  // Close the mesh cylinder
125  if( err == dtkNoError )
126  err = Colladaw::EndNode();
127  // Close the facetted data node
128  if( err == dtkNoError )
129  err = Colladaw::EndNode();
130 
131  if( reinstanciate )
132  {
133  // "Facetted data (Reinstanciated)" creation
134  if( err == dtkNoError )
135  {
136  nodeName = "Facetted data (Reinstanciated)";
137  err = Colladaw::InitNode( nodeName, transfo );
138  }
139  // Reinstanciating prototype nodeID
140  if( err == dtkNoError )
141  err = Colladaw::ReinstanciatePrototype( nodeID );
142  // Closing node
143  if( err == dtkNoError )
144  err = Colladaw::EndNode();
145  }
146  // Rootnode closing : VERY IMPORTANT, you must close all nodes that were opened.
147  if( err == dtkNoError )
148  err = Colladaw::EndNode();
149  // And free memory allocated for writing
150  if( err == dtkNoError )
151  err = Colladaw::EndWrite();
152 
153  cout << "=> " << outputFileName.c_str() << endl << "Collada Write end" << endl;
154 
155  return err;
156 }

◆ FbxWriteSample()

int FbxWriteSample ( const Dtk_string &  inResultDirectory)
93 {
94  Dtk_string outputDirectory, fileName;
95  cout << endl << "----------------------------------------------" << endl;
96 
97  // Choosing output directory and file name
98  outputDirectory = inResultDirectory + L"Fbx/";
99  outputDirectory.FixPathSeparator();
100  outputDirectory.mkdir();
101 
102  cout << "Fbx Write start" << endl;
103  // sample 1 : just wirte 2 meshes
104  fileName = outputDirectory + L"twomeshes.fbx";
105  Dtk_ErrorStatus err = FbxwTwoMeshes( fileName );
106  if( err == dtkNoError )
107  cout << "=> " << fileName.c_str() << endl;
108  else
109  cout << "error : " << dtkTypeError( err ).c_str() << endl;
110 
111  // sample 2 : write instances
112  fileName = outputDirectory + L"twomeshes.fbx";
113  err = FbxwInstances( fileName );
114  if( err == dtkNoError )
115  cout << "=> " << fileName.c_str() << endl;
116  else
117  cout << "error : " << dtkTypeError( err ).c_str() << endl;
118 
119  cout << "Fbx Write end" << endl;
120 
121  return err;
122 }

◆ GltfWriteSample()

int GltfWriteSample ( const Dtk_string &  inResultDirectory)
101 {
102  Dtk_string outputDirectory, fileName;
103  cout << endl << "----------------------------------------------" << endl;
104 
105  // Choosing output directory and file name
106  outputDirectory = inResultDirectory + L"Gltf/";
107  outputDirectory.FixPathSeparator();
108  outputDirectory.mkdir();
109 
110  cout << "Gltf Write start" << endl;
111  cout << "sample 1" << endl;
112  // sample 1 : just write 2 meshes
113  fileName = outputDirectory + L"twomeshes.gltf";
114  Dtk_ErrorStatus errorStatus = GltfwTwoMeshes( fileName );
115  if( errorStatus == dtkNoError )
116  cout << "=> " << fileName.c_str() << endl;
117  else
118  cout << "error : " << dtkTypeError( errorStatus ).c_str() << endl;
119 
120  cout << "sample 2" << endl;
121  // sample 2 : write instances
122  fileName = outputDirectory + L"instances.gltf";
123  errorStatus = GltfwInstances( fileName );
124  if( errorStatus == dtkNoError )
125  cout << "=> " << fileName.c_str() << endl;
126  else
127  cout << "error : " << dtkTypeError( errorStatus ).c_str() << endl;
128 
129  cout << "Gltf Write end" << endl;
130 
131  return errorStatus;
132 }

◆ IfcWriteSample()

int IfcWriteSample ( const Dtk_string &  inResultDirectory)
197 {
198  Dtk_string outputDirectory, outputFileName;
199  cout << endl << "----------------------------------------------" << endl;
200  cout << "Ifc Write start" << endl;
201 
202  // Choosing output directory and file name
203  outputDirectory = inResultDirectory + L"Ifc/";
204  outputDirectory.FixPathSeparator();
205  outputDirectory.mkdir();
206 
207  //The ProjectInformation class enables you to set global information while initializing the writer module
208  //This information is optionnali
209  Ifcw::ProjectInformation myInfo;
210  myInfo.projectAuthor = L"my name";
211  myInfo.buildingName = L"sample building";
212  myInfo.siteLatitude = 45.7;
213  myInfo.siteLongitude = 4.8;
214  myInfo.siteElevation = 173000;
215 
216  // First we initialize writing with name of files, log file and the configuration we want to use
217  Ifcw::WriteOptions myOptions;
218  myOptions.versionIndicator = 0; //IFC4
219  myOptions.buildingTypeRecognition = 0; //Forces building type recognition. If set to true, all IfcElement without a building element type set will be analyzed (looking through their metadata etc.. to see if we can deduce their building type
220  outputFileName = outputDirectory + L"sample.ifc";
221  Dtk_ErrorStatus st = Ifcw::InitWrite( outputFileName, Dtk_string( outputDirectory + L"testifcw.log" ), myOptions, &myInfo );
222 
223  if( st != dtkNoError )
224  {
225  cout << "error : " << dtkTypeError( st ).c_str() << endl;
226  return st;
227  }
228 
229  //Write an ifc object/entity
230  ProcessBasicWall( myOptions.versionIndicator != 1 );
231  ProcessWallClassification();
232  ProcessMultiMeshWall();
233  ProcessPrototypedColumns( 5 );
234 
235  Ifcw::EndWrite();
236 
237  cout << "=> " << outputFileName.c_str() << endl << "Ifc Write end" << endl;
238 
239  return 0;
240 }

◆ IgesWriteSample()

int IgesWriteSample ( const Dtk_string &  inResultDirectory)
148 {
149  cout << endl << "----------------------------------------------" << endl;
150  cout << "Iges Write start" << endl;
151  //Standard Iges Sample File Processing
152  int err = IgesAssemblySample( inResultDirectory );
153  cout << "Iges Write end" << endl;
154 
155  return err;
156 }

◆ JtWriteSample()

int JtWriteSample ( const Dtk_string &  inResultDirectory)
1179 {
1180  cout << endl << "----------------------------------------------" << endl;
1181  cout <<"Jt Write start" << endl;
1182 
1183  tess_InitTesselation("./", 0.005); // Init Tessellation : working directory and default tolerance (needed for writing bodies)
1184  tess_ComputeBoundariesFromMesh(0); // Disable wire creation on mesh during Brep tessellation.
1185 
1186  int err = AllJtWTests(inResultDirectory); // all tests.
1187 
1188  tess_EndTesselation(); // End of tessellation
1189  cout <<"Jt Write end" << endl;
1190 
1191 
1192  return err;
1193 }

◆ ObjWriteSample()

int ObjWriteSample ( const Dtk_string &  inResultDirectory)
80 {
81  cout << endl << "----------------------------------------------" << endl;
82  cout << "Obj Write start" << endl;
83  //Standard Obj Sample File Processing
84  int err = StandardObjSample( inResultDirectory );
85  cout << "Obj Write end" << endl;
86  return err;
87 }

◆ ParasolidWriteSample()

int ParasolidWriteSample ( const Dtk_string &  inResultDirectory)
17 {
18  cout << endl << "----------------------------------------------" << endl;
19  cout << "Parasolid Write start" << endl;
20  // Choosing output directory and file name
21  Dtk_string outputDirectory = inResultDirectory + L"Parasolid/";
22  outputDirectory.FixPathSeparator();
23  outputDirectory.mkdir();
24  Dtk_string outputFileName0 = outputDirectory + L"sample_listofbody.x_t";
25 
26  // We construct 3 parts
27  Dtk_BodyPtr body1 = sampleWriter::CreateCube();
28  Dtk_BodyPtr body2 = sampleWriter::CreateOpenShell();
29  Dtk_BodyPtr body3 = sampleWriter::CreateCurves();
30 
31  // We add the 3 parts in an array
32  Dtk_tab<Dtk_BodyPtr> arrayOfParts;
33  arrayOfParts.push_back( body1 );
34  arrayOfParts.push_back( body2 );
35  arrayOfParts.push_back( body3 );
36 
37  // First we initialize writing with name of files and protection function if needed (3rd parameter)
38  Dtk_bool muteMode = DTK_TRUE; // no log write
39  DtkErrorStatus status = psw_InitFile( outputFileName0, muteMode );
40 
41  if( status != dtkNoError )
42  {
43  cout << "error : " << dtkTypeError( status ).c_str() << endl;
44  return status;
45  }
46 
47 
48  // Then we write the 3 parts constructed
49  Dtk_Size_t i, l = arrayOfParts.size();
50  Dtk_tab<Dtk_ID> returnID;
51  for( i = 0; i < l; ++i )
52  status = psw_WriteBody( arrayOfParts[ i ], returnID );
53 
54  // And free memory allocated for writing
55  status = psw_EndFile( returnID );
56 
57 
58  if( status != dtkNoError )
59  {
60  cout << "error : " << dtkTypeError( status ).c_str() << endl;
61  }
62  else
63  cout << "=> " << outputFileName0.c_str() << endl;
64 
65 
66  // then we write the same 3 part as an assembly that use these parts 2 times
67  Dtk_string outputFileName1 = outputDirectory + L"sample_assemblyofbody.x_t";
68  status = psw_InitFile( outputFileName1, muteMode );
69 
70  // first we register all part ID
71  Dtk_tab<Dtk_ID> partID (l, 1);
72  for( i = 0; i < l; ++i )
73  {
74  returnID.clear();
75  status = psw_WriteBody( arrayOfParts[ i ], returnID );
76  if( returnID.size() > 1 )
77  { // if more than one parasolid body created we decide to create a subassembly
78  Dtk_ID outIdass;
79  status = psw_CreateEmptyAssembly( outIdass );
80  Dtk_transfoPtr MatrixIdentity = Dtk_transfo::create();
81  for( Dtk_Size_t j = 0; j < returnID.size(); j++ )
82  {
83  Dtk_ID outIdInst;
84  status = psw_CreateInstance( outIdass, returnID[ j ], MatrixIdentity, outIdInst );
85  }
86 
87  partID[ i ] = outIdass;
88  status = psw_LinkAttribut( outIdass );
89  }
90  else
91  partID[ i ] = returnID[ 0 ];
92 
93  Dtk_string partName = L"DtkPart";
94  partName.add_int((int)i);
95  Dtk_InfoPtr info = Dtk_Info::create();
96  info->SetName( partName );
97  info->SetId ( Dtk_Int32 (i + 1) );
98  Dtk_Val MyVal = Dtk_Val("MyValue");
99  info->AddCustomerDefinedAttribute("MyAttribute", MyVal);
100 
101  status = psw_CreateAttribut( partID[ i ], info );
102  }
103 
104  // we create an assembly
105  Dtk_ID assemblyID;
106  status = psw_CreateEmptyAssembly( assemblyID );
107 
108  Dtk_string assName = L"DtkAssembly";
109  Dtk_InfoPtr info = Dtk_Info::create();
110  info->SetName( assName );
111  info->SetId( 5 );
112 
113  status = psw_CreateAttribut( assemblyID, info );
114 
115  // we create each instance of the parts
116  for( i = 0; i < l; ++i )
117  {
118  Dtk_transfoPtr Matrix1 = Dtk_transfo::create();
119  Matrix1->setOrigin( Dtk_pnt( 100.0, 0.0, 0.0 ) );
120  Dtk_ID outIdInst;
121  status = psw_CreateInstance( assemblyID, partID[ i ], Matrix1, outIdInst );
122 
123  Dtk_string instName = L"DtkInstance";
124  instName.add_int( ( int )i );
125  info->SetName( instName );
126  info->SetId( Dtk_Int32( 10 + i) );
127  status = psw_CreateAttribut( outIdInst, info );
128 
129 
130  Dtk_transfoPtr Matrix2 = Dtk_transfo::create();
131  Matrix2->setOrigin( Dtk_pnt( 100.0, 100.0, 100.0 ) );
132  status = psw_CreateInstance( assemblyID, partID[ i ], Matrix2, outIdInst );
133 
134  Dtk_string instName2 = L"DtkInstance";
135  instName2.add_int( ( int )(i + l));
136  info->SetName( instName2 );
137  info->SetId( Dtk_Int32( 10 + i + l ) );
138  status = psw_CreateAttribut( outIdInst, info );
139  }
140 
141  status = psw_LinkAttribut( assemblyID );
142 
143  returnID.clear();
144  // And free memory allocated for writing
145  status = psw_EndFile( returnID );
146 
147  if( status != dtkNoError )
148  {
149  cout << "error : " << dtkTypeError( status ).c_str() << endl;
150  }
151  else
152  cout << "=> " << outputFileName1.c_str() << endl;
153 
154  cout << "Parasolid Write end" << endl;
155 
156  return 0;
157 }

◆ PdfWriteSample()

int PdfWriteSample ( const Dtk_string &  inResultDirectory)
1055 {
1056  Dtk_ErrorStatus errStatus;
1057  cout << endl << "----------------------------------------------" << endl;
1058  cout << "Pdf Write start" << endl;
1059 
1060  Dtk_string imageDirectory = L"../InputImages/";
1061  Dtk_string outputDirectory;
1062 
1063  // Choosing output directory and file name
1064  outputDirectory = inResultDirectory + L"Pdf/";
1065  outputDirectory.FixPathSeparator();
1066  outputDirectory.mkdir();
1067 
1068  Dtk_string pdfFileName = outputDirectory + L"PDFW_SampleOneMesh_1_1.pdf";
1069  errStatus = PdfwSampleOneMesh_1_1( pdfFileName );
1070 
1071  pdfFileName = outputDirectory + L"PDFW_SampleMeshes_1_2.pdf";
1072  errStatus = PdfwSampleMeshes_1_2( pdfFileName );
1073 
1074  pdfFileName = outputDirectory + L"PDFW_SampleOneMeshRender_1_3.pdf";
1075  errStatus = PdfwSampleOneMeshRender_1_3( pdfFileName, imageDirectory );
1076 
1077  pdfFileName = outputDirectory + L"PDFW_SampleBody_2_1.pdf";
1078  errStatus = PdfwSampleBody_2_1( pdfFileName );
1079 
1080  pdfFileName = outputDirectory + L"PDFW_SampleWireBody_2_2.pdf";
1081  errStatus = PdfwSampleWireBody_2_2( pdfFileName );
1082 
1083  pdfFileName = outputDirectory + L"PDFW_SampleBodyVisibility_2_3.pdf";
1084  errStatus = PdfwSampleBodyVisibility_2_3( pdfFileName );
1085 
1086  pdfFileName = outputDirectory + L"PDFW_SampleAssembly_3_1.pdf";
1087  errStatus = PdfwSampleAssembly_3_1( pdfFileName );
1088 
1089  pdfFileName = outputDirectory + L"PDFW_SamplePartInstances_3_2.pdf";
1090  errStatus = PdfwSamplePartInstances_3_2( pdfFileName );
1091 
1092  pdfFileName = outputDirectory + L"PDFW_SampleAsmInstances_3_3.pdf";
1093  errStatus = PdfwSampleAsmInstances_3_3( pdfFileName );
1094 
1095  pdfFileName = outputDirectory + L"PDFW_SampleInstancesColors_3_4.pdf";
1096  errStatus = PdfwSampleInstancesColors_3_4( pdfFileName );
1097 
1098  pdfFileName = outputDirectory + L"PDFW_SampleInstancesVisibility_3_5.pdf";
1099  errStatus = PdfwSampleInstancesVisibility_3_5( pdfFileName );
1100 
1101  pdfFileName = outputDirectory + L"PDFW_SampleMetadatas_4_1.pdf";
1102  errStatus = PdfwSampleMetadatas_4_1( pdfFileName );
1103 
1104  pdfFileName = outputDirectory + L"PDFW_SampleDocumentProperties_4_2.pdf";
1105  errStatus = PdfwSampleDocumentProperties_4_2( pdfFileName );
1106 
1107  pdfFileName = outputDirectory + L"PDFW_SampleSimplePMI_5_1.pdf";
1108  errStatus = PdfwSampleSimplePMI_5_1( pdfFileName );
1109 
1110  pdfFileName = outputDirectory + L"PDFW_SampleSimpleModelview_5_2.pdf";
1111  errStatus = PdfwSampleSimpleModelview_5_2( pdfFileName );
1112 
1113  pdfFileName = outputDirectory + L"PDFW_Sample_MV_association_5_3.pdf";
1114  errStatus = PdfwSample_MV_association_5_3( pdfFileName );
1115 
1116  pdfFileName = outputDirectory + L"PDFW_SamplePMI_Geom_association_5_4.pdf";
1117  errStatus = PdfwSamplePMI_Geom_association_5_4( pdfFileName );
1118 
1119  pdfFileName = outputDirectory + L"PDFW_SampleModelview_sections_5_5.pdf";
1120  errStatus = PdfwSampleModelview_section_5_5( pdfFileName );
1121 
1122  pdfFileName = outputDirectory + L"PDFW_SamplePMI_PMI_association_5_6.pdf";
1123  errStatus = PdfwSamplePMI_PMI_association_5_6( pdfFileName );
1124 
1125  pdfFileName = outputDirectory + L"PDFW_SampleAxis_References_5_7.pdf";
1126  errStatus = PdfwSampleAxis_References_5_7( pdfFileName );
1127 
1128  pdfFileName = outputDirectory + L"PDFW_SampleCloudPoint_6_1.pdf";
1129  errStatus = PdfwSampleCloudPoint_6_1( pdfFileName );
1130 
1131  pdfFileName = outputDirectory + L"PDFW_SampleBillboard_7_1.pdf";
1132 
1133  errStatus = PdfwSampleBillboard_7_1( pdfFileName, imageDirectory );
1134 
1135  pdfFileName = outputDirectory + L"PDFW_SampleSecuredPdf_8_1.pdf";
1136  errStatus = PdfwSampleSecuredPdf_8_1( pdfFileName );
1137 
1138  pdfFileName = outputDirectory + L"PDFW_SampleLayoutMultipleViews_9_1.pdf";
1139  errStatus = PdfwSampleLayoutMultipleViews_9_1( pdfFileName );
1140 
1141  cout << "Pdf Write end" << endl;
1142 
1143  return errStatus;
1144 }

◆ PlmxmlWriteSample()

int PlmxmlWriteSample ( const Dtk_string &  inResultDirectory)
101 {
102  std::cout << endl << "----------------------------------------------" << endl;
103  std::cout << "Plmxml Write start" << endl;
104 
105  tess_InitTesselation("./", 0.005); // For JT : Init Tessellation : working directory and default tolerance (needed for writing bodies)
106  tess_ComputeBoundariesFromMesh(0); // Disable wire creation on mesh during Brep tessellation.
107 
108  int err = PlmxmlwritesampleJT(inResultDirectory);
109 
110  tess_EndTesselation(); // End of tessellation
111  std::cout << "Plmxml Write end" << endl;
112 
113 
114  return err;
115 }

◆ SatWriteSample()

int SatWriteSample ( const Dtk_string &  inResultDirectory)
16 {
17  Dtk_string outputFileName, outputDirectory;
18 
19  cout << endl << "----------------------------------------------" << endl;
20  cout << "Acis Write start" << endl;
21 
22  // Choosing output directory and file name
23  outputDirectory = inResultDirectory + L"Acis/";
24  outputDirectory.FixPathSeparator();
25  outputDirectory.mkdir();
26  outputFileName = outputDirectory + L"sample.sat";
27 
28  // First you have to initialize the Sat writer
29  int status = satw_InitFile( outputFileName );
30 
31  if( status )
32  {
33  cout << "error : " << dtkTypeError( status ).c_str() << endl;
34  return status;
35  }
36 
37  // We create 2 bodies
38  Dtk_BodyPtr body1 = sampleWriter::CreateCube();
39  Dtk_BodyPtr body2 = sampleWriter::CreateOpenShell();
40 
41  // We init the part
42  satw_InitPart();
43 
44  // We write the 2 bodies
45  satw_WriteBody( body1 );
46  satw_WriteBody( body2 );
47 
48  // We close the part
49  satw_EndPart();
50 
51  // We free memory allocated for writing
52  satw_EndFile();
53  cout << "=> " << outputFileName.c_str() << endl;
54  cout << "Acis Write end" << endl;
55 
56  return 0;
57 }

◆ StepWriteSample()

int StepWriteSample ( const Dtk_string &  inResultDirectory)
754 {
755  Dtk_string outputFileName, outputDirectory;
756 
757  std::cout << endl << "----------------------------------------------" << std::endl;
758  std::cout << "Step Write start" << std::endl;
759 
760  stepw_SetModeProp( 3 );
761  stepw_SetModeFdt( 1 );
762 
763  // Choosing output directory and file name
764  outputDirectory = inResultDirectory + L"Step/";
765  outputDirectory.FixPathSeparator();
766  outputDirectory.mkdir();
767 
768  // First, initialize the Step writer
769  //int codeForAP203 = 1;
770  int codeForAP214 = 2;
771  //int codeForAP203E2 = 3;
772  int codeForAP242 = 4;
773  int dummy;
774 
775  {
776  outputFileName = outputDirectory + L"SamplePart_BodyOnly.step";
777  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP214 ) );
778  stepw::sample::WritePart_BodyOnly( L"SamplePart_BodyOnly", dummy );
779  PRINT_ERROR( stepw_EndFile() );
780  std::cout << "=> " << outputFileName.c_str() << std::endl;
781  }
782  //[...]
783  //end_of_mainstepwrite
784  {
785  outputFileName = outputDirectory + L"SamplePart_BodyWithAxisSystem.step";
786  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP214 ) );
787  stepw::sample::WritePart_BodyWithAxisSystem( L"SamplePart_BodyWithAxisSystem", dummy );
788  PRINT_ERROR( stepw_EndFile() );
789  std::cout << "=> " << outputFileName.c_str() << std::endl;
790  }
791  {
792  outputFileName = outputDirectory + L"SamplePart_WireframeOnly.step";
793  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP214 ) );
794  stepw::sample::WritePart_WireframeOnly( L"SamplePart_WireframeOnly", dummy );
795  PRINT_ERROR( stepw_EndFile() );
796  std::cout << "=> " << outputFileName.c_str() << std::endl;
797  }
798  {
799  outputFileName = outputDirectory + L"SamplePart_MeshOnly.step";
800  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP214 ) );
801  stepw::sample::WritePart_MeshOnly( L"SamplePart_MeshOnly", dummy );
802  PRINT_ERROR( stepw_EndFile() );
803  std::cout << "=> " << outputFileName.c_str() << std::endl;
804  }
805  {
806  outputFileName = outputDirectory + L"SamplePart_MeshWithFaceColors.step";
807  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP214 ) );
808  stepw::sample::WritePart_MeshWithFaceColors( L"SamplePart_MeshWithFaceColors", dummy );
809  PRINT_ERROR( stepw_EndFile() );
810  std::cout << "=> " << outputFileName.c_str() << std::endl;
811  }
812  {
813  outputFileName = outputDirectory + L"SamplePart_BodyAndMeshFromTessellation.step";
814  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP214 ) );
815  stepw::sample::WritePart_BodyAndMeshFromTessellation( L"SamplePart_BodyAndMeshFromTessellation", dummy );
816  PRINT_ERROR( stepw_EndFile() );
817  std::cout << "=> " << outputFileName.c_str() << std::endl;
818  }
819  {
820  outputFileName = outputDirectory + L"SamplePart_WithProperties.step";
821  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP214 ) );
822  stepw::sample::WritePart_WithProperties( L"SamplePart_WithProperties", dummy );
823  PRINT_ERROR( stepw_EndFile() );
824  std::cout << "=> " << outputFileName.c_str() << std::endl;
825  }
826  {
827  outputFileName = outputDirectory + L"SamplePart_BodyInNamedLayer.step";
828  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
829  stepw::sample::WritePart_BodyInNamedLayer( L"SamplePart_BodyInNamedLayer", dummy );
830  PRINT_ERROR( stepw_EndFile() );
831  std::cout << "=> " << outputFileName.c_str() << std::endl;
832  }
833  {
834  outputFileName = outputDirectory + L"SamplePart_Datum.step";
835  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
836  stepw::sample::WritePart_Datum( L"SamplePart_Datum", dummy );
837  PRINT_ERROR( stepw_EndFile() );
838  std::cout << "=> " << outputFileName.c_str() << std::endl;
839  }
840  {
841  outputFileName = outputDirectory + L"SamplePart_GeometricalTolerance.step";
842  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
843  stepw::sample::WritePart_GeometricalTolerance( L"SamplePart_GeometricalTolerance", dummy );
844  PRINT_ERROR( stepw_EndFile() );
845  std::cout << "=> " << outputFileName.c_str() << std::endl;
846  }
847  {
848  outputFileName = outputDirectory + L"SamplePart_UsedByExternalAssembly.step";
849  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
850  stepw::sample::WritePart_UsedByExternalAssembly( L"SamplePart_UsedByExternalAssembly", dummy );
851  PRINT_ERROR( stepw_EndFile() );
852  std::cout << "=> " << outputFileName.c_str() << std::endl;
853  }
854  {
855  outputFileName = outputDirectory + L"SampleAssembly.step";
856  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
857  stepw::sample::WriteAssembly( L"SampleAssembly" );
858  PRINT_ERROR( stepw_EndFile() );
859  std::cout << "=> " << outputFileName.c_str() << std::endl;
860  }
861  {
862  outputFileName = outputDirectory + L"SampleAssembly_DimensionFDT.step";
863  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
864  stepw::sample::WriteAssembly_DimensionFDT( L"SampleAssembly_DimensionFDT");
865  PRINT_ERROR( stepw_EndFile() );
866  std::cout << "=> " << outputFileName.c_str() << std::endl;
867  }
868  {
869  outputFileName = outputDirectory + L"SampleAssembly_WithProperties.step";
870  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
871  stepw::sample::WriteAssembly_WithProperties( L"SampleAssembly_WithProperties");
872  PRINT_ERROR( stepw_EndFile() );
873  std::cout << "=> " << outputFileName.c_str() << std::endl;
874  }
875  {
876  outputFileName = outputDirectory + L"SampleAssembly_InstanceAttributes.step";
877  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
878  stepw::sample::WriteAssembly_InstanceAttributes( L"SampleAssembly_InstanceAttributes" );
879  PRINT_ERROR( stepw_EndFile() );
880  std::cout << "=> " << outputFileName.c_str() << std::endl;
881  }
882  {
883  outputFileName = outputDirectory + L"SampleAssembly_BasicExternalReferences.step";
884  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
885  stepw::sample::WriteAssembly_BasicExternalReferences( L"SampleAssembly_BasicExternalReferences");
886  PRINT_ERROR( stepw_EndFile() );
887  std::cout << "=> " << outputFileName.c_str() << std::endl;
888  }
889  {
890  outputFileName = outputDirectory + L"SampleAssembly_BasicExternalReference_DimensionFDT.step";
891  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
892  stepw::sample::WriteAssembly_BasicExternalReference_DimensionFDT( L"SampleAssembly_BasicExternalReference_DimensionFDT");
893  PRINT_ERROR( stepw_EndFile() );
894  std::cout << "=> " << outputFileName.c_str() << std::endl;
895  }
896  {
897  outputFileName = outputDirectory + L"SampleAssembly_NestedExternalReferences.step";
898  PRINT_ERROR( stepw_InitFile( outputFileName, " sample ", codeForAP242 ) );
899  stepw::sample::WriteAssembly_NestedExternalReferences( L"SampleAssembly_NestedExternalReferences");
900  PRINT_ERROR( stepw_EndFile() );
901  std::cout << "=> " << outputFileName.c_str() << std::endl;
902  }
903 
904  std::cout << "Step Write end" << std::endl;
905 
906  return 0;
907 }

◆ SwWriteSample()

int SwWriteSample ( Dtk_API *  inDtkAPI,
const Dtk_string &  inResultDirectory 
)
213 {
214  cout << endl << "----------------------------------------------" << endl;
215  cout << "Solidworks Write start" << endl;
216  // Choosing output directory and file name
217  Dtk_string outputDirectory = inResultDirectory + "Sw/";
218  outputDirectory.FixPathSeparator();
219  outputDirectory.mkdir();
220  {
221  //remove old file
222  Dtk_string temp;
223  temp = outputDirectory + L"my_test_part.sldprt";
224  temp.unlink();
225  temp = outputDirectory + L"my_test_part2.sldprt";
226  temp.unlink();
227  temp = outputDirectory + L"my_test_assembly.sldasm";
228  temp.unlink();
229  temp = outputDirectory + L"logwrite.txt";
230  temp.unlink();
231  }
232 
233  Dtk_ErrorStatus dtkerror;
234 
235  Dtk_string StrSchemaPath = inResultDirectory + L"../bin/Schema/";
236 
237 #ifdef PSKERNEL_USER
238  //First if you haven't done yet, start the parasolid session
239  StartParasolid();
240  //And informs that the session is started
241  sw::sww::SetIsAlreadyStart( -1 );
242 
243  //Set the schema path
244 #ifndef Linux
245  wchar_t *schPath;
246  schPath = ( wchar_t* )malloc( sizeof( wchar_t ) * ( StrSchemaPath.len() + 10 ) );
247  swprintf( schPath, 255, L"P_SCHEMA=%s", StrSchemaPath.w_str() );
248  _wputenv( schPath );
249 #else
250  char *schPath;
251  schPath = ( char* )malloc( sizeof( char ) * ( StrSchemaPath.len() + 10 ) );
252  sprintf( schPath, "P_SCHEMA=%s", StrSchemaPath.c_str() );
253  putenv( schPath );
254 #endif
255 
256  //dont delete it because getenv doesn't work or retrun null string
257  //free(schPath);
258  //schPath=NULL;
259 #endif
260  if( inDtkAPI != NULL )
261  inDtkAPI->SetSchemaDir( StrSchemaPath );
262  else
263  {
264  return dtkErrorAPINotStarted;
265  }
266 
267  Dtk_string logwrite = inDtkAPI->GetWorkingDir() + L"logwrite.txt";
268  Dtk_string FilenamePart;
269  dtkerror = sw::sww::InitWriter( logwrite, NULL, sw::sww::english );
270 
271  Dtk_string xmtfile = inResultDirectory + L"/xmt/CS_WHEEL_CAP.X_T";
272 
273 
274  if( dtkerror == dtkNoError )
275  {
276  //how to create part file
277  FilenamePart = outputDirectory + L"my_test_part.sldprt";
278  create_part( FilenamePart, xmtfile );
279  }
280 
281 
282  if( dtkerror == dtkNoError )
283  {
284  FilenamePart = outputDirectory + L"my_test_part2.sldprt";
285  create_part( FilenamePart, xmtfile );
286  }
287 
288 
289  if( dtkerror == dtkNoError )
290  {
291  //how to create assembly file
292  Dtk_string FilenameAssm = outputDirectory + L"my_test_assembly.sldasm";
293  create_assembly( FilenameAssm, FilenamePart );
294  }
295 
296  sw::sww::EndWriter();
297 
298 #ifdef PSKERNEL_USER
299  //Stop the parasolid session
300  sw::sww::SetIsAlreadyStart( -2 );
301  StopParasolid();
302 #endif
303  cout << "Solidworks Write end" << endl;
304 
305  return dtkerror;
306 }

◆ UgWriteSample()

int UgWriteSample ( const Dtk_string &  inResultDirectory)
766 {
767  Dtk_string outputDirectory, nxDirectory;
768  Dtk_ErrorStatus errStatus;
769 
770  std::cout << endl << "----------------------------------------------" << endl;
771  std::cout << "Ug Write start" << endl;
772 
773  nxDirectory = inResultDirectory + L"NX-Unigraphics/";
774  nxDirectory.FixPathSeparator();
775  nxDirectory.mkdir();
776 
777  // Choosing output for version NX5
778  outputDirectory = inResultDirectory + L"NX-Unigraphics/nx5/";
779  outputDirectory.FixPathSeparator();
780  outputDirectory.mkdir();
781  errStatus = UgWriteSampleVersion(outputDirectory, DTK_UGW_VERSION_NX5);
782 
783  // Choosing output for version NX1980
784  outputDirectory = inResultDirectory + L"NX-Unigraphics/nx1980/";
785  outputDirectory.FixPathSeparator();
786  outputDirectory.mkdir();
787  errStatus = UgWriteSampleVersion(outputDirectory, DTK_UGW_VERSION_NX1980);
788 
789  // Choosing output for version NX2212
790  outputDirectory = inResultDirectory + L"NX-Unigraphics/nx2212/";
791  outputDirectory.FixPathSeparator();
792  outputDirectory.mkdir();
793  errStatus = UgWriteSampleVersion(outputDirectory, DTK_UGW_VERSION_NX2212);
794 
795  std::cout << "Ug Write end" << endl;
796 
797  return errStatus;
798 }
PdfwSampleSecuredPdf_8_1
Dtk_ErrorStatus PdfwSampleSecuredPdf_8_1(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:877
satw_InitPart
DtkErrorStatus satw_InitPart()
Initializes the writing of a 3D part.
Dtk_mesh_asm_node
This class gathers asm node related datas.
Definition: cgrw.hpp:16
ProcessAsm
Dtk_ErrorStatus ProcessAsm(const Dtk_string &inResultDirectory)
Definition: testlibcatiav5write.cpp:350
Dtk_ID
uint32_t Dtk_ID
Definition: define.h:691
Dtk_transfo
This is the Transformation dedicated class.
Definition: dtk_transfo.hpp:19
ProcessBasicWall
Dtk_ErrorStatus ProcessBasicWall(Dtk_bool inMesh)
Definition: testlibifcwrite.cpp:22
Ifcw::ProjectInformation::buildingName
Dtk_string buildingName
Definition: IFCWriter.h:56
PdfwSampleMetadatas_4_1
Dtk_ErrorStatus PdfwSampleMetadatas_4_1(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:475
psw_CreateInstance
DtkErrorStatus psw_CreateInstance(Dtk_ID inIdAss, Dtk_ID inIdPart, Dtk_transfoPtr &Matrix, Dtk_ID &outIdInst)
Create an Instance item of a part referenced by inIdPart.
Dtk_Info::SetName
Dtk_ErrorStatus SetName(Dtk_string inName)
sampleWriter::CreateMeshCube
Dtk_MeshPtr CreateMeshCube()
Mesh Cube sample.
Definition: testcreatemesh.cpp:209
stepw::sample::WritePart_MeshOnly
DtkErrorStatus WritePart_MeshOnly(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:111
PdfwSampleAxis_References_5_7
Dtk_ErrorStatus PdfwSampleAxis_References_5_7(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:759
psw_InitFile
DtkErrorStatus psw_InitFile(const Dtk_string &inFileOut, Dtk_bool muteMode, Dtk_Int32 inVersion=180)
Initialise a file to be written.
Colladaw::EndNode
DtkErrorStatus EndNode()
End the node.
catiav5w::WriteOptions
This class provides several options to tunes CatiaV5 Writter. It must be provided to catiav5w::InitWr...
Definition: catiav5w.hpp:41
Dtk_Info::AddCustomerDefinedAttribute
Dtk_ErrorStatus AddCustomerDefinedAttribute(Dtk_string name, Dtk_Val val)
Dtk_transfo::setOrigin
void setOrigin(const Dtk_pnt &O)
Set a new O center point.
Dtk_mesh_asm_node::set_id
void set_id(int inId)
Set an Id.
Dtk_transfo::create
static Dtk_SmartPtr< Dtk_transfo > create()
Dtk_transfo::setZdir
void setZdir(const Dtk_dir &Z)
Set a new Z vector.
Ifcw::ProjectInformation::siteElevation
Dtk_Double64 siteElevation
Definition: IFCWriter.h:62
Colladaw::InitWrite
DtkErrorStatus InitWrite(const Dtk_string &inOutputFile, const Dtk_string &inLogFile, WriteOptions &inOptions)
Initialize the Collada Writer
Ifcw::InitWrite
DtkErrorStatus InitWrite(const Dtk_string &inOutputFile, const Dtk_string &inLogFile, const WriteOptions &inOptions, ProjectInformation *inProjectInfo=nullptr)
Initialize the Ifc Writer and the IFC version you want to write.
Ifcw::WriteOptions::versionIndicator
int versionIndicator
Int representing IFC version to use : 0 ( default ) = IFC2x3; 1 = IFC4.
Definition: IFCWriter.h:28
DTK_TRUE
#define DTK_TRUE
Definition: define.h:729
_3dxmlw::WriteOptions
This class provides several options to tune 3dxml Writer. It must be provided to _3dxmlw::InitWrite m...
Definition: 3dxmlw.hpp:89
Dtk_mesh_asm_node::add_axis_system
int add_axis_system(Dtk_AxisSystemPtr inAxisSystem)
Add an Dtk_AxisSystemPtr in Dtk_mesh_asm_node in the current asm node.
Ifcw::WriteOptions::buildingTypeRecognition
Dtk_bool buildingTypeRecognition
DTK_TRUE : enable building type recognition (deduces if an element is an IFCWALL, IFCWINDOW....
Definition: IFCWriter.h:30
create_assembly
void create_assembly(const Dtk_string &inFilename, const Dtk_string &inFilenamePart)
Definition: testlibswwrite.cpp:144
DTK_UGW_VERSION_NX5
#define DTK_UGW_VERSION_NX5
Definition: ugw.hpp:7
FbxwInstances
Dtk_ErrorStatus FbxwInstances(const Dtk_string &outputFileName)
Definition: testlibfbxwrite.cpp:58
PdfwSamplePartInstances_3_2
Dtk_ErrorStatus PdfwSamplePartInstances_3_2(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:232
Dtk_string
This is a high level string class.
Definition: dtk_string.hpp:58
Dtk_Size_t
size_t Dtk_Size_t
Definition: define.h:714
create_part
void create_part(const Dtk_string &inFilename, const Dtk_string &inParasolidFile)
Definition: testlibswwrite.cpp:56
Dtk_string::unlink
int unlink() const
File Utility : Delete a file.
stepw::sample::WritePart_BodyWithAxisSystem
DtkErrorStatus WritePart_BodyWithAxisSystem(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:74
Ifcw::ProjectInformation::projectAuthor
Dtk_string projectAuthor
Definition: IFCWriter.h:57
sampleWriter::CreateAxisSystem
Dtk_AxisSystemPtr CreateAxisSystem()
Definition: testcreatecube.cpp:1529
PdfwSampleLayoutMultipleViews_9_1
Dtk_ErrorStatus PdfwSampleLayoutMultipleViews_9_1(const Dtk_string &pdfFileName)
Definition: testlibpdfwrite.cpp:1001
PRINT_ERROR
#define PRINT_ERROR(inStatus)
Definition: testwriters.h:10
stepw::sample::WritePart_WireframeOnly
DtkErrorStatus WritePart_WireframeOnly(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:94
PdfwSampleModelview_section_5_5
Dtk_ErrorStatus PdfwSampleModelview_section_5_5(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:672
Dtk_bool
char Dtk_bool
Definition: define.h:727
Dtk_API::GetWorkingDir
const Dtk_string & GetWorkingDir() const
PdfwSampleBillboard_7_1
Dtk_ErrorStatus PdfwSampleBillboard_7_1(const Dtk_string &inOutputFileName, const Dtk_string &inImageDirectory)
Definition: testlibpdfwrite.cpp:844
dtkErrorAPINotStarted
@ dtkErrorAPINotStarted
Definition: error_dtk.hpp:105
Dtk_API::SetSchemaDir
Dtk_ErrorStatus SetSchemaDir(const Dtk_string &inSchemaDir)
Set Schema Directory needed for Unigraphics, Parasolid, Solidedge, Solidworks and Jt readers.
Dtk_mesh_asm_node::set_color
void set_color(Dtk_RGB &inColor)
set color on Dtk_mesh_asm_node
Colladaw::EndWrite
DtkErrorStatus EndWrite()
Creation of the output file and free the Collada Writer
tess_InitTesselation
int tess_InitTesselation(Dtk_string inWorkingDirectory, double inTolerance)
Init the tesselation library.
Dtk_transfo::setXdir
void setXdir(const Dtk_dir &X)
Set a new X vector.
sampleWriter::FillFacesColors
void FillFacesColors(Dtk_MeshPtr &inoutCubeMesh)
Filling mesh faces with colors.
Definition: testcreatemesh.cpp:246
cgrw_EndWrite
int cgrw_EndWrite()
Free the Cgr Writer
stepw_SetModeProp
DtkErrorStatus stepw_SetModeProp(const int inMode)
Activates/Deactivates writing of properties : User Attributes, Product Data.
Dtk_3MFWriter::InitWrite
DtkErrorStatus InitWrite(const Dtk_string &inOutputFile, const Dtk_string &inLogFile, const WriteOptions &inOptions)
Initialize the 3mf Writer
Dtk_string::add_int
void add_int(const int integer, int force_unsigned_int=0)
concat an int to the Dtk_string (convert the int to Dtk_string)
psw_CreateAttribut
DtkErrorStatus psw_CreateAttribut(Dtk_ID inIdCompo, Dtk_InfoPtr &info)
Create all attribut attached to a component (body, assembly, instance)
Dtk_Val
Definition: dtk_val.hpp:67
Colladaw::WriteOptions
This class provides several options to tune Collada Writer. It must be provided to Colladaw::InitWrit...
Definition: colladaw.hpp:23
WriteEntity
Dtk_ErrorStatus WriteEntity(const Dtk_MeshPtr &inCubeMesh, const Dtk_MeshPtr &inCylinderMesh)
Definition: testlib3dxmlwrite.cpp:16
stepw_InitFile
DtkErrorStatus stepw_InitFile(const Dtk_string &inFileName, const char *inOriginatingSystem=" user ", const int inSchema=0)
Initializes a file to be written.
PdfwSampleInstancesVisibility_3_5
Dtk_ErrorStatus PdfwSampleInstancesVisibility_3_5(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:429
PlmxmlwritesampleJT
Dtk_ErrorStatus PlmxmlwritesampleJT(const Dtk_string &inResultDirectory)
Definition: testlibplmxmlwrite.cpp:36
stepw::sample::WriteAssembly_BasicExternalReferences
DtkErrorStatus WriteAssembly_BasicExternalReferences(const Dtk_string &inRootAssemblyName)
Definition: testlibstepwrite.cpp:591
sampleWriter::CreateMeshWire
Dtk_MeshPtr CreateMeshWire()
Wire mesh sample.
Definition: testcreatemesh.cpp:390
PdfwSampleOneMesh_1_1
Dtk_ErrorStatus PdfwSampleOneMesh_1_1(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:22
Colladaw::WriteOptions::ConvertRenderInfos
Dtk_bool ConvertRenderInfos
Definition: colladaw.hpp:33
stepw::sample::WritePart_BodyOnly
DtkErrorStatus WritePart_BodyOnly(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:56
sw::sww::InitWriter
Dtk_ErrorStatus InitWriter(const Dtk_string &inLogFile, Licence_dtk inLicFct, sw::sww::language inLanguage=sw::sww::english)
Initialize the Solidworks Writer
stepw_SetModeFdt
DtkErrorStatus stepw_SetModeFdt(const int inMode, const int inPolyline=2)
Activates/Deactivates writing of FDT.
_3dxmlw::EndWrite
DtkErrorStatus EndWrite()
Creation of the output file and free the 3dxmlw Writer
Dtk_3MFWriter::WriteOptions
This class provides several options to tune 3mf Writer. It must be provided to _3mfw::InitWrite metho...
Definition: 3mfw.hpp:29
PdfwSampleCloudPoint_6_1
Dtk_ErrorStatus PdfwSampleCloudPoint_6_1(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:788
ProcessMultiMeshWall
Dtk_ErrorStatus ProcessMultiMeshWall()
Definition: testlibifcwrite.cpp:145
Ifcw::ProjectInformation::siteLatitude
Dtk_Double64 siteLatitude
Definition: IFCWriter.h:60
cgrw_WriteMeshAsm
Dtk_status cgrw_WriteMeshAsm(Dtk_mesh_asm_node *inRoot)
Write a mesh assembly.
Dtk_Int32
int32_t Dtk_Int32
Definition: define.h:689
FbxwTwoMeshes
Dtk_ErrorStatus FbxwTwoMeshes(const Dtk_string &outputFileName)
Definition: testlibfbxwrite.cpp:17
stepw::sample::WritePart_BodyInNamedLayer
DtkErrorStatus WritePart_BodyInNamedLayer(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:336
IgesAssemblySample
int IgesAssemblySample(const Dtk_string &inResultDirectory)
Definition: testlibigeswrite.cpp:71
sw::sww::EndWriter
Dtk_ErrorStatus EndWriter()
Free the Solidworks Writer
Ifcw::WriteOptions
This class provides several options to tune the IFC Writer. It must be provided to Ifcw::InitWrite me...
Definition: IFCWriter.h:18
PdfwSampleBodyVisibility_2_3
Dtk_ErrorStatus PdfwSampleBodyVisibility_2_3(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:159
PdfwSampleMeshes_1_2
Dtk_ErrorStatus PdfwSampleMeshes_1_2(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:46
Dtk_SmartPtr< Dtk_Entity >::DtkDynamicCast
static Dtk_SmartPtr< Dtk_Entity > DtkDynamicCast(const Dtk_SmartPtr< T2 > &p)
Definition: util_ptr_dtk.hpp:101
GltfwTwoMeshes
Dtk_ErrorStatus GltfwTwoMeshes(const Dtk_string &outputFileName)
Definition: testlibgltfwrite.cpp:17
cgrw_InitWrite
int cgrw_InitWrite(Dtk_string inFileWritten, Dtk_string inLogFile, Licence_dtk inLicFct, Dtk_string inLicenceFile, const WriteOptions &inOptions=WriteOptions())
Initialize the Cgr Writer
psw_CreateEmptyAssembly
DtkErrorStatus psw_CreateEmptyAssembly(Dtk_ID &outIdass)
Create the entry item of an assembly.
Dtk_ErrorStatus
Dtk_ErrorStatus
Definition: error_dtk.hpp:6
satw_InitFile
DtkErrorStatus satw_InitFile(const Dtk_string &inFileOut, const satw_WriteOptions &inOptions=satw_WriteOptions())
Initializes a file to be written.
Dtk_3MFWriter::WriteEntity
Dtk_ErrorStatus WriteEntity(const Dtk_EntityPtr &inEntity)
Write the entity provided in parameter in a node.
stepw::sample::WritePart_Datum
DtkErrorStatus WritePart_Datum(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:210
sampleWriter::CreateCubeRenderInfos
Dtk_RenderInfosPtr CreateCubeRenderInfos()
Definition: testcreatemesh.cpp:500
Dtk_Info::SetId
Dtk_ErrorStatus SetId(const Dtk_Int32 &inId)
stepw::sample::WriteAssembly_InstanceAttributes
DtkErrorStatus WriteAssembly_InstanceAttributes(const Dtk_string &inRootAssemblyName)
Definition: testlibstepwrite.cpp:549
ProcessPrototypedColumns
Dtk_ErrorStatus ProcessPrototypedColumns(int columnNumber)
Definition: testlibifcwrite.cpp:94
stepw::sample::WriteAssembly_BasicExternalReference_DimensionFDT
DtkErrorStatus WriteAssembly_BasicExternalReference_DimensionFDT(const Dtk_string &inRootAssemblyName)
Definition: testlibstepwrite.cpp:672
Ifcw::EndWrite
DtkErrorStatus EndWrite()
Creation of the output file and free the Ifc Writer
Dtk_transfo::setScale
void setScale(Dtk_Double64 scale)
Set a new scale.
Dtk_SmartPtr
Definition: util_ptr_dtk.hpp:37
stepw_EndFile
DtkErrorStatus stepw_EndFile()
Ends the writing of the current STEP file.
Ifcw::ProjectInformation::siteLongitude
Dtk_Double64 siteLongitude
Definition: IFCWriter.h:61
dtkTypeError
Dtk_string dtkTypeError(Dtk_Int32 errNumero)
catiav5w::EndWrite
Dtk_ErrorStatus EndWrite()
Free the Catia V5 Writer
catiav5w::WriteOptions::SetFileRelease
Dtk_ErrorStatus SetFileRelease(const Dtk_UInt32 inRelease)
Sets the release for the written files.
Dtk_string::c_str
const char * c_str() const
Retrieve the ASCII conversion string.
sampleWriter::CreateMeshCylinder
Dtk_MeshPtr CreateMeshCylinder(int nbpoints)
Mesh Cylinder sample.
Definition: testcreatemesh.cpp:339
PdfwSampleInstancesColors_3_4
Dtk_ErrorStatus PdfwSampleInstancesColors_3_4(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:331
Dtk_mesh_asm_node::add_mesh
int add_mesh(Dtk_MeshPtr mesh)
Add an Dtk_mesh in Dtk_mesh_asm_node in the current asm node.
Dtk_transfo::setYdir
void setYdir(const Dtk_dir &Y)
Set a new Y vector.
PdfwSampleAssembly_3_1
Dtk_ErrorStatus PdfwSampleAssembly_3_1(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:191
Dtk_string::mkdir
int mkdir() const
File Utility : Create a Directory.
PdfwSampleSimplePMI_5_1
Dtk_ErrorStatus PdfwSampleSimplePMI_5_1(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:545
Dtk_pnt
This is a mathematical point class.
Definition: dtk_pnt.hpp:22
UgWriteSampleVersion
Dtk_ErrorStatus UgWriteSampleVersion(const Dtk_string &outputDirectory, int version)
Definition: testlibugwrite.cpp:693
PdfwSamplePMI_Geom_association_5_4
Dtk_ErrorStatus PdfwSamplePMI_Geom_association_5_4(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:640
psw_WriteBody
Dtk_ErrorStatus psw_WriteBody(Dtk_BodyPtr &inBody)
Writes a Body of a 3D part (3D content of a product), of any kind (solid, shell / faces,...
PdfwSampleAsmInstances_3_3
Dtk_ErrorStatus PdfwSampleAsmInstances_3_3(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:276
Dtk_string::FixPathSeparator
void FixPathSeparator()
File Utility : Fixes path separator consistency. It lets you replace the '\' or '/' by the OS needed ...
stepw::sample::WritePart_UsedByExternalAssembly
DtkErrorStatus WritePart_UsedByExternalAssembly(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:309
PdfwSample_MV_association_5_3
Dtk_ErrorStatus PdfwSample_MV_association_5_3(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:599
PdfwSampleDocumentProperties_4_2
Dtk_ErrorStatus PdfwSampleDocumentProperties_4_2(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:501
satw_EndPart
DtkErrorStatus satw_EndPart()
Ends the writing of a part.
sw::sww::english
@ english
Definition: solidworksw.hpp:25
Dtk_3MFWriter
3MF Writer main class.
Definition: 3mfw.hpp:16
Colladaw::ReinstanciatePrototype
DtkErrorStatus ReinstanciatePrototype(Dtk_ID inID)
Reinstanciate a node.
stepw::sample::WriteAssembly_WithProperties
DtkErrorStatus WriteAssembly_WithProperties(const Dtk_string &inRootAssemblyName)
Definition: testlibstepwrite.cpp:495
stepw::sample::WritePart_GeometricalTolerance
DtkErrorStatus WritePart_GeometricalTolerance(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:258
tess_ComputeBoundariesFromMesh
int tess_ComputeBoundariesFromMesh()
: Check value of option memorize noundaries of mesh
stepw::sample::WriteAssembly_NestedExternalReferences
DtkErrorStatus WriteAssembly_NestedExternalReferences(const Dtk_string &inRootAssemblyName)
Definition: testlibstepwrite.cpp:630
Dtk_tab
This is a high level array class.
Definition: util_stl_dtk.hpp:85
Dtk_transfo::addTranslate
void addTranslate(const Dtk_dir &V)
Translate the Dtk_transfo.
WriteOptions
This class provides several options to tunes cgr Writter. It must be provided to cgr::cgrw_InitWrite ...
Definition: cgrw.hpp:77
sampleWriter::CreateCube
Dtk_BodyPtr CreateCube()
Definition: testcreatecube.cpp:1320
stepw::sample::WritePart_BodyAndMeshFromTessellation
DtkErrorStatus WritePart_BodyAndMeshFromTessellation(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:149
Dtk_tab::size
Dtk_Size_t size() const
Returns the size of the array.
Definition: util_stl_dtk.hpp:504
Ifcw::ProjectInformation
This struct enables the user to define global properties regarding the project, construction site and...
Definition: IFCWriter.h:51
DTK_UGW_VERSION_NX1980
#define DTK_UGW_VERSION_NX1980
Definition: ugw.hpp:8
GltfwInstances
Dtk_ErrorStatus GltfwInstances(const Dtk_string &outputFileName)
Definition: testlibgltfwrite.cpp:57
tess_EndTesselation
void tess_EndTesselation()
Free the data used by tesselation library.
_3dxmlw::InitWrite
DtkErrorStatus InitWrite(const Dtk_string &inOutputFile, const Dtk_string &inLogFile, WriteOptions &inOptions)
Initialize the 3dxmlw Writer
PdfwSamplePMI_PMI_association_5_6
Dtk_ErrorStatus PdfwSamplePMI_PMI_association_5_6(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:720
PdfwSampleWireBody_2_2
Dtk_ErrorStatus PdfwSampleWireBody_2_2(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:137
stepw::sample::WritePart_WithProperties
DtkErrorStatus WritePart_WithProperties(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:174
Dtk_string::len
int len() const
Retrieve the length of the Dtk_string.
Colladaw::InitNode
DtkErrorStatus InitNode(Dtk_string &inNodeName, const Dtk_transfo &inTransfo, Dtk_InfoPtr &inInfo, Dtk_ID &outID)
Initialize a node.
StandardObjSample
int StandardObjSample(const Dtk_string &inResultDirectory)
Definition: testlibobjwrite.cpp:17
psw_EndFile
DtkErrorStatus psw_EndFile(Dtk_tab< Dtk_ID > &inTabIds, Dtk_bool binForceListOfBody=DTK_FALSE)
Ends the writing of the Parasolid (x_t or x_b) file.
PdfwSampleSimpleModelview_5_2
Dtk_ErrorStatus PdfwSampleSimpleModelview_5_2(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:567
sampleWriter::CreateCurves
Dtk_BodyPtr CreateCurves()
Definition: testcreatecube.cpp:1361
stepw::sample::WriteAssembly
DtkErrorStatus WriteAssembly(const Dtk_string &inRootAssemblyName)
Definition: testlibstepwrite.cpp:369
Dtk_3MFWriter::EndWrite
DtkErrorStatus EndWrite()
Creation of the output file and free the Obj Writer
stepw::sample::WriteAssembly_DimensionFDT
DtkErrorStatus WriteAssembly_DimensionFDT(const Dtk_string &inRootAssemblyName)
Definition: testlibstepwrite.cpp:408
dtkNoError
@ dtkNoError
Definition: error_dtk.hpp:144
Dtk_tab::push_back
void push_back(const T &x)
Inserts an element at the end of the array.
Definition: util_stl_dtk.hpp:417
catiav5w::InitWrite
Dtk_ErrorStatus InitWrite(const Dtk_string &inLogFile, Licence_dtk inLicFct, const WriteOptions &inOptions=WriteOptions())
Initialize the Catia V5 Writer
PdfwSampleOneMeshRender_1_3
Dtk_ErrorStatus PdfwSampleOneMeshRender_1_3(const Dtk_string &inOutputFileName, const Dtk_string &inImageDirectory)
Definition: testlibpdfwrite.cpp:101
satw_WriteBody
DtkErrorStatus satw_WriteBody(const Dtk_BodyPtr &inBody)
Writes a Body.
psw_LinkAttribut
DtkErrorStatus psw_LinkAttribut(Dtk_ID inIdAss)
link all attributes attached to an assembly
Dtk_tab::clear
void clear(int no_delete=0)
Resets the Dtk_tab content.
Definition: util_stl_dtk.hpp:353
PdfwSampleBody_2_1
Dtk_ErrorStatus PdfwSampleBody_2_1(const Dtk_string &inOutputFileName)
Definition: testlibpdfwrite.cpp:120
Dtk_RGB
Definition: dtk_rgb.hpp:7
AllJtWTests
int AllJtWTests(const Dtk_string &inResultDirectory)
Definition: testlibjtwrite.cpp:1097
WriteOptions::SetFileRelease
void SetFileRelease(const Dtk_UInt32 inRelease)
Sets the release for the written files.
Definition: cgrw.hpp:90
Dtk_Info::create
static Dtk_SmartPtr< Dtk_Info > create()
Calls default constructor to allocate a new object.
Colladaw::WriteEntity
Dtk_ErrorStatus WriteEntity(const Dtk_EntityPtr &inEntity)
Write the entity provided in parameter in a node.
Dtk_dir
This is a mathematical direction class.
Definition: dtk_dir.hpp:15
Dtk_mesh_asm_node::add_asm_instance
int add_asm_instance(Dtk_mesh_asm_node *inMeshAsm, Dtk_transfo *inTransfo)
Add an asm instance to the current asm node.
DTK_UGW_VERSION_NX2212
#define DTK_UGW_VERSION_NX2212
Definition: ugw.hpp:9
stepw::sample::WritePart_MeshWithFaceColors
DtkErrorStatus WritePart_MeshWithFaceColors(const Dtk_string &inPartName, int &outPartID)
Definition: testlibstepwrite.cpp:129
ProcessWallClassification
Dtk_ErrorStatus ProcessWallClassification()
Definition: testlibifcwrite.cpp:61
sampleWriter::CreateOpenShell
Dtk_BodyPtr CreateOpenShell()
Definition: testcreatecube.cpp:1347
sw::sww::SetIsAlreadyStart
void SetIsAlreadyStart(const Dtk_Int32 &inStop)
ONLY for PSKERNEL user.
satw_EndFile
DtkErrorStatus satw_EndFile()
Ends the writing of the Sat file.