IFCWriter.h

Go to the documentation of this file.

#ifndef _IFCW_HPP_
#define _IFCW_HPP_
//! \brief Exported APIs for Ifc (.ifc) Write Library
 
namespace Ifcw
{
     //! \class WriteOptions 
     //! \brief This class provides several options to tune the IFC Writer.\n
     //! It must be provided to Ifcw::InitWrite method.
     //! \code
     //! //...
     //! Dtk_string LogFile = L"MyLogFile.log";
     //! Ifcw::WriteOptions IFCOptions;
     //! Dtk_ErrorStatus err = Ifcw::InitWrite( LogFile, NULL, PdfOptions);
     //! //...
     //! \endcode
     class WriteOptions
     {
     protected:
     public:
 
          //! \BaseConstructor
          WriteOptions() : buildingTypeRecognition( DTK_TRUE ), versionIndicator ( 1 )
          {
          }
          
          //! Int representing IFC version to use : 0 ( default ) = IFC2x3; 1 = IFC4
          int versionIndicator;
          //! DTK_TRUE : enable building type recognition (deduces if an element is an IFCWALL, IFCWINDOW...), DTK_FALSE : disable building type recognition
          Dtk_bool buildingTypeRecognition;
     };
 
     //! \struct ProjectInformation
     //! \brief This struct enables the user to define global properties regarding the project, construction site and building.\n
     //! It is used in the Ifcw::InitWrite method.
     //! \see InitWrite
     //!
     //! Here is the detailed mapping of this struct field and IFC data :
     //! projectPhase <-> IFCPROJECT.Phase
     //! projectName <-> IFCPROJECT.Name
     //! projectDetailedName <-> IFCPROJECT.LongName
     //! siteLatitude <-> IFCSITE.RefLatitude in degree
     //! siteLongitude <-> IFCSITE.RefLongitude in degree
     //! siteElevation <-> IFCSITE.RefElevation in meter
     //! buildingAddress <-> IFCBUILDING.BuildingAddress
     //! buildingName <-> IFCBUILDING.Name AND IFCBUILDING.LongName
     //! projectAuthor <-> IFCPERSON.GivenName
     //! organizationName <-> IFCORGANIZATION.Name
     //! organizationDescription <-> IFCORGANIZATION.Description
     struct ProjectInformation
     {
          Dtk_string projectPhase;
          Dtk_string projectName;
          Dtk_string projectDetailedName;
          Dtk_string buildingAddress;
          Dtk_string buildingName;
          Dtk_string projectAuthor;
          Dtk_string organizationName;
          Dtk_string organizationDescription;
          Dtk_Double64 siteLatitude;
          Dtk_Double64 siteLongitude;
          Dtk_Double64 siteElevation;
          ProjectInformation() : 
               projectPhase("Project Phase"),
               projectName("Project Name"),
               projectDetailedName("Project Detailed Name"),
               buildingAddress("Building Address"),
               buildingName("Building Name"),
               projectAuthor("Author"),
               organizationName("Organization name"),
               organizationDescription("Organization description"),
               siteLatitude(0.),
               siteLongitude(0.),
               siteElevation(0.)
          { };
          ~ProjectInformation(){ };
          ProjectInformation& operator=( ProjectInformation&&  p );
     };
 
 
     //! \class IfcCalendarDate 
     //! \brief This class represents an IFC date.\n
     //! \remark Definition from ISO/CD 10303-41:1992: A date which is defined by a day in a month of a year.
     struct IfcCalendarDate
     {
     private:
          int day; //!< An int between 1 and 31.
          int month; //!< An int between 1 and 12.
          int year; //!< A positive int.
     public:
          //! \BaseConstructor
          IfcCalendarDate();
          IfcCalendarDate( const int& inDay, const int& inMonth, const int& iYear );
          friend bool operator==( IfcCalendarDate const& lhs, IfcCalendarDate const& rhs )
          {
               return lhs.day == rhs.day && lhs.month == rhs.month && lhs.year == rhs.year;
          };
          //! \brief Getter for the date day
          //! \return The date day
          int GetDay() const;
          //! \brief Getter for the date month
          //! \return The date month
          int GetMonth() const;
          //! \brief Getter for the date year
          //! \return The date year
          int GetYear() const;
     };
 
     namespace classification
     {
          //! \class IfcClassification
          //! \brief A class that represents a classification system, like UniFormat, Omniclass, SfB...    
          //! \remark Ifc objects are not directly link to IfcClassification in 2x3 and have to be linked to IfcClassificationReference
          //! \see IfcClassificationReference
          //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_3/RC1/HTML/schema/ifcexternalreferenceresource/lexical/ifcclassification.htm
          class IfcClassification
          {
          private:
               IfcCalendarDate                                                               editionDate; //!< Classification version date ou publication.
               Dtk_string                                                                           source; //!< Where the classification comes from (publisher). Mandatory.
               Dtk_string                                                                        edition; //!< Classification version. Mandatory.
               Dtk_string                                                                             name; //!< Classifition name, like "UniFormat". Optionnal.
          public:
               //! \BaseConstructor
               //! \remark Should not be used because at classification source and edition are mandatory parameter.
               IfcClassification();
               //! \brief Constructor taking 3 parameters.
               //! \param [in] inSource : Classification source.
               //! \param [in] inEdition : Classification edition.
               //! \param [in] inName : Classification name.
               //! \remark name is optionnal.
               IfcClassification( Dtk_string inSource, Dtk_string inEdition, Dtk_string inName = "" );
               friend bool operator==( IfcClassification const& lhs, IfcClassification const& rhs )
               {
                    return lhs.editionDate == rhs.editionDate && lhs.source == rhs.source && lhs.edition == rhs.edition && lhs.name == rhs.name;
               };
               //! \brief Getter for the classification edition date
               //! \return The classification edition date
               const IfcCalendarDate & GetEditionDate() const;
               //! \brief Getter for the classification source
               //! \return The classification source
               const Dtk_string & GetSource() const;
               //! \brief Getter for the classification edition
               //! \return The classification edition
               const Dtk_string & GetEdition() const;
               //! \brief Getter for the classification name
               //! \return The classification name
               const Dtk_string & GetName() const;
               //! \brief Setter for the classification name
               //! \param [in] inName : The classification name to be used
               void SetName( Dtk_string inName );
               //! \brief Setter for the classification source
               //! \param [in] inSource : The classification source to be used
               void SetSource( Dtk_string inSource );
               //! \brief Setter for the classification edition
               //! \param [in] inEdition : The classification edition to be used
               void SetEdition( Dtk_string inEdition );
               //! \brief Setter for the classification edition date
               //! \param [in] inDate : The ifc date to be used
               void SetEditionDate( IfcCalendarDate inDate );
               //! \brief Setter for the classification edition date
               //! \param [in] inDay : The day of date to be used
               //! \param [in] inMonth : The month of date to be used
               //! \param [in] inYear : The year of date to be used
               void SetEditionDate( int inDay, int inMonth, int inYear );
          };
 
          //! \class IfcClassificationReference
          //! \brief This class represent a classification reference to be used for an ifc object, e.g.: B2010 in OmniClass for exterior walls. It is link to a classification.
          //! \see IfcClassification
          //! \remark One of its parameter have to be assigned (all optionals).
          //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_3/RC1/HTML/schema/ifcexternalreferenceresource/lexical/ifcclassificationreference.htm
          //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_3/RC1/HTML/schema/ifcexternalreferenceresource/lexical/ifcexternalreference.htm
          class IfcClassificationReference
          {
          private:
               IfcClassification                                                  referencedSource;//!< The classification that is referred.
               Dtk_string                                                                        location;//!< Location where the classification can be accessed (URL). Optionnal.
               Dtk_string                                                                  itemReference;//!< Item reference provides a unique identifier of the referenced item within the classification. Optionnal.
               Dtk_string                                                                             name;//!<    Name to further specify the reference. Optionnal.
 
          public:
               //! \BaseConstructor
               //! \remark One of the parameter should be set, otherwise name will be set to 'Undefined'. 
               IfcClassificationReference( Dtk_string inLocation = "", Dtk_string inItemReference = "", Dtk_string inName = "", IfcClassification inReferencedSource = IfcClassification() );
               friend bool operator==( IfcClassificationReference const& lhs, IfcClassificationReference const& rhs )
               {
                    return lhs.referencedSource == rhs.referencedSource
                    && lhs.location == rhs.location
                    && lhs.itemReference == rhs.itemReference && lhs.name == rhs.name;
               };
               //! \brief Getter for the classification the reference is linked to
               //! \return The classification the reference is linked to
               const IfcClassification & GetReferencedSource() const;
               //! \brief Getter for the reference location
               //! \return The reference location
               const Dtk_string & GetLocation() const;
               //! \brief Getter for the reference item reference
               //! \return The reference item reference
               const Dtk_string & GetItemReference() const;
               //! \brief Getter for the reference name
               //! \return The reference name
               const Dtk_string & GetName() const;
               //! \brief Setter for the reference location
               //! \param [in] inLocation : reference location to be used
               void SetLocation( Dtk_string inLocation );
               //! \brief Setter for the reference item reference
               //! \param [in] inItemReference : reference item reference to be used
               void SetItemReference( Dtk_string inItemReference );
               //! \brief Setter for the reference name
               //! \param [in] inName : reference name to be used
               void SetName( Dtk_string inName );
          };
 
     }
 
     //! \enum IfcBuildingElement 
     //! \brief This enum provides commonly used ifc building elements types, to define entities to be written.\n
     //! It is used in the Ifcw::SetIfcBuildingElement method.
     //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_3/RC1/HTML/schema/ifcproductextension/lexical/ifcbuiltelement.htm
     enum IfcBuildingElement
     {
          IfcBeam,
          IfcBuildingElementProxy,
          IfcColumn,
          IfcCovering,
          IfcCurtainWall,
          IfcDoor,
          IfcFooting,
          IfcMember,
          IfcPlate,
          IfcRailing,
          IfcRamp,
          IfcRampFlight,
          IfcRoof,
          IfcSlab,
          IfcStair,
          IfcStairFlight,
          IfcWall,
          IfcWindow
     };
 
     //!  \class IfcType
     //! \brief A IfcType is used to define the common properties of a certain type or style of an entity that may be applied to instances of that entity type. 
     //! \remark Types may be exchanged without being already assigned to occurrences.
     //! \remark Type shapes are overwritten by occurence shapes. Type properties are added to occurence properties and overwritten for those which have the same filed.
     //! \see https://standards.buildingsmart.org/IFC/DEV/IFC4_3/RC1/HTML/schema/ifcproductextension/lexical/ifcelementtype.htm
     class IfcType
     {
     private :
          Dtk_tab<Dtk_MetaDataPtr>                                              propertySet; //!< The shared properties of the objects that will be assigned this type. Optional.
          Dtk_tab <Dtk_EntityPtr>                                   shapeReprensentation; //!< The shared representation shape of the objects that will be assigned this type.
          Dtk_string                                                            buildingElement; //!< The building element type of the objects that will be assigned to this type. (e.g. IfcWall, IfcBeam...)
          Dtk_string                                                                  predefinedType; //!< Predefined type of the building element subtype (e.g. if productSubType = IFCROOF : FLAT_ROOF, SHED_ROOF...). If not set, will be set to "NOTDEFINED". Overrides IfcElement predefined type
          Dtk_string                                                                               tag; //!< The tag (or label) identifier at the particular type of a product, e.g. the article number (like the EAN). Optional.
          Dtk_string                                                                           name; //!< Name for the defined type. Optional.
          Dtk_ID                                                                                    ID; //!< Id of the type, to be identified when creating objects of that type.
 
     public:        
          IfcType();
          ~IfcType();
          //! \brief Getter for type property set
          //! \return The set of properties assigned to the type
          const Dtk_tab<Dtk_MetaDataPtr> & GetPropertySet() const;
          //! \brief Getter for type shape representation
          //! \return The entities of the shape reprentation of the type
          const Dtk_tab<Dtk_EntityPtr> & GetShapeRepresentation() const;
          //! \brief Getter for type tag
          //! \return The tag of the type
          const Dtk_string & GetTag() const;
          //! \brief Getter for type name
          //! \return The name of the type
          const Dtk_string & GetName() const;
          //! \brief Getter for type ID
          //! \return The ID of the type
          Dtk_ID GetID() const;
          //! \brief Getter for IfcType building element subtype. 
          //! \return The Ifc building element type assigned in the IfcType
          const Dtk_string & GetBuildingElementType() const;
          //! \brief Getter for IfcType predefined type. 
          //! \return The predefined type assigned in the IfcType
          const Dtk_string & GetPredefinedType() const;
          //! \brief Setter for IfcType building element type. 
          //! \param [in] inType : The building element type to be assigned in the IfcType
          void SetBuildingElementType( const Dtk_string & inType );
          //! \brief Setter for IfcElement building element subtype. 
          //! \param [in] inTypeEnum : The building element subtype to be assigned in the IfcType
          void SetBuildingElementType( IfcBuildingElement inTypeEnum );
          //! \brief Setter for IfcType propertySet. 
          //! \param [in] inProperties : The property set to be attached to the IfcType
          //! \param [in] inSetName : The name of the property set (default is "UserDefined")
          void SetPropertySet( Dtk_tab<Dtk_MetaDataPtr> inProperties, const Dtk_string & inSetName = "" );         
          //! \brief Adds a property to IfcType current property set. 
          //! \param [in] inProperty : The property to be added to the property set
          //! \param [in] inSetName : The name of the property set in which the property belong
          void AddProperty( Dtk_MetaDataPtr inProperty, const Dtk_string & inSetName = "" );
          //! \brief Setter for IfcType shapeRepresentation (geometry)
          //! \param [in] inShapes : The entities to be assigned as shape representation (only Dtk_mesh are supported for now)
          void SetShape( Dtk_tab< Dtk_EntityPtr > inShapes );
          //! \brief Adds an entity to IfcType shape representation (geometry)
          //! \param [in] inShape : The entity to add in the shape representation (only Dtk_mesh are supported for now)
          void AddShape( Dtk_EntityPtr inShape );
          //! \brief Setter for IfcType tag
          //! \param [in] inTag : The tag of the type
          void SetTag( const Dtk_string & inTag );
          //! \brief Setter for IfcType name
          //! \param [in] inName : The name of the type
          void SetName( const Dtk_string & inName );
          //! \brief Setter for IfcType ID
          //! \param [in] inID : The ID of the type
          void SetID( const Dtk_ID & inID );
          //! \brief Setter for IfcType predefined type
          //! \param [in] inType : The predefined type of the IfcType
          void SetPredefinedType( const Dtk_string & inType );
     };
 
     //! \class IfcElement 
     //! \brief This class provides several parameters for the next ifc entity to be written, as its custom property set, level, classification.\n
     //! It must be provided to Ifcw::InitObject method.
    //! \remark The propertySet can gather properties from different IfcPropertySet, we'll write as many set as there are different set names
     //! \see SetPropertySet, AddProperty
     //! \code
     //! //...
     //! Dtk_string ifcType = L"IFCWALL";
     //! Ifcw::IfcElement* entityParams = new IfcElement();
     //! entityParams->SetIfcType( ifcType );
     //! Dtk_ErrorStatus err = Ifcw::InitObject( entityParams );
     //! //...
     //! \endcode
     class IfcElement
     {
     private:
          classification::IfcClassificationReference           classificationReference; //!< Object reference in classification. Optionnal.
          Dtk_tab<Dtk_MetaDataPtr>                                            propertySet; //!< Object properties. Set name is determine by Dtk_MetaData category. If different categories are set, different property sets will be written.
          Dtk_string                                                                             name; //!< Object name. Default is 'UNDEFINED'
          Dtk_string                                                          buildingElementType; //!< Object type, like IFCWALL, IFCCOLUMN... Default is IFCBUILDINGELEMENTPROXY \see IfcBuildingElement
          Dtk_string                                                                predefinedType; //!< //!< Predefined type of the building element subtype (e.g. if productSubType = IFCROOF : FLAT_ROOF, SHED_ROOF...). If not set, will be set to "NOTDEFINED"
          Dtk_string                                                                             GUID; //!< Object GUID. If not set a GUID will be generated.
          Dtk_string                                                                           level; //!< Building level where the object belongs to. If not set will be placed in the building without level.
          Dtk_string                                                                             tag; //!< Tag identifier of the object occurence, e.g. position, serial number.
          Dtk_RGB                                                                              color; //!< Object color. Default is grey.
          Dtk_transfo                                                                   instanceTrf; //!< Instance transformation matrice (if the object is instantiated)
          Dtk_ID                                                                              typeID; //!< Object IfcType ID (only if it belongs to a IfcType). If type shapes are defined, they will be used as this object representation shapes (if it has no shape entities assigned through further WriteEntity call).
 
     public:
          //! \BaseConstructor
          IfcElement();
          //! \brief Getter for IfcElement propertySet
          //! \return The table of propertySet assigned to the IfcElement
          const Dtk_tab<Dtk_MetaDataPtr> & GetPropertySet() const;
          //! \brief Getter for a single IfcElement property
          //! \param [in] pos : The position in the table for the property to retrieve
          //! \return The property at position pos
          Dtk_MetaDataPtr GetPropertyAtPos( Dtk_Size_t pos ) const;
          //! \brief Getter for IfcType ID. 
          //! \return The ID of the current object type
          Dtk_ID GetTypeID() const;
          //! \brief Getter for IfcElement name. 
          //! \return The name assigned in the IfcElement
          const Dtk_string & GetName() const;
          //! \brief Getter for IfcElement GUID
          //! \return The GUID assigned in the IfcElement.
          const Dtk_string & GetGUID() const;
          //! \brief Getter for IfcElement level
          //! \return The level assigned in the IfcElement.
          const Dtk_string & GetLevel() const;
          //! \brief Getter for IfcElement tag
          //! \return The tag assigned in the IfcElement.
          const Dtk_string & GetTag() const;
          //! \brief Getter for IfcElement building element type. 
          //! \return The building element type assigned in the IfcElement
          const Dtk_string & GetBuildingElementType() const;
          //! \brief Getter for IfcElement predefined type. 
          //! \return The building element predefined type assigned in the IfcElement
          const Dtk_string & GetPredefinedType() const;
          //! \brief Getter for IfcElement color. 
          //! \return The color assigned in the IfcElement
          Dtk_RGB GetColor() const;
          //! \brief Getter for IfcElement instance transformation matrice. 
          //! \return The instance transformation matrice assigned in the IfcElement
          const Dtk_transfo & GetInstanceTrf() const;
          //! \brief Getter for classification reference
          //! \return The classification reference assigned in the IfcElement
          const classification::IfcClassificationReference & GetClassificationReference() const;
          //! \brief Setter for IfcElement propertySet. 
          //! \param [in] inProperties : The property set to be attached to the IfcElement
          //! \param [in] inSetName : The name of the property set (default is "UserDefined")
          void SetPropertySet( Dtk_tab<Dtk_MetaDataPtr> inProperties, const Dtk_string & inSetName = "" );
          //! \brief Adds a property to IfcElement current property set. 
          //! \param [in] inProperty : The property to be added to the property set
          //! \param [in] inSetName : The name of the property set in which the property belong
          void AddProperty( Dtk_MetaDataPtr inProperty, Dtk_string inSetName = "" );
          //! \brief Setter for IfcElement name. 
          //! \param [in] inName : The name to be assigned in the IfcElement
          void SetName( Dtk_string inName );
          //! \brief Setter for IfcElement IfcType ID. 
          //! \param [in] inID : The type ID to be assigned in the IfcElement
          void SetTypeID( const Dtk_ID & inID );
          //! \brief Setter for IfcElement GUID. 
          //! \param [in] inGUID : The GUID to be assigned in the IfcElement
          void SetGUID( Dtk_string inGUID );
          //! \brief Setter for IfcElement level. 
          //! \param [in] inLevel : The level to be assigned in the IfcElement
          void SetLevel( Dtk_string inLevel );
          //! \brief Setter for IfcElement tag. 
          //! \param [in] inTag : The tag to be assigned in the IfcElement
          void SetTag( Dtk_string inTag );
          //! \brief Setter for IfcElement building element type. 
          //! \param [in] inType : The building element type to be assigned in the IfcElement
          void SetBuildingElementType( Dtk_string inType );
          //! \brief Setter for IfcElement building element type. 
          //! \param [in] inTypeEnum : The building element type to be assigned in the IfcElement
          void SetBuildingElementType( IfcBuildingElement inTypeEnum );
          //! \brief Setter for IfcElement predefined type. 
          //! \param [in] inType : The building element predefined type to be assigned in the IfcElement
          void SetPredefinedType( const Dtk_string & inType );
          //! \brief Setter for IfcElement color. 
          //! \param [in] inColor : The color to be assigned in the IfcElement
          void SetColor( const Dtk_RGB & inColor );
          //! \brief Setter for IfcElement instance transformation matrice. 
          //! \param [in] inTrf : The instance transformation matrice to be assigned in the IfcElement
          void SetInstanceTrf( const Dtk_transfo & inTrf );
          //! \brief Setter for IfcElement classification reference
          //! \param [in] inClassificationRef : The classification reference to be assigned in the IfcElement
          void SetClassificationReference( classification::IfcClassificationReference inClassificationRef );
     };
 
    //! \brief Initialize the Ifc Writer and the IFC version you want to write 
    //! \return dtkNoError if it is OK.
    //! \param [in] inOutputFile : Output file name
    //! \param [in] inLogFile : Log file
     //! \param [in] inOptions : options to tune the IFC Writer
    //! \remark This function is the first call for the writer, it must me called after Dtk_API::StartAPI(...)
     //! \see WriteOptions
    DtkErrorStatus InitWrite(const Dtk_string& inOutputFile, const Dtk_string& inLogFile, const WriteOptions& inOptions, ProjectInformation* inProjectInfo = nullptr);
 
 
    //! \brief Creation of the output file and free the Ifc Writer  
    //! \return dtkNoError if it is OK.
    //! \remark used as the last function used for the writer.
    DtkErrorStatus EndWrite();
 
     //! \brief Initialize an ifcobject with various information. 
     //! \param [in] inParameters : The parameters you want for the object to be written (see IfcElement class)
     //! \return dtkNoError if it is OK.
     //! \remark To close the current object you will need to call EndObject() function .
     DtkErrorStatus InitObject( IfcElement inParameters );
 
     //! \brief Ends the current object
     //! \return dtkNoError if it is OK.
     DtkErrorStatus EndObject();
 
    //! \brief Write the entity provided in parameter. The entity corresponds to current object geometry (e.g: a Dtk_MeshPtr())
    //! \param [in] inEntity : The Entity to be written
     //! \param [in] inMat : The matrice that needs to be applied before the writing
    //! \return dtkNoError if it is OK.
    //! \remark This function is used to write entities (only Dtk_MeshPtr ).
    Dtk_ErrorStatus WriteEntity(const Dtk_EntityPtr& inEntity, const Dtk_transfo & inMat = Dtk_transfo());
 
     //! \brief Write the type provided in parameter. The type can exists by itself without having entities related to it.
     //! \param [in] inType : The ifcType to be written
     //! \return dtkNoError if it is OK.
     //! \remark Should be used before WriteEntity if the entity to be written uses the current ifcType.
     Dtk_ErrorStatus WriteType( const IfcType& inType );
 
}// namespace Ifcw
 
#endif