FxBIM.h

Go to the documentation of this file.

//
// (C) Copyright 2020-2023 by Graebert GmbH.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted, 
// provided that the above copyright notice appears in all copies and 
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting 
// documentation.
//
// GRAEBERT PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS. 
// GRAEBERT SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  GRAEBERT GMBH 
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
 
#pragma once
 
#ifndef _MSC_VER
    #define FXBIM_API
    #define FXBIM_COMMON_CODE_API
#else
    #if defined( FX_BIM_CONVERTERS )
        #ifdef FXBIM_COMMON_CODE_EXPORTS
            #define FXBIM_API
            #define FXBIM_COMMON_CODE_API __declspec(dllexport)
        #else
            #define FXBIM_API
            #define FXBIM_COMMON_CODE_API __declspec(dllimport)
        #endif
    #elif defined( FXBIM_SC )
        #if defined( FXBIM_SCEXE )
            #define FXBIM_API
            #define FXBIM_COMMON_CODE_API
        #else
            #define FXBIM_API __declspec(dllimport)
            #define FXBIM_COMMON_CODE_API __declspec(dllimport)
        #endif
    #else
        #ifdef FXBIM_EXPORTS
            #define FXBIM_API __declspec(dllexport)
            #define FXBIM_COMMON_CODE_API __declspec(dllexport)
        #else
            #define FXBIM_API __declspec(dllimport)
            #define FXBIM_COMMON_CODE_API __declspec(dllimport)
        #endif
    #endif
#endif
 
#if defined( QT_VERSION )
#include <QtCore/QString>
#endif
 
#include <OdaCommon.h>
#include <OdaDefs.h>
#include <DbDatabase.h>
#include <DbBlockReference.h>
 
#include "FxBIMEntityReference.h"
 
#include <memory>
#include <map>
#include <vector>
 
enum class Error
{
    eOk = 0,
    eFail,
    eAbort,
    eInvalidParameter,
    eNullFamSymbol,
    eGeomIsNotNode,
    eGeomIsNotGElement,
    eNotImplemented,
    eDegenerateTopology,
    eDegenerateGeometry,
    eNullBmDatabase,
    eNullBmObject,
    eNullBmObjectId,
    eNullDbObjectId,
    eNotFound,
    eNotThatKindOfClass,
    eWrongIFCFormat,
    eWrongRVTFormat,
    eCVTInvalidParameter,
    eCVTInvalidConversionType,
    eCVTInvalidSource,
    eCVTInvalidDestinationFolder,
    eCVTInvalidDestinationExists,
    eCVTViewUnset,
    eCVTUnsupportedPlatform,
    eWrongTRBGeometryDefinition,
    eUnsupportedTRBGeometryDefinition
};
 
namespace FxBIM
{
    FXBIM_COMMON_CODE_API OdString ToString( const Error& e );
}
 
enum class fileType
{
    eUnknown = 0,
    eRevit = 1,
    eIFC = 2,
    eTRB = 3
};
 
class OdString;
class OdDbHostAppProgressMeter;
 
#include <functional>
#include <RxObject.h>
 
class CFxBIMDatabaseReference;
typedef OdSmartPtr< CFxBIMDatabaseReference > CFxBIMDatabaseReferencePtr;
 
#if !defined( XENON )
    class CFxBIMIPCClient;
#endif // !defined( XENON )
 
struct FXBIM_API Conversion
{
    enum Type
    {
        eNone,
        eConvertFromRevit,
        eConvertFromIfc,
        eConvertToIfc,
        eConvertFromTrb
    } _c;
 
    using fn_start_t = std::function< void( const OdString& viewName, OdInt64 idView ) >;
    using fn_ready_t = std::function< void( const OdString& dwgPath, const OdString& originalPath, const OdString& viewName, OdInt64 idView, int flags ) >;
    using fn_finish_t = std::function< void( int exitCode, int exitStatus ) >;
    using fn_abort_t = std::function< bool() >;
    using fn_error_t = std::function< void( const OdString& err ) >;
 
    struct Data
    {
        fn_start_t _fnStart = nullptr;
        fn_ready_t _fnReady = nullptr;
        fn_finish_t _fnFinish = nullptr;
        fn_abort_t _fnAbort = nullptr;
        fn_error_t _fnError = nullptr;
        OdDbHostAppProgressMeter* _pProgress = 0;
    } _d;
 
    enum Flags
    {
        eFNone = 0x0,
        eFFailWithoutServer = 0x1, //Converter fails without IPC server connection
        eFMaskInternal = 0xFF, //Flags starting from 0x100 are internal
    };
    int _flags = eFFailWithoutServer;
 
    Conversion();
    explicit Conversion( fileType type, Data data, int flags );
 
    static Conversion::Type FromString( const OdString& arg );
    static OdString ToString( const Conversion& c );
 
#if !defined( XENON )
    std::shared_ptr< CFxBIMIPCClient > _ipc;
#endif // !defined( XENON )
};
 
namespace FxBIM
{
    const OdString kBIMModuleName = OD_T( "FxBIM" );
 
    enum Version
    {
        k2019 = 1,
        k2020 = 2,
        k2021 = 3,
        k2022 = 4,
        k2023 = 5,
        kSP0 = 0,
        kSP1 = 1,
        kSP2 = 2,
        kSP3 = 3,
    };
 
    //TODO: verify what version it should be
    constexpr OdInt16 kCurrenVersionMajor = k2023;
    constexpr OdInt16 kCurrenVersionMinor = kSP0;
    constexpr OdInt16 kCurrenVersionRevision = 4;
 
    FXBIM_API OdInt64 bimVersion( OdInt16 major, OdInt16 minor, OdInt16 revision );
    FXBIM_API OdInt64 currentVersion();
}
 
#if defined( QT_VERSION )
FXBIM_COMMON_CODE_API OdString convert( const QString& qstr );
FXBIM_COMMON_CODE_API QString convert( const OdString& odstr );
#endif
 
class CFxBIMObject;
typedef std::shared_ptr< CFxBIMObject > CFxBIMObjectPtr;
 
class FXBIM_API CFxBIMObject : public std::enable_shared_from_this< CFxBIMObject >
{
protected:
    CFxBIMObject();
    virtual ~CFxBIMObject();
};
 
#include <DbObjectId.h>
 
namespace FxBIM
{
    template <typename T>
    std::shared_ptr<T> cast( CFxBIMObjectPtr pBase )
    {
        std::shared_ptr<T> p = std::dynamic_pointer_cast< T, CFxBIMObject >( pBase );
        return( p );
    }
 
    template <typename T>
    OdSmartPtr<T> cast( OdDbObjectId id, OdDb::OpenMode mode = OdDb::kForRead, bool openErased = false )
    {
        OdSmartPtr<T> p = T::cast( id.openObject( mode, openErased ) );
        return( p );
    }
}
 
class CFxBIMIterator;
typedef std::shared_ptr< CFxBIMIterator > CFxBIMIteratorPtr;
class CFxBIMIteratorRA;
typedef std::shared_ptr< CFxBIMIteratorRA > CFxBIMIteratorRAPtr;
class CFxBIMDbIterator;
typedef std::shared_ptr< CFxBIMDbIterator > CFxBIMDbIteratorPtr;
class CFxBIMDbIteratorRA;
typedef std::shared_ptr< CFxBIMDbIteratorRA > CFxBIMDbIteratorRAPtr;
 
#include <functional>
 
class FXBIM_API CFxBIMIterator
{
public:
    virtual ~CFxBIMIterator() {};
    virtual void SetPredicate( std::function< bool( CFxBIMObjectPtr ) > p ) = 0;
    virtual void Start() = 0;
    virtual bool Done() = 0;
    virtual void Next() = 0;
 
    virtual CFxBIMObjectPtr Object() = 0;
};
 
class FXBIM_API CFxBIMIteratorRA
{
public:
    virtual ~CFxBIMIteratorRA() {};
    virtual size_t Count() = 0;
    virtual CFxBIMObjectPtr Object( size_t index ) = 0;
};
 
#include <DbObjectId.h>
 
class FXBIM_API CFxBIMDbIterator
{
public:
    virtual ~CFxBIMDbIterator() {};
    virtual void SetPredicate( std::function< bool( OdDbObjectId ) > p ) = 0;
    virtual void Start() = 0;
    virtual bool Done() = 0;
    virtual void Next() = 0;
 
    virtual OdDbObjectId Object() = 0;
};
 
class FXBIM_API CFxBIMDbIteratorRA
{
public:
    virtual ~CFxBIMDbIteratorRA() {};
    virtual size_t Count() = 0;
    virtual OdDbObjectId Object( size_t index ) = 0;
};
 
enum class BimStandards
{
    eUnset = -2,
    eUnknown = -1,
    eISO = 0,
    eANSI = 1,
};
 
enum class BimUnitsLength
{
    eUndefined = 0,
    eFeet = 1,
    eInch = 2,
    eM = 3,
    eDM = 4,
    eCM = 5,
    eMM = 6,
};
 
enum class BimUnitsStyle
{
    eAuto        = 0, // Will choose the style according the BIMUNITSLENGTH
    eSuperscript = 1, // Force m^2, ft^2 style
    ePrefix      = 2, // Force sq m, sq ft syle
};
 
enum class BimLabelUnitsPolicy
{
    eAuto   = 0,
    eAlways = 1,
    eNever  = 2,
};
 
enum class BimUnitsArea
{
    eUndefined = 0,
    eSqFeet = 1,
    eSqInches = 2,
    eSqMeters = 3,
    eSqDM = 4,
    eSqCM = 5,
    eSqMM = 6
};
 
enum class BimUnitsVolume
{
    //TODO: Update the list
    eUndefined = 0,
    eCubicFeet = 1,
    eCubicInches = 2,
    eCubicMeters = 3,
    eCubicDecimeters = 4,
    eCubicCentimeters = 5,
    eCubicMilimeters = 6,
};
 
enum class EBIMView
{
    e3DView = 0,
    e2DView = 1,
};
 
 
namespace FxBIM
{
    class FXBIM_API Standard
    {
    public:
        explicit Standard( const OdString& name );
 
        const OdString& Name() const;
        const BimStandards& Type() const;
 
        bool operator< ( const Standard& other ) const;
 
        static OdString ToString( BimStandards standard );
        static BimStandards FromString( const OdString& standard );
 
    protected:
        OdString m_Name;
        BimStandards m_Type = BimStandards::eUnset;
    };
 
    FXBIM_API OdString BIMSTANDARD( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMSTANDARD( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API double BIMHPSCALE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMHPSCALE( OdDbDatabase* pDb, const double& value );
 
    FXBIM_COMMON_CODE_API int BIMUNITSLENGTH( const OdDbDatabase* pDb );
    FXBIM_COMMON_CODE_API void SetBIMUNITSLENGTH( OdDbDatabase* pDb, const int& value );
 
    FXBIM_API int BIMUNITSSTYLE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMUNITSSTYLE( OdDbDatabase* pDb, const int& value );
 
    FXBIM_API OdString BIMVPSCALE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMVPSCALE( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCURRENTDIMSTYLE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCURRENTDIMSTYLE( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMPROJECTPATH( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMPROJECTPATH( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCALLOUTSFILE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTSFILE( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCALLOUTBLOCKPLAN( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTBLOCKPLAN( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCALLOUTBLOCKSECTION( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTBLOCKSECTION( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCALLOUTBLOCKSECTIONALT( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTBLOCKSECTIONALT( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCALLOUTBLOCKELEVATION( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTBLOCKELEVATION( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMVIEWTITLEBLOCK( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMVIEWTITLEBLOCK( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMAUTOFILTER( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMAUTOFILTER( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMAUTOTEMPLATE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMAUTOTEMPLATE( OdDbDatabase* pDb, const OdString& value );
}
 
namespace FxBIM
{
    FXBIM_API bool BIMCALLOUTSONOFF( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTSONOFF( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API bool BIMCLIPPINGBOXONOFF( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCLIPPINGBOXONOFF( OdDbDatabase* pDb, const bool& value );
}
 
namespace FxBIM
{
    enum class EFileType
    {
        eModelDrawing       = 0x0, //Files in 'models' directory
        eFlatshotDrawing    = 0x1  //Files in 'drawings' directory
    };
 
    FXBIM_API Error resolvePath( const OdDbDatabase* pDb, OdString& path, EFileType eFileType );
}
 
namespace FxBIM
{
    FXBIM_API OdString GetAbsoluteFilePath( const OdString& sPath, OdDbDatabase* pCurrentDb );
#if defined( QT_VERSION )
    FXBIM_API QString GetAbsoluteFilePath( const QString& sPath, OdDbDatabase* pCurrentDb );
#endif
}
 
#if !defined( FX_BIM_CONVERTERS )
namespace FxBIM
{
    FXBIM_API Error getRotation( OdDbBlockReferencePtr pBlkRef, double& angle );
    FXBIM_API Error setRotation( OdDbBlockReferencePtr pBlkRef, double angle );
 
    /*
     * Given a database, it tried to find the scale applied to the import. It then return a scale that 
     * can be used for call-outs and labels to have a nice representation
     */
    FXBIM_API double getImportScaleLabel( OdDbDatabasePtr database );
}
 
#endif // !defined( FX_BIM_CONVERTERS )