Sample

//start_of_mainxmtwrite_dtk
 
#ifdef WIN32
#include <windows.h>
#endif  
 
#include "testwriters.h"
//DATAKIT headers needed
#include "datakit.h"
#include "psw/psw.hpp"
 
#include "SampleWriter/testcreatecube.hpp"
 
int
ParasolidWriteSample( const Dtk_string &inResultDirectory )
{
     cout << endl << "----------------------------------------------" << endl;
     cout << "Parasolid Write start" << endl;
     // Choosing output directory and file name
     Dtk_string outputDirectory = inResultDirectory + L"dtk/Parasolid/";
     outputDirectory.FixPathSeparator();
     outputDirectory.mkdir();
     Dtk_string outputFileName0 = outputDirectory + L"sample_listofbody.x_t";
 
     // We construct 3 parts 
     Dtk_BodyPtr body1 = sampleWriter::CreateCube();
     Dtk_BodyPtr body2 = sampleWriter::CreateOpenShell();
     Dtk_BodyPtr body3 = sampleWriter::CreateCurves();
 
     // We add the 3 parts in an array
     Dtk_tab<Dtk_BodyPtr> arrayOfParts;
     arrayOfParts.push_back( body1 );
     arrayOfParts.push_back( body2 );
     arrayOfParts.push_back( body3 );
 
     // First we initialize writing with name of files and protection function if needed (3rd parameter)
     Dtk_bool muteMode = DTK_TRUE;  //  no log write
     DtkErrorStatus status = psw_InitFile( outputFileName0, muteMode );
 
     if( status != dtkNoError )
     {
          cout << "error : " << dtkTypeError( status ).c_str() << endl;
          return status;
     }
 
 
     // Then we write the 3 parts constructed
     Dtk_Size_t i, l = arrayOfParts.size();
     Dtk_tab<Dtk_ID> returnID;
     for( i = 0; i < l; ++i )
          status = psw_WriteBody( arrayOfParts[ i ], returnID );
 
     // And free memory allocated for writing
     status = psw_EndFile( returnID );
 
 
     if( status != dtkNoError )
     {
          cout << "error : " << dtkTypeError( status ).c_str() << endl;
     }
     else
          cout << "=> " << outputFileName0.c_str() << endl;
 
     
     // then we write the same 3 part as an assembly that use these parts 2 times 
     Dtk_string outputFileName1 = outputDirectory + L"sample_assemblyofbody.x_t";
     status = psw_InitFile( outputFileName1, muteMode );
 
     // first we register all part ID
     Dtk_tab<Dtk_ID> partID (l, 1);
     for( i = 0; i < l; ++i )
     {
          returnID.clear();
          status = psw_WriteBody( arrayOfParts[ i ], returnID );
          if( returnID.size() > 1 )
          {  // if more than one parasolid body created we decide to create a subassembly 
               Dtk_ID outIdass;
               status = psw_CreateEmptyAssembly( outIdass );
               Dtk_transfoPtr MatrixIdentity = Dtk_transfo::create();
               for( Dtk_Size_t j = 0; j < returnID.size(); j++ )
               {
                    Dtk_ID outIdInst;
                    status = psw_CreateInstance( outIdass, returnID[ j ], MatrixIdentity, outIdInst );
               }
 
               partID[ i ] = outIdass;
               status = psw_LinkAttribut( outIdass );
          }
          else
               partID[ i ] = returnID[ 0 ];
 
          Dtk_string partName = L"DtkPart";
          partName.add_int((int)i);
          Dtk_InfoPtr info = Dtk_Info::create();
          info->SetName( partName );
          info->SetId ( Dtk_Int32 (i + 1) );
 
          status = psw_CreateAttribut( partID[ i ], info );
     }
 
     // we create an assembly 
     Dtk_ID assemblyID;
     status = psw_CreateEmptyAssembly( assemblyID );
 
     Dtk_string assName = L"DtkAssembly";
     Dtk_InfoPtr info = Dtk_Info::create();
     info->SetName( assName );
     info->SetId( 5 );
 
     status = psw_CreateAttribut( assemblyID, info );
 
     // we create each instance of the parts 
     for( i = 0; i < l; ++i )
     {
          Dtk_transfoPtr Matrix1 = Dtk_transfo::create();
          Matrix1->setOrigin( Dtk_pnt( 100.0, 0.0, 0.0 ) );
          Dtk_ID outIdInst;
          status = psw_CreateInstance( assemblyID, partID[ i ], Matrix1, outIdInst );
 
          Dtk_string instName = L"DtkInstance";
          instName.add_int( ( int )i );
          info->SetName( instName );
          info->SetId( Dtk_Int32( 10 + i) );
          status = psw_CreateAttribut( outIdInst, info );
 
 
          Dtk_transfoPtr Matrix2 = Dtk_transfo::create();
          Matrix2->setOrigin( Dtk_pnt( 100.0, 100.0, 100.0 ) );
          status = psw_CreateInstance( assemblyID, partID[ i ], Matrix2, outIdInst );
 
          Dtk_string instName2 = L"DtkInstance";
          instName2.add_int( ( int )(i + l));
          info->SetName( instName2 );
          info->SetId( Dtk_Int32( 10 + i + l ) );
          status = psw_CreateAttribut( outIdInst, info );
     }
 
     status = psw_LinkAttribut( assemblyID );
 
     returnID.clear();
     // And free memory allocated for writing
     status = psw_EndFile( returnID );
 
     if( status != dtkNoError )
     {
          cout << "error : " << dtkTypeError( status ).c_str() << endl;
     }
     else
          cout << "=> " << outputFileName1.c_str() << endl;
 
     cout << "Parasolid Write end" << endl;
 
     return 0;
}
//end_of_mainxmtwrite_dtk