assimp/code/IFCLoader.cpp

/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------

Copyright (c) 2006-2017, assimp team

All rights reserved.

Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the
following conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.

* Redistributions in binary form must reproduce the above
  copyright notice, this list of conditions and the
  following disclaimer in the documentation and/or other
  materials provided with the distribution.

* Neither the name of the assimp team, nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior
  written permission of the assimp team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

----------------------------------------------------------------------
*/

/** @file  IFCLoad.cpp
 *  @brief Implementation of the Industry Foundation Classes loader.
 */


#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER

#include <iterator>
#include <limits>
#include <tuple>

#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
#   include <contrib/unzip/unzip.h>
#endif

#include "IFCLoader.h"
#include "STEPFileReader.h"

#include "IFCUtil.h"

#include "MemoryIOWrapper.h"
#include <assimp/scene.h>
#include <assimp/Importer.hpp>
#include <assimp/importerdesc.h>


namespace Assimp {
    template<> const std::string LogFunctions<IFCImporter>::log_prefix = "IFC: ";
}

using namespace Assimp;
using namespace Assimp::Formatter;
using namespace Assimp::IFC;

/* DO NOT REMOVE this comment block. The genentitylist.sh script
 * just looks for names adhering to the IfcSomething naming scheme
 * and includes all matches in the whitelist for code-generation. Thus,
 * all entity classes that are only indirectly referenced need to be
 * mentioned explicitly.

  IfcRepresentationMap
  IfcProductRepresentation
  IfcUnitAssignment
  IfcClosedShell
  IfcDoor

 */

namespace {


// forward declarations
void SetUnits(ConversionData& conv);
void SetCoordinateSpace(ConversionData& conv);
void ProcessSpatialStructures(ConversionData& conv);
void MakeTreeRelative(ConversionData& conv);
void ConvertUnit(const EXPRESS::DataType& dt,ConversionData& conv);

} // anon

static const aiImporterDesc desc = {
    "Industry Foundation Classes (IFC) Importer",
    "",
    "",
    "",
    aiImporterFlags_SupportBinaryFlavour,
    0,
    0,
    0,
    0,
    "ifc ifczip stp"
};


// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
IFCImporter::IFCImporter()
{}

// ------------------------------------------------------------------------------------------------
// Destructor, private as well
IFCImporter::~IFCImporter()
{
}

// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool IFCImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
{
    const std::string& extension = GetExtension(pFile);
    if (extension == "ifc" || extension == "ifczip" || extension == "stp" ) {
        return true;
    } else if ((!extension.length() || checkSig) && pIOHandler)   {
        // note: this is the common identification for STEP-encoded files, so
        // it is only unambiguous as long as we don't support any further
        // file formats with STEP as their encoding.
        const char* tokens[] = {"ISO-10303-21"};
        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
    }
    return false;
}

// ------------------------------------------------------------------------------------------------
// List all extensions handled by this loader
const aiImporterDesc* IFCImporter::GetInfo () const
{
    return &desc;
}


// ------------------------------------------------------------------------------------------------
// Setup configuration properties for the loader
void IFCImporter::SetupProperties(const Importer* pImp)
{
    settings.skipSpaceRepresentations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS,true);
    settings.useCustomTriangulation = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION,true);
    settings.conicSamplingAngle = std::min(std::max(pImp->GetPropertyFloat(AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE, AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE), 5.0f), 120.0f);
	settings.cylindricalTessellation = std::min(std::max(pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION, AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION), 3), 180);
	settings.skipAnnotations = true;
}


// ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure.
void IFCImporter::InternReadFile( const std::string& pFile,
    aiScene* pScene, IOSystem* pIOHandler)
{
    std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile));
    if (!stream) {
        ThrowException("Could not open file for reading");
    }


    // if this is a ifczip file, decompress its contents first
    if(GetExtension(pFile) == "ifczip") {
#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
        unzFile zip = unzOpen( pFile.c_str() );
        if(zip == NULL) {
            ThrowException("Could not open ifczip file for reading, unzip failed");
        }

        // chop 'zip' postfix
        std::string fileName = pFile.substr(0,pFile.length() - 3);

        std::string::size_type s = pFile.find_last_of('\\');
        if(s == std::string::npos) {
            s = pFile.find_last_of('/');
        }
        if(s != std::string::npos) {
            fileName = fileName.substr(s+1);
        }

        // search file (same name as the IFCZIP except for the file extension) and place file pointer there
        if(UNZ_OK == unzGoToFirstFile(zip)) {
            do {
                // get file size, etc.
                unz_file_info fileInfo;
                char filename[256];
                unzGetCurrentFileInfo( zip , &fileInfo, filename, sizeof(filename), 0, 0, 0, 0 );
                if (GetExtension(filename) != "ifc") {
                    continue;
                }
                uint8_t* buff = new uint8_t[fileInfo.uncompressed_size];
                LogInfo("Decompressing IFCZIP file");
                unzOpenCurrentFile( zip  );
                const int ret = unzReadCurrentFile( zip, buff, fileInfo.uncompressed_size);
                size_t filesize = fileInfo.uncompressed_size;
                if ( ret < 0 || size_t(ret) != filesize )
                {
                    delete[] buff;
                    ThrowException("Failed to decompress IFC ZIP file");
                }
                unzCloseCurrentFile( zip );
                stream.reset(new MemoryIOStream(buff,fileInfo.uncompressed_size,true));
                break;

                if (unzGoToNextFile(zip) == UNZ_END_OF_LIST_OF_FILE) {
                    ThrowException("Found no IFC file member in IFCZIP file (1)");
                }

            } while(true);
        }
        else {
            ThrowException("Found no IFC file member in IFCZIP file (2)");
        }

        unzClose(zip);
#else
        ThrowException("Could not open ifczip file for reading, assimp was built without ifczip support");
#endif
    }

    std::unique_ptr<STEP::DB> db(STEP::ReadFileHeader(stream));
    const STEP::HeaderInfo& head = static_cast<const STEP::DB&>(*db).GetHeader();

    if(!head.fileSchema.size() || head.fileSchema.substr(0,3) != "IFC") {
        ThrowException("Unrecognized file schema: " + head.fileSchema);
    }

    if (!DefaultLogger::isNullLogger()) {
        LogDebug("File schema is \'" + head.fileSchema + '\'');
        if (head.timestamp.length()) {
            LogDebug("Timestamp \'" + head.timestamp + '\'');
        }
        if (head.app.length()) {
            LogDebug("Application/Exporter identline is \'" + head.app  + '\'');
        }
    }

    // obtain a copy of the machine-generated IFC scheme
    EXPRESS::ConversionSchema schema;
    GetSchema(schema);

    // tell the reader which entity types to track with special care
    static const char* const types_to_track[] = {
        "ifcsite", "ifcbuilding", "ifcproject"
    };

    // tell the reader for which types we need to simulate STEPs reverse indices
    static const char* const inverse_indices_to_track[] = {
        "ifcrelcontainedinspatialstructure", "ifcrelaggregates", "ifcrelvoidselement", "ifcreldefinesbyproperties", "ifcpropertyset", "ifcstyleditem"
    };

    // feed the IFC schema into the reader and pre-parse all lines
    STEP::ReadFile(*db, schema, types_to_track, inverse_indices_to_track);
    const STEP::LazyObject* proj =  db->GetObject("ifcproject");
    if (!proj) {
        ThrowException("missing IfcProject entity");
    }

    ConversionData conv(*db,proj->To<IfcProject>(),pScene,settings);
    SetUnits(conv);
    SetCoordinateSpace(conv);
    ProcessSpatialStructures(conv);
    MakeTreeRelative(conv);

    // NOTE - this is a stress test for the importer, but it works only
    // in a build with no entities disabled. See
    //     scripts/IFCImporter/CPPGenerator.py
    // for more information.
    #ifdef ASSIMP_IFC_TEST
        db->EvaluateAll();
    #endif

    // do final data copying
    if (conv.meshes.size()) {
        pScene->mNumMeshes = static_cast<unsigned int>(conv.meshes.size());
        pScene->mMeshes = new aiMesh*[pScene->mNumMeshes]();
        std::copy(conv.meshes.begin(),conv.meshes.end(),pScene->mMeshes);

        // needed to keep the d'tor from burning us
        conv.meshes.clear();
    }

    if (conv.materials.size()) {
        pScene->mNumMaterials = static_cast<unsigned int>(conv.materials.size());
        pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials]();
        std::copy(conv.materials.begin(),conv.materials.end(),pScene->mMaterials);

        // needed to keep the d'tor from burning us
        conv.materials.clear();
    }

    // apply world coordinate system (which includes the scaling to convert to meters and a -90 degrees rotation around x)
    aiMatrix4x4 scale, rot;
    aiMatrix4x4::Scaling(static_cast<aiVector3D>(IfcVector3(conv.len_scale)),scale);
    aiMatrix4x4::RotationX(-AI_MATH_HALF_PI_F,rot);

    pScene->mRootNode->mTransformation = rot * scale * conv.wcs * pScene->mRootNode->mTransformation;

    // this must be last because objects are evaluated lazily as we process them
    if ( !DefaultLogger::isNullLogger() ){
        LogDebug((Formatter::format(),"STEP: evaluated ",db->GetEvaluatedObjectCount()," object records"));
    }
}

namespace {


// ------------------------------------------------------------------------------------------------
void ConvertUnit(const IfcNamedUnit& unit,ConversionData& conv)
{
    if(const IfcSIUnit* const si = unit.ToPtr<IfcSIUnit>()) {

        if(si->UnitType == "LENGTHUNIT") {
            conv.len_scale = si->Prefix ? ConvertSIPrefix(si->Prefix) : 1.f;
            IFCImporter::LogDebug("got units used for lengths");
        }
        if(si->UnitType == "PLANEANGLEUNIT") {
            if (si->Name != "RADIAN") {
                IFCImporter::LogWarn("expected base unit for angles to be radian");
            }
        }
    }
    else if(const IfcConversionBasedUnit* const convu = unit.ToPtr<IfcConversionBasedUnit>()) {

        if(convu->UnitType == "PLANEANGLEUNIT") {
            try {
                conv.angle_scale = convu->ConversionFactor->ValueComponent->To<EXPRESS::REAL>();
                ConvertUnit(*convu->ConversionFactor->UnitComponent,conv);
                IFCImporter::LogDebug("got units used for angles");
            }
            catch(std::bad_cast&) {
                IFCImporter::LogError("skipping unknown IfcConversionBasedUnit.ValueComponent entry - expected REAL");
            }
        }
    }
}

// ------------------------------------------------------------------------------------------------
void ConvertUnit(const EXPRESS::DataType& dt,ConversionData& conv)
{
    try {
        const EXPRESS::ENTITY& e = dt.To<ENTITY>();

        const IfcNamedUnit& unit = e.ResolveSelect<IfcNamedUnit>(conv.db);
        if(unit.UnitType != "LENGTHUNIT" && unit.UnitType != "PLANEANGLEUNIT") {
            return;
        }

        ConvertUnit(unit,conv);
    }
    catch(std::bad_cast&) {
        // not entity, somehow
        IFCImporter::LogError("skipping unknown IfcUnit entry - expected entity");
    }
}

// ------------------------------------------------------------------------------------------------
void SetUnits(ConversionData& conv)
{
    // see if we can determine the coordinate space used to express.
    for(size_t i = 0; i <  conv.proj.UnitsInContext->Units.size(); ++i ) {
        ConvertUnit(*conv.proj.UnitsInContext->Units[i],conv);
    }
}


// ------------------------------------------------------------------------------------------------
void SetCoordinateSpace(ConversionData& conv)
{
    const IfcRepresentationContext* fav = NULL;
    for(const IfcRepresentationContext& v : conv.proj.RepresentationContexts) {
        fav = &v;
        // Model should be the most suitable type of context, hence ignore the others
        if (v.ContextType && v.ContextType.Get() == "Model") {
            break;
        }
    }
    if (fav) {
        if(const IfcGeometricRepresentationContext* const geo = fav->ToPtr<IfcGeometricRepresentationContext>()) {
            ConvertAxisPlacement(conv.wcs, *geo->WorldCoordinateSystem, conv);
            IFCImporter::LogDebug("got world coordinate system");
        }
    }
}


// ------------------------------------------------------------------------------------------------
void ResolveObjectPlacement(aiMatrix4x4& m, const IfcObjectPlacement& place, ConversionData& conv)
{
    if (const IfcLocalPlacement* const local = place.ToPtr<IfcLocalPlacement>()){
        IfcMatrix4 tmp;
        ConvertAxisPlacement(tmp, *local->RelativePlacement, conv);

        m = static_cast<aiMatrix4x4>(tmp);

        if (local->PlacementRelTo) {
            aiMatrix4x4 tmp;
            ResolveObjectPlacement(tmp,local->PlacementRelTo.Get(),conv);
            m = tmp * m;
        }
    }
    else {
        IFCImporter::LogWarn("skipping unknown IfcObjectPlacement entity, type is " + place.GetClassName());
    }
}

// ------------------------------------------------------------------------------------------------
bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector< aiNode* >& subnodes_src, unsigned int matid, ConversionData& conv)
{
    // insert a custom node here, the cartesian transform operator is simply a conventional transformation matrix
    std::unique_ptr<aiNode> nd(new aiNode());
    nd->mName.Set("IfcMappedItem");

    // handle the Cartesian operator
    IfcMatrix4 m;
    ConvertTransformOperator(m, *mapped.MappingTarget);

    IfcMatrix4 msrc;
    ConvertAxisPlacement(msrc,*mapped.MappingSource->MappingOrigin,conv);

    msrc = m*msrc;

    std::vector<unsigned int> meshes;
    const size_t old_openings = conv.collect_openings ? conv.collect_openings->size() : 0;
    if (conv.apply_openings) {
        IfcMatrix4 minv = msrc;
        minv.Inverse();
        for(TempOpening& open :*conv.apply_openings){
            open.Transform(minv);
        }
    }

    unsigned int localmatid = ProcessMaterials(mapped.GetID(),matid,conv,false);
    const IfcRepresentation& repr = mapped.MappingSource->MappedRepresentation;

    bool got = false;
    for(const IfcRepresentationItem& item : repr.Items) {
        if(!ProcessRepresentationItem(item,localmatid,meshes,conv)) {
            IFCImporter::LogWarn("skipping mapped entity of type " + item.GetClassName() + ", no representations could be generated");
        }
        else got = true;
    }

    if (!got) {
        return false;
    }

    AssignAddedMeshes(meshes,nd.get(),conv);
    if (conv.collect_openings) {

        // if this pass serves us only to collect opening geometry,
        // make sure we transform the TempMesh's which we need to
        // preserve as well.
        if(const size_t diff = conv.collect_openings->size() - old_openings) {
            for(size_t i = 0; i < diff; ++i) {
                (*conv.collect_openings)[old_openings+i].Transform(msrc);
            }
        }
    }

    nd->mTransformation =  nd_src->mTransformation * static_cast<aiMatrix4x4>( msrc );
    subnodes_src.push_back(nd.release());

    return true;
}

// ------------------------------------------------------------------------------------------------
struct RateRepresentationPredicate {

    int Rate(const IfcRepresentation* r) const {
        // the smaller, the better

        if (! r->RepresentationIdentifier) {
            // neutral choice if no extra information is specified
            return 0;
        }


        const std::string& name = r->RepresentationIdentifier.Get();
        if (name == "MappedRepresentation") {
            if (!r->Items.empty()) {
                // take the first item and base our choice on it
                const IfcMappedItem* const m = r->Items.front()->ToPtr<IfcMappedItem>();
                if (m) {
                    return Rate(m->MappingSource->MappedRepresentation);
                }
            }
            return 100;
        }

        return Rate(name);
    }

    int Rate(const std::string& r) const {


        if (r == "SolidModel") {
            return -3;
        }

        // give strong preference to extruded geometry.
        if (r == "SweptSolid") {
            return -10;
        }

        if (r == "Clipping") {
            return -5;
        }

        // 'Brep' is difficult to get right due to possible voids in the
        // polygon boundaries, so take it only if we are forced to (i.e.
        // if the only alternative is (non-clipping) boolean operations,
        // which are not supported at all).
        if (r == "Brep") {
            return -2;
        }

        // Curves, bounding boxes - those will most likely not be loaded
        // as we can't make any use out of this data. So consider them
        // last.
        if (r == "BoundingBox" || r == "Curve2D") {
            return 100;
        }
        return 0;
    }

    bool operator() (const IfcRepresentation* a, const IfcRepresentation* b) const {
        return Rate(a) < Rate(b);
    }
};

// ------------------------------------------------------------------------------------------------
void ProcessProductRepresentation(const IfcProduct& el, aiNode* nd, std::vector< aiNode* >& subnodes, ConversionData& conv)
{
    if(!el.Representation) {
        return;
    }

    // extract Color from metadata, if present
    unsigned int matid = ProcessMaterials( el.GetID(), std::numeric_limits<uint32_t>::max(), conv, false);
    std::vector<unsigned int> meshes;

    // we want only one representation type, so bring them in a suitable order (i.e try those
    // that look as if we could read them quickly at first). This way of reading
    // representation is relatively generic and allows the concrete implementations
    // for the different representation types to make some sensible choices what
    // to load and what not to load.
    const STEP::ListOf< STEP::Lazy< IfcRepresentation >, 1, 0 >& src = el.Representation.Get()->Representations;
    std::vector<const IfcRepresentation*> repr_ordered(src.size());
    std::copy(src.begin(),src.end(),repr_ordered.begin());
    std::sort(repr_ordered.begin(),repr_ordered.end(),RateRepresentationPredicate());
    for(const IfcRepresentation* repr : repr_ordered) {
        bool res = false;
        for(const IfcRepresentationItem& item : repr->Items) {
            if(const IfcMappedItem* const geo = item.ToPtr<IfcMappedItem>()) {
                res = ProcessMappedItem(*geo,nd,subnodes,matid,conv) || res;
            }
            else {
                res = ProcessRepresentationItem(item,matid,meshes,conv) || res;
            }
        }
        // if we got something meaningful at this point, skip any further representations
        if(res) {
            break;
        }
    }
    AssignAddedMeshes(meshes,nd,conv);
}

typedef std::map<std::string, std::string> Metadata;

// ------------------------------------------------------------------------------------------------
void ProcessMetadata(const ListOf< Lazy< IfcProperty >, 1, 0 >& set, ConversionData& conv, Metadata& properties,
    const std::string& prefix = "",
    unsigned int nest = 0)
{
    for(const IfcProperty& property : set) {
        const std::string& key = prefix.length() > 0 ? (prefix + "." + property.Name) : property.Name;
        if (const IfcPropertySingleValue* const singleValue = property.ToPtr<IfcPropertySingleValue>()) {
            if (singleValue->NominalValue) {
                if (const EXPRESS::STRING* str = singleValue->NominalValue.Get()->ToPtr<EXPRESS::STRING>()) {
                    std::string value = static_cast<std::string>(*str);
                    properties[key]=value;
                }
                else if (const EXPRESS::REAL* val = singleValue->NominalValue.Get()->ToPtr<EXPRESS::REAL>()) {
                    float value = static_cast<float>(*val);
                    std::stringstream s;
                    s << value;
                    properties[key]=s.str();
                }
                else if (const EXPRESS::INTEGER* val = singleValue->NominalValue.Get()->ToPtr<EXPRESS::INTEGER>()) {
                    int64_t value = static_cast<int64_t>(*val);
                    std::stringstream s;
                    s << value;
                    properties[key]=s.str();
                }
            }
        }
        else if (const IfcPropertyListValue* const listValue = property.ToPtr<IfcPropertyListValue>()) {
            std::stringstream ss;
            ss << "[";
            unsigned index=0;
            for(const IfcValue::Out& v : listValue->ListValues) {
                if (!v) continue;
                if (const EXPRESS::STRING* str = v->ToPtr<EXPRESS::STRING>()) {
                    std::string value = static_cast<std::string>(*str);
                    ss << "'" << value << "'";
                }
                else if (const EXPRESS::REAL* val = v->ToPtr<EXPRESS::REAL>()) {
                    float value = static_cast<float>(*val);
                    ss << value;
                }
                else if (const EXPRESS::INTEGER* val = v->ToPtr<EXPRESS::INTEGER>()) {
                    int64_t value = static_cast<int64_t>(*val);
                    ss << value;
                }
                if (index+1<listValue->ListValues.size()) {
                    ss << ",";
                }
                index++;
            }
            ss << "]";
            properties[key]=ss.str();
        }
        else if (const IfcComplexProperty* const complexProp = property.ToPtr<IfcComplexProperty>()) {
            if(nest > 2) { // mostly arbitrary limit to prevent stack overflow vulnerabilities
                IFCImporter::LogError("maximum nesting level for IfcComplexProperty reached, skipping this property.");
            }
            else {
                ProcessMetadata(complexProp->HasProperties, conv, properties, key, nest + 1);
            }
        }
        else {
            properties[key]="";
        }
    }
}


// ------------------------------------------------------------------------------------------------
void ProcessMetadata(uint64_t relDefinesByPropertiesID, ConversionData& conv, Metadata& properties)
{
    if (const IfcRelDefinesByProperties* const pset = conv.db.GetObject(relDefinesByPropertiesID)->ToPtr<IfcRelDefinesByProperties>()) {
        if (const IfcPropertySet* const set = conv.db.GetObject(pset->RelatingPropertyDefinition->GetID())->ToPtr<IfcPropertySet>()) {
            ProcessMetadata(set->HasProperties, conv, properties);
        }
    }
}

// ------------------------------------------------------------------------------------------------
aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, ConversionData& conv, std::vector<TempOpening>* collect_openings = NULL)
{
    const STEP::DB::RefMap& refs = conv.db.GetRefs();

    // skip over space and annotation nodes - usually, these have no meaning in Assimp's context
    bool skipGeometry = false;
    if(conv.settings.skipSpaceRepresentations) {
        if(el.ToPtr<IfcSpace>()) {
            IFCImporter::LogDebug("skipping IfcSpace entity due to importer settings");
            skipGeometry = true;
        }
    }

    if(conv.settings.skipAnnotations) {
        if(el.ToPtr<IfcAnnotation>()) {
            IFCImporter::LogDebug("skipping IfcAnnotation entity due to importer settings");
            return NULL;
        }
    }

    // add an output node for this spatial structure
    std::unique_ptr<aiNode> nd(new aiNode());
    nd->mName.Set(el.GetClassName()+"_"+(el.Name?el.Name.Get():"Unnamed")+"_"+el.GlobalId);
    nd->mParent = parent;

    conv.already_processed.insert(el.GetID());

    // check for node metadata
    STEP::DB::RefMapRange children = refs.equal_range(el.GetID());
    if (children.first!=refs.end()) {
        Metadata properties;
        if (children.first==children.second) {
            // handles single property set
            ProcessMetadata((*children.first).second, conv, properties);
        }
        else {
            // handles multiple property sets (currently all property sets are merged,
            // which may not be the best solution in the long run)
            for (STEP::DB::RefMap::const_iterator it=children.first; it!=children.second; ++it) {
                ProcessMetadata((*it).second, conv, properties);
            }
        }

        if (!properties.empty()) {
            aiMetadata* data = aiMetadata::Alloc( static_cast<unsigned int>(properties.size()) );
            unsigned int index( 0 );
            for ( const Metadata::value_type& kv : properties ) {
                data->Set( index++, kv.first, aiString( kv.second ) );
            }
            nd->mMetaData = data;
        }
    }

    if(el.ObjectPlacement) {
        ResolveObjectPlacement(nd->mTransformation,el.ObjectPlacement.Get(),conv);
    }

    std::vector<TempOpening> openings;

    IfcMatrix4 myInv;
    bool didinv = false;

    // convert everything contained directly within this structure,
    // this may result in more nodes.
    std::vector< aiNode* > subnodes;
    try {
        // locate aggregates and 'contained-in-here'-elements of this spatial structure and add them in recursively
        // on our way, collect openings in *this* element
        STEP::DB::RefMapRange range = refs.equal_range(el.GetID());

        for(STEP::DB::RefMapRange range2 = range; range2.first != range.second; ++range2.first) {
            // skip over meshes that have already been processed before. This is strictly necessary
            // because the reverse indices also include references contained in argument lists and
            // therefore every element has a back-reference hold by its parent.
            if (conv.already_processed.find((*range2.first).second) != conv.already_processed.end()) {
                continue;
            }
            const STEP::LazyObject& obj = conv.db.MustGetObject((*range2.first).second);

            // handle regularly-contained elements
            if(const IfcRelContainedInSpatialStructure* const cont = obj->ToPtr<IfcRelContainedInSpatialStructure>()) {
                if(cont->RelatingStructure->GetID() != el.GetID()) {
                    continue;
                }
                for(const IfcProduct& pro : cont->RelatedElements) {
                    if(pro.ToPtr<IfcOpeningElement>()) {
                        // IfcOpeningElement is handled below. Sadly we can't use it here as is:
                        // The docs say that opening elements are USUALLY attached to building storey,
                        // but we want them for the building elements to which they belong.
                        continue;
                    }

                    aiNode* const ndnew = ProcessSpatialStructure(nd.get(),pro,conv,NULL);
                    if(ndnew) {
                        subnodes.push_back( ndnew );
                    }
                }
            }
            // handle openings, which we collect in a list rather than adding them to the node graph
            else if(const IfcRelVoidsElement* const fills = obj->ToPtr<IfcRelVoidsElement>()) {
                if(fills->RelatingBuildingElement->GetID() == el.GetID()) {
                    const IfcFeatureElementSubtraction& open = fills->RelatedOpeningElement;

                    // move opening elements to a separate node since they are semantically different than elements that are just 'contained'
                    std::unique_ptr<aiNode> nd_aggr(new aiNode());
                    nd_aggr->mName.Set("$RelVoidsElement");
                    nd_aggr->mParent = nd.get();

                    nd_aggr->mTransformation = nd->mTransformation;

                    std::vector<TempOpening> openings_local;
                    aiNode* const ndnew = ProcessSpatialStructure( nd_aggr.get(),open, conv,&openings_local);
                    if (ndnew) {

                        nd_aggr->mNumChildren = 1;
                        nd_aggr->mChildren = new aiNode*[1]();


                        nd_aggr->mChildren[0] = ndnew;

                        if(openings_local.size()) {
                            if (!didinv) {
                                myInv = aiMatrix4x4(nd->mTransformation ).Inverse();
                                didinv = true;
                            }

                            // we need all openings to be in the local space of *this* node, so transform them
                            for(TempOpening& op :openings_local) {
                                op.Transform( myInv*nd_aggr->mChildren[0]->mTransformation);
                                openings.push_back(op);
                            }
                        }
                        subnodes.push_back( nd_aggr.release() );
                    }
                }
            }
        }

        for(;range.first != range.second; ++range.first) {
            // see note in loop above
            if (conv.already_processed.find((*range.first).second) != conv.already_processed.end()) {
                continue;
            }
            if(const IfcRelAggregates* const aggr = conv.db.GetObject((*range.first).second)->ToPtr<IfcRelAggregates>()) {
                if(aggr->RelatingObject->GetID() != el.GetID()) {
                    continue;
                }

                // move aggregate elements to a separate node since they are semantically different than elements that are just 'contained'
                std::unique_ptr<aiNode> nd_aggr(new aiNode());
                nd_aggr->mName.Set("$RelAggregates");
                nd_aggr->mParent = nd.get();

                nd_aggr->mTransformation = nd->mTransformation;

                nd_aggr->mChildren = new aiNode*[aggr->RelatedObjects.size()]();
                for(const IfcObjectDefinition& def : aggr->RelatedObjects) {
                    if(const IfcProduct* const prod = def.ToPtr<IfcProduct>()) {

                        aiNode* const ndnew = ProcessSpatialStructure(nd_aggr.get(),*prod,conv,NULL);
                        if(ndnew) {
                            nd_aggr->mChildren[nd_aggr->mNumChildren++] = ndnew;
                        }
                    }
                }

                subnodes.push_back( nd_aggr.release() );
            }
        }

        conv.collect_openings = collect_openings;
        if(!conv.collect_openings) {
            conv.apply_openings = &openings;
        }

        if (!skipGeometry) {
          ProcessProductRepresentation(el,nd.get(),subnodes,conv);
          conv.apply_openings = conv.collect_openings = NULL;
        }

        if (subnodes.size()) {
            nd->mChildren = new aiNode*[subnodes.size()]();
            for(aiNode* nd2 : subnodes) {
                nd->mChildren[nd->mNumChildren++] = nd2;
                nd2->mParent = nd.get();
            }
        }
    }
    catch(...) {
        // it hurts, but I don't want to pull boost::ptr_vector into -noboost only for these few spots here
        std::for_each(subnodes.begin(),subnodes.end(),delete_fun<aiNode>());
        throw;
    }

    ai_assert(conv.already_processed.find(el.GetID()) != conv.already_processed.end());
    conv.already_processed.erase(conv.already_processed.find(el.GetID()));
    return nd.release();
}

// ------------------------------------------------------------------------------------------------
void ProcessSpatialStructures(ConversionData& conv)
{
    // XXX add support for multiple sites (i.e. IfcSpatialStructureElements with composition == COMPLEX)


    // process all products in the file. it is reasonable to assume that a
    // file that is relevant for us contains at least a site or a building.
    const STEP::DB::ObjectMapByType& map = conv.db.GetObjectsByType();

    ai_assert(map.find("ifcsite") != map.end());
    const STEP::DB::ObjectSet* range = &map.find("ifcsite")->second;

    if (range->empty()) {
        ai_assert(map.find("ifcbuilding") != map.end());
        range = &map.find("ifcbuilding")->second;
        if (range->empty()) {
            // no site, no building -  fail;
            IFCImporter::ThrowException("no root element found (expected IfcBuilding or preferably IfcSite)");
        }
    }

	std::vector<aiNode*> nodes;

    for(const STEP::LazyObject* lz : *range) {
        const IfcSpatialStructureElement* const prod = lz->ToPtr<IfcSpatialStructureElement>();
        if(!prod) {
            continue;
        }
        IFCImporter::LogDebug("looking at spatial structure `" + (prod->Name ? prod->Name.Get() : "unnamed") + "`" + (prod->ObjectType? " which is of type " + prod->ObjectType.Get():""));

        // the primary sites are referenced by an IFCRELAGGREGATES element which assigns them to the IFCPRODUCT
        const STEP::DB::RefMap& refs = conv.db.GetRefs();
        STEP::DB::RefMapRange ref_range = refs.equal_range(conv.proj.GetID());
        for(; ref_range.first != ref_range.second; ++ref_range.first) {
            if(const IfcRelAggregates* const aggr = conv.db.GetObject((*ref_range.first).second)->ToPtr<IfcRelAggregates>()) {

                for(const IfcObjectDefinition& def : aggr->RelatedObjects) {
                    // comparing pointer values is not sufficient, we would need to cast them to the same type first
                    // as there is multiple inheritance in the game.
                    if (def.GetID() == prod->GetID()) {
                        IFCImporter::LogDebug("selecting this spatial structure as root structure");
                        // got it, this is one primary site.
						nodes.push_back(ProcessSpatialStructure(NULL, *prod, conv, NULL));
                    }
                }

            }
        }
    }

	size_t nb_nodes = nodes.size();

	if (nb_nodes == 0) {
		IFCImporter::LogWarn("failed to determine primary site element, taking all the IfcSite");
		for (const STEP::LazyObject* lz : *range) {
			const IfcSpatialStructureElement* const prod = lz->ToPtr<IfcSpatialStructureElement>();
			if (!prod) {
				continue;
			}

			nodes.push_back(ProcessSpatialStructure(NULL, *prod, conv, NULL));
		}

		nb_nodes = nodes.size();
	}

	if (nb_nodes == 1) {
		conv.out->mRootNode = nodes[0];
	}
	else if (nb_nodes > 1) {
		conv.out->mRootNode = new aiNode("Root");
		conv.out->mRootNode->mParent = NULL;
		conv.out->mRootNode->mNumChildren = static_cast<unsigned int>(nb_nodes);
		conv.out->mRootNode->mChildren = new aiNode*[conv.out->mRootNode->mNumChildren];
		
		for (size_t i = 0; i < nb_nodes; ++i) {
			aiNode* node = nodes[i];

			node->mParent = conv.out->mRootNode;

			conv.out->mRootNode->mChildren[i] = node;
		}
	}
	else {
		IFCImporter::ThrowException("failed to determine primary site element");
	}
}

// ------------------------------------------------------------------------------------------------
void MakeTreeRelative(aiNode* start, const aiMatrix4x4& combined)
{
    // combined is the parent's absolute transformation matrix
    const aiMatrix4x4 old = start->mTransformation;

    if (!combined.IsIdentity()) {
        start->mTransformation = aiMatrix4x4(combined).Inverse() * start->mTransformation;
    }

    // All nodes store absolute transformations right now, so we need to make them relative
    for (unsigned int i = 0; i < start->mNumChildren; ++i) {
        MakeTreeRelative(start->mChildren[i],old);
    }
}

// ------------------------------------------------------------------------------------------------
void MakeTreeRelative(ConversionData& conv)
{
    MakeTreeRelative(conv.out->mRootNode,IfcMatrix4());
}

} // !anon



#endif