IFC Write Sample

//start_of_mainifcwrite
//This sample show you how to write some ifc objects with several parameters and mesh geometry.
 
 
Dtk_ErrorStatus ProcessBasicWall( Dtk_bool inMesh )
{
     //Create a new set of parameters for the ifc element to be written
     Ifcw::IfcElement inParameters = Ifcw::IfcElement();
 
     //Set parameters value according to your needs (OPTIONAL)
     Dtk_RGB myColor = Dtk_RGB( 150, 40, 20 ); //Brick color
     inParameters.SetColor( myColor );
 
     //Initialize the current object with those parameters
     Dtk_ErrorStatus errorStatus = Ifcw::InitObject( inParameters );
 
     if( errorStatus != dtkNoError )
     {
          cout << "Can't write object " << errorStatus << endl;
          return dtkErrorInvalidComponent;
     }
 
     Dtk_EntityPtr entityShape;
     if( inMesh ) // Create ifc object tessallated geometry (mesh)   
     {
          Dtk_pnt wallFirstPoint = Dtk_pnt( 40, 40, 0 );
          Dtk_pnt wallSecondPoint = Dtk_pnt( 140, 45, 80 );
          Dtk_MeshPtr mesh = sampleWriter::CreateMeshCuboid( wallFirstPoint, wallSecondPoint );
          entityShape = Dtk_EntityPtr::DtkDynamicCast( mesh );
     }
     else // Create ifc object exact geometry (brep); available in IFC4
     {
          Dtk_BodyPtr body = sampleWriter::CreateCube();
          entityShape = Dtk_EntityPtr::DtkDynamicCast( body );
     }
     // And write the ifc object with previous parameters and geometry
     Ifcw::WriteEntity( entityShape );
 
     // Close the current object     
     Ifcw::EndObject();
     return dtkNoError;
}
 
Dtk_ErrorStatus ProcessWallClassification()
{
     //Create a new set of parameters for the ifc element to be written
     Ifcw::IfcElement inParameters = Ifcw::IfcElement();
     inParameters.SetName( L"wallClassified" );
     inParameters.SetBuildingElementType( Ifcw::IfcWall );
     //Create an IfcClassification to represent the classification you're using (e.g. : UniFormat, OmniClass, SfB...)
     //Create the reference in this classification you want to assign to the ifc entity to be written
     Ifcw::classification::IfcClassification classification = Ifcw::classification::IfcClassification( "ASTM", "E1557", "UniFormat II" );
     Ifcw::classification::IfcClassificationReference ref = Ifcw::classification::IfcClassificationReference( "https://www.wbdg.org/FFC/VA/VACOST/triservicemoduniformat.pdf", "B201001", "EXTERIOR CLOSURE", classification );
     inParameters.SetClassificationReference( ref );
 
     //Initialize the current object with those parameters
     Dtk_ErrorStatus errorStatus = Ifcw::InitObject( inParameters );
     if( errorStatus != dtkNoError )
     {
          cout << "Can't write object : " << errorStatus << endl;;
          return dtkErrorInvalidComponent;
     }
 
     // Create ifc object geometry (mesh)
     Dtk_pnt wallFirstPoint = Dtk_pnt( 140, -250, 0 );
     Dtk_pnt wallSecondPoint = Dtk_pnt( 145, -70, 60 );
     Dtk_MeshPtr mesh = sampleWriter::CreateMeshCuboid( wallFirstPoint, wallSecondPoint );
 
     //Write the geometry of our object. Multiple meshes are possible
     Ifcw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( mesh ), Dtk_transfo() );
 
     //Write the current object and close it    
     Ifcw::EndObject();
     return dtkNoError;
}
 
Dtk_ErrorStatus ProcessPrototypedColumns( int columnNumber )
{
     //Create a new set of parameters for the ifc entity to be written
     Ifcw::IfcType myColumnType = Ifcw::IfcType();
     Dtk_transfo transformationMatrix;
     Dtk_string name = "Column";
 
     //Set type parameters according to your needs
     myColumnType.SetName( name );
     myColumnType.SetBuildingElementType( Ifcw::IfcColumn );
     myColumnType.SetPredefinedType( "COLUMN" );
     myColumnType.SetID( 1 );
 
     //Set properties shared by all futur occurences of the type
     Dtk_MetaDataPtr myMetadatum1 = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, "radius", "2.5", "DOUBLE" );
     Dtk_MetaDataPtr myMetadatum2 = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, "Manufacturer", "Datakit", "STRING" );
     myColumnType.AddProperty( myMetadatum1 );
     myColumnType.AddProperty( myMetadatum2, "Identity Data" );
 
     // Create ifc type geometry (mesh)   
     Dtk_MeshPtr mesh = sampleWriter::CreateMeshCylinder( 30 );
     myColumnType.AddShape( Dtk_EntityPtr::DtkDynamicCast( mesh ) );
     //Write the type we have set
     Dtk_ErrorStatus errorStatus = Ifcw::WriteType( myColumnType );
     if( errorStatus != dtkNoError )
     {
          cout << "Can't write type : " << errorStatus << endl;;
          return dtkErrorInvalidComponent;
     }
 
     //Now we create colmun occurences of the type we just created. They will share its geometry
     for( int i = 0; i < columnNumber; i++ )
     {
          Dtk_string nameInst = name;
          nameInst.add_int( i + 1 );
          transformationMatrix.addTranslate( Dtk_dir( -30, -30, 0 ) );
 
          Ifcw::IfcElement inInstanceParameters = Ifcw::IfcElement();
          inInstanceParameters.SetName( nameInst );
          inInstanceParameters.SetBuildingElementType( Ifcw::IfcColumn );
          inInstanceParameters.SetLevel( L"Ground floor" );
          inInstanceParameters.SetTypeID( 1 );
          inInstanceParameters.SetInstanceTrf( transformationMatrix );
 
          Ifcw::InitObject( inInstanceParameters );
          Ifcw::EndObject();
     }
 
     return dtkNoError;
}
 
Dtk_ErrorStatus ProcessMultiMeshWall()
{
     //Create a new set of parameters for the ifc entity to be written
     Ifcw::IfcElement inParameters = Ifcw::IfcElement();
     //Set parameters value according to your needs (OPTIONAL)
     inParameters.SetName( L"myWall" );
     inParameters.SetBuildingElementType( Ifcw::IfcWall );
     inParameters.SetLevel( L"Ground floor" );
     inParameters.SetGUID( L"00024NEV9DMsnaPcrdUcjs" );
     Dtk_RGB myColor = Dtk_RGB( 135, 60, 20 ); //Another brick color
     inParameters.SetColor( myColor );
 
     //For custom ifc properties, create desired Dtk_MetaDataPtr (OPTIONAL)
     Dtk_MetaDataPtr myMetadatum1 = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, "customLength", "2.5", "DOUBLE" );
     Dtk_MetaDataPtr myMetadatum2 = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, "Manufacturer", "Datakit", "STRING" );
     //You can assign a category to Dtk_MetaDataPtr, to create Ifc property sets with different name (OPTIONAL)
     myMetadatum2->SetCategory( "Identity Data" );
 
     //you can either add single metadatum...
     inParameters.AddProperty( myMetadatum1 );
     inParameters.AddProperty( myMetadatum2 );
 
     //...or work with a table
     //Dtk_tab<Dtk_MetaDataPtr> inMetadata = Dtk_tab<Dtk_MetaDataPtr>();
     //inMetadata.push_back( myMetadatum1 );
     //inMetadata.push_back( myMetadatum2 );
     //inParameters->SetPropertySet( inMetadata );
 
     //Initialize the current object with those parameters
     Dtk_ErrorStatus errorStatus = Ifcw::InitObject( inParameters );
     if( errorStatus != dtkNoError )
     {
          cout << "Can't write object : " << errorStatus << endl;;
          return dtkErrorInvalidComponent;
     }
 
     // Create ifc object geometry ((here there are several meshes))mesh)
     Dtk_pnt wallFirstPoint = Dtk_pnt( 140, 45, 0 );
     Dtk_pnt wallSecondPoint = Dtk_pnt( 145, -40, 80 );
     Dtk_MeshPtr mesh = sampleWriter::CreateMeshCuboid( wallFirstPoint, wallSecondPoint );
 
     // Now we write the geometry of our object. Multiple meshes are possible
     Ifcw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( mesh ), Dtk_transfo() );
     mesh->Transform( Dtk_transfo( Dtk_dir( 1, 0, 0 ), Dtk_dir( 0, 1, 0 ), Dtk_dir( 0, 0, 1 ), Dtk_pnt( 0, 87, 0 ) ) );
     Ifcw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( mesh ), Dtk_transfo() );
 
     //Write the current object and close it     
     Ifcw::EndObject();
     return dtkNoError;
}
 
int IfcWriteSample( const Dtk_string &inResultDirectory )
{
     Dtk_string outputDirectory, outputFileName;
     cout << endl << "----------------------------------------------" << endl;
     cout << "Ifc Write start" << endl;
 
     // Choosing output directory and file name
     outputDirectory = inResultDirectory + L"dtk/Ifc/";
     outputDirectory.FixPathSeparator();
     outputDirectory.mkdir();
 
     //The ProjectInformation class enables you to set global information while initializing the writer module
     //This information is optionnali
     Ifcw::ProjectInformation myInfo;
     myInfo.projectAuthor = "my name";
     myInfo.buildingName = "sample building";
     myInfo.siteLatitude = 45.7;
     myInfo.siteLongitude = 4.8;
     myInfo.siteElevation = 173000;
 
     // First we initialize writing with name of files, log file and the configuration we want to use
     Ifcw::WriteOptions myOptions;
    myOptions.versionIndicator = 1; //IFC4
    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
     outputFileName = outputDirectory + L"sample.ifc";
     Dtk_ErrorStatus st = Ifcw::InitWrite( outputFileName, Dtk_string( outputDirectory + L"testifcw.log" ), myOptions, &myInfo );
 
     if( st != dtkNoError )
     {
          cout << "error : " << dtkTypeError( st ).c_str() << endl;
          return st;
     }
 
     //Write an ifc object/entity
     ProcessBasicWall( myOptions.versionIndicator != 1 );
     ProcessWallClassification();
     ProcessMultiMeshWall();
     ProcessPrototypedColumns( 5 );
 
     Ifcw::EndWrite();
 
     cout << "=> " << outputFileName.c_str() << endl << "Ifc Write end" << endl;
 
     return 0;
}
//end_of_mainifcwrite