Change signature of attribute setters to take and return boost::optionals

Remove set- prefix for setters
2026-08-07 16:31:37 +00:00 · 2015-03-20 21:11:46 +00:00
325 changed files with 162342 additions and 292589 deletions
@@ -1,16 +0,0 @@
-# Dependency and build folders created by the build scripts
-/deps*/
-/build*/
-/install*/
-/win/BuildDepsCache*.txt
-# IfcExpressParser residue
-/src/ifcexpressparser/express_parser.py
-# General Python residue
-__pycache__
-*.py.bak
-# Visual Studio Code files
-.vscode
-# PyCharm files
-.idea
-# OSX files
-.DS_Store
@@ -1,7 +0,0 @@
-[submodule "test/input"]
-	path = test/input
-	url = https://github.com/IfcOpenShell/files
-	ignore = dirty
-[submodule "src/ifcopenshell-python/ifcopenshell/mvd"]
-	path = src/ifcopenshell-python/ifcopenshell/mvd
-	url = https://github.com/opensourceBIM/python-mvdxml/
@@ -1,68 +0,0 @@
-language: cpp
-compiler:
-  - gcc
-  - clang
-os: linux
-dist: bionic
-sudo: required
-
-before_install:
-  - "sudo add-apt-repository -y ppa:freecad-community/ppa"
-  - sudo apt-get update -qq
-
-
-install:
-  - |
-    sudo apt-get install -y \
-    libocct-data-exchange-dev libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev \
-    libboost-system-dev libboost-program-options-dev libboost-regex-dev libboost-thread-dev libboost-date-time-dev libboost-iostreams-dev libboost-filesystem-dev \
-    build-essential cmake python2.7 libpython2.7-dev swig zlib1g liblzma5 opencollada-dev wget apt-transport-https
-  - sudo mkdir -p /usr/include/json/nlohmann/
-  - sudo wget https://github.com/nlohmann/json/releases/download/v3.6.1/json.hpp -O /usr/include/json/nlohmann/json.hpp
-  - sudo sh -c 'curl https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add -'
-  - sudo sh -c 'curl https://storage.googleapis.com/download.dartlang.org/linux/debian/dart_stable.list > /etc/apt/sources.list.d/dart_stable.list'
-  - sudo apt-get update -qq && sudo apt-get install -y dart
-  - export PATH=$PATH:/usr/lib/dart/bin:$HOME/.pub-cache/bin
-  - git clone https://github.com/KhronosGroup/glTF-Validator && pushd glTF-Validator && pub get && pub global activate --source path ./ && popd
-
-script:
-  - pwd
-  - cd cmake
-  - mkdir build
-  - cd build
-  - |
-    cmake \
-    -DOCC_INCLUDE_DIR=/usr/include/opencascade \
-    -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
-    -DPYTHON_LIBRARY=/usr/lib/python2.7/config-x86_64-linux-gnu/libpython2.7.so \
-    -DPYTHON_INCLUDE_DIR=/usr/include/python2.7 \
-    -DPYTHON_EXECUTABLE=/usr/bin/python2.7 \
-    -DLIBXML2_INCLUDE_DIR=/usr/include/libxml2 \
-    -DLIBXML2_LIBRARIES="/usr/lib/x86_64-linux-gnu/libxml2.a;/lib/x86_64-linux-gnu/libz.so.1;/lib/x86_64-linux-gnu/liblzma.so.5;/usr/lib/x86_64-linux-gnu/libicuuc.so;/usr/lib/x86_64-linux-gnu/libicudata.so" \
-    -DGLTF_SUPPORT=On \
-    -DJSON_INCLUDE_DIR=/usr/include/json \
-    ..
-  - sudo make -j2 install
-    
-  - cd ../../test
-  - /usr/bin/python2.7 tests.py
-
-  - cd input
-  
-  - /usr/local/bin/IfcConvert -yv acad2010_walls.ifc acad2010_walls.glb
-  - gltf_validator acad2010_walls.glb
-  
-  - python -c "from __future__ import print_function; from io import open; import ifcopenshell; f = ifcopenshell.open('encoding.ifc'); print(f[1][0], file=open('encoding.txt', 'w', encoding='utf-8'))" && grep "'a' 1m³ ≤ 5m³ ≥ 10m³" encoding.txt
-  
-  - |
-    (for i in *.ifc; do \
-    echo $i | tee -a log; \
-    timeout 1m /usr/local/bin/IfcConvert -yv "$i" "$i.dae" --validate >> log 2>&1; \
-    echo $i $? >> statuses; \
-    done) || true
-  - echo Failed
-  - grep -v 0$ statuses
-  - grep -v 0$ statuses | wc -l
-  - echo Succeeded
-  - grep 0$ statuses
-  - grep 0$ statuses | wc -l
@@ -0,0 +1,65 @@
+IfcOpenShell 
+============
+open source (LGPL) software library for working with the IFC file format
+
+
+http://IfcOpenShell.org
+
+
+Compiling on Windows
+====================
+Users are advised to use the Visual Studio .sln file in the win/ folder.
+For Windows users a prebuilt Open CASCADE version is available from the
+http://opencascade.org website. Download and install this version and
+provide the paths to the Open CASCADE header and library files to MS
+Visual Studio C++.
+
+For building the Autodesk 3ds Max plugin, the 3ds Max SDK needs to be
+installed as well as 3ds Max itself. Please provide the include and
+library paths to Visual Studio.
+
+For building the IfcPython wrapper, SWIG needs to be installed. Please
+download the latest swigwin version from http://www.swig.org/download.html.
+After extracting the .zip file, please add the extracted folder to the PATH
+environment variable. Python needs to be installed, please provide the
+include and library paths to Visual Studio.
+
+
+
+Compiling on *nix
+====================
+Users are advised to build IfcOpenShell using the cmake file provided in
+the cmake/ folder. There might be an Open CASCADE package in your operating
+system's software repository. If not, you will need to compile Open 
+CASCADE yourself. See http://opencascade.org.
+
+For building the IfcPython wrapper, SWIG and Python development are
+required.
+
+To build IfcOpenShell please take the following steps:
+$ cd /path/to/IfcOpenShell/cmake
+$ mkdir build
+$ cd build
+Optionally:
+  $ OCC_INCLUDE_PATH="/path/to/OpenCASCADE/include"
+  $ OCC_LIBRARY_PATH="/path/to/OpenCASCADE/lib"
+  $ export OCC_INCLUDE_PATH
+  $ export OCC_LIBRARY_PATH
+$ cmake ../
+$ make
+
+If all worked out correctly you can now use IfcOpenShell. For example:
+$ wget ftp://ftp.dds.no/pub/ifc/Munkerud/Munkerud_hus6_BE.zip
+$ unzip Munkerud_hus6_BE.zip
+$ ./IfcObj Munkerud_hus6_BE.ifc
+$ less Munkerud_hus6_BE.obj
+Or:
+$ wget ftp://ftp.dds.no/pub/ifc/Munkerud/Munkerud_hus6_BE.zip
+$ unzip Munkerud_hus6_BE.zip
+$ python
+>>> import IfcImport
+>>> IfcImport.Init('Munkerud_hus6_BE.ifc')
+>>> geom = IfcImport.Get()
+>>> geom.name
+>>> for v in geom.mesh.verts: v
+
@@ -1,226 +0,0 @@
-IfcOpenShell 
-============
-IfcOpenShell is an open source ([LGPL]) software library for working with the Industry Foundation Classes ([IFC]) 
-file format. Currently supported IFC releases are [IFC2x3 TC1] and [IFC4 Add2 TC1].
-
-For more information, see
-* [http://ifcopenshell.org](http://ifcopenshell.org)  
-* [http://academy.ifcopenshell.org](http://academy.ifcopenshell.org)
-
-[![Build Status](https://api.travis-ci.org/IfcOpenShell/IfcOpenShell.png)](https://api.travis-ci.org/IfcOpenShell/IfcOpenShell)
-
-Prerequisites
-------------
-* Git
-* CMake (2.6 or newer)
-* Windows: [Visual Studio] 2008 or newer with C++ toolset (or [Visual C++ Build Tools]) or [MSYS2] + MinGW
-* *nix: GCC 4.7 or newer, or Clang (any version)
-
-Dependencies
-------------
-* [Boost](http://www.boost.org/)
-* [Open Cascade](http://opencascade.org) - *optional*, but required for building IfcGeom
-  ([official](http://www.opencascade.org/getocc/download/loadocc/), "OCCT", or [community edition](https://github.com/tpaviot/oce), "OCE")  
-  For converting IFC representation items into BRep solids and tesselated meshes
-* [OpenCOLLADA](https://github.com/khronosGroup/OpenCOLLADA/) - *optional*  
-  For IfcConvert to be able to write tessellated Collada (.dae) files
-* [SWIG](http://www.swig.org/) and [Python](https://www.python.org/) - *optional*  
-  For building the IfcOpenShell Python interface and the Blender add-on
-* [3ds Max SDK](http://www.autodesk.com/products/3ds-max/free-trial) - *optional*  
-  For building the 3ds Max plug-in.
-  All recent versions of 3ds Max (2014 and newer) are 64-bit only, so a 64-bit installation is assumed.
-
-Building IfcOpenShell
---------------------
-
-**Note:** The path where the source code is cloned to can contain spaces but non-ASCII characters are very likely to cause problems with the build.
-
-### Compiling on Windows
-The preferred way to fetch and build this project's dependencies is to use the build scripts
-in win/ folder. **See [win/readme.md] for more information**.
-
-#### Using Visual Studio
-Instructions in a nutshell (**assuming Visual Studio 2015 x64 environment variables set**):
-
-    > cd IfcOpenShell\win
-    > build-deps.cmd
-    > run-cmake.bat
-
-You can now open and build the solution file in Visual Studio:
-
-    > ..\build-vs2015-x64\IfcOpenShell.sln
-
-As the scripts default to using the `RelWithDebInfo` configuration, and a freshly created solution by CMake defaults
-to `Debug`, make sure to switch the used build configuration. Build the `INSTALL` project (right-click -> Project
-Only) to deploy the headers and binaries into a single location if wanted/needed.
-
-Alternatively, one can use the utility batch file(s) to build and install the project easily from the command-line
-(installing a project will build it also, if required):
-
-    > install-ifcopenshell.bat
-
-#### Using MSYS2 + MinGW
-
-Start the MSYS2 Shell and then:
-
-    $ cd IfcOpenShell/win
-    $ ./build-deps.sh
-    $ ./run-cmake.sh
-    $ ./install-ifcopenshell.sh
-
-#### Using Bash on Ubuntu on Windows
-
-Start Bash on Ubuntu on Windows and follow the instructions below. Compiling on Ubuntu 14.04.4 LTS using GCC 4.8.4
-or Clang 3.5 has been confirmed to work.
-
-### Compiling on *nix
-
-The following instructions are for Ubuntu, modify as required for other operating systems. [nix/build-all.py] script
-can be experimented with and studied for pointers for other operating systems, but note that this script is not currently
-meant to be used for a typical IfcOpenShell workspace setup.
-
-Note: where `make -j` is written, add a number roughly equal to the amount of CPU cores + 1.
-
-**1)** Install most of the prerequisites and dependencies:
-
-    $ sudo apt-get install git cmake gcc g++ libboost-all-dev
-
-**2a)** Either use an OCE package from your operating system's software repository
-
-    $ sudo apt-get install liboce-foundation-dev liboce-modeling-dev liboce-ocaf-dev liboce-visualization-dev liboce-ocaf-lite-dev
-
-**2b)** or (if not available, or the latest code is wanted) compile OCE yourself (note that the build takes a long time):
-
-    $ sudo apt-get install libftgl-dev libtbb2 libtbb-dev libgl1-mesa-dev libfreetype6-dev
-    $ git clone https://github.com/tpaviot/oce.git
-    $ cd oce
-    $ mkdir build && cd build
-    $ cmake ..
-    $ make -j
-    $ sudo make install
-
-**2c)** or obtain and compile OCCT from http://www.opencascade.org/getocc/download/loadocc/
-
-**3)** For building IfcConvert with COLLADA (.dae) support (on by default), OpenCOLLADA is needed:
-
-    $ sudo apt-get install libpcre3-dev libxml2-dev
-    $ git clone https://github.com/KhronosGroup/OpenCOLLADA.git
-    $ cd OpenCOLLADA
-    Using a known good revision, but HEAD should work too:
-    $ git checkout 064a60b65c2c31b94f013820856bc84fb1937cc6
-    $ mkdir build && cd build
-    $ cmake ..
-    $ make -j
-    $ sudo make install
-
-**4)** For building the IfcPython wrapper (on by default), SWIG and Python development are needed, if not already available:
-
-    $ sudo apt-get install python-all-dev swig
-
-**5)** To build IfcOpenShell please take the following steps. Alternatively use environment variables for setting the
-dependencies' paths. `OCC_INCLUDE_DIR` might be needed to set also. `OPENCOLLADA_INCLUDE_DIR` and `OPENCOLLADA_LIBRARY_DIR`
-(and potentially `PCRE_LIBRARY_DIR`) are needed if building with COLLADA support. (`-DCOLLADA_SUPPORT=0` disables it).
-
-    $ cd /path/to/IfcOpenShell
-    $ mkdir build && cd build
-    $ cmake ../cmake -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu/ \
-          -DOPENCOLLADA_INCLUDE_DIR="/usr/local/include/opencollada" \
-          -DOPENCOLLADA_LIBRARY_DIR="/usr/local/lib/opencollada"  \
-          -DPCRE_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu/
-    $ make -j
-
-If all worked out correctly you can now use IfcOpenShell. See the examples below.
-
-**6)** Install the project if wanted:
-
-    $ sudo make install
-
-Installing IfcOpenShell with Conda
----------------------------------
-Another option for building and installing IfcOpenShell is to use the popular
-[Anaconda Python Distribution](https://www.anaconda.com/download).
-The requirements are spread across a number of channels.
-You can add these channels to your configuration, or specify them all on the command line:
-
-    $ conda install -c conda-forge -c oce -c dlr-sc -c ifcopenshell ifcopenshell
-
-Usage examples
--------------
-
-**Invoking IfcConvert from the command line**
-
-    $ wget ftp://ftp.dds.no/pub/ifc/Munkerud/Munkerud_hus6_BE.zip
-    $ unzip Munkerud_hus6_BE.zip
-    $ ./IfcConvert Munkerud_hus6_BE.ifc
-    $ less Munkerud_hus6_BE.obj
-
-**Using the IfcOpenShell Python interface**
-
-    $ wget -O duplex.zip http://projects.buildingsmartalliance.org/files/?artifact_id=4278
-    $ unzip duplex.zip
-    $ python
-    >>> import ifcopenshell
-    >>> f = ifcopenshell.open("Duplex_A_20110907_optimized.ifc")
-    >>>
-    >>> # Accessing entity instances by type:
-    >>> f.by_type("ifcwall")[:2]
-    [#91=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FL9r',#1,'Basic Wall:Interior - Partition (92mm Stud):144586',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5198,#18806,'144586'), #92=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FLIE',#1,'Basic Wall:Interior - Partition (92mm Stud):143921',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5206,#18805,'143921')]
-    >>> wall = _[0]
-    >>> len(wall) # number of EXPRESS attributes
-    8
-    >>>
-    >>> # Accessing EXPRESS attributes by name:
-    >>> wall.GlobalId 
-    '2O2Fr$t4X7Zf8NOew3FL9r'
-    >>> wall.Name = "My wall"
-    >>> wall.NonExistingAttr
-    Traceback (most recent call last):
-      File "<stdin>", line 1, in <module>
-      File ".\ifcopenshell.py", line 14, in __getattr__
-        except: raise AttributeError("entity instance of type '%s' has no attribute'%s'"%(self.wrapped_data.is_a(), name)) from None
-    AttributeError: entity instance of type 'IfcWallStandardCase' has no attribute 'NonExistingAttr'
-    >>> wall.GlobalId = 3
-    Traceback (most recent call last):
-      File "<stdin>", line 1, in <module>
-      File ".\ifcopenshell.py", line 26, in __setattr__
-        self[self.wrapped_data.get_argument_index(key)] = value
-      File ".\ifcopenshell.py", line 30, in __setitem__
-        self.wrapped_data.set_argument(idx, entity_instance.map_value(value))
-      File ".\ifc_wrapper.py", line 118, in <lambda>
-        set_argument = lambda self,x,y: self._set_argument(x) if y is None else self
-    ._set_argument(x,y)
-      File ".\ifc_wrapper.py", line 114, in _set_argument
-        def _set_argument(self, *args): return _ifc_wrapper.entity_instance__set_argument(self, *args)
-    RuntimeError: INT is not a valid type for 'GlobalId'
-    >>> # Creating new entity instances
-    >>> f.createIfcCartesianPoint(Coordinates=(1.0,1.5,2.0))
-    #27530=IfcCartesianPoint((1.,1.5,2.))
-    >>> 
-    >>> # Working with GlobalId attributes:
-    >>> import uuid
-    >>> ifcopenshell.guid.compress(uuid.uuid1().hex)
-    '3x4C8Q_6qHuv$P$FYkANRX'
-    >>> new_guid = _
-    >>> owner_hist = f.by_type("IfcOwnerHistory")[0]
-    >>> new_wall = f.createIfcWallStandardCase(new_guid, owner_hist, None, None, Tag='my_tag')
-    >>> new_wall.ObjectType = ''
-    >>> new_wall.ObjectPlacement = new_wall.Representation = None
-    >>>
-    >>> # Accessing entity instances by instance id or GlobalId:
-    >>> f[92]
-    #92=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FLIE',#1,'Basic Wall:Interior - Partition (92mm Stud):143921',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5206,#18805,'143921')
-    >>> f['2O2Fr$t4X7Zf8NOew3FLIE']
-    #92=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FLIE',#1,'Basic Wall:Interior - Partition (92mm Stud):143921',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5206,#18805,'143921')
-    >>>
-    >>> # Writing IFC-SPF files to disk:
-    >>> f.write("out.ifc")
-
-[LGPL]: https://github.com/IfcOpenShell/IfcOpenShell/tree/master/COPYING "LGPL"
-[IFC]: http://www.buildingsmart-tech.org/specifications/ifc-overview "IFC"
-[IFC2x3 TC1]: http://www.buildingsmart-tech.org/specifications/ifc-releases/ifc2x3-tc1-release "IFC2x3 TC1"
-[IFC4 Add1]: http://www.buildingsmart-tech.org/specifications/ifc-releases/ifc4-add1-release "IFC4 Add1"
-[Visual Studio]: https://www.visualstudio.com/ "Visual Studio"
-[Visual C++ Build Tools]: http://landinghub.visualstudio.com/visual-cpp-build-tools "Visual C++ Build Tools"
-[MSYS2]: https://msys2.github.io/ "MSYS2"
-[win/readme.md]: https://github.com/IfcOpenShell/IfcOpenShell/tree/master/win/readme.md "win/readme.md"
-[nix/build-all.py]: https://github.com/IfcOpenShell/IfcOpenShell/tree/master/nix/build-all.py "nix/build-all.py"
@@ -1,803 +1,235 @@
-################################################################################
-#                                                                              #
-# This file is part of IfcOpenShell.                                           #
-#                                                                              #
-# IfcOpenShell is free software: you can redistribute it and/or modify         #
-# it under the terms of the Lesser GNU General Public License as published by  #
-# the Free Software Foundation, either version 3.0 of the License, or          #
-# (at your option) any later version.                                          #
-#                                                                              #
-# IfcOpenShell is distributed in the hope that it will be useful,              #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 #
-# Lesser GNU General Public License for more details.                          #
-#                                                                              #
-# You should have received a copy of the Lesser GNU General Public License     #
-# along with this program. If not, see <http://www.gnu.org/licenses/>.         #
-#                                                                              #
-################################################################################
-
-cmake_minimum_required(VERSION 3.1.3)
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)  # not necessary, but encouraged
-
+cmake_minimum_required (VERSION 2.6)
 project (IfcOpenShell)

-foreach(max_year RANGE 2014 2030)
-set(max_sdk "$ENV{ADSK_3DSMAX_SDK_${max_year}}")
-if (NOT "${max_sdk}" STREQUAL "")
-MESSAGE(STATUS "Autodesk 3ds Max SDK found at ${max_sdk}")
-set(HAS_MAX TRUE)
-endif()
-endforeach()
-
-OPTION(COLLADA_SUPPORT "Build IfcConvert with COLLADA support (requires OpenCOLLADA)." ON)
-OPTION(IFCXML_SUPPORT "Build IfcParse with ifcXML support (requires libxml2)." ON)
-OPTION(ENABLE_BUILD_OPTIMIZATIONS "Enable certain compiler and linker optimizations on RelWithDebInfo and Release builds." OFF)
-OPTION(IFCCONVERT_DOUBLE_PRECISION "IfcConvert: Use double precision floating-point numbers." ON)
-OPTION(BUILD_IFCGEOM "Build IfcGeom." ON)
-OPTION(BUILD_IFCPYTHON "Build IfcPython." ON)
-OPTION(BUILD_EXAMPLES "Build example applications." ON)
-OPTION(BUILD_GEOMSERVER "Build IfcGeomServer executable." ON)
-OPTION(BUILD_CONVERT "Build IfcConvert executable." ON)
-OPTION(USE_VLD "Use Visual Leak Detector for debugging memory leaks, MSVC-only." OFF)
-OPTION(USE_MMAP "Adds a command line options to parse IFC files from memory mapped files using Boost.Iostreams" OFF)
-OPTION(USE_VOXELS "Use voxelized geometries as a fallback mechanism to calculate quantities in IfcGeomServer" OFF)
-OPTION(USE_CGAL "Use CGAL as an alternative geometry kernel implementation" OFF)
-OPTION(USE_STATIC_MSVC_RUNTIME "Link to the static runtime on MSVC." ON)
-OPTION(BUILD_SHARED_LIBS "Build IfcParse and IfcGeom as shared libs (SO/DLL)." OFF)
-if (${HAS_MAX})
-OPTION(BUILD_IFCMAX "Build IfcMax, a 3ds Max plug-in, Windows-only." ON)
-endif()
-if (${BUILD_CONVERT})
-OPTION(GLTF_SUPPORT "Build IfcConvert with glTF support (requires json.hpp)." OFF)
-endif()
-
-# TODO QtViewer is deprecated ATM as it uses the 0.4 API
-# OPTION(BUILD_QTVIEWER "Build IfcOpenShell Qt GUI Viewer (requires Qt 4 framework)." OFF)
-
-if((BUILD_CONVERT OR BUILD_GEOMSERVER OR BUILD_IFCPYTHON) AND (NOT BUILD_IFCGEOM))
-    message(STATUS "'IfcGeom' is required with current outputs")
-    set(BUILD_IFCGEOM ON)
-endif()
-
-# Specify where to install files
-IF(NOT BINDIR)
-    set(BINDIR bin)
-ENDIF()
-IF(NOT IS_ABSOLUTE ${BINDIR})
-    set(BINDIR ${CMAKE_INSTALL_PREFIX}/${BINDIR})
-ENDIF()
-MESSAGE(STATUS "BINDIR: ${BINDIR}")
-
-IF(NOT INCLUDEDIR)
-    set(INCLUDEDIR include)
-ENDIF()
-IF(NOT IS_ABSOLUTE ${INCLUDEDIR})
-    set(INCLUDEDIR ${CMAKE_INSTALL_PREFIX}/${INCLUDEDIR})
-ENDIF()
-MESSAGE(STATUS "INCLUDEDIR: ${INCLUDEDIR}")
-
-IF(NOT LIBDIR)
-    set(LIBDIR lib)
-ENDIF()
-IF(NOT IS_ABSOLUTE ${LIBDIR})
-    set(LIBDIR ${CMAKE_INSTALL_PREFIX}/${LIBDIR})
-ENDIF()
-MESSAGE(STATUS "LIBDIR: ${LIBDIR}")
-
-set(IFCOPENSHELL_LIBARY_DIR "") # for *nix rpaths
-
-if (BUILD_SHARED_LIBS)
-    add_definitions(-DIFC_SHARED_BUILD)
-    if (MSVC)
-        message(WARNING "Building DLLs against the static VC run-time. This is not recommended if the DLLs are to be redistributed.")
-        # C4521: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
-        # There will be couple hundreds of these so suppress them away, https://msdn.microsoft.com/en-us/library/esew7y1w.aspx
-        add_definitions(-wd4251)
-    endif()
-    set(IFCOPENSHELL_LIBARY_DIR "${LIBDIR}")
-endif()
-
-# Create cache entries if absent for environment variables
-MACRO(UNIFY_ENVVARS_AND_CACHE VAR)
-	IF ((NOT DEFINED ${VAR}) AND (NOT "$ENV{${VAR}}" STREQUAL ""))
-		SET(${VAR} "$ENV{${VAR}}" CACHE STRING "${VAR}" FORCE)
-	ENDIF()
-ENDMACRO()
-
-UNIFY_ENVVARS_AND_CACHE(OCC_INCLUDE_DIR)
-UNIFY_ENVVARS_AND_CACHE(OCC_LIBRARY_DIR)
-UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_INCLUDE_DIR)
-UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_LIBRARY_DIR)
-UNIFY_ENVVARS_AND_CACHE(LIBXML2_INCLUDE_DIR)
-UNIFY_ENVVARS_AND_CACHE(LIBXML2_LIBRARIES)
-UNIFY_ENVVARS_AND_CACHE(PCRE_LIBRARY_DIR)
-UNIFY_ENVVARS_AND_CACHE(PYTHON_EXECUTABLE)
-UNIFY_ENVVARS_AND_CACHE(CGAL_INCLUDE_DIR)
-UNIFY_ENVVARS_AND_CACHE(CGAL_LIBRARY_DIR)
-UNIFY_ENVVARS_AND_CACHE(GMP_INCLUDE_DIR)
-UNIFY_ENVVARS_AND_CACHE(GMP_LIBRARY_DIR)
-UNIFY_ENVVARS_AND_CACHE(MPFR_INCLUDE_DIR)
-UNIFY_ENVVARS_AND_CACHE(MPFR_LIBRARY_DIR)
-UNIFY_ENVVARS_AND_CACHE(VOXEL_INCLUDE_DIR)
-UNIFY_ENVVARS_AND_CACHE(VOXEL_LIBRARY_DIR)
-
-if (GLTF_SUPPORT AND BUILD_CONVERT)
-UNIFY_ENVVARS_AND_CACHE(JSON_INCLUDE_DIR)
-FIND_FILE(json_hpp "json.hpp" ${JSON_INCLUDE_DIR}/nlohmann)
-IF(json_hpp)
-	MESSAGE(STATUS "JSON for Modern C++ header file found")
-ELSE()
-	MESSAGE(FATAL_ERROR "Unable to find JSON for Modern C++ header file, aborting")
-ENDIF()
-add_definitions(-DWITH_GLTF)
-endif()
-
-# Set INSTALL_RPATH for target
-MACRO(SET_INSTALL_RPATHS _target _paths)
-    SET(${_target}_rpaths "")
-    FOREACH(_path ${_paths})
-        LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${_path}" isSystemDir)
-        IF("${isSystemDir}" STREQUAL "-1")
-            LIST(APPEND ${_target}_rpaths ${_path})
-        ENDIF()
-    ENDFOREACH()
-    MESSAGE(STATUS "Set INSTALL_RPATH for ${_target}: ${${_target}_rpaths}")
-    SET_TARGET_PROPERTIES(${_target} PROPERTIES INSTALL_RPATH "${${_target}_rpaths}")
-ENDMACRO()
-
-# Find Boost: On win32 the (hardcoded) default is to use static libraries and
-# runtime, when doing running conda-build we pick what conda prepared for us.
-IF(WIN32 AND ("$ENV{CONDA_BUILD}" STREQUAL ""))
-	SET(Boost_USE_STATIC_LIBS ON)
-	SET(Boost_USE_MULTITHREADED ON)
-    if (USE_STATIC_MSVC_RUNTIME)
-        SET(Boost_USE_STATIC_RUNTIME ON)
-    endif()
-ELSE()
-    # Disable Boost's autolinking as the libraries to be linked to are supplied
-    # already by CMake, and it's going to conflict if there are multiple, as is
-    # the case in conda-forge's libboost feedstock.
-    ADD_DEFINITIONS(-DBOOST_ALL_NO_LIB)
-    IF(WIN32)
-        # Necessary for boost version >= 1.67
-        SET(BCRYPT_LIBRARIES "bcrypt.lib")
-    ENDIF()
-ENDIF()
-
-set(BOOST_COMPONENTS system program_options regex thread date_time)
-if(USE_MMAP OR USE_VOXELS)
-    if(MSVC)
-        # filesystem is necessary for the utf-16 wpath
-        set(BOOST_COMPONENTS ${BOOST_COMPONENTS} iostreams filesystem)
-    else()
-        set(BOOST_COMPONENTS ${BOOST_COMPONENTS} iostreams)
-    endif()
-	if(USE_MMAP)
-		add_definitions(-DUSE_MMAP)
-	endif()
-endif()
-
-if (IFCXML_SUPPORT)
-    add_definitions(-DWITH_IFCXML)
-endif()
-
-if (USE_VOXELS)
-    FIND_LIBRARY(libvoxel NAMES voxel libvoxel PATHS ${VOXEL_LIBRARY_DIR} NO_DEFAULT_PATH)
-    FIND_LIBRARY(libvoxec NAMES voxec libvoxec PATHS ${VOXEL_LIBRARY_DIR} NO_DEFAULT_PATH)
-    set(VOXEL_LIBRARIES ${libvoxel} ${libvoxec})
-	ADD_DEFINITIONS("-DUSE_VOXELS")
-endif()
-
-FIND_PACKAGE(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
+FIND_PACKAGE(Boost REQUIRED COMPONENTS program_options)
 MESSAGE(STATUS "Boost include files found in ${Boost_INCLUDE_DIRS}")
 MESSAGE(STATUS "Boost libraries found in ${Boost_LIBRARY_DIRS}")

-# Usage:
-# set(SOME_LIRARIES foo bar)
-# add_debug_variants(SOME_LIRARIES "${SOME_LIRARIES}" d)
-# "foo bar" -> "optimized foo debug food optimized bar debug bard"
-# or
-# set(SOME_LIRARIES path/foo.lib)
-# add_debug_variants(SOME_LIRARIES "${SOME_LIRARIES}" "d")
-# "path/foo.lib" -> "optimized path/foo.lib debug path/food.lib"
-# TODO Could be refined: take the library file extension as a parameter and
-# make sure the lib variable ends with not just contains it.
-function(add_debug_variants NAME LIBRARIES POSTFIX)
-    set(LIBRARIES_STR "${LIBRARIES}")
-    set(LIBRARIES "")
-    # the result, "optimized <lib> debug <lib>", needs to be a list instead of a string
-    foreach(lib ${LIBRARIES_STR})
-        list(APPEND LIBRARIES optimized)
-        if ("${lib}" MATCHES ".lib")
-            string(REPLACE ".lib" "" lib ${lib})
-            list(APPEND LIBRARIES ${lib}.lib)
-        else()
-            list(APPEND LIBRARIES ${lib})
-        endif()
-
-        list(APPEND LIBRARIES debug)
-        if ("${lib}" MATCHES ".lib")
-            string(REPLACE ".lib" "" lib ${lib})
-            list(APPEND LIBRARIES ${lib}${POSTFIX}.lib)
-        else()
-            list(APPEND LIBRARIES ${lib}${POSTFIX})
-        endif()
-    endforeach()
-    set(${NAME} ${LIBRARIES} PARENT_SCOPE)
-endfunction()
-
-if(BUILD_IFCGEOM)
-
-# Find Open CASCADE
-IF("${OCC_INCLUDE_DIR}" STREQUAL "")
-	SET(OCC_INCLUDE_DIR "/usr/include/oce/" CACHE FILEPATH "Open CASCADE header files")
-	MESSAGE(STATUS "Looking for Open CASCADE include files in: ${OCC_INCLUDE_DIR}")
+# Find Open CASCADE header files
+IF("$ENV{OCC_INCLUDE_DIR}" STREQUAL "") 
+	SET(OCC_INCLUDE_DIR "/usr/include/opencascade/" CACHE FILEPATH "Open CASCADE header files")
+	MESSAGE(STATUS "Looking for opencascade include files in: ${OCC_INCLUDE_DIR}")
 	MESSAGE(STATUS "Use OCC_INCLUDE_DIR to specify another directory")
 ELSE()
-	SET(OCC_INCLUDE_DIR ${OCC_INCLUDE_DIR} CACHE FILEPATH "Open CASCADE header files")
-	MESSAGE(STATUS "Looking for Open CASCADE include files in: ${OCC_INCLUDE_DIR}")
+	SET(OCC_INCLUDE_DIR $ENV{OCC_INCLUDE_DIR} CACHE FILEPATH "Open CASCADE header files")
+	MESSAGE(STATUS "Looking for opencascade include files in: ${OCC_INCLUDE_DIR}")
 ENDIF()

-FIND_FILE(gp_Pnt_hxx "gp_Pnt.hxx" ${OCC_INCLUDE_DIR})
+FIND_FILE(gp_Pnt_hxx "gp_Pnt.hxx" ${OCC_INCLUDE_DIR} /usr/inc /usr/local/inc /usr/local/include/oce)
 IF(gp_Pnt_hxx)
 	MESSAGE(STATUS "Header files found")
 ELSE()
 	MESSAGE(FATAL_ERROR "Unable to find header files, aborting")
 ENDIF()

-SET(OPENCASCADE_LIBRARY_NAMES
-	TKernel TKMath TKBRep TKGeomBase TKGeomAlgo TKG3d TKG2d TKShHealing TKTopAlgo TKMesh TKPrim TKBool TKBO
-	TKFillet TKSTEP TKSTEPBase TKSTEPAttr TKXSBase TKSTEP209 TKIGES TKOffset
-)
-
-IF("${OCC_LIBRARY_DIR}" STREQUAL "")
+# Find Open CASCADE library files
+IF("$ENV{OCC_LIBRARY_DIR}" STREQUAL "") 
 	SET(OCC_LIBRARY_DIR "/usr/lib/" CACHE FILEPATH "Open CASCADE library files")
-	MESSAGE(STATUS "Looking for Open CASCADE library files in: ${OCC_LIBRARY_DIR}")
+	MESSAGE(STATUS "Looking for opencascade library files in: ${OCC_LIBRARY_DIR}")
 	MESSAGE(STATUS "Use OCC_LIBRARY_DIR to specify another directory")
 ELSE()
-	SET(OCC_LIBRARY_DIR ${OCC_LIBRARY_DIR} CACHE FILEPATH "Open CASCADE library files")
-	MESSAGE(STATUS "Looking for Open CASCADE library files in: ${OCC_LIBRARY_DIR}")
+	SET(OCC_LIBRARY_DIR $ENV{OCC_LIBRARY_DIR} CACHE FILEPATH "Open CASCADE library files")
+	MESSAGE(STATUS "Looking for opencascade library files in: ${OCC_LIBRARY_DIR}")
 ENDIF()

-FIND_LIBRARY(libTKernel NAMES TKernel TKerneld PATHS ${OCC_LIBRARY_DIR} NO_DEFAULT_PATH)
+FIND_LIBRARY(libTKernel "TKernel" ${OCC_LIBRARY_DIR} /usr/lib /usr/lib64 /usr/local/lib /usr/local/lib64)
 IF(libTKernel)
 	MESSAGE(STATUS "Library files found")
 ELSE()
 	MESSAGE(FATAL_ERROR "Unable to find library files, aborting")
 ENDIF()

-# Use the found libTKernel as a template for all other OCC libraries
-# TODO Extract this into macro/function
-foreach(lib ${OPENCASCADE_LIBRARY_NAMES})
-    # Make sure we'll handle the Windows/MSVC debug postfix convetion too.
-    string(REPLACE TKerneld "${lib}" lib_path "${libTKernel}")
-    string(REPLACE TKernel "${lib}" lib_path "${lib_path}")
-	list(APPEND OPENCASCADE_LIBRARIES "${lib_path}")
-endforeach()
+IF("$ENV{ICU_INCLUDE_DIR}" STREQUAL "")
+    MESSAGE(STATUS "No ICU include directory specified")
+ElSE()
+    SET(ICU_INCLUDE_DIR CACHE FILEPATH "ICU header files")
+ENDIF()

-list(APPEND GEOMETRY_KERNELS opencascade)
+IF("$ENV{ICU_LIBRARY_DIR}" STREQUAL "")
+    MESSAGE(STATUS "No ICU library directory specified")
+ElSE()
+    SET(ICU_LIBRARY_DIR CACHE FILEPATH "ICU library files")
+ENDIF()

-if (USE_CGAL)
-add_definitions(-DIFOPSH_USE_CGAL)
-list(APPEND GEOMETRY_KERNELS cgal)
-SET(CGAL_LIBRARY_NAMES libCGAL_Core libCGAL_ImageIO libCGAL)
-# Find CGAL
-IF("${CGAL_INCLUDE_DIR}" STREQUAL "")
-	SET(CGAL_INCLUDE_DIR "/usr/include/" CACHE FILEPATH "CGAL header files")
-	MESSAGE(STATUS "Looking for CGAL include files in: ${CGAL_INCLUDE_DIR}")
-	MESSAGE(STATUS "Use CGAL_INCLUDE_DIR to specify another directory")
+FIND_LIBRARY(icu "icuuc" /usr/lib /usr/lib64 /usr/local/lib /usr/local/lib64 ${ICU_LIBRARY_DIR})
+
+IF(icu)
+    MESSAGE(STATUS "ICU libraries found")
+    ADD_DEFINITIONS(-DHAVE_ICU)
 ELSE()
-	SET(CGAL_INCLUDE_DIR ${CGAL_INCLUDE_DIR} CACHE FILEPATH "CGAL header files")
-	MESSAGE(STATUS "Looking for CGAL include files in: ${CGAL_INCLUDE_DIR}")
+    MESSAGE(STATUS "Unable to find ICU library files, continuing")	
 ENDIF()
-IF("${CGAL_LIBRARY_DIR}" STREQUAL "")
-	SET(CGAL_LIBRARY_DIR "/usr/lib/" CACHE FILEPATH "CGAL library files")
-	MESSAGE(STATUS "Looking for CGAL library files in: ${CGAL_LIBRARY_DIR}")
-	MESSAGE(STATUS "Use CGAL_LIBRARY_DIR to specify another directory")
+
+IF("$ENV{OPENCOLLADA_INCLUDE_DIR}" STREQUAL "")
+    MESSAGE(STATUS "No OpenCOLLADA include directory specified")
+    SET(OPENCOLLADA_INCLUDE_DIR "/usr/local/include/opencollada" CACHE FILEPATH "OpenCOLLADA header files")
+ElSE()
+    SET(OPENCOLLADA_INCLUDE_DIR "$ENV{OPENCOLLADA_INCLUDE_DIR}" CACHE FILEPATH "OpenCOLLADA header files")
+ENDIF()
+
+IF("$ENV{OPENCOLLADA_LIBRARY_DIR}" STREQUAL "")
+    MESSAGE(STATUS "No OpenCOLLADA library directory specified")
+    SET(OPENCOLLADA_LIBRARY_DIR "/usr/local/lib/opencollada" CACHE FILEPATH "OpenCOLLADA library files")
+ElSE()
+    SET(OPENCOLLADA_LIBRARY_DIR "$ENV{OPENCOLLADA_LIBRARY_DIR}" CACHE FILEPATH "OpenCOLLADA library files")
+ENDIF()
+
+SET(OPENCOLLADA_INCLUDE_DIRS "${OPENCOLLADA_INCLUDE_DIR}/COLLADABaseUtils" "${OPENCOLLADA_INCLUDE_DIR}/COLLADAStreamWriter")
+
+FIND_FILE(COLLADASWStreamWriter_h "COLLADASWStreamWriter.h" ${OPENCOLLADA_INCLUDE_DIRS})
+IF(COLLADASWStreamWriter_h)
+    MESSAGE(STATUS "OpenCOLLADA header files found")
+    ADD_DEFINITIONS(-DWITH_OPENCOLLADA)
+    SET(OPENCOLLADA_LIBRARIES 
+        GeneratedSaxParser MathMLSolver OpenCOLLADABaseUtils
+        OpenCOLLADAFramework OpenCOLLADASaxFrameworkLoader
+        OpenCOLLADAStreamWriter UTF buffer ftoa pcre
+    )
 ELSE()
-	SET(CGAL_LIBRARY_DIR ${CGAL_LIBRARY_DIR} CACHE FILEPATH "CGAL library files")
-	MESSAGE(STATUS "Looking for CGAL library files in: ${CGAL_LIBRARY_DIR}")
-ENDIF()
-FIND_LIBRARY(libCGAL NAMES CGAL PATHS ${CGAL_LIBRARY_DIR} NO_DEFAULT_PATH)
-IF(libCGAL)
-        MESSAGE(STATUS "CGAL library files found")
-        foreach(lib ${CGAL_LIBRARY_NAMES})
-            string(REPLACE libCGAL "${lib}" lib_path "${libCGAL}")
-            list(APPEND CGAL_LIBRARIES "${lib_path}")
-        endforeach()
-ELSE()
-        FILE(GLOB CGAL_LIBRARIES ${CGAL_LIBRARY_DIR}/*CGAL*.lib)
-        message(STATUS CGAL_LIBRARIES ${CGAL_LIBRARIES})
-        LIST(LENGTH CGAL_LIBRARY_NAMES num_cgal_library_names)
-        LIST(LENGTH CGAL_LIBRARIES num_cgal_libraries)
-        message(STATUS ${num_cgal_library_names} ${num_cgal_libraries})
-        LINK_DIRECTORIES("${CGAL_LIBRARY_DIR}")
-        if(NOT "${num_cgal_library_names}" STREQUAL "${num_cgal_libraries}")
-            MESSAGE(FATAL_ERROR "Unable to find CGAL library files, aborting")
-        endif()
-        MESSAGE(STATUS "CGAL library files found")
+    MESSAGE(STATUS "OpenCOLLADA header files not found, continuing without COLLADA support")
 ENDIF()

-FIND_LIBRARY(libGMP NAMES gmp mpir PATHS ${GMP_LIBRARY_DIR} NO_DEFAULT_PATH)
-FIND_LIBRARY(libMPFR NAMES mpfr PATHS ${MPFR_LIBRARY_DIR} NO_DEFAULT_PATH)
-IF(NOT libGMP)
-        MESSAGE(FATAL_ERROR "Unable to find GMP library files, aborting")
-ENDIF()
-IF(NOT libMPFR)
-        MESSAGE(FATAL_ERROR "Unable to find MPFR library files, aborting")
-ENDIF()
-list(APPEND CGAL_LIBRARIES "${libMPFR}")
-list(APPEND CGAL_LIBRARIES "${libGMP}")
-endif()
+INCLUDE(CheckIncludeFileCXX)

-if(MSVC)
-    add_definitions(-DHAVE_NO_DLL)
-    add_debug_variants(OPENCASCADE_LIBRARIES "${OPENCASCADE_LIBRARIES}" d)
-endif()
-if (WIN32)
-    # OCC might require linking to Winsock depending on the version and build configuration
-    list(APPEND OPENCASCADE_LIBRARIES ws2_32.lib)
-endif()
+MACRO(CHECK_ADD_OCE_OCC_DEF INCLUDE)
+	STRING(REPLACE . _ STR ${INCLUDE})
+	STRING(TOUPPER ${STR} STR)
+	CHECK_INCLUDE_FILE_CXX("${INCLUDE}" FOUND_${STR})
+	IF(FOUND_${STR})
+		ADD_DEFINITIONS(-DOCE_HAVE_${STR})
+		ADD_DEFINITIONS(-DHAVE_${STR})
+	ENDIF(FOUND_${STR})
+ENDMACRO(CHECK_ADD_OCE_OCC_DEF)

-# Make sure cross-referenced symbols between static OCC libraries get
-# resolved. Also add thread and rt libraries.
-get_filename_component(libTKernelExt ${libTKernel} EXT)
-if("${libTKernelExt}" STREQUAL ".a")
-    set(OCCT_STATIC ON)
-endif()
-
-if(OCCT_STATIC)
-    find_package(Threads)
-    # OPENCASCADE_LIBRARIES repeated three times below in order to fix cyclic dependencies - use --start-group ... --end-group instead?
-    set(OPENCASCADE_LIBRARIES -Wl,--start-group ${OPENCASCADE_LIBRARIES} -Wl,--end-group ${CMAKE_THREAD_LIBS_INIT})
-    if (NOT APPLE AND NOT WIN32)
-        set(OPENCASCADE_LIBRARIES ${OPENCASCADE_LIBRARIES} "rt")
-    endif()
-    if (NOT WIN32)
-        set(OPENCASCADE_LIBRARIES ${OPENCASCADE_LIBRARIES} "dl")
-    endif()
-endif()
-
-endif(BUILD_IFCGEOM)
-
-IF(COLLADA_SUPPORT AND BUILD_CONVERT)
-	# Find OpenCOLLADA
-	IF("${OPENCOLLADA_INCLUDE_DIR}" STREQUAL "")
-		MESSAGE(STATUS "No OpenCOLLADA include directory specified")
-		SET(OPENCOLLADA_INCLUDE_DIR "/usr/include/opencollada" CACHE FILEPATH "OpenCOLLADA header files")
-	ELSE()
-		SET(OPENCOLLADA_INCLUDE_DIR "${OPENCOLLADA_INCLUDE_DIR}" CACHE FILEPATH "OpenCOLLADA header files")
-	ENDIF()
-
-	IF("${OPENCOLLADA_LIBRARY_DIR}" STREQUAL "")
-		MESSAGE(STATUS "No OpenCOLLADA library directory specified")
-		FIND_LIBRARY(OPENCOLLADA_FRAMEWORK_LIB NAMES OpenCOLLADAFramework
-			PATHS /usr/lib64/opencollada /usr/lib/opencollada /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib)
-		GET_FILENAME_COMPONENT(OPENCOLLADA_LIBRARY_DIR ${OPENCOLLADA_FRAMEWORK_LIB} PATH)
-	ENDIF()
-
-	FIND_LIBRARY(OpenCOLLADAFramework NAMES OpenCOLLADAFramework OpenCOLLADAFrameworkd PATHS ${OPENCOLLADA_LIBRARY_DIR} NO_DEFAULT_PATH)
-    if (OpenCOLLADAFramework)
-        message(STATUS "OpenCOLLADA library files found")
-    else()
-        message(FATAL_ERROR "COLLADA_SUPPORT enabled, but unable to find OpenCOLLADA libraries. "
-            "Disable COLLADA_SUPPORT or fix OpenCOLLADA paths to proceed.")
-    endif()
-
-	SET(OPENCOLLADA_LIBRARY_DIR "${OPENCOLLADA_LIBRARY_DIR}" CACHE FILEPATH "OpenCOLLADA library files")
-
-	SET(OPENCOLLADA_INCLUDE_DIRS "${OPENCOLLADA_INCLUDE_DIR}/COLLADABaseUtils" "${OPENCOLLADA_INCLUDE_DIR}/COLLADAStreamWriter")
-
-	FIND_FILE(COLLADASWStreamWriter_h "COLLADASWStreamWriter.h" ${OPENCOLLADA_INCLUDE_DIRS})
-	IF(COLLADASWStreamWriter_h)
-		MESSAGE(STATUS "OpenCOLLADA header files found")
-		ADD_DEFINITIONS(-DWITH_OPENCOLLADA)
-		SET(OPENCOLLADA_LIBRARY_NAMES
-			GeneratedSaxParser MathMLSolver OpenCOLLADABaseUtils OpenCOLLADAFramework OpenCOLLADASaxFrameworkLoader
-			OpenCOLLADAStreamWriter UTF buffer ftoa
-		)
-
-		# Use the found OpenCOLLADAFramework as a template for all other OpenCOLLADA libraries
-		foreach(lib ${OPENCOLLADA_LIBRARY_NAMES})
-            # Make sure we'll handle the Windows/MSVC debug postfix convetion too.
-            string(REPLACE OpenCOLLADAFrameworkd "${lib}" lib_path "${OpenCOLLADAFramework}")
-            string(REPLACE OpenCOLLADAFramework "${lib}" lib_path "${lib_path}")
- 			list(APPEND OPENCOLLADA_LIBRARIES "${lib_path}")
-		endforeach()
-
-		if("${PCRE_LIBRARY_DIR}" STREQUAL "")
-            if(WIN32)
-                find_library(pcre_library NAMES pcre pcred PATHS ${OPENCOLLADA_LIBRARY_DIR} NO_DEFAULT_PATH)
-            else()
-                find_library(pcre_library NAMES pcre PATHS ${OPENCOLLADA_LIBRARY_DIR})
-            endif()
-			GET_FILENAME_COMPONENT(PCRE_LIBRARY_DIR ${pcre_library} PATH)
-		else()
-			find_library(pcre_library NAMES pcre pcred PATHS ${PCRE_LIBRARY_DIR} NO_DEFAULT_PATH)
-		endif()
-
-		if (pcre_library)
-			SET(OPENCOLLADA_LIBRARY_DIR ${OPENCOLLADA_LIBRARY_DIR} ${PCRE_LIBRARY_DIR})
-            if (MSVC)
-                # Add release lib regardless whether release or debug found. Debug version will be appended below.
-                list(APPEND OPENCOLLADA_LIBRARIES "${PCRE_LIBRARY_DIR}/pcre.lib")
-            else()
-                list(APPEND OPENCOLLADA_LIBRARIES "${pcre_library}")
-            endif()
-        else()
-            message(FATAL_ERROR "COLLADA_SUPPORT enabled, but unable to find PCRE. "
-                "Disable COLLADA_SUPPORT or fix PCRE_LIBRARY_DIR path to proceed.")
-		endif()
-
-		IF(MSVC)
-			add_debug_variants(OPENCOLLADA_LIBRARIES "${OPENCOLLADA_LIBRARIES}" d)
-		ENDIF()
-	ELSE()
-        message(FATAL_ERROR "COLLADA_SUPPORT enabled, but unable to find OpenCOLLADA headers. "
-            "Disable COLLADA_SUPPORT or fix OpenCOLLADA paths to proceed.")
-	ENDIF()
-ENDIF()
+CHECK_ADD_OCE_OCC_DEF(limits)
+CHECK_ADD_OCE_OCC_DEF(climits)
+CHECK_ADD_OCE_OCC_DEF(limits.h)  
+CHECK_ADD_OCE_OCC_DEF(fstream)
+CHECK_ADD_OCE_OCC_DEF(fstream.h)
+CHECK_ADD_OCE_OCC_DEF(iomanip)
+CHECK_ADD_OCE_OCC_DEF(iomanip.h)
+CHECK_ADD_OCE_OCC_DEF(iostream)  
+CHECK_ADD_OCE_OCC_DEF(iostream.h)

 IF(NOT CMAKE_BUILD_TYPE)
-	SET(CMAKE_BUILD_TYPE "Release")
-ENDIF()
-
-if(ENABLE_BUILD_OPTIMIZATIONS)
-	if(MSVC)
-        # NOTE: RelWithDebInfo and Release use O2 (= /Ox /Gl /Gy/ = Og /Oi /Ot /Oy /Ob2 /Gs /GF /Gy) by default,
-        # with the exception with RelWithDebInfo has /Ob1 instead. /Ob2 has been observed to improve the performance
-        # of IfcConvert significantly.
-        # TODO Setting of /GL and /LTCG don't seem to apply for static libraries (IfcGeom, IfcParse)
-		# C++
-		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Ob2 /GL")
-		set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
-		# Linker
-		# /OPT:REF enables also /OPT:ICF and disables INCREMENTAL
-		set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG /OPT:REF")
-		# /OPT:NOICF is recommended when /DEBUG is used (http://msdn.microsoft.com/en-us/library/xe4t6fc1.aspx)
-		set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:NOICF")
-		set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG /OPT:REF")
-		set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG /OPT:NOICF")
-	else()
-        # GCC-like: Release should use O3 but RelWithDebInfo 02 so enforce 03. Anything other useful that could be added here?
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
-        set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELEASE} -O3")
-	endif()
-endif()
+ 	SET(CMAKE_BUILD_TYPE "Release")
+ENDIF(NOT CMAKE_BUILD_TYPE)

 IF(MSVC)
-    # Enable solution folders (free VS versions prior to 2012 don't support solution folders)
-    if (MSVC_VERSION GREATER 1600)
-        set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-    endif()
+    ADD_DEFINITIONS(-D_UNICODE)
+ElSE(MSVC)
+    ADD_DEFINITIONS(-fPIC -Wno-non-virtual-dtor)
+ENDIF(MSVC)

-	IF(USE_VLD)
-		ADD_DEFINITIONS(-DUSE_VLD)
-	ENDIF()
-	# Enforce Unicode for CRT and Win32 API calls
-	ADD_DEFINITIONS(-D_UNICODE -DUNICODE)
-	# Disable warnings about unsafe C functions; we could use the safe C99 & C11 versions if we have no need for supporting old compilers.
-	ADD_DEFINITIONS(-D_SCL_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS)
-	ADD_DEFINITIONS(-bigobj) # required for building the big ifcXXX.objs, https://msdn.microsoft.com/en-us/library/ms173499.aspx
-	# Bump up the warning level from the default 3 to 4.
-	ADD_DEFINITIONS(-W4)
-	IF(MSVC_VERSION GREATER 1800) # > 2013
-		# Disable overeager and false positives causing C4458 ("declaration of 'indentifier' hides class member"), at least for now.
-		ADD_DEFINITIONS(-wd4458)
-	ENDIF()
-    # Enforce standards-conformance on VS > 2015, older Boost versions fail to compile with this    
-    if (MSVC_VERSION GREATER 1900 AND (Boost_MAJOR_VERSION GREATER 1 OR Boost_MINOR_VERSION GREATER 66))
-		# @todo currently fails
-        # add_definitions(-permissive-)
-    endif()
-    
-    if(USE_STATIC_MSVC_RUNTIME)
-        # Link against the static VC runtime
-        IF("$ENV{CONDA_BUILD}" STREQUAL "")
-        FOREACH(flag CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL
-                CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
-                CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
-            IF(${flag} MATCHES "/MD")
-                STRING(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
-            ENDIF()
-            IF(${flag} MATCHES "/MDd")
-                STRING(REGEX REPLACE "/MDd" "/MTd" ${flag} "${${flag}}")
-            ENDIF()
-        ENDFOREACH()
-        ENDIF()
-    endif()
-ElSE()
-    add_definitions(-Wall -Wextra)
-    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        add_definitions(-Wno-tautological-constant-out-of-range-compare)
-    else()
-        add_definitions(-Wno-maybe-uninitialized)
-    endif()
-    # -fPIC is not relevant on Windows and creates pointless warnings
-    if (UNIX)
-        add_definitions(-fPIC)
-    endif()
-ENDIF()
+INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${OCC_INCLUDE_DIR} ${OPENCOLLADA_INCLUDE_DIRS} /usr/inc /usr/local/inc /usr/local/include/oce ${ICU_INCLUDE_DIR} ${Boost_INCLUDE_DIRS})

-if (IFCCONVERT_DOUBLE_PRECISION)
-    SET(CONVERT_PRECISION "-DIFCCONVERT_DOUBLE_PRECISION")
-endif()
-
-INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${OCC_INCLUDE_DIR} ${OPENCOLLADA_INCLUDE_DIRS}
-	${Boost_INCLUDE_DIRS} ${LIBXML2_INCLUDE_DIR} ${JSON_INCLUDE_DIR}
-	${CGAL_INCLUDE_DIR} ${GMP_INCLUDE_DIR} ${MPFR_INCLUDE_DIR} ${VOXEL_INCLUDE_DIR}
+ADD_LIBRARY(IfcParse STATIC
+  ../src/ifcparse/Ifc2x3-latebound.cpp
+  ../src/ifcparse/Ifc2x3.cpp
+  ../src/ifcparse/Ifc4-latebound.cpp
+  ../src/ifcparse/Ifc4.cpp
+  ../src/ifcparse/IfcCharacterDecoder.cpp
+  ../src/ifcparse/IfcGuidHelper.cpp
+  ../src/ifcparse/IfcHierarchyHelper.cpp
+  ../src/ifcparse/IfcLateBoundEntity.cpp
+  ../src/ifcparse/IfcParse.cpp
+  ../src/ifcparse/IfcSIPrefix.cpp
+  ../src/ifcparse/IfcSpfHeader.cpp
+  ../src/ifcparse/IfcUtil.cpp
+  ../src/ifcparse/IfcWrite.cpp
 )

-function(files_for_ifc_version IFC_VERSION RESULT_NAME)
-    set(IFC_PARSE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../src/ifcparse)
-    set(${RESULT_NAME} 
-        ${IFC_PARSE_DIR}/Ifc${IFC_VERSION}.h 
-        ${IFC_PARSE_DIR}/Ifc${IFC_VERSION}enum.h
-        ${IFC_PARSE_DIR}/Ifc${IFC_VERSION}.cpp
-		PARENT_SCOPE
-    )
-endfunction()
-
-set(SCHEMA_VERSIONS "2x3" "4" "4x1" "4x2")
-
-if(COMPILE_SCHEMA)
-	# @todo, this appears to be untested at the moment
-
-    find_package(PythonInterp)
-    
-    IF(NOT PYTHONINTERP_FOUND)
-        MESSAGE(FATAL_ERROR "A Python interpreter is necessary when COMPILE_SCHEMA is enabled. Disable COMPILE_SCHEMA or fix Python paths to proceed.")
-    ENDIF()
-    
-    set(IFC_RELEASE_NOT_USED ${SCHEMA_VERSIONS})
-    
-    # Install pyparsing if necessary
-    execute_process(COMMAND ${PYTHON_EXECUTABLE} -m pip freeze OUTPUT_VARIABLE PYTHON_PACKAGE_LIST)
-    if ("${PYTHON_PACKAGE_LIST}" STREQUAL "")
-        execute_process(COMMAND pip freeze OUTPUT_VARIABLE PYTHON_PACKAGE_LIST)
-        if ("${PYTHON_PACKAGE_LIST}" STREQUAL "")
-            message(WARNING "Failed to find pip. Pip is required to automatically install pyparsing")
-        endif()
-    endif()
-    string(FIND "${PYTHON_PACKAGE_LIST}" pyparsing PYPARSING_FOUND)
-    if ("${PYPARSING_FOUND}" STREQUAL "-1")
-        message(STATUS "Installing pyparsing")
-        execute_process(COMMAND ${PYTHON_EXECUTABLE} -m pip "install" --user pyparsing RESULT_VARIABLE SUCCESS)
-        if (NOT "${SUCCESS}" STREQUAL "0")
-            execute_process(COMMAND pip "install" --user pyparsing RESULT_VARIABLE SUCCESS)
-            if (NOT "${SUCCESS}" STREQUAL "0")
-                message(WARNING "Failed to automatically install pyparsing. Please install manually")
-            endif()
-        endif()
-    else()
-        message(STATUS "Python interpreter with pyparsing found")
-    endif()
-    
-    # Bootstrap the parser
-    message(STATUS "Compiling schema, this will take a while...")
-    execute_process(COMMAND ${PYTHON_EXECUTABLE} bootstrap.py express.bnf 
-        WORKING_DIRECTORY ../src/ifcexpressparser 
-        OUTPUT_FILE express_parser.py
-        RESULT_VARIABLE SUCCESS)
-
-    if (NOT "${SUCCESS}" STREQUAL "0")
-        MESSAGE(FATAL_ERROR "Failed to bootstrap parser. Make sure pyparsing is installed")
-    endif()
-        
-    # Generate code
-    execute_process(COMMAND ${PYTHON_EXECUTABLE} ../ifcexpressparser/express_parser.py ../../${COMPILE_SCHEMA}
-        WORKING_DIRECTORY ../src/ifcparse
-        OUTPUT_VARIABLE COMPILED_SCHEMA_NAME)
-    
-    # Prevent the schema that had just been compiled from being excluded
-	foreach(s ${SCHEMA_VERSIONS})
-		if("${COMPILED_SCHEMA_NAME}" STREQUAL "${s}")
-			list(REMOVE_ITEM IFC_RELEASE_NOT_USED "${s}")
-		endif()
-	endforeach()
-endif()
-
-# Boost >= 1.58 requires BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE to build on some Linux distros.
-if(NOT Boost_VERSION LESS 105800)
-    add_definitions(-DBOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE)
-endif()
-
-set(IFCOPENSHELL_LIBRARIES IfcParse)
-if (BUILD_IFCGEOM)
-	foreach(s ${SCHEMA_VERSIONS})
-		set(IFCGEOM_SCHEMA_LIBRARIES ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom_ifc${s})
-	endforeach()
-	set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES})
-endif()
-if (BUILD_CONVERT)
-	foreach(s ${SCHEMA_VERSIONS})
-		set(SERIALIZER_SCHEMA_LIBRARIES ${SERIALIZER_SCHEMA_LIBRARIES} Serializers_ifc${s})
-	endforeach()
-	set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} Serializers ${SERIALIZER_SCHEMA_LIBRARIES})
-endif()
-
-# IfcParse
-file(GLOB IFCPARSE_H_FILES ../src/ifcparse/*.h)
-file(GLOB IFCPARSE_CPP_FILES ../src/ifcparse/*.cpp)
-set(IFCPARSE_FILES ${IFCPARSE_CPP_FILES} ${IFCPARSE_H_FILES})
-
-add_library(IfcParse ${IFCPARSE_FILES})
-set_target_properties(IfcParse PROPERTIES COMPILE_FLAGS -DIFC_PARSE_EXPORTS)
-
-TARGET_LINK_LIBRARIES(IfcParse ${Boost_LIBRARIES} ${BCRYPT_LIBRARIES} ${LIBXML2_LIBRARIES})
-
-if (BUILD_IFCGEOM)
-
-foreach(kernel ${GEOMETRY_KERNELS})
-string(TOUPPER ${kernel} KERNEL_UPPER)
-file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/schema_agnostic/${kernel}/*.h)
-file(GLOB IFCGEOM_CPP_FILES ../src/ifcgeom/schema_agnostic/${kernel}/*.cpp)
-set(IFCGEOM_FILES ${IFCGEOM_CPP_FILES} ${IFCGEOM_H_FILES})
-
-add_library(IfcGeom_${kernel} STATIC ${IFCGEOM_FILES})
-set_target_properties(IfcGeom_${kernel} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS")
-target_link_libraries(IfcGeom_${kernel} IfcParse ${${KERNEL_UPPER}_LIBRARIES})
-list(APPEND IfcGeom_libraries IfcGeom_${kernel})
-endforeach()
-
-foreach(schema ${SCHEMA_VERSIONS})
-
-file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/kernel_agnostic/*.h)
-file(GLOB IFCGEOM_CPP_FILES ../src/ifcgeom/kernel_agnostic/*.cpp)
-set(IFCGEOM_FILES ${IFCGEOM_CPP_FILES} ${IFCGEOM_H_FILES})
-
-add_library(IfcGeom_ifc${schema} STATIC ${IFCGEOM_FILES})
-set_target_properties(IfcGeom_ifc${schema} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIfcSchema=Ifc${schema}")
-target_link_libraries(IfcGeom_ifc${schema} IfcParse)
-list(APPEND IfcGeom_libraries IfcGeom_ifc${schema})
-
-foreach(kernel ${GEOMETRY_KERNELS})
-file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/kernels/${kernel}/*.h)
-file(GLOB IFCGEOM_CPP_FILES ../src/ifcgeom/kernels/${kernel}/*.cpp)
-set(IFCGEOM_FILES ${IFCGEOM_CPP_FILES} ${IFCGEOM_H_FILES})
-
-add_library(IfcGeom_${kernel}_ifc${schema} STATIC ${IFCGEOM_FILES})
-set_target_properties(IfcGeom_${kernel}_ifc${schema} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIfcSchema=Ifc${schema}")
-target_link_libraries(IfcGeom_${kernel}_ifc${schema} IfcGeom_${kernel} IfcGeom_ifc${schema})
-list(APPEND IfcGeom_libraries IfcGeom_${kernel}_ifc${schema})
-endforeach()
-
-endforeach()
-
-file(GLOB SCHEMA_AGNOSTIC_H_FILES ../src/ifcgeom/schema_agnostic/*.h)
-file(GLOB SCHEMA_AGNOSTIC_CPP_FILES ../src/ifcgeom/schema_agnostic/*.cpp)
-set(SCHEMA_AGNOSTIC_FILES ${SCHEMA_AGNOSTIC_H_FILES} ${SCHEMA_AGNOSTIC_CPP_FILES})
-
-add_library(IfcGeom ${SCHEMA_AGNOSTIC_FILES})
-set_target_properties(IfcGeom PROPERTIES COMPILE_FLAGS -DIFC_GEOM_EXPORTS)
-
-if (UNIX)
-find_package(Threads)
-endif()
-
-TARGET_LINK_LIBRARIES(IfcGeom ${IfcGeom_libraries} ${CMAKE_THREAD_LIBS_INIT})
-
-endif(BUILD_IFCGEOM)
-
-if (BUILD_CONVERT)
-
-# Serializers
-file(GLOB SERIALIZERS_H_FILES ../src/serializers/*.h)
-file(GLOB SERIALIZERS_CPP_FILES ../src/serializers/*.cpp)
-set(SERIALIZERS_FILES ${SERIALIZERS_H_FILES} ${SERIALIZERS_CPP_FILES})
-file(GLOB SERIALIZERS_S_H_FILES ../src/serializers/schema_dependent/*.h)
-file(GLOB SERIALIZERS_S_CPP_FILES ../src/serializers/schema_dependent/*.cpp)
-set(SERIALIZERS_S_FILES ${SERIALIZERS_S_H_FILES} ${SERIALIZERS_S_CPP_FILES})
-
-foreach(s ${SCHEMA_VERSIONS})
-	add_library(Serializers_ifc${s} STATIC ${SERIALIZERS_S_FILES})
-	set_target_properties(Serializers_ifc${s} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIfcSchema=Ifc${s} ${CONVERT_PRECISION}")
-	TARGET_LINK_LIBRARIES(Serializers_ifc${s} IfcGeom ${OPENCASCADE_LIBRARIES})
-endforeach()
-
-add_library(Serializers ${SERIALIZERS_FILES})
-set_target_properties(Serializers PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS ${CONVERT_PRECISION}")
-
-TARGET_LINK_LIBRARIES(Serializers ${SERIALIZER_SCHEMA_LIBRARIES})
-
-# IfcConvert
-file(GLOB IFCCONVERT_CPP_FILES ../src/ifcconvert/*.cpp)
-file(GLOB IFCCONVERT_H_FILES ../src/ifcconvert/*.h)
-set(IFCCONVERT_FILES ${IFCCONVERT_CPP_FILES} ${IFCCONVERT_H_FILES})
-ADD_EXECUTABLE(IfcConvert ${IFCCONVERT_FILES})
-set_target_properties(IfcConvert PROPERTIES COMPILE_FLAGS "${CONVERT_PRECISION}")
-
-TARGET_LINK_LIBRARIES(IfcConvert ${IFCOPENSHELL_LIBRARIES} ${Boost_LIBRARIES} ${OPENCOLLADA_LIBRARIES})
-
-if ((NOT WIN32) AND BUILD_SHARED_LIBS)
-    # Only set RPATHs when building shared libraries (i.e. IfcParse and
-    # IfcGeom are dynamically linked). Not necessarily a perfect solution
-    # but probably a good indication of whether RPATHs are necessary.
-    SET_INSTALL_RPATHS(IfcConvert "${IFCOPENSHELL_LIBARY_DIR};${OCC_LIBRARY_DIR};${Boost_LIBRARY_DIRS};${OPENCOLLADA_LIBRARY_DIR}")
-endif()
-
-INSTALL(TARGETS IfcConvert
-    ARCHIVE DESTINATION ${LIBDIR}
-    LIBRARY DESTINATION ${LIBDIR}
-    RUNTIME DESTINATION ${BINDIR}
+ADD_LIBRARY(IfcGeom STATIC
+  ../src/ifcgeom/IfcGeomCurves.cpp
+  ../src/ifcgeom/IfcGeomFaces.cpp
+  ../src/ifcgeom/IfcGeomFunctions.cpp
+  ../src/ifcgeom/IfcGeomHelpers.cpp
+  ../src/ifcgeom/IfcGeomMaterial.cpp
+  ../src/ifcgeom/IfcGeomRenderStyles.cpp
+  ../src/ifcgeom/IfcGeomRepresentation.cpp
+  ../src/ifcgeom/IfcGeomShapes.cpp
+  ../src/ifcgeom/IfcGeomWires.cpp
+  ../src/ifcgeom/IfcRegister.cpp
 )

-endif(BUILD_CONVERT)
+IF(icu)
+    TARGET_LINK_LIBRARIES(IfcParse icuuc)
+ENDIF()

-# IfcGeomServer
-if(BUILD_GEOMSERVER)
+TARGET_LINK_LIBRARIES(IfcGeom IfcParse)

-file(GLOB CPP_FILES ../src/ifcgeomserver/*.cpp)
-file(GLOB H_FILES ../src/ifcgeomserver/*.h)
-set(SOURCE_FILES ${CPP_FILES} ${H_FILES})
-ADD_EXECUTABLE(IfcGeomServer ${SOURCE_FILES})
-TARGET_LINK_LIBRARIES(IfcGeomServer ${IFCOPENSHELL_LIBRARIES} ${Boost_LIBRARIES} ${VOXEL_LIBRARIES})
+LINK_DIRECTORIES (${LINK_DIRECTORIES} ${IfcOpenShell_BINARY_DIR} ${OCC_LIBRARY_DIR} ${OPENCOLLADA_LIBRARY_DIR} /usr/lib /usr/lib64 /usr/local/lib /usr/local/lib64 ${ICU_LIBRARY_DIR} ${Boost_LIBRARY_DIRS}) 

-if ((NOT WIN32) AND BUILD_SHARED_LIBS)
-    SET_INSTALL_RPATHS(IfcGeomServer "${IFCOPENSHELL_LIBARY_DIR};${OCC_LIBRARY_DIR};${Boost_LIBRARY_DIRS}")
-endif()
-
-INSTALL(TARGETS IfcGeomServer
-    ARCHIVE DESTINATION ${LIBDIR}
-    LIBRARY DESTINATION ${LIBDIR}
-    RUNTIME DESTINATION ${BINDIR}
+ADD_EXECUTABLE(IfcConvert
+    ../src/ifcconvert/ColladaSerializer.cpp
+    ../src/ifcconvert/IfcConvert.cpp
+    ../src/ifcconvert/OpenCascadeBasedSerializer.cpp
+    ../src/ifcconvert/WavefrontObjSerializer.cpp
+    ../src/ifcconvert/XmlSerializer.cpp
 )

-endif()
+TARGET_LINK_LIBRARIES (IfcConvert IfcParse IfcGeom TKernel TKMath TKBRep TKGeomBase TKGeomAlgo TKG3d TKG2d TKShHealing TKTopAlgo TKMesh TKPrim TKBool TKBO TKFillet TKSTEP TKSTEPBase TKSTEPAttr TKXSBase TKSTEP209 TKIGES TKOffset ${Boost_LIBRARIES} ${OPENCOLLADA_LIBRARIES})

-IF(BUILD_IFCPYTHON)
-	ADD_SUBDIRECTORY(../src/ifcwrap ifcwrap)
-ENDIF()
+ADD_EXECUTABLE(IfcGeomServer
+    ../src/ifcgeomserver/IfcGeomServer.cpp
+)

-IF(BUILD_EXAMPLES)
-	ADD_SUBDIRECTORY(../src/examples examples)
-ENDIF()
+TARGET_LINK_LIBRARIES (IfcGeomServer IfcParse IfcGeom TKernel TKMath TKBRep TKGeomBase TKGeomAlgo TKG3d TKG2d TKShHealing TKTopAlgo TKMesh TKPrim TKBool TKBO TKFillet TKSTEP TKSTEPBase TKSTEPAttr TKXSBase TKSTEP209 TKIGES TKOffset)

-IF(BUILD_IFCMAX)
-	ADD_SUBDIRECTORY(../src/ifcmax ifcmax)
-ENDIF()
+# Build python wrapper using separate CMakeLists.txt
+ADD_SUBDIRECTORY(../src/ifcwrap ifcwrap)
+
+# Build IfcParseExamples using separate CMakeLists.txt
+ADD_SUBDIRECTORY(../src/examples examples)
+
+# ADD_SUBDIRECTORY(../src/qtviewer qtviewer)

 # CMake installation targets
-INSTALL(FILES ${IFCPARSE_H_FILES} 
-	DESTINATION ${INCLUDEDIR}/ifcparse
+SET(include_files_geom
+    ../src/ifcgeom/IfcGeom.h
+    ../src/ifcgeom/IfcGeomElement.h
+    ../src/ifcgeom/IfcGeomIterator.h
+    ../src/ifcgeom/IfcGeomIteratorSettings.h
+    ../src/ifcgeom/IfcGeomMaterial.h
+    ../src/ifcgeom/IfcGeomRenderStyles.h
+    ../src/ifcgeom/IfcGeomRepresentation.h
+    ../src/ifcgeom/IfcRegister.h
+    ../src/ifcgeom/IfcRegisterConvertCurve.h
+    ../src/ifcgeom/IfcRegisterConvertFace.h
+    ../src/ifcgeom/IfcRegisterConvertShape.h
+    ../src/ifcgeom/IfcRegisterConvertShapes.h
+    ../src/ifcgeom/IfcRegisterConvertWire.h
+    ../src/ifcgeom/IfcRegisterCreateCache.h
+    ../src/ifcgeom/IfcRegisterDef.h
+    ../src/ifcgeom/IfcRegisterGeomHeader.h
+    ../src/ifcgeom/IfcRegisterIsShapeCollection.h
+    ../src/ifcgeom/IfcRegisterPurgeCache.h
+    ../src/ifcgeom/IfcRegisterUndef.h
+    ../src/ifcgeom/IfcRepresentationShapeItem.h
 )
-
-INSTALL(TARGETS IfcParse
-	ARCHIVE DESTINATION ${LIBDIR}
-	LIBRARY DESTINATION ${LIBDIR}
-	RUNTIME DESTINATION ${BINDIR}
+SET(include_files_parse
+    ../src/ifcparse/Ifc2x3-latebound.h
+    ../src/ifcparse/Ifc2x3.h
+    ../src/ifcparse/Ifc2x3enum.h
+    ../src/ifcparse/Ifc4-latebound.h
+    ../src/ifcparse/Ifc4.h
+    ../src/ifcparse/Ifc4enum.h
+    ../src/ifcparse/IfcCharacterDecoder.h
+    ../src/ifcparse/IfcEntityDescriptor.h
+    ../src/ifcparse/IfcException.h
+    ../src/ifcparse/IfcFile.h
+    ../src/ifcparse/IfcHierarchyHelper.h
+    ../src/ifcparse/IfcLateBoundEntity.h
+    ../src/ifcparse/IfcParse.h
+    ../src/ifcparse/IfcSIPrefix.h
+    ../src/ifcparse/IfcSpfHeader.h
+    ../src/ifcparse/IfcSpfStream.h
+    ../src/ifcparse/IfcUtil.h
+    ../src/ifcparse/IfcWritableEntity.h
+    ../src/ifcparse/IfcWrite.h
+    ../src/ifcparse/SharedPointer.h
 )
-
-if(BUILD_IFCGEOM)
-INSTALL(FILES ${IFCGEOM_H_FILES} 
-	DESTINATION ${INCLUDEDIR}/ifcgeom
-)
-
-INSTALL(FILES  ${SCHEMA_AGNOSTIC_H_FILES} 
-	DESTINATION ${INCLUDEDIR}/ifcgeom/schema_agnostic
-)
-
-INSTALL(TARGETS IfcGeom ${IfcGeom_libraries}
-	ARCHIVE DESTINATION ${LIBDIR}
-	LIBRARY DESTINATION ${LIBDIR}
-	RUNTIME DESTINATION ${BINDIR}
-)
-endif()
-
-if(BUILD_CONVERT)
-INSTALL(TARGETS Serializers ${SERIALIZER_SCHEMA_LIBRARIES}
-	ARCHIVE DESTINATION ${LIBDIR}
-	LIBRARY DESTINATION ${LIBDIR}
-	RUNTIME DESTINATION ${BINDIR}
-)
-
-INSTALL(FILES  ${SERIALIZERS_FILES}
-	DESTINATION ${INCLUDEDIR}/serializers/
-)
-
-INSTALL(FILES  ${SERIALIZERS_S_FILES}
-	DESTINATION ${INCLUDEDIR}/serializers/schema_dependent
-)
-endif()
+INSTALL(FILES ${include_files_geom} DESTINATION include/ifcgeom)
+INSTALL(FILES ${include_files_parse} DESTINATION include/ifcparse)
+INSTALL(TARGETS IfcConvert DESTINATION bin)
+INSTALL(TARGETS IfcParse IfcGeom DESTINATION lib)
@@ -1,29 +0,0 @@
-mkdir build && cd build
-
-REM Remove dot from PY_VER for use in library name
-REM From https://github.com/tpaviot/pythonocc-core/blob/master/ci/conda/bld.bat
-set MY_PY_VER=%PY_VER:.=%
-
-cmake -G "NMake Makefiles" ^
- -DCMAKE_INSTALL_PREFIX="%LIBRARY_PREFIX%" ^
- -DCMAKE_BUILD_TYPE=Release ^
- -DCMAKE_PREFIX_PATH="%LIBRARY_PREFIX%" ^
- -DCMAKE_SYSTEM_PREFIX_PATH="%LIBRARY_PREFIX%" ^
- -DPYTHON_EXECUTABLE="%PYTHON%" ^
- -DPYTHON_INCLUDE_DIR="%PREFIX%"/include ^
- -DPYTHON_LIBRARY="%PREFIX%"/libs/python%MY_PY_VER%.lib ^
- -DBOOST_LIBRARYDIR="%LIBRARY_PREFIX%\lib" ^
- -DBOOST_INCLUDEDIR="%LIBRARY_PREFIX%\include" ^
- -DOCC_INCLUDE_DIR="%LIBRARY_PREFIX%\include\oce" ^
- -DOCC_LIBRARY_DIR="%LIBRARY_PREFIX%\lib" ^
- -DCOLLADA_SUPPORT=Off ^
- -DBUILD_EXAMPLES=Off ^
- -DBUILD_GEOMSERVER=Off ^
- -DBUILD_CONVERT=Off ^
- ../cmake
- 
-if errorlevel 1 exit 1
-
-cmake --build . --target INSTALL --config Release
-
-if errorlevel 1 exit 1
@@ -1,34 +0,0 @@
-# From https://github.com/tpaviot/pythonocc-core/blob/master/ci/conda/build.sh
-if [ "$PY3K" == "1" ]; then
-    MY_PY_VER="${PY_VER}m"
-else
-    MY_PY_VER="${PY_VER}"
-fi
-
-if [ `uname` == Darwin ]; then
-    PY_LIB="libpython${MY_PY_VER}.dylib"
-    export   CFLAGS="$CFLAGS   -Wl,-flat_namespace,-undefined,suppress"
-    export CXXFLAGS="$CXXFLAGS -Wl,-flat_namespace,-undefined,suppress"
-    export  LDFLAGS="$LDFLAGS  -Wl,-flat_namespace,-undefined,suppress"
-else
-    PY_LIB="libpython${MY_PY_VER}.so"
-fi
-
-mkdir build && cd build
-
-cmake \
- -DCMAKE_INSTALL_PREFIX=$PREFIX \
- -DCMAKE_BUILD_TYPE=Release \
- -DCMAKE_PREFIX_PATH=$PREFIX \
- -DCMAKE_SYSTEM_PREFIX_PATH=$PREFIX \
- -DOCC_INCLUDE_DIR=$PREFIX/include/oce \
- -DOCC_LIBRARY_DIR=$PREFIX/lib \
- -DPYTHON_EXECUTABLE:FILEPATH=$PYTHON \
- -DPYTHON_INCLUDE_DIR:PATH=$PREFIX/include/python$MY_PY_VER \
- -DPYTHON_LIBRARY:FILEPATH=$PREFIX/lib/${PY_LIB} \
- -DCOLLADA_SUPPORT=Off \
- ../cmake
-
-make -j$CPU_COUNT _ifcopenshell_wrapper
-cd ifcwrap
-make install/local
@@ -1,36 +0,0 @@
-package:
-  name: ifcopenshell
-  version: "0.6.0a1"
-
-source:
-  git_rev: "v0.6.0a1"
-  git_url: https://github.com/IfcOpenShell/IfcOpenShell
-
-build:
-  number: 0
-  features:
-    - vc9     # [win and py27]
-    - vc10    # [win and py34]
-    - vc14    # [win and py35]
-    - vc14    # [win and py36]
-
-requirements:
-  build:
-    - gcc     # [osx]
-    - make
-    - python
-    - oce ==0.18.3
-    - cmake
-    - swig >=3.0.9
-    - libboost
-    - icu
-  run:
-    - libgcc  # [osx]
-    - python
-    - oce ==0.18.3
-    - libboost
-    - icu
-
-about:
-  home: http://ifcopenshell.org
-  license: LGPL
@@ -1,825 +0,0 @@
-#!/usr/bin/python
-###############################################################################
-#                                                                             #
-# This file is part of IfcOpenShell.                                          #
-#                                                                             #
-# IfcOpenShell is free software: you can redistribute it and/or modify        #
-# it under the terms of the Lesser GNU General Public License as published by #
-# the Free Software Foundation, either version 3.0 of the License, or         #
-# (at your option) any later version.                                         #
-#                                                                             #
-# IfcOpenShell is distributed in the hope that it will be useful,             #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
-# Lesser GNU General Public License for more details.                         #
-#                                                                             #
-# You should have received a copy of the Lesser GNU General Public License    #
-# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
-#                                                                             #
-###############################################################################
-
-###############################################################################
-#                                                                             #
-# This script builds IfcOpenShell and its dependencies                        #
-#                                                                             #
-# Prerequisites for this script to function correctly:                        #
-#     * git * bzip2 * tar * c(++) compilers * yacc * autoconf                 #
-#                                                                             #
-#   if building with USE_OCCT additionally:                                   #
-#     * freetype * glx.h                                                      #
-#                                                                             #
-#   if building with -shared                                                  #
-#     * libgl1-mesa-dev libxext-dev libxmu-dev libxmu-headers libxi-dev       #
-#                                                                             #
-#   for python37 to install correctly additionally:                           #
-#     * libffi(-dev[el])                                                      #
-#                                                                             #
-#     on debian 7.8 these can be obtained with:                               #
-#          $ apt-get install git gcc g++ autoconf bison bzip2                 #
-#            libfreetype6-dev mesa-common-dev libffi-dev                      #
-#                                                                             #
-#     on ubuntu 14.04:                                                        #
-#          $ apt-get install git gcc g++ autoconf bison make                  #
-#            libfreetype6-dev mesa-common-dev libffi-dev                      #
-#                                                                             #
-#     on OS X El Capitan with homebrew:                                       #
-#          $ brew install git bison autoconf automake freetype libffi         #
-#                                                                             #
-###############################################################################
-
-from __future__ import print_function
-
-import logging
-import os
-import sys
-import subprocess as sp
-import shutil
-import time
-import tarfile
-import multiprocessing
-
-PYTHON_MAJOR = sys.version_info[0]
-
-if PYTHON_MAJOR >= 3:
-    from urllib.request import urlretrieve
-else:
-    # Not Python 3 - today, it is most likely to be Python 2
-    # But note that this might need an update when Python 4
-    # might be around one day
-    from urllib import urlretrieve
-
-
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
-ch = logging.StreamHandler()
-ch.setLevel(logging.INFO)
-logger.addHandler(ch)
-
-PROJECT_NAME="IfcOpenShell"
-PYTHON_VERSIONS=["2.7.16", "3.2.6", "3.3.6", "3.4.6", "3.5.3", "3.6.2", "3.7.3"]
-JSON_VERSION="v3.6.1"
-OCE_VERSION="0.18"
-# OCCT_VERSION="7.1.0"
-# OCCT_HASH="89aebde"
-# OCCT_VERSION="7.2.0"
-# OCCT_HASH="88af392"
-OCCT_VERSION="7.3.0p3"
-BOOST_VERSION="1.69.0"
-#PCRE_VERSION="8.39"
-PCRE_VERSION="8.41"
-#LIBXML2_VERSION="2.9.3"
-LIBXML2_VERSION="2.9.9"
-CMAKE_VERSION="3.4.1"
-#CMAKE_VERSION="3.14.5"
-SWIG_VERSION="3.0.12"
-#SWIG_VERSION="4.0.0"
-#OPENCOLLADA_VERSION="v1.6.63"
-OPENCOLLADA_VERSION="v1.6.68"
-GMP_VERSION="6.1.2"
-MPFR_VERSION="3.1.5"
-CGAL_VERSION="4.13"
-
-# binaries
-cp="cp"
-bash="bash"
-uname="uname"
-git="git"
-bunzip2="bunzip2"
-tar="tar"
-cc="cc"
-cplusplus="c++"
-autoconf="autoconf"
-automake="automake"
-yacc="yacc"
-make="make"
-date = "date"
-curl="curl"
-wget="wget"
-strip="strip"
-
-# Helper function for coloured printing
-
-NO_COLOR="\033[0m" # <ref>http://stackoverflow.com/questions/5947742/how-to-change-the-output-color-of-echo-in-linux</ref>
-BLACK_ON_WHITE="\033[0;30;107m"
-RED="\033[31m"
-GREEN="\033[32m"
-YELLOW="\033[33m"
-MAGENTA="\033[35m"
-
-def cecho(message, color=NO_COLOR):
-    """Logs message `message` in color `color`."""
-    logger.info("%s%s\033[0m" % (color, message))
-
-def which(cmd):
-    for path in os.environ["PATH"].split(":"):
-        if os.path.exists(path) and cmd in os.listdir(path):
-            return cmd
-    return None
-
-def get_os():
-    ret_value = sp.check_output([uname, "-s"]).strip()
-    return ret_value
-
-def to_pystring(x):
-    """ Python 2 & 3 compatibility function for strings handling 
-    (to solve TypeError "Can't mix strings and bytes in path components" for Python 3).
-    Reference https://github.com/hugsy/gef/issues/382 """
-    res = str(x, encoding="utf-8") if PYTHON_MAJOR == 3 else x
-    substs = [("\n","\\n"), ("\r","\\r"), ("\t","\\t"), ("\v","\\v"), ("\b","\\b"), ]
-    for x,y in substs: res = res.replace(x,y)
-    return res
-
-# Set defaults for missing empty environment variables
-
-USE_OCCT = os.environ.get("USE_OCCT", "true").lower() == "true"
-
-TOOLSET = None
-if get_os() == "Darwin":
-    # C++11 features used in OCCT 7+ need a more recent stdlib
-    TOOLSET = "10.9" if USE_OCCT else "10.6"
-   
-try:
-    IFCOS_NUM_BUILD_PROCS = os.environ["IFCOS_NUM_BUILD_PROCS"]
-except KeyError:
-    IFCOS_NUM_BUILD_PROCS=multiprocessing.cpu_count() + 1
-
-try:
-    TARGET_ARCH = os.environ["TARGET_ARCH"]
-except KeyError:
-    TARGET_ARCH = sp.check_output([uname, "-m"]).strip()
-
-CMAKE_DIR=os.path.realpath(os.path.join("..", "cmake"))
-
-try:
-    DEPS_DIR = os.environ["DEPS_DIR"]
-except KeyError:
-    path = [b"..", b"build", sp.check_output(uname).strip(), TARGET_ARCH]
-    if TOOLSET:
-        path.append(TOOLSET)
-        
-    DEPS_DIR = to_pystring(os.path.realpath(os.path.join(*path)))
-
-if not os.path.exists(DEPS_DIR):
-    os.makedirs(DEPS_DIR)
-
-try:
-    BUILD_CFG=os.environ["BUILD_CFG"]
-except KeyError:
-    BUILD_CFG="RelWithDebInfo"
-
-
-# Print build configuration information
-
-cecho ("""This script fetches and builds %s and its dependencies
-""" % (PROJECT_NAME,), BLACK_ON_WHITE)
-cecho("""Script configuration:
-
-""", GREEN)
-cecho("""* Target Architecture    = %s""" % (TARGET_ARCH,), MAGENTA)
-cecho(" - Whether 32-bit (i686) or 64-bit (x86_64) will be built.")
-cecho("""* USE_OCCT               = %r""" % (USE_OCCT,), MAGENTA)
-if USE_OCCT:
-    cecho(" - Compiling against official Open Cascade")
-else:
-    cecho(" - Compiling against Open Cascade Community Edition")
-cecho("* Dependency Directory   = %s" % (DEPS_DIR,), MAGENTA)
-cecho(" - The directory where %s dependencies are installed." % (PROJECT_NAME,))
-cecho("* Build Config Type      = %s" % (BUILD_CFG,), MAGENTA)
-cecho(""" - The used build configuration type for the dependencies.
-   Defaults to RelWithDebInfo if not specified.""")
-
-if BUILD_CFG == "MinSizeRel":
-    cecho("     WARNING: MinSizeRel build can suffer from a significant performance loss.", RED)
-
-cecho("* IFCOS_NUM_BUILD_PROCS  = %s" % (IFCOS_NUM_BUILD_PROCS,), MAGENTA)
-cecho(""" - How many compiler processes may be run in parallel.
-""")
-
-dependency_tree = {
-    'IfcParse': ('boost',  'libxml2'),
-    'IfcGeom': ('IfcParse',  'occ',  'cgal', 'voxel'),
-    'IfcConvert': ('IfcGeom',  'OpenCOLLADA', 'json'),
-    'OpenCOLLADA': ('libxml2',  'pcre'),
-    'IfcGeomServer': ('IfcGeom', ),
-    'IfcOpenShell-Python': ('python',  'swig',  'IfcGeom'),
-    'voxel': ('occ',),
-    'swig': ('pcre',),
-    'boost': (),
-    'libxml2': (),
-    'python': (),
-    'swig': (),
-    'occ': (),
-    'cgal': (),
-    'pcre': (),
-    'json': ()
-}
-
-def v(dep):
-   yield dep
-   for d in dependency_tree[dep]:
-     for x in v(d):
-       yield x
-
-tgts = [s for s in sys.argv[1:] if not s.startswith("-")]
-flags = set(s for s in sys.argv[1:] if s.startswith("-"))
-
-BUILD_STATIC = not "-shared" in flags
-ENABLE_FLAG = "--enable-static" if BUILD_STATIC else "--enable-shared"
-DISABLE_FLAG = "--disable-shared" if BUILD_STATIC else "--disable-static"
-LINK_TYPE = "static" if BUILD_STATIC else "shared"
-LINK_TYPE_UCFIRST = LINK_TYPE[0].upper() + LINK_TYPE[1:]
-LIBRARY_EXT = "a" if BUILD_STATIC else "so"
-PIC = "-fPIC" if BUILD_STATIC else ""
-
-if len(tgts):
-    targets = set(sum((list(v(target)) for target in tgts), []))
-else:
-    targets = set(dependency_tree.keys())
-
-print("Building:", *sorted(targets, key=lambda t: len(list(v(t)))))
-
-# Check that required tools are in PATH
-
-for cmd in [git, bunzip2, tar, cc, cplusplus, autoconf, automake, yacc, make, "patch", "m4"]:
-    if which(cmd) is None:
-        raise ValueError("Required tool '%s' not installed or not added to PATH" % (cmd,))
-
-# identifiers for the download tool (could be less memory consuming as ints, but are more verbose as strings)
-download_tool_default = download_tool_py = "py"
-download_tool_git = "git"
-
-# Create log directory and file
-
-log_dir = os.path.join(DEPS_DIR, "logs")
-if not os.path.exists(log_dir):
-    os.makedirs(log_dir)
-LOG_FILE="%s.log" % (os.path.join(log_dir, to_pystring(sp.check_output([date, "+%Y%m%d"]).strip())),)
-if not os.path.exists(LOG_FILE):
-    open(LOG_FILE, "w").close()
-logger.info("using command log file '%s'" % (LOG_FILE,))
-
-def run(cmds, cwd=None):
-
-    """
-    Wraps `subprocess.Popen.communicate()` and logs the command being executed,
-    sets up logging `stderr` to `LOG_FILE` (in append mode) and returns stdout
-    with leading and trailing whitespace removed.
-    """
-
-    logger.debug("running command %r in directory %r" % (" ".join(cmds), cwd))
-    log_file_handle = open(LOG_FILE, "ab")
-    proc = sp.Popen(cmds, cwd=cwd, stdout=sp.PIPE, stderr=sp.PIPE)
-    stdout, stderr = proc.communicate()
-    log_file_handle.write(stdout)
-    log_file_handle.write(stderr)
-    log_file_handle.close()
-    logger.debug("command returned %r" % proc.returncode)
-
-    if proc.returncode != 0:
-        print("-" * 70)
-        print(stderr)
-        print("-" * 70)
-        raise Exception("Command `%s` returned exit code %d" % (" ".join(cmds), proc.returncode))
-
-    return stdout.strip()
-
-BOOST_VERSION_UNDERSCORE=BOOST_VERSION.replace(".", "_")
-CMAKE_VERSION_2=CMAKE_VERSION[:CMAKE_VERSION.rindex('.')]
-
-OCE_LOCATION="https://github.com/tpaviot/oce/archive/OCE-%s.tar.gz" % (OCE_VERSION,)
-BOOST_LOCATION="http://downloads.sourceforge.net/project/boost/boost/%s/boost_%s.tar.bz2" % (BOOST_VERSION, BOOST_VERSION_UNDERSCORE)
-
-# Helper functions
-
-def run_autoconf(arg1, configure_args, cwd):
-    configure_path = os.path.realpath(os.path.join(cwd, "..", "configure"))
-    install_dir = os.path.realpath("%s/install/%s" % (DEPS_DIR, arg1))
-    if not os.path.exists(install_dir):
-        # Some (MPFR) need to have prefix dir manually created
-        os.makedirs(install_dir)
-    if not os.path.exists(configure_path):
-        run([bash, "./autogen.sh"], cwd=os.path.realpath(os.path.join(cwd, ".."))) # only run autogen.sh in the directory it is located and use cwd to achieve that in order to not mess up things
-    # Using `sh` over `bash` fixes issues with building swig 
-    run(["/bin/sh", "../configure"]+configure_args+["--prefix=%s" % install_dir], cwd=cwd)
-
-def run_cmake(arg1, cmake_args, cmake_dir=None, cwd=None):
-    if cmake_dir is None:
-        P=".."
-    else:
-        P=cmake_dir
-    cmake_path= os.path.join(DEPS_DIR, "install", "cmake-%s" % (CMAKE_VERSION,), "bin", "cmake")
-    run([cmake_path, P]+cmake_args+["-DCMAKE_BUILD_TYPE=%s" % (BUILD_CFG,)], cwd=cwd)
-
-def git_clone_or_pull_repository(clone_url, target_dir, revision=None):
-    """Lazily clones the `git` repository denoted by `clone_url` into
-    the `target_dir` or pulls latest changes if the `target_dir` exists (naively assumes
-    that a working clone exists there) and optionally checks out a revision
-    `revision` after cloning or in the existing clone if `revision` is not
-    `None`."""
-    if not os.path.exists(target_dir):
-        logger.info("cloning '%s' into '%s'" % (clone_url, target_dir))
-        run([git, "clone", clone_url, target_dir])
-    else:
-        logger.info("directory '%s' already cloned. Pulling latest changes." % (target_dir,))
-
-    # detect whether we are on a branch and pull
-    if run([git, "rev-parse", "--abbrev-ref", "HEAD"], cwd=target_dir) != "HEAD":
-        run([git, "pull", clone_url], cwd=target_dir)
-
-    if revision != None:
-        run([git, "checkout", revision], cwd=target_dir)
-
-
-def build_dependency(name, mode, build_tool_args, download_url, download_name, download_tool=download_tool_default, revision=None, patch=None, additional_files={}, no_append_name=False):
-    """Handles building of dependencies with different tools (which are
-    distinguished with the `mode` argument. `build_tool_args` is expected to be
-    a list which is necessary in order to not mess up quoting of compiler and
-    linker flags."""
-    check_dir = os.path.join(DEPS_DIR, "install", name)
-    if os.path.exists(check_dir):
-        logger.info( "Found existing %s, skipping" % (name,))
-        return
-    build_dir = os.path.join(DEPS_DIR, "build")
-    if not os.path.exists(build_dir):
-        os.makedirs(build_dir)
-        
-    logger.info("\rFetching %s...   " % (name,))
-    
-    if download_tool == download_tool_py:
-        if no_append_name:
-            url = download_url
-        else:
-            url = os.path.join(download_url, download_name)
-            
-        download_path = os.path.join(build_dir, download_name)
-        if not os.path.exists(download_path):
-            urlretrieve(url, os.path.join(build_dir, download_path))
-        else:
-            logger.info("Download '%s' already exists, assuming it's an undamaged download and that it has been extracted if possible, skipping" % (download_path,))
-    elif download_tool == download_tool_git:
-        logger.info("\rChecking %s...   " % (name,))
-        git_clone_or_pull_repository(download_url, target_dir=os.path.join(build_dir, download_name), revision=revision)
-    else:
-        raise ValueError("download tool '%s' is not supported" % (download_tool,))
-    download_dir = os.path.join(build_dir, download_name)
-    
-    if os.path.isdir(download_dir):
-        extract_dir_name=download_name
-        extract_dir = os.path.join(build_dir, extract_dir_name)
-    else:
-        download_tarfile_path = os.path.join(build_dir, download_name)
-        if download_name.endswith(".tar.gz") or download_name.endswith(".tgz"):
-            compr = "gz"
-        elif download_name.endswith(".tar.bz2"):
-            compr = "bz2"
-        else:
-            raise RuntimeError("fix source for new download type")
-        download_tarfile = tarfile.open(name=download_tarfile_path, mode="r:%s" % (compr,))
-        extract_dir_name= os.path.commonprefix(download_tarfile.getnames()) # tarfile seriously doesn't have a function to retrieve the root directory more easily
-        #run([tar, "--exclude=\"*/*\"", "-tf", download_name], cwd=build_dir).strip() no longer works
-        if extract_dir_name is None:
-            extract_dir_name= run([bash, "-c", "tar -tf %s 2> /dev/null | head -n 1 | cut -f1 -d /" % (download_name,)], cwd=build_dir)
-        extract_dir = os.path.join(build_dir, extract_dir_name)
-        if not os.path.exists(extract_dir):
-            run([tar, "-xf", download_name], cwd=build_dir)
-    
-    for path, url in additional_files.items():
-        if not os.path.exists(path):
-            urlretrieve(url, os.path.join(extract_dir, path))
-            
-    if patch is not None:
-        patch_abs = os.path.abspath(os.path.join(os.path.dirname(__file__), patch))
-        if os.path.exists(patch_abs):
-            try: run(["patch", "-p1", "--batch", "--forward", "-i", patch_abs], cwd=extract_dir)
-            except Exception as e:
-                # Assert that the patch has already been applied
-                run(["patch", "-p1", "--batch", "--reverse", "--dry-run", "-i", patch_abs], cwd=extract_dir)
-            
-    if mode != "bjam":
-        extract_build_dir = os.path.join(extract_dir, "build")
-        if os.path.exists(extract_build_dir):
-            shutil.rmtree(extract_build_dir)
-        os.makedirs(extract_build_dir)
-
-        logger.info("\rConfiguring %s..." % (name,))
-        if mode == "autoconf":
-            run_autoconf(name, build_tool_args, cwd=extract_build_dir)
-        elif mode == "cmake":
-            run_cmake(name, build_tool_args, cwd=extract_build_dir)
-        else:
-            raise ValueError()
-        logger.info("\rBuilding %s...   " % (name,))
-        run([make, "-j%s" % (IFCOS_NUM_BUILD_PROCS,)], cwd=extract_build_dir)
-        logger.info( "\rInstalling %s... " % (name,))
-        run([make, "install"], cwd=extract_build_dir)
-        logger.info( "\rInstalled %s     \n" % (name,))
-    else:
-        logger.info( "\rConfiguring %s..." % (name,))
-        run([bash, "./bootstrap.sh"], cwd=extract_dir)
-        logger.info("\rBuilding %s...   " % (name,))
-        run(["./b2", "-j%s" % (IFCOS_NUM_BUILD_PROCS,)]+build_tool_args, cwd=extract_dir)
-        logger.info("\rInstalling %s... " % (name,))
-        shutil.copytree(os.path.join(extract_dir, "boost"), os.path.join(DEPS_DIR, "install", "boost-%s" % BOOST_VERSION, "boost"))
-        logger.info("\rInstalled %s     \n" % (name,))
-
-cecho("Collecting dependencies:", GREEN)
-
-# Set compiler flags for 32bit builds on 64bit system
-# TODO: This is untested
-
-ADDITIONAL_ARGS=[]
-BOOST_ADDRESS_MODEL=[]
-if TARGET_ARCH == "i686" and run([uname, "-m"]).strip() == "x86_64":
-    ADDITIONAL_ARGS=["-m32", "-arch i386"]
-    BOOST_ADDRESS_MODEL=["architecture=x86", "address-model=32"]
-
-if get_os() == "Darwin":
-    ADDITIONAL_ARGS=["-mmacosx-version-min=%s" % TOOLSET]+ADDITIONAL_ARGS
-
-# If the linker supports GC sections, set it up to reduce binary file size
-# -fPIC is required for the shared libraries to work
-
-CXXFLAGS=os.environ.get("CXXFLAGS", "")
-CFLAGS=os.environ.get("CFLAGS", "")
-LDFLAGS=os.environ.get("LDFLAGS", "")
-
-if sp.call([bash, "-c", "ld --gc-sections 2>&1 | grep -- --gc-sections &> /dev/null"]) != 0:
-    CXXFLAGS_MINIMAL="%s %s %s" % (CXXFLAGS, PIC, str.join(" ", ADDITIONAL_ARGS))
-    CFLAGS_MINIMAL="%s %s %s" % (CFLAGS, PIC, str.join(" ", ADDITIONAL_ARGS))
-    if BUILD_STATIC:
-        CXXFLAGS="%s %s -fdata-sections -ffunction-sections -fvisibility=hidden -fvisibility-inlines-hidden %s" % (CXXFLAGS, PIC, str.join(" ", ADDITIONAL_ARGS))
-        CFLAGS="%s   %s -fdata-sections -ffunction-sections -fvisibility=hidden %s"% (CFLAGS, PIC, str.join(" ", ADDITIONAL_ARGS))
-    else:
-        CXXFLAGS=CXXFLAGS_MINIMAL
-        CFLAGS=CFLAGS_MINIMAL
-    LDFLAGS="%s  -Wl,--gc-sections %s" % (LDFLAGS, str.join(" ", ADDITIONAL_ARGS))
-else:
-    CXXFLAGS_MINIMAL="%s %s %s" % (CXXFLAGS, PIC, str.join(" ", ADDITIONAL_ARGS))
-    CFLAGS_MINIMAL="%s   %s %s" % (CFLAGS, PIC, str.join(" ", ADDITIONAL_ARGS))
-    if BUILD_STATIC:
-        CXXFLAGS="%s %s -fvisibility=hidden -fvisibility-inlines-hidden %s" % (CXXFLAGS, PIC, str.join(" ", ADDITIONAL_ARGS))
-        CFLAGS="%s   %s -fvisibility=hidden -fvisibility-inlines-hidden %s" % (CFLAGS, PIC, str.join(" ", ADDITIONAL_ARGS))
-    else:
-        CXXFLAGS=CXXFLAGS_MINIMAL
-        CFLAGS=CFLAGS_MINIMAL
-    LDFLAGS="%s %s" % (LDFLAGS, str.join(" ", ADDITIONAL_ARGS))
-    
-os.environ["CXXFLAGS"] = CXXFLAGS
-os.environ["CFLAGS"] = CFLAGS
-os.environ["LDFLAGS"] = LDFLAGS
-
-# Some dependencies need a more recent CMake version than most distros provide
-build_dependency(name="cmake-%s" % (CMAKE_VERSION,), mode="autoconf", build_tool_args=[], download_url="https://cmake.org/files/v%s" % (CMAKE_VERSION_2,), download_name="cmake-%s.tar.gz" % (CMAKE_VERSION,))
-
-# Extract compiler flags from CMake to harmonize settings with other autoconf dependencies
-CMAKE_FLAG_EXTRACT_DIR="ifcopenshell_cmake_test_%s" % (time.time(),)
-# was sp.check_output([bash, "-c", "cat /dev/urandom | env LC_CTYPE=C tr -dc 'a-zA-Z0-9' | head -c 32"]), in bash script, unclear what the exact required format is and whether it's needed
-if os.path.exists(CMAKE_FLAG_EXTRACT_DIR):
-    shutil.rmtree(CMAKE_FLAG_EXTRACT_DIR)
-os.makedirs(CMAKE_FLAG_EXTRACT_DIR)
-BUILD_CFG_UPPER=BUILD_CFG.upper()
-for FL in ["C", "CXX"]:
-    run([bash, "-c", """echo "
-    message(\"\${CMAKE_%s_FLAGS_%s}\")
-    " > CMakeLists.txt""" % (FL, BUILD_CFG_UPPER)], cwd=CMAKE_FLAG_EXTRACT_DIR)
-    FL="%sFLAGS" % (FL,)
-    FLM="%sFLAGS_MINIMAL" % (FL,)
-# @TODO: bash code unclear
-#    exec("%sFLAGS=%s" % (FL, sp.check_output([os.path.join(DEPS_DIR, "install", "cmake-%s" % (CMAKE_VERSION,), "bin", "cmake"), "."
-#    declare ${FL}FLAGS_MINIMAL="`$DEPS_DIR/install/cmake-$CMAKE_VERSION/bin/cmake . 2>&1 >/dev/null` ${!FLM}"
-shutil.rmtree(CMAKE_FLAG_EXTRACT_DIR)
-
-if "json" in targets:
-    json_url = "https://github.com/nlohmann/json/releases/download/{JSON_VERSION}/json.hpp".format(**locals())
-    json_install_path = "{DEPS_DIR}/install/json/nlohmann/json.hpp".format(**locals())
-    if not os.path.exists(os.path.dirname(json_install_path)):
-        os.makedirs(os.path.dirname(json_install_path))
-    if not os.path.exists(json_install_path):
-        urlretrieve(json_url, json_install_path)
-
-if "pcre" in targets:
-    build_dependency(
-        name="pcre-{PCRE_VERSION}".format(**locals()),
-        mode="autoconf",
-        build_tool_args=[DISABLE_FLAG],
-        download_url="https://downloads.sourceforge.net/project/pcre/pcre/{PCRE_VERSION}/".format(**locals()),
-        download_name="pcre-{PCRE_VERSION}.tar.bz2".format(**locals())
-    )
-
-# An issue exists with swig-1.3 and python >= 3.2
-# Therefore, build a recent copy from source
-if "swig" in targets:
-    build_dependency(
-        name="swig",
-        mode="autoconf",
-        build_tool_args=["--with-pcre-prefix={DEPS_DIR}/install/pcre-{PCRE_VERSION}".format(**locals())],
-        download_url="https://github.com/swig/swig.git",
-        download_name="swig",
-        download_tool=download_tool_git,
-        revision="rel-{SWIG_VERSION}".format(**locals())
-    )
-
-if USE_OCCT and "occ" in targets:
-    build_dependency(
-        name="occt-{OCCT_VERSION}".format(**locals()),
-        mode="cmake",
-        build_tool_args=[
-            "-DINSTALL_DIR={DEPS_DIR}/install/occt-{OCCT_VERSION}".format(**locals()),
-            "-DBUILD_LIBRARY_TYPE={LINK_TYPE_UCFIRST}".format(**locals()),
-            "-DBUILD_MODULE_Draw=0",
-        ],
-        download_url = "https://git.dev.opencascade.org/repos/occt.git",
-        download_name = "occt",
-        download_tool=download_tool_git,
-        patch="./patches/occt/enable-exception-handling.patch",
-        revision="V" + OCCT_VERSION.replace('.', '_')
-    )
-    occ_include_dir = "{DEPS_DIR}/install/occt-{OCCT_VERSION}/include/opencascade".format(**locals())
-    occ_library_dir = "{DEPS_DIR}/install/occt-{OCCT_VERSION}/lib".format(**locals())
-elif "occ" in targets:
-    build_dependency(
-        name="oce-{OCE_VERSION}".format(**locals()),
-        mode="cmake",
-        build_tool_args=[
-            "-DOCE_DISABLE_TKSERVICE_FONT=ON",
-            "-DOCE_TESTING=OFF",
-            "-DOCE_BUILD_SHARED_LIB=OFF",
-            "-DOCE_DISABLE_X11=ON",
-            "-DOCE_VISUALISATION=OFF",
-            "-DOCE_OCAF=OFF",
-            "-DOCE_INSTALL_PREFIX={DEPS_DIR}/install/oce-{OCE_VERSION}".format(**locals())
-        ],
-        download_url="https://github.com/tpaviot/oce/archive/",
-        download_name="OCE-{OCE_VERSION}.tar.gz".format(**locals())
-    )
-    occ_include_dir = "{DEPS_DIR}/install/oce-{OCE_VERSION}/include/oce".format(**locals())
-    occ_library_dir = "{DEPS_DIR}/install/oce-{OCE_VERSION}/lib"
-
-        
-if "libxml2" in targets:
-    build_dependency(
-        "libxml2-{LIBXML2_VERSION}".format(**locals()),
-        "autoconf",
-        build_tool_args=[
-            "--without-python",
-            ENABLE_FLAG,
-            DISABLE_FLAG,
-            "--without-zlib",
-            "--without-iconv",
-            "--without-lzma"
-        ],
-        download_url="ftp://xmlsoft.org/libxml2/",
-        download_name="libxml2-{LIBXML2_VERSION}.tar.gz".format(**locals())
-    )
-    
-if "OpenCOLLADA" in targets:
-    build_dependency(
-        "OpenCOLLADA",
-        "cmake",
-        build_tool_args=[
-            "-DLIBXML2_INCLUDE_DIR={DEPS_DIR}/install/libxml2-{LIBXML2_VERSION}/include/libxml2".format(**locals()),
-            "-DLIBXML2_LIBRARIES={DEPS_DIR}/install/libxml2-{LIBXML2_VERSION}/lib/libxml2.{LIBRARY_EXT}".format(**locals()),
-            "-DPCRE_INCLUDE_DIR={DEPS_DIR}/install/pcre-{PCRE_VERSION}/include".format(**locals()),
-            "-DPCRE_PCREPOSIX_LIBRARY={DEPS_DIR}/install/pcre-{PCRE_VERSION}/lib/libpcreposix.{LIBRARY_EXT}".format(**locals()),
-            "-DPCRE_PCRE_LIBRARY={DEPS_DIR}/install/pcre-{PCRE_VERSION}/lib/libpcre.{LIBRARY_EXT}".format(**locals()),
-            "-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/OpenCOLLADA/".format(**locals())
-        ],
-        download_url="https://github.com/KhronosGroup/OpenCOLLADA.git",
-        download_name="OpenCOLLADA",
-        download_tool=download_tool_git,
-        revision=OPENCOLLADA_VERSION
-    )
-
-if "python" in targets:
-    # Python should not be built with -fvisibility=hidden, from experience that introduces segfaults
-    OLD_CXX_FLAGS=os.environ["CXXFLAGS"]
-    OLD_C_FLAGS=os.environ["CFLAGS"]
-    os.environ["CXXFLAGS"]=CXXFLAGS_MINIMAL
-    os.environ["CFLAGS"]=CFLAGS_MINIMAL
-
-    # On OSX a dynamic python library is built or it would not be compatible
-    # with the system python because of some threading initialization
-    PYTHON_CONFIGURE_ARGS=[]
-    if get_os() == "Darwin":
-        PYTHON_CONFIGURE_ARGS=["--disable-static", "--enable-shared"]
-
-    def get_python_unicode_confs(py_ver):
-        if py_ver < "3.3":
-            return [("--enable-unicode=ucs2",""), ("--enable-unicode=ucs4","u")]
-        else: return [("","")]
-
-    def PYTHON_VERSION_CONFS():
-        for v in PYTHON_VERSIONS:
-            for unicode_conf, abi_tag in get_python_unicode_confs(v):
-                yield v, unicode_conf, abi_tag
-
-    for PYTHON_VERSION, unicode_conf, abi_tag in PYTHON_VERSION_CONFS():
-        build_dependency(
-            "python-{PYTHON_VERSION}{abi_tag}".format(**locals()),
-            "autoconf",
-            PYTHON_CONFIGURE_ARGS + [unicode_conf],
-            "http://www.python.org/ftp/python/{PYTHON_VERSION}/".format(**locals()),
-            "Python-{PYTHON_VERSION}.tgz".format(**locals())
-        )
-
-    os.environ["CXXFLAGS"]=OLD_CXX_FLAGS
-    os.environ["CFLAGS"]=OLD_C_FLAGS
-
-if "boost" in targets:
-    str_concat = lambda prefix: lambda postfix: "" if postfix.strip() == "" else "=".join((prefix, postfix.strip()))
-    build_dependency(
-        "boost-{BOOST_VERSION}".format(**locals()),
-        mode="bjam",
-        build_tool_args=[
-            "--stagedir={DEPS_DIR}/install/boost-{BOOST_VERSION}".format(**locals()),
-            "--with-system",
-            "--with-program_options",
-            "--with-regex",
-            "--with-thread",
-            "--with-date_time",
-            "--with-iostreams",
-            "link={LINK_TYPE}".format(**locals())
-                                                                         ] + \
-            BOOST_ADDRESS_MODEL                                            + \
-            list(map(str_concat("cxxflags"), CXXFLAGS.strip().split(' '))) + \
-            list(map(str_concat("linkflags"), LDFLAGS.strip().split(' '))) + \
-            ["stage", "-s", "NO_BZIP2=1"],
-        download_url="http://downloads.sourceforge.net/project/boost/boost/{BOOST_VERSION}/".format(**locals()),
-        download_name="boost_{BOOST_VERSION_UNDERSCORE}.tar.bz2".format(**locals())
-    )
-    
-if "cgal" in targets:
-    build_dependency(name="gmp-%s" % (GMP_VERSION,), mode="autoconf", build_tool_args=["--disable-shared", "--with-pic"], download_url="https://ftp.gnu.org/gnu/gmp/", download_name="gmp-%s.tar.bz2" % (GMP_VERSION,))
-    build_dependency(name="mpfr-%s" % (MPFR_VERSION,), mode="autoconf", build_tool_args=["--disable-shared", "--with-gmp=%s/install/gmp-%s" % (DEPS_DIR, GMP_VERSION)], download_url="http://www.mpfr.org/mpfr-%s/" % (MPFR_VERSION,), download_name="mpfr-%s.tar.bz2" % (MPFR_VERSION,))
-    
-    OLD_BUILD_CFG = BUILD_CFG
-    if BUILD_CFG != "Debug":
-        # CGAL only supports Debug and Release for CMAKE_BUILD_TYPE
-        BUILD_CFG = "Release"
-    build_dependency(name="cgal-{CGAL_VERSION}".format(**locals()), mode="cmake", build_tool_args=["-DGMP_LIBRARIES=%s/install/gmp-%s/lib/libgmp.a" % (DEPS_DIR, GMP_VERSION), "-DGMP_INCLUDE_DIR=%s/install/gmp-%s/include" % (DEPS_DIR, GMP_VERSION), "-DMPFR_LIBRARIES=%s/install/mpfr-%s/lib/libmpfr.a" % (DEPS_DIR, MPFR_VERSION), "-DMPFR_INCLUDE_DIR=%s/install/mpfr-%s/include" % (DEPS_DIR, MPFR_VERSION), "-DBoost_INCLUDE_DIR=%s/install/boost-%s" % (DEPS_DIR, BOOST_VERSION), "-DCMAKE_INSTALL_PREFIX=%s/install/cgal-%s/" % (DEPS_DIR, CGAL_VERSION), "-DBUILD_SHARED_LIBS=Off"], download_url="https://github.com/CGAL/cgal.git", download_name="cgal", download_tool=download_tool_git, revision="releases/CGAL-{CGAL_VERSION}".format(**locals()))
-    BUILD_CFG = OLD_BUILD_CFG
-    
-if "voxel" in targets:
-    build_dependency(
-        "voxel",
-        "cmake",
-        build_tool_args=[
-            "-DIFC_SUPPORT=Off",
-            "-DOCC_INCLUDE_DIR="    +occ_include_dir,
-            "-DOCC_LIBRARY_DIR="    +occ_library_dir,
-            "-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/voxel".format(**locals()),
-            "-DBOOST_ROOT="        "{DEPS_DIR}/install/boost-{BOOST_VERSION}".format(**locals())
-        ],
-        download_url="https://github.com/opensourceBIM/voxel.git",
-        download_name="voxel",
-        download_tool=download_tool_git,
-        revision="master"
-    )
-
-cecho("Building IfcOpenShell:", GREEN)
-
-IFCOS_DIR=os.path.join(DEPS_DIR, "build", "ifcopenshell")
-if os.path.exists(IFCOS_DIR):
-    shutil.rmtree(IFCOS_DIR)
-os.makedirs(IFCOS_DIR)
-
-executables_dir = os.path.join(IFCOS_DIR, "executables")
-if not os.path.exists(executables_dir):
-    os.makedirs(executables_dir)
-
-logger.info("\rConfiguring executables...")
-
-OFF_ON = ["OFF", "ON"]
-
-cmake_args=[
-    "-DUSE_MMAP="                      "OFF",
-    "-DBUILD_EXAMPLES="                "OFF",
-    "-DBUILD_IFCPYTHON="               "OFF",
-    "-DBUILD_SHARED_LIBS="            +OFF_ON[not BUILD_STATIC],
-    "-DBUILD_IFCGEOM="                +OFF_ON["IfcGeom" in targets],
-    "-DBUILD_GEOMSERVER="             +OFF_ON["IfcGeomServer" in targets],
-    "-DBUILD_CONVERT="                +OFF_ON["IfcConvert" in targets],
-    "-DCMAKE_INSTALL_PREFIX="          "{DEPS_DIR}/install/ifcopenshell".format(**locals()),
-    "-DBOOST_ROOT="                    "{DEPS_DIR}/install/boost-{BOOST_VERSION}".format(**locals()),
-    "-DGLTF_SUPPORT="                  "ON",
-    "-DJSON_INCLUDE_DIR="              "{DEPS_DIR}/install/json".format(**locals())
-]
-
-if "occ" in targets:
-    cmake_args.extend([
-        "-DOCC_INCLUDE_DIR="           +occ_include_dir,
-        "-DOCC_LIBRARY_DIR="           +occ_library_dir
-    ])
-elif "occ" in targets:
-    cmake_args.extend([
-        "-DOCC_INCLUDE_DIR="           +occ_include_dir,
-        "-DOCC_LIBRARY_DIR="           +occ_library_dir
-    ])
-
-if "cgal" in targets:
-    cmake_args.extend([
-        "-DCGAL_INCLUDE_DIR="          "{DEPS_DIR}/install/cgal-{CGAL_VERSION}/include".format(**locals()),
-        "-DCGAL_LIBRARY_DIR="          "{DEPS_DIR}/install/cgal-{CGAL_VERSION}/lib".format(**locals()),
-        "-DGMP_INCLUDE_DIR="           "{DEPS_DIR}/install/gmp-{GMP_VERSION}/include".format(**locals()),
-        "-DGMP_LIBRARY_DIR="           "{DEPS_DIR}/install/gmp-{GMP_VERSION}/lib".format(**locals()),
-        "-DMPFR_INCLUDE_DIR="          "{DEPS_DIR}/install/mpfr-{MPFR_VERSION}/include".format(**locals()),
-        "-DMPFR_LIBRARY_DIR="          "{DEPS_DIR}/install/mpfr-{MPFR_VERSION}/lib".format(**locals())
-    ])
-
-if "OpenCOLLADA" in targets:
-    cmake_args.extend([
-        "-DOPENCOLLADA_INCLUDE_DIR="   "{DEPS_DIR}/install/OpenCOLLADA/include/opencollada".format(**locals()),
-        "-DOPENCOLLADA_LIBRARY_DIR="   "{DEPS_DIR}/install/OpenCOLLADA/lib/opencollada".format(**locals())
-    ])
-
-if "pcre" in targets:
-    cmake_args.append(
-        "-DPCRE_LIBRARY_DIR="          "{DEPS_DIR}/install/pcre-{PCRE_VERSION}/lib".format(**locals())
-    )
-
-if "libxml2" in targets:
-    cmake_args.extend([
-        "-DLIBXML2_INCLUDE_DIR="       "{DEPS_DIR}/install/libxml2-{LIBXML2_VERSION}/include/libxml2".format(**locals()),
-        "-DLIBXML2_LIBRARIES="         "{DEPS_DIR}/install/libxml2-{LIBXML2_VERSION}/lib/libxml2.{LIBRARY_EXT}".format(**locals())
-    ])
-
-run_cmake("", cmake_args, cmake_dir=CMAKE_DIR, cwd=executables_dir)
-
-logger.info("\rBuilding executables...   ")
-
-run([make, "-j{IFCOS_NUM_BUILD_PROCS}".format(**locals())], cwd=executables_dir)
-run([make, "install/strip" if BUILD_CFG == "Release" else "install"], cwd=executables_dir)
-
-if "IfcOpenShell-Python" in targets:
-
-    # On OSX the actual Python library is not linked against.
-    ADDITIONAL_ARGS=""
-    if get_os() == "Darwin":
-        ADDITIONAL_ARGS="-Wl,-flat_namespace,-undefined,suppress"
-
-    os.environ["CXXFLAGS"]="%s %s" % (CXXFLAGS_MINIMAL, ADDITIONAL_ARGS)
-    os.environ["CFLAGS"]="%s %s" % (CFLAGS_MINIMAL, ADDITIONAL_ARGS)
-    os.environ["LDFLAGS"]="%s %s" % (LDFLAGS, ADDITIONAL_ARGS)
-
-    for PYTHON_VERSION, _, TAG in PYTHON_VERSION_CONFS():
-        logger.info("\rConfiguring python {PYTHON_VERSION}{TAG} wrapper...".format(**locals()))
-
-        python_dir = os.path.join(IFCOS_DIR, "python-{PYTHON_VERSION}{TAG}".format(**locals()))
-        if not os.path.exists(python_dir):
-            os.makedirs(python_dir)
-
-        PYTHON_LIBRARY=run([bash, "-c", "ls    {DEPS_DIR}/install/python-{PYTHON_VERSION}{TAG}/lib/libpython*.*".format(**locals())])
-        PYTHON_INCLUDE=run([bash, "-c", "ls -d {DEPS_DIR}/install/python-{PYTHON_VERSION}{TAG}/include/python*".format(**locals())])
-        PYTHON_EXECUTABLE=os.path.join(DEPS_DIR, "install", "python-{PYTHON_VERSION}{TAG}".format(**locals()), "bin", "python{PYTHON_VERSION[0]}".format(**locals()))
-        os.environ["PYTHON_LIBRARY_BASENAME"]=os.path.basename(PYTHON_LIBRARY)
-
-        run_cmake("",
-            cmake_args=[
-                "-DBUILD_SHARED_LIBS="       "OFF" if BUILD_STATIC else "ON",
-                "-DBOOST_ROOT="              "{DEPS_DIR}/install/boost-{BOOST_VERSION}".format(**locals()),
-                "-DOCC_INCLUDE_DIR="         +occ_include_dir,
-                "-DOCC_LIBRARY_DIR="         +occ_library_dir,
-                "-DPYTHON_LIBRARY="          +PYTHON_LIBRARY,
-                "-DPYTHON_EXECUTABLE="       +PYTHON_EXECUTABLE,
-                "-DPYTHON_INCLUDE_DIR="      +PYTHON_INCLUDE,
-                "-DSWIG_EXECUTABLE="         "{DEPS_DIR}/install/swig/bin/swig".format(**locals()),
-                "-DCMAKE_INSTALL_PREFIX="    "{DEPS_DIR}/install/ifcopenshell/tmp".format(**locals()),
-                "-DLIBXML2_INCLUDE_DIR="     "{DEPS_DIR}/install/libxml2-{LIBXML2_VERSION}/include/libxml2".format(**locals()),
-                "-DLIBXML2_LIBRARIES="       "{DEPS_DIR}/install/libxml2-{LIBXML2_VERSION}/lib/libxml2.{LIBRARY_EXT}".format(**locals()),
-                "-DCOLLADA_SUPPORT=OFF"
-            ], cmake_dir=CMAKE_DIR, cwd=python_dir)
-        
-        logger.info("\rBuilding python %s%s wrapper...   " % (PYTHON_VERSION, TAG))
-
-        run([make, "-j%s" % (IFCOS_NUM_BUILD_PROCS,), "_ifcopenshell_wrapper"], cwd=python_dir)
-        run([make, "install/local"], cwd=os.path.join(python_dir, "ifcwrap"))
-
-        module_dir = os.path.dirname(run([PYTHON_EXECUTABLE, "-c", "from __future__ import print_function; import inspect, ifcopenshell; print(inspect.getfile(ifcopenshell))"]))
-
-        if get_os() != "Darwin":
-            # TODO: This symbol name depends on the Python version?
-            run([strip, "-s", "-K", "PyInit__ifcopenshell_wrapper", "_ifcopenshell_wrapper.so"], cwd=module_dir)
-
-        run([cp, "-R", module_dir, os.path.join(DEPS_DIR, "install", "ifcopenshell", "python-%s%s" % (PYTHON_VERSION, TAG))])
-
-logger.info("\rBuilt IfcOpenShell...\n\n")
@@ -1,32 +0,0 @@
-http://git.dev.opencascade.org/gitweb/?p=occt.git;a=commitdiff;h=0ab4e621833f4eae945a3762c9a29ee12e2eec53#patch1
-diff --git a/src/HLRBRep/HLRBRep_InternalAlgo.cxx b/src/HLRBRep/HLRBRep_InternalAlgo.cxx
-index ca885ca..c13cb06 100644 (file)
--- a/src/HLRBRep/HLRBRep_InternalAlgo.cxx
-+++ b/src/HLRBRep/HLRBRep_InternalAlgo.cxx
-@@ -165,7 +165,7 @@ void HLRBRep_InternalAlgo::Update ()
-       SB.Bounds(v1,v2,e1,e2,f1,f2);
- 
-       for (Standard_Integer e = e1; e <= e2; e++) {
-        HLRBRep_EdgeData ed = aEDataArray.ChangeValue(e);
-+        HLRBRep_EdgeData& ed = aEDataArray.ChangeValue(e);
-         HLRAlgo::DecodeMinMax(ed.MinMax(), TheMin, TheMax);
-        if (FirstTime) {
-          FirstTime = Standard_False;
-@@ -307,7 +307,7 @@ void HLRBRep_InternalAlgo::InitEdgeStatus ()
-   Standard_Integer nf = myDS->NbFaces();
- 
-   for (Standard_Integer e = 1; e <= ne; e++) {
-    HLRBRep_EdgeData ed = aEDataArray.ChangeValue(e);
-+    HLRBRep_EdgeData& ed = aEDataArray.ChangeValue(e);
-     if (ed.Selected()) ed.Status().ShowAll();
-   }
- //  for (Standard_Integer f = 1; f <= nf; f++) {
-@@ -368,7 +368,7 @@ void HLRBRep_InternalAlgo::Select ()
-     Standard_Integer nf = myDS->NbFaces();
-     
-     for (Standard_Integer e = 1; e <= ne; e++) {
-      HLRBRep_EdgeData ed = aEDataArray.ChangeValue(e);
-+      HLRBRep_EdgeData& ed = aEDataArray.ChangeValue(e);
-       ed.Selected(Standard_True);
-     }
-     
@@ -1,17 +0,0 @@
-Description: Enable exception handling
- Upstream defaults to no exception handling for performance reasons,
- but in OCCT's role as a shared library it's better for Debian to
- enable it.
-Author: Kurt Kremitzki <kkremitzki@gmail.com>
-Last-Update: 2018-06-10
-
--- a/adm/cmake/occt_defs_flags.cmake
-+++ b/adm/cmake/occt_defs_flags.cmake
-@@ -138,5 +138,5 @@
-   set (CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -s")
- endif()
- 
-set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DNo_Exception")
-set (CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -DNo_Exception")
-+#set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DNo_Exception")
-+#set (CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -DNo_Exception")
@@ -1,30 +1,5 @@
-################################################################################
-#                                                                              #
-# This file is part of IfcOpenShell.                                           #
-#                                                                              #
-# IfcOpenShell is free software: you can redistribute it and/or modify         #
-# it under the terms of the Lesser GNU General Public License as published by  #
-# the Free Software Foundation, either version 3.0 of the License, or          #
-# (at your option) any later version.                                          #
-#                                                                              #
-# IfcOpenShell is distributed in the hope that it will be useful,              #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 #
-# Lesser GNU General Public License for more details.                          #
-#                                                                              #
-# You should have received a copy of the Lesser GNU General Public License     #
-# along with this program. If not, see <http://www.gnu.org/licenses/>.         #
-#                                                                              #
-################################################################################
-
 ADD_EXECUTABLE(IfcParseExamples IfcParseExamples.cpp)
-TARGET_LINK_LIBRARIES(IfcParseExamples IfcParse)
-set_target_properties(IfcParseExamples PROPERTIES FOLDER Examples)
+TARGET_LINK_LIBRARIES (IfcParseExamples IfcParse)

 ADD_EXECUTABLE(IfcOpenHouse IfcOpenHouse.cpp)
-TARGET_LINK_LIBRARIES(IfcOpenHouse ${IFCOPENSHELL_LIBRARIES} ${OPENCASCADE_LIBRARIES})
-set_target_properties(IfcOpenHouse PROPERTIES FOLDER Examples)
-
-ADD_EXECUTABLE(IfcAdvancedHouse IfcAdvancedHouse.cpp)
-TARGET_LINK_LIBRARIES(IfcAdvancedHouse ${IFCOPENSHELL_LIBRARIES} ${OPENCASCADE_LIBRARIES})
-set_target_properties(IfcAdvancedHouse PROPERTIES FOLDER Examples)
+TARGET_LINK_LIBRARIES (IfcOpenHouse IfcParse IfcGeom TKernel TKMath TKBRep TKGeomBase TKGeomAlgo TKG3d TKG2d TKShHealing TKTopAlgo TKMesh TKPrim TKBool TKBO TKFillet TKOffset)
@@ -1,177 +0,0 @@
-/********************************************************************************
- *                                                                              *
- * This file is part of IfcOpenShell.                                           *
- *                                                                              *
- * IfcOpenShell is free software: you can redistribute it and/or modify         *
- * it under the terms of the Lesser GNU General Public License as published by  *
- * the Free Software Foundation, either version 3.0 of the License, or          *
- * (at your option) any later version.                                          *
- *                                                                              *
- * IfcOpenShell is distributed in the hope that it will be useful,              *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
- * Lesser GNU General Public License for more details.                          *
- *                                                                              *
- * You should have received a copy of the Lesser GNU General Public License     *
- * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
- *                                                                              *
- ********************************************************************************/
-
-#include <string>
-#include <iostream>
-#include <fstream>
-
-#include <TColgp_Array2OfPnt.hxx>
-#include <TColgp_Array1OfPnt.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <TColStd_Array1OfInteger.hxx>
-
-#include <Geom_BSplineSurface.hxx>
-
-#include <BRepBuilderAPI_MakeFace.hxx>
-#include <BRepBuilderAPI_NurbsConvert.hxx>
-
-#include <BRepPrimAPI_MakeBox.hxx>
-#include <BRepPrimAPI_MakeSphere.hxx>
-
-#include <BRepAlgoAPI_Cut.hxx>
-
-#include <Standard_Version.hxx>
-
-#define IfcSchema Ifc2x3
-#include "../ifcparse/macros.h"
-#include "../ifcparse/Ifc2x3.h"
-#include "../ifcparse/IfcBaseClass.h"
-#include "../ifcparse/IfcHierarchyHelper.h"
-
-#include "../ifcgeom/schema_agnostic/Serialization.h"
-
-#if USE_VLD
-#include <vld.h>
-#endif
-
-// The creation of Nurbs-surface for the IfcSite mesh, to be implemented lateron
-void createGroundShape(TopoDS_Shape& shape);
-
-int main() {
-
-	// The IfcHierarchyHelper is a subclass of the regular IfcFile that provides several
-	// convenience functions for working with geometry in IFC files.
-	IfcHierarchyHelper<IfcSchema> file;
-	file.header().file_name().name("IfcAdvancedHouse.ifc");
-
-	IfcSchema::IfcBuilding* building = file.addBuilding();
-	// By adding a building, a hierarchy has been automatically created that consists of the following
-	// structure: IfcProject > IfcSite > IfcBuilding
-
-	// Lateron changing the name of the IfcProject can be done by obtaining a reference to the 
-	// project, which has been created automatically.
-	file.getSingle<IfcSchema::IfcProject>()->setName("IfcOpenHouse");
-
-	// To demonstrate the ability to serialize arbitrary opencascade solids a building envelope is
-	// constructed by applying boolean operations. Naturally, in IFC, building elements should be 
-	// modeled separately, with rich parametric and relational semantics. Creating geometry in this
-	// way does not preserve any history and is merely a demonstration of technical capabilities.
-	TopoDS_Shape outer =   BRepPrimAPI_MakeBox(gp_Pnt(-5000., -180., -2000.), gp_Pnt(5000., 5180., 3000.)).Shape();
-	TopoDS_Shape inner =   BRepPrimAPI_MakeBox(gp_Pnt(-4640.,  180.,     0.), gp_Pnt(4640., 4820., 3000.)).Shape();
-	TopoDS_Shape window1 = BRepPrimAPI_MakeBox(gp_Pnt(-5000., -180.,   400.), gp_Pnt( 500., 1180., 2000.)).Shape();
-	TopoDS_Shape window2 = BRepPrimAPI_MakeBox(gp_Pnt( 2070., -180.,   400.), gp_Pnt(3930.,  180., 2000.)).Shape();
-
-	TopoDS_Shape building_shell = BRepAlgoAPI_Cut(
-		BRepAlgoAPI_Cut(
-			BRepAlgoAPI_Cut(outer, inner),
-			window1
-			),
-		window2
-	);
-
-	// Since the solid consists only of planar faces and straight edges it can be serialized as an
-	// IfcFacetedBRep. If it would not be a polyhedron, serialise() can only be successful when linked
-	// to the IFC4 model and with `advanced` set to `true` which introduces IfcAdvancedFace. It would
-	// return `0` otherwise.
-	IfcSchema::IfcProductDefinitionShape* building_shape = IfcGeom::serialise(STRINGIFY(IfcSchema), building_shell, false)->as<IfcSchema::IfcProductDefinitionShape>();
-	
-	file.addEntity(building_shape);
-	IfcSchema::IfcRepresentation* rep = *building_shape->Representations()->begin();
-	rep->setContextOfItems(file.getRepresentationContext("model"));
-
-	building->setRepresentation(building_shape);
-
-	// A pale white colour is assigned to the building.
-	file.setSurfaceColour(
-		building_shape, 0.75, 0.73, 0.68);
-
-	// For the ground mesh of the IfcSite we will use a Nurbs surface created in Open Cascade. Only
-	// in IFC4 the surface can be directly serialized. In IFC2X3 the it will have to be tesselated.
-	TopoDS_Shape shape;
-	createGroundShape(shape);
-
-	IfcSchema::IfcProductDefinitionShape* ground_representation = IfcGeom::serialise(STRINGIFY(IfcSchema), shape, true)->as<IfcSchema::IfcProductDefinitionShape>();
-	if (!ground_representation) {
-		ground_representation = IfcGeom::tesselate(STRINGIFY(IfcSchema), shape, 100.)->as<IfcSchema::IfcProductDefinitionShape>();
-	}
-	file.getSingle<IfcSchema::IfcSite>()->setRepresentation(ground_representation);
-	
-	IfcSchema::IfcRepresentation::list::ptr ground_reps = file.getSingle<IfcSchema::IfcSite>()->Representation()->Representations();
-	for (IfcSchema::IfcRepresentation::list::it it = ground_reps->begin(); it != ground_reps->end(); ++it) {
-		(*it)->setContextOfItems(file.getRepresentationContext("Model"));
-	}
-	file.addEntity(ground_representation);
-	file.setSurfaceColour(ground_representation, 0.15, 0.25, 0.05);
-
-    /*
-    // Note that IFC lacks elementary surfaces that STEP does have, such as spherical_surface.
-    // BRepBuilderAPI_NurbsConvert can be used to serialize such surfaces as nurbs surfaces.
-	TopoDS_Shape sphere = BRepPrimAPI_MakeSphere(gp_Pnt(), 1000.).Shape();
-	IfcSchema::IfcProductDefinitionShape* sphere_representation = IfcGeom::serialise(sphere, true);
-	if (S(IfcSchema::Identifier) == "IFC4") {
-		sphere = BRepBuilderAPI_NurbsConvert(sphere, true).Shape();
-		sphere_representation = IfcGeom::serialise(sphere, true);
-	}
-    */
-
-	// Finally create a file stream for our output and write the IFC file to it.
-	std::ofstream f("IfcAdvancedHouse.ifc");
-	f << file;
-}
-
-void createGroundShape(TopoDS_Shape& shape) {
-	TColgp_Array2OfPnt cv (0, 4, 0, 4);
-	cv.SetValue(0, 0, gp_Pnt(-10000, -10000, -4130));
-	cv.SetValue(0, 1, gp_Pnt(-10000,  -4330, -4130));
-	cv.SetValue(0, 2, gp_Pnt(-10000,      0, -5130));
-	cv.SetValue(0, 3, gp_Pnt(-10000,   4330, -7130));
-	cv.SetValue(0, 4, gp_Pnt(-10000,  10000, -7130));
-	cv.SetValue(1, 0, gp_Pnt( -3330, -10000, -5130));
-	cv.SetValue(1, 1, gp_Pnt( -7670,  -3670,  5000));
-	cv.SetValue(1, 2, gp_Pnt( -9000,      0,  1000));
-	cv.SetValue(1, 3, gp_Pnt( -7670,   7670,  6000));
-	cv.SetValue(1, 4, gp_Pnt( -3330,  10000, -4130));
-	cv.SetValue(2, 0, gp_Pnt(     0, -10000, -5530));
-	cv.SetValue(2, 1, gp_Pnt(     0,  -3670,  3000));
-	cv.SetValue(2, 2, gp_Pnt(     0,      0, -12000));
-	cv.SetValue(2, 3, gp_Pnt(     0,   7670,  1500));
-	cv.SetValue(2, 4, gp_Pnt(     0,  10000, -4130));
-	cv.SetValue(3, 0, gp_Pnt(  3330, -10000, -6130));
-	cv.SetValue(3, 1, gp_Pnt(  7670,  -3670,  6000));
-	cv.SetValue(3, 2, gp_Pnt(  9000,      0,  5000));
-	cv.SetValue(3, 3, gp_Pnt(  7670,   9000,  7000));
-	cv.SetValue(3, 4, gp_Pnt(  3330,  10000, -4130));
-	cv.SetValue(4, 0, gp_Pnt( 10000, -10000, -6130));
-	cv.SetValue(4, 1, gp_Pnt( 10000,  -4330, -5130));
-	cv.SetValue(4, 2, gp_Pnt( 10000,      0, -4130));
-	cv.SetValue(4, 3, gp_Pnt( 10000,   4330, -4130));
-	cv.SetValue(4, 4, gp_Pnt( 10000,  10000, -8130));
-	TColStd_Array1OfReal knots(0, 1);
-	knots(0) = 0;
-	knots(1) = 1;		
-	TColStd_Array1OfInteger mult(0, 1);
-	mult(0) = 5;
-	mult(1) = 5;	
-	Handle(Geom_BSplineSurface) surf = new Geom_BSplineSurface(cv, knots, knots, mult, mult, 4, 4);
-#if OCC_VERSION_HEX < 0x60502
-	shape = BRepBuilderAPI_MakeFace(surf);
-#else
-	shape = BRepBuilderAPI_MakeFace(surf, Precision::Confusion());
-#endif
-}
@@ -28,50 +28,44 @@

 #include <Geom_BSplineSurface.hxx>
 #include <BRepBuilderAPI_MakeFace.hxx>
+
 #include <Standard_Version.hxx>

-#include <BRepGProp.hxx>
-#include <GProp_GProps.hxx>
-
-#include <Precision.hxx>
-
-#define IfcSchema Ifc2x3
-#include "../ifcparse/macros.h"
+#ifdef USE_IFC4
+#include "../ifcparse/Ifc4.h"
+#else
 #include "../ifcparse/Ifc2x3.h"
-#include "../ifcparse/IfcBaseClass.h"
-#include "../ifcparse/IfcHierarchyHelper.h"
-
-#include "../ifcgeom/schema_agnostic/Serialization.h"
-
-#if USE_VLD
-#include <vld.h>
 #endif

+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/IfcHierarchyHelper.h"
+#include "../ifcgeom/IfcGeom.h"
+
 // Some convenience typedefs and definitions. 
 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
+typedef IfcWrite::IfcGuidHelper guid;
 typedef std::pair<double, double> XY;
-boost::none_t const null = boost::none;
+boost::none_t const null = (static_cast<boost::none_t>(0));

 // The creation of Nurbs-surface for the IfcSite mesh, to be implemented lateron
 void createGroundShape(TopoDS_Shape& shape);

-int main() {
+int main(int argc, char** argv) {

 	// The IfcHierarchyHelper is a subclass of the regular IfcFile that provides several
 	// convenience functions for working with geometry in IFC files.
-	IfcHierarchyHelper<IfcSchema> file;
+	IfcHierarchyHelper file;
 	file.header().file_name().name("IfcOpenHouse.ifc");

 	// Start by adding a wall to the file, initially leaving most attributes blank.
 	IfcSchema::IfcWallStandardCase* south_wall = new IfcSchema::IfcWallStandardCase(
 		guid(), 			// GlobalId
-		0, 					// OwnerHistory
+		0,	 				// OwnerHistory
 		S("South wall"), 	// Name
 		null, 				// Description
 		null, 				// ObjectType
-		0, 					// ObjectPlacement
-		0, 					// Representation
+		null, 				// ObjectPlacement
+		null, 				// Representation
 		null				// Tag
 #ifdef USE_IFC4
 		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
@@ -84,10 +78,10 @@ int main() {

 	// Lateron changing the name of the IfcProject can be done by obtaining a reference to the 
 	// project, which has been created automatically.
-	file.getSingle<IfcSchema::IfcProject>()->setName("IfcOpenHouse");
+	file.getSingle<IfcSchema::IfcProject>()->Name(S("IfcOpenHouse"));

 	// An IfcOwnerHistory has been initialized as well, which should be assigned to the wall.
-	south_wall->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+	south_wall->OwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());

 	// The wall will be shaped as a box, with the dimensions specified in millimeters. The resulting
 	// product definition will consist of both a body representation as well as an axis representation
@@ -96,12 +90,12 @@ int main() {

 	// Obtain a reference to the placement of the IfcBuildingStorey in order to create a hierarchy
 	// of placements for the products
-	IfcSchema::IfcObjectPlacement* storey_placement = file.getSingle<IfcSchema::IfcBuildingStorey>()->ObjectPlacement();
+	IfcSchema::IfcObjectPlacement* storey_placement = *file.getSingle<IfcSchema::IfcBuildingStorey>()->ObjectPlacement();

 	// The shape has to be assigned to the representation of the wall and is placed at the origin
 	// of the coordinate system.
-	south_wall->setRepresentation(south_wall_shape);
-	south_wall->setObjectPlacement(file.addLocalPlacement(storey_placement));
+	south_wall->Representation(south_wall_shape);
+	south_wall->ObjectPlacement(file.addLocalPlacement(storey_placement));

 	// A pale white colour is assigned to the wall.
 	IfcSchema::IfcPresentationStyleAssignment* wall_colour = file.setSurfaceColour(
@@ -109,17 +103,17 @@ int main() {

 	// Now create a footing for the wall to rest on.
 	IfcSchema::IfcFooting* footing = new IfcSchema::IfcFooting(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		S("Footing"), null, null, 0, 0, null, IfcSchema::IfcFootingTypeEnum::IfcFootingType_STRIP_FOOTING);
+		S("Footing"), null, null, null, null, null, IfcSchema::IfcFootingTypeEnum::IfcFootingType_STRIP_FOOTING);

 	file.addBuildingProduct(footing);

 	// The footing will span the entire floor plan of our building. The IfcRepresentationContext is
 	// something that has been created automatically as well, but representations could have been 
 	// assigned to a specific context, for example to add a two dimensional plan representation as well.
-	footing->setRepresentation(file.addBox(10100, 5460, 2000));
-	footing->setObjectPlacement(file.addLocalPlacement(storey_placement, 0, 2500, -2000));
+	footing->Representation(file.addBox(10100, 5460, 2000));
+	footing->ObjectPlacement(file.addLocalPlacement(storey_placement, 0, 2500, -2000));
 	// The footing will have a dark gray colour
-	IfcSchema::IfcPresentationStyleAssignment* footing_colour = file.setSurfaceColour(footing->Representation(), 0.26, 0.22, 0.18);
+	IfcSchema::IfcPresentationStyleAssignment* footing_colour = file.setSurfaceColour(*footing->Representation(), 0.26, 0.22, 0.18);

 	// IFC has two ways to apply boolean operations to geometry. IfcBooleanResults are commonly used 
 	// to clip geometry to a surface, for example to a slanted roof. For openings that are filled 
@@ -127,7 +121,7 @@ int main() {

 	// An opening element is created with rectangular geometry:
 	IfcSchema::IfcOpeningElement* west_opening = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(south_wall->ObjectPlacement(), -2500, 0, 400),
+		null, null, null, file.addLocalPlacement(*south_wall->ObjectPlacement(), -2500, 0, 400),
 		file.addBox(6000, 3630, 1600), null
 #ifdef USE_IFC4
 		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
@@ -153,7 +147,7 @@ int main() {
 	
 	// Create a roof element that will consist of two slabs:
 	IfcSchema::IfcRoof* roof = new IfcSchema::IfcRoof(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("Roof"), null, null,
-		file.addLocalPlacement(storey_placement), 0, null, IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
+		file.addLocalPlacement(storey_placement), null, null, IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);

 	// The roof geometry is slanted 45 degrees by specifying a direction for the box extrusion
 	IfcSchema::IfcShapeRepresentation* roof_rep = file.addEmptyRepresentation();
@@ -162,21 +156,21 @@ int main() {

 	// CV-2x3-144: Roofs are aggregates and shall have at least one contained element and no own geometry
 	IfcSchema::IfcSlab* south_roof_part = new IfcSchema::IfcSlab(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("South roof"), 
-		null, null, 0, 0, null, IfcSchema::IfcSlabTypeEnum::IfcSlabType_ROOF);
+		null, null, null, null, null, IfcSchema::IfcSlabTypeEnum::IfcSlabType_ROOF);
 	
 	// The geometry is instantiated by using IfcMappedItems. This way geometry definitions can
 	// be reused while maintaining the cardinality constraint that the ShapeOfProduct relation
 	// imposes on the IfcProductDefinitionShape. Note that this constrained is lifted in IFC4.
-	south_roof_part->setRepresentation(file.addMappedItem(roof_rep));
-	south_roof_part->setObjectPlacement(file.addLocalPlacement(roof->ObjectPlacement(), 0, -400, 2700));
+	south_roof_part->Representation(file.addMappedItem(roof_rep));
+	south_roof_part->ObjectPlacement(file.addLocalPlacement(*roof->ObjectPlacement(), 0, -400, 2700));
 	
 	// The same roof geometry is re-used on the north side of the roof, by inverting the X-axis of
 	// the local placement the roof is rotated 180 degrees around the Z-axis
 	IfcSchema::IfcSlab* north_roof_part = new IfcSchema::IfcSlab(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("North roof"),
-		null, null, 0, 0, null, IfcSchema::IfcSlabTypeEnum::IfcSlabType_ROOF);
-	north_roof_part->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
-	north_roof_part->setRepresentation(file.addMappedItem(roof_rep));
-	north_roof_part->setObjectPlacement(file.addLocalPlacement(roof->ObjectPlacement(), 0, 5400, 2700, 0, 0, 1, -1, 0, 0));
+		null, null, null, null, null, IfcSchema::IfcSlabTypeEnum::IfcSlabType_ROOF);
+	north_roof_part->OwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+	north_roof_part->Representation(file.addMappedItem(roof_rep));
+	north_roof_part->ObjectPlacement(file.addLocalPlacement(*roof->ObjectPlacement(), 0, 5400, 2700, 0, 0, 1, -1, 0, 0));
 	
 	IfcSchema::IfcObjectDefinition::list::ptr roof_parts(new IfcSchema::IfcObjectDefinition::list);
 	roof_parts->push(south_roof_part);
@@ -199,50 +193,47 @@ int main() {
 #endif	
 	);
 	file.addBuildingProduct(north_wall);
-	file.setSurfaceColour(north_wall->Representation(), wall_colour);
+	file.setSurfaceColour(*north_wall->Representation(), wall_colour);

-	// Two identical representations are created for the two remaining walls. Mapped items
-	// are not used, because it is not allowed by the standard for wall body representations.
-	// MappedItems are not allowed for Axis representations as per CV-2x3-161
-	IfcSchema::IfcProductDefinitionShape* clipped_wall_body_reps[2];
-	for (int i = 0; i < 2; ++i) {
-		IfcSchema::IfcShapeRepresentation* body = file.addEmptyRepresentation();
-		file.addBox(body, 5000, 360, 6000);
-		// The wall geometry is clipped using two IfcHalfSpaceSolids, created from an 
-		// 'axis 3d placement' that specifies the plane against which the geometry is clipped.
-		file.clipRepresentation(body, file.addPlacement3d(-2500, 0, 3000, -1, 0, 1), false);
-		file.clipRepresentation(body, file.addPlacement3d(2500, 0, 3000, 1, 0, 1), false);
-		file.setSurfaceColour(body, wall_colour);
-
-		IfcSchema::IfcShapeRepresentation* axis = file.addEmptyRepresentation("Axis", "Curve2D");
-		file.addAxis(axis, 5000);
-
-		IfcSchema::IfcRepresentation::list::ptr reps(new IfcSchema::IfcRepresentation::list);
-		reps->push(body);
-		reps->push(axis);
-		clipped_wall_body_reps[i] = new IfcSchema::IfcProductDefinitionShape(null, null, reps);
-	}
+	IfcSchema::IfcShapeRepresentation* clipped_wall_body_rep = file.addEmptyRepresentation();
+	file.addBox(clipped_wall_body_rep, 5000, 360, 6000);
+	// The east wall geometry is clipped using two IfcHalfSpaceSolids, created from an 
+	// 'axis 3d placement' that specifies the plane against which the geometry is clipped.
+	file.clipRepresentation(clipped_wall_body_rep, file.addPlacement3d(-2500, 0, 3000, -1, 0, 1), false);
+	file.clipRepresentation(clipped_wall_body_rep, file.addPlacement3d(2500, 0, 3000, 1, 0, 1), false);

 	// Now create a wall on the east of the building, again starting with just a box shape
 	IfcSchema::IfcWallStandardCase* east_wall = new IfcSchema::IfcWallStandardCase(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		S("East wall"), null, null, file.addLocalPlacement(storey_placement, 4820, 2500, 0, 0, 0, 1, 0, 1, 0), clipped_wall_body_reps[0], null
+		S("East wall"), null, null, file.addLocalPlacement(storey_placement, 4820, 2500, 0, 0, 0, 1, 0, 1, 0), file.addMappedItem(clipped_wall_body_rep), null
 #ifdef USE_IFC4
 		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
 #endif	
 	);
 	file.addBuildingProduct(east_wall);

+	file.setSurfaceColour(clipped_wall_body_rep, wall_colour);
+
 	// The east wall is copied to the west location of the house
 	IfcSchema::IfcWallStandardCase* west_wall = new IfcSchema::IfcWallStandardCase(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		S("West wall"), null, null, file.addLocalPlacement(storey_placement, -4820, 2500, 0, 0, 0, 1, 0, -1, 0), clipped_wall_body_reps[1], null
+		S("West wall"), null, null, file.addLocalPlacement(storey_placement, -4820, 2500, 0, 0, 0, 1, 0, -1, 0), file.addMappedItem(clipped_wall_body_rep), null
 #ifdef USE_IFC4
 		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
 #endif	
 	);
 	file.addBuildingProduct(west_wall);

+	for (int i = 0; i < 2; ++i) {
+		// CV-2x3-161: MappedItems are not allowed for Axis representations
+		IfcSchema::IfcWallStandardCase* wall = i == 0 ? east_wall : west_wall;
+		IfcSchema::IfcShapeRepresentation* wall_axis_rep = file.addEmptyRepresentation("Axis", "Curve2D");
+		file.addAxis(wall_axis_rep, 5000);
+		IfcSchema::IfcRepresentation::list::ptr reps = wall->Representation().get()->Representations();
+		reps->push(wall_axis_rep);
+		wall->Representation().get()->Representations(reps);
+	}
+
 	// The west wall is assigned an opening element we created for the south wall, opening elements are
-	// not shared across building elements, even if they share the same representation. Hence, the east
+	// not shared accross building elements, even if they share the same representation. Hence, the east
 	// wall will not feature this opening.
 	// NB: an Opening Element can only be used to create a single void within a single Element, as per:
 	// http://www.buildingsmart-tech.org/ifc/IFC2x3/TC1/html/ifcproductextension/lexical/ifcfeatureelementsubtraction.htm
@@ -250,7 +241,7 @@ int main() {
 	// Not all viewers support opening elements with mapped representations, hence an exact copy of the
 	// same subtraction box is instantiated for the otherwise identical opening element.
 	IfcSchema::IfcOpeningElement* west_opening_copy = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(west_wall->ObjectPlacement(), 2500, -2500+4820, 400, 0, 0, 1, 0, 1, 0),
+		null, null, null, file.addLocalPlacement(*west_wall->ObjectPlacement(), 2500, -2500+4820, 400, 0, 0, 1, 0, 1, 0),
 		file.addBox(6000, 3630, 1600), null
 #ifdef USE_IFC4
 		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
@@ -264,30 +255,14 @@ int main() {
 	// will be tesselated using the deflection specified.
 	TopoDS_Shape shape;
 	createGroundShape(shape);
-	IfcSchema::IfcProductDefinitionShape* ground_representation = IfcGeom::tesselate(STRINGIFY(IfcSchema), shape, 100.)->as<IfcSchema::IfcProductDefinitionShape>();
-	file.getSingle<IfcSchema::IfcSite>()->setRepresentation(ground_representation);
-
-	GProp_GProps prop;
-	BRepGProp::SurfaceProperties(shape, prop);
-	const double site_area = prop.Mass() / 1000 / 1000;
-
-	IfcSchema::IfcProperty::list::ptr properties(new IfcSchema::IfcProperty::list);
-	properties->push(new IfcSchema::IfcPropertySingleValue("TotalArea", null, new IfcSchema::IfcAreaMeasure(site_area), 0));
-	IfcSchema::IfcPropertySet* pset = new IfcSchema::IfcPropertySet(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("Pset_SiteCommon"), null, properties);
-#ifdef USE_IFC4	
-	IfcSchema::IfcObjectDefinition::list::ptr related_objs(new IfcSchema::IfcObjectDefinition::list);
-#else
-	IfcSchema::IfcObject::list::ptr related_objs(new IfcSchema::IfcObject::list);
-#endif
-	related_objs->push(file.getSingle<IfcSchema::IfcSite>());
-	IfcSchema::IfcRelDefinesByProperties* site_prop = new IfcSchema::IfcRelDefinesByProperties(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, related_objs, pset);
-	file.addEntity(site_prop);
-
-	IfcSchema::IfcRepresentation::list::ptr ground_reps = file.getSingle<IfcSchema::IfcSite>()->Representation()->Representations();
-	for (IfcSchema::IfcRepresentation::list::it it = ground_reps->begin(); it != ground_reps->end(); ++it) {
-		(*it)->setContextOfItems(file.getRepresentationContext("Model"));
+	IfcEntityList::ptr geometrical_entities(new IfcEntityList);
+	IfcSchema::IfcProductDefinitionShape* ground_representation = IfcGeom::tesselate(shape, 100., geometrical_entities);
+	file.getSingle<IfcSchema::IfcSite>()->Representation(ground_representation);
+	file.addEntities(geometrical_entities);
+	IfcSchema::IfcShapeRepresentation::list::ptr ground_reps = geometrical_entities->as<IfcSchema::IfcShapeRepresentation>();
+	for (IfcSchema::IfcShapeRepresentation::list::it it = ground_reps->begin(); it != ground_reps->end(); ++it) {
+		(*it)->ContextOfItems(file.getRepresentationContext("Model"));
 	}
-	file.addEntity(ground_representation);
 	file.setSurfaceColour(ground_representation, 0.15, 0.25, 0.05);

 	// According to the Ifc2x3 schema an IfcWallStandardCase needs to have an IfcMaterialLayerSet
@@ -338,9 +313,9 @@ int main() {
 		null, 
 		null,
 #ifdef USE_IFC4
-		file.instances_by_type<IfcSchema::IfcWallStandardCase>()->generalize(),
+		file.entitiesByType<IfcSchema::IfcWallStandardCase>()->generalize(),
 #else
-		file.instances_by_type<IfcSchema::IfcWallStandardCase>()->as<IfcSchema::IfcRoot>(),
+		file.entitiesByType<IfcSchema::IfcWallStandardCase>()->as<IfcSchema::IfcRoot>(),
 #endif
 		layer_usage);

@@ -368,7 +343,7 @@ int main() {
 	);

 	file.addBuildingProduct(stair);
-	file.setSurfaceColour(stair->Representation(), footing_colour);
+	file.setSurfaceColour(*stair->Representation(), footing_colour);

 	IfcSchema::IfcOpeningElement* door_opening = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
 		null, null, null, file.addLocalPlacement(storey_placement, 5000-180, 2500-900, 0), file.addBox(1000, 1000, 2200), null
@@ -383,19 +358,19 @@ int main() {
 	// can be a composition of multiple solids. The following door will be composed of four boxes
 	// which constitute the door and its frame.
 	IfcSchema::IfcDoor* door = new IfcSchema::IfcDoor(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, null,
-		file.addLocalPlacement(storey_placement, 4800, 1600, 0, 0, 0, 1, 0, 1, 0), 0, null, 2200, 1000
+		file.addLocalPlacement(storey_placement, 4800, 1600, 0, 0, 0, 1, 0, 1, 0), null, null, 2200, 1000
 #ifdef USE_IFC4
 		, IfcSchema::IfcDoorTypeEnum::IfcDoorType_DOOR
 		, IfcSchema::IfcDoorTypeOperationEnum::IfcDoorTypeOperation_SINGLE_SWING_LEFT
 		, null
 #endif
 	);
-	door->setRepresentation(file.addBox(80, 80, 2120, 0, file.addPlacement3d(460, 0, 0)));
-	IfcSchema::IfcRepresentation::list::ptr door_representations = door->Representation()->Representations();
+	door->Representation(file.addBox(80, 80, 2120, 0, file.addPlacement3d(460, 0, 0)));
+	IfcSchema::IfcRepresentation::list::ptr door_representations = door->Representation().get()->Representations();
 	IfcSchema::IfcShapeRepresentation* door_body = 0;
 	for (IfcSchema::IfcRepresentation::list::it i = door_representations->begin(); i != door_representations->end(); ++i) {
 		IfcSchema::IfcRepresentation* rep = *i;
-		if (rep->declaration().is(IfcSchema::IfcShapeRepresentation::Class()) && rep->RepresentationIdentifier() == "Body") {
+		if (rep->is(IfcSchema::Type::IfcShapeRepresentation) && *rep->RepresentationIdentifier() == "Body") {
 			door_body = (IfcSchema::IfcShapeRepresentation*) rep;
 		}
 	}
@@ -403,20 +378,16 @@ int main() {
 	file.addBox(door_body, 1000, 80,  80, 0, file.addPlacement3d(   0, 0, 2120));
 	file.addBox(door_body, 860, 30, 2120);
 	file.addBuildingProduct(door);
-	file.setSurfaceColour(door->Representation(), 0.9, 0.9, 0.9);
+	file.setSurfaceColour(*door->Representation(), 0.9, 0.9, 0.9);
 	file.addEntity(new IfcSchema::IfcRelFillsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, door_opening, door));

-	IfcSchema::IfcDoorStyle* door_style = new IfcSchema::IfcDoorStyle(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("Door type"), null, null, null, null, null,
-		IfcSchema::IfcDoorStyleOperationEnum::IfcDoorStyleOperation_SINGLE_SWING_LEFT, IfcSchema::IfcDoorStyleConstructionEnum::IfcDoorStyleConstruction_WOOD, false, false);
-	file.addRelatedObject<IfcSchema::IfcRelDefinesByType>(door_style, door);
-
 	// Surface styles are assigned to representation items, hence there is no real limitation to
 	// assign different colours within the same representation. However, some viewers have 
 	// difficulties rendering products with representation items with different surface styles. 
 	// Therefore we will construct the window as a decomposition of beams and a plate, in which 
 	// only the plate will have a transparent material assigned.

-	// The window frame will consists of four separate beams.
+	// The window frame will consists of four seperate beams.
 	// AutoCAD Architecture will create an internal window type for the IfcWindow created.
 	// Therefore the OverallWidth and OverallHeight of the window attributes will need to
 	// match the bounding box of the representation. Furthermore, the window placement needs
@@ -458,7 +429,7 @@ int main() {
 		// Create the window at the current location
 		IfcSchema::IfcLocalPlacement* place = *it;
 		IfcSchema::IfcWindow* window = new IfcSchema::IfcWindow(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-			null, null, null, place, 0, null, 1600, 1860
+			null, null, null, place, null, null, 1600, 1860
 #ifdef USE_IFC4
 			, IfcSchema::IfcWindowTypeEnum::IfcWindowType_WINDOW
 			, IfcSchema::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioning_SINGLE_PANEL
@@ -467,10 +438,10 @@ int main() {
 	);
 		file.addBuildingProduct(window);		

-		// Initialize a list of parts for the window to be composed of
+		// Initalize a list of parts for the window to be composed of
 		IfcSchema::IfcObjectDefinition::list::ptr window_parts(new IfcTemplatedEntityList<IfcSchema::IfcObjectDefinition>());

-		// The placements for the beams are not shared across the different windows because every
+		// The placements for the beams are not shared accross the different windows because every
 		// beam is placed relative to its parent window entity.
 		IfcSchema::IfcLocalPlacement::list::ptr frame_placements (new IfcTemplatedEntityList<IfcSchema::IfcLocalPlacement>());
 		frame_placements->push(file.addLocalPlacement(storey_placement,  930,45));
@@ -506,7 +477,7 @@ int main() {
 		file.addEntity(glass_part);
 		window_parts->push(glass_part);
 		file.relatePlacements(window, glass_part);
-		file.setSurfaceColour(glass_part->Representation(), 0.6, 0.7, 0.75, 0.1);
+		file.setSurfaceColour(*glass_part->Representation(), 0.6, 0.7, 0.75, 0.1);
 		
 		// Now create a decomposition relation between the window and the parts. Most viewers and authoring
 		// tools will consider the window a single entity that can be selected as a whole.
@@ -17,15 +17,9 @@
 *                                                                              *
 ********************************************************************************/

-// TODO: Multiple schemas
-#define IfcSchema Ifc2x3
-
 #include "../ifcparse/IfcFile.h"
-#include "../ifcparse/Ifc2x3.h"

-#if USE_VLD
-#include <vld.h>
-#endif
+using namespace IfcSchema;

 int main(int argc, char** argv) {

@@ -38,8 +32,8 @@ int main(int argc, char** argv) {
 	Logger::SetOutput(&std::cout,&std::cout);

 	// Parse the IFC file provided in argv[1]
-	IfcParse::IfcFile file(argv[1]);
-	if (!file.good()) {
+	IfcParse::IfcFile file;
+	if ( ! file.Init(argv[1]) ) {
 		std::cout << "Unable to parse .ifc file" << std::endl;
 		return 1;
 	}
@@ -60,19 +54,20 @@ int main(int argc, char** argv) {
 	// we need to cast them to IfcWindows. Since these properties 
 	// are optional we need to make sure the properties are 
 	// defined for the window in question before accessing them.
-	IfcSchema::IfcBuildingElement::list::ptr elements = file.instances_by_type<IfcSchema::IfcBuildingElement>();
+	IfcBuildingElement::list::ptr elements = file.entitiesByType<IfcBuildingElement>();

 	std::cout << "Found " << elements->size() << " elements in " << argv[1] << ":" << std::endl;
 	
-	for (IfcSchema::IfcBuildingElement::list::it it = elements->begin(); it != elements->end(); ++it) {
+	for ( IfcBuildingElement::list::it it = elements->begin(); it != elements->end(); ++ it ) {
 		
-		const IfcSchema::IfcBuildingElement* element = *it;
-		std::cout << element->data().toString() << std::endl;
+		const IfcBuildingElement* element = *it;
+		std::cout << element->entity->toString() << std::endl;
 		
-		const IfcSchema::IfcWindow* window;
-		if ((window = element->as<IfcSchema::IfcWindow>()) != 0) {
-			if (window->hasOverallWidth() && window->hasOverallHeight()) {
-				const double area = window->OverallWidth()*window->OverallHeight();
+		if ( element->is(IfcWindow::Class()) ) {
+			const IfcWindow* window = (IfcWindow*)element;
+			
+			if ( window->OverallWidth() && window->OverallHeight() ) {
+				const double area = window->OverallWidth().get() * window->OverallHeight().get();
 				std::cout << "The area of this window is " << area << std::endl;
 			}
 		}
@@ -33,8 +33,8 @@
 #include "../ifcparse/IfcHierarchyHelper.h"

 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
-boost::none_t const null = boost::none;
+typedef IfcWrite::IfcGuidHelper guid;
+boost::none_t const null = (static_cast<boost::none_t>(0));
 static int i = 0;

 void create_product_from_item(IfcHierarchyHelper& file, IfcSchema::IfcRepresentationItem* item, const std::string& s) {
@@ -43,16 +43,16 @@ void create_product_from_item(IfcHierarchyHelper& file, IfcSchema::IfcRepresenta
 	file.addBuildingProduct(product);
 	product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());

-	product->setObjectPlacement(file.addLocalPlacement(0, 120 * i++));
+	product->setObjectPlacement(file.addLocalPlacement(120 * i++));

-	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list());
-	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list());
+	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
+	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
 	items->push(item);

 	if (s == "GeometricSet") {
 		IfcSchema::IfcGeometricSet* set = new IfcSchema::IfcGeometricSet(items->generalize());
 		file.addEntity(set);
-		items = IfcSchema::IfcRepresentationItem::list::ptr(new IfcSchema::IfcRepresentationItem::list());
+		items = IfcSchema::IfcRepresentationItem::list(new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
 		items->push(set);
 	}
 		
@@ -60,7 +60,7 @@ void create_product_from_item(IfcHierarchyHelper& file, IfcSchema::IfcRepresenta
 		file.getSingle<IfcSchema::IfcRepresentationContext>(), S("Body"), s, items);
 	reps->push(rep);

-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
+	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
 	file.addEntity(rep);
 	file.addEntity(shape);
 		
@@ -109,11 +109,11 @@ void create_products_from_curve(IfcHierarchyHelper& file, IfcSchema::IfcBoundedC
 int main(int argc, char** argv) {
 	const char filename[] = "IfcArbitraryOpenProfileDef.ifc";
 	IfcHierarchyHelper file;
-	file.header().file_name().name(filename);
+	file.filename(filename);

 	double coords1[] = {-50.0, 0.0};
 	double coords2[] = { 50.0, 0.0};
-	IfcSchema::IfcCartesianPoint::list::ptr points (new IfcSchema::IfcCartesianPoint::list());
+	IfcSchema::IfcCartesianPoint::list points (new IfcTemplatedEntityList<IfcSchema::IfcCartesianPoint>());
 	points->push(new IfcSchema::IfcCartesianPoint(std::vector<double>(coords1, coords1+2)));
 	points->push(new IfcSchema::IfcCartesianPoint(std::vector<double>(coords2, coords2+2)));
 	file.addEntities(points->generalize());
@@ -126,8 +126,8 @@ int main(int argc, char** argv) {
 	file.addEntity(ellipse);
 	IfcEntityList::ptr trim1(new IfcEntityList);
 	IfcEntityList::ptr trim2(new IfcEntityList);
-	trim1->push(new IfcSchema::IfcParameterValue(  0.));
-	trim2->push(new IfcSchema::IfcParameterValue(180.));
+	trim1->push(new IfcWrite::IfcSelectHelper(  0., Ifc2x3::Type::IfcParameterValue));
+	trim2->push(new IfcWrite::IfcSelectHelper(180., Ifc2x3::Type::IfcParameterValue));
 	IfcSchema::IfcTrimmedCurve* trim = new IfcSchema::IfcTrimmedCurve(ellipse, trim1, trim2, true, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
 	file.addEntity(trim);

@@ -32,19 +32,19 @@
 #include "../ifcparse/IfcHierarchyHelper.h"

 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
-boost::none_t const null = boost::none;
+typedef IfcWrite::IfcGuidHelper guid;
+boost::none_t const null = (static_cast<boost::none_t>(0));

 int main(int argc, char** argv) {
 	const char filename[] = "IfcCompositeProfileDef.ifc";
 	IfcHierarchyHelper file;
-	file.header().file_name().name(filename);
+	file.filename(filename);

 	double coords1[] = {100.0, 0.0};
 	double coords2[] = {200.0, 0.0};
 	double coords3[] = {300.0, 0.0};

-	IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list());
+	IfcSchema::IfcProfileDef::list profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());

 	IfcSchema::IfcCartesianTransformationOperator2D* transform1 = new IfcSchema::IfcCartesianTransformationOperator2D(file.addDoublet<IfcSchema::IfcDirection>(1, 0), file.addDoublet<IfcSchema::IfcDirection>(0, -1), file.addDoublet<IfcSchema::IfcCartesianPoint>(40, 0), null);
 	IfcSchema::IfcCartesianTransformationOperator2D* transform2 = new IfcSchema::IfcCartesianTransformationOperator2D(file.addDoublet<IfcSchema::IfcDirection>(0, -1), file.addDoublet<IfcSchema::IfcDirection>(1, 0), file.addDoublet<IfcSchema::IfcCartesianPoint>(40, 0), 0.3);
@@ -98,15 +98,15 @@ int main(int argc, char** argv) {
 	file.addEntity(composite);
 	file.addEntity(solid);
 		
-	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list());
-	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list());
+	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
+	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
 		
 	items->push(solid);
 	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
 		file.getSingle<IfcSchema::IfcRepresentationContext>(), S("Body"), S("SweptSolid"), items);
 	reps->push(rep);

-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
+	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
 	file.addEntity(rep);
 	file.addEntity(shape);
 		
@@ -32,8 +32,8 @@
 #include "../ifcparse/IfcHierarchyHelper.h"

 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
-boost::none_t const null = boost::none;
+typedef IfcWrite::IfcGuidHelper guid;
+boost::none_t const null = (static_cast<boost::none_t>(0));

 class Node {
 private:
@@ -135,7 +135,7 @@ public:
 int main(int argc, char** argv) {
 	const char filename[] = "IfcCsgPrimitive.ifc";
 	IfcHierarchyHelper file;
-	file.header().file_name().name(filename);
+	file.filename(filename);

 	IfcSchema::IfcRepresentationItem* csg1 = Node::Box(8000.,6000.,3000.).subtract(
 		Node::Box(7600.,5600.,2800.).move(200.,200.,200.)
@@ -171,8 +171,8 @@ int main(int argc, char** argv) {

 	product->setObjectPlacement(file.addLocalPlacement());
 		
-	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list());
-	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list());
+	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
+	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
 		
 	items->push(csg1);
 	items->push(csg2);
@@ -180,7 +180,7 @@ int main(int argc, char** argv) {
 		file.getSingle<IfcSchema::IfcRepresentationContext>(), S("Body"), S("CSG"), items);
 	reps->push(rep);

-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(null, null, reps);
+	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
 	file.addEntity(rep);
 	file.addEntity(shape);
 		
@@ -32,8 +32,8 @@
 #include "../ifcparse/IfcHierarchyHelper.h"

 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
-boost::none_t const null = boost::none;
+typedef IfcWrite::IfcGuidHelper guid;
+boost::none_t const null = (static_cast<boost::none_t>(0));

 typedef struct {
 	double r1;
@@ -58,7 +58,7 @@ void create_testcase_for(IfcHierarchyHelper& file, const EllipsePie& pie, Ifc2x3
 	Ifc2x3::IfcCartesianPoint* p2 = new Ifc2x3::IfcCartesianPoint(coords2);
 	Ifc2x3::IfcCartesianPoint* p3 = new Ifc2x3::IfcCartesianPoint(coords3);
 	
-	Ifc2x3::IfcCartesianPoint::list::ptr points(new Ifc2x3::IfcCartesianPoint::list());
+	Ifc2x3::IfcCartesianPoint::list points(new IfcTemplatedEntityList<Ifc2x3::IfcCartesianPoint>());
 	points->push(p3);
 	points->push(p1);
 	points->push(p2);
@@ -70,8 +70,8 @@ void create_testcase_for(IfcHierarchyHelper& file, const EllipsePie& pie, Ifc2x3
 	IfcEntityList::ptr trim1(new IfcEntityList);
 	IfcEntityList::ptr trim2(new IfcEntityList);
 	if (pref == Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER) {
-		trim1->push(new Ifc2x3::IfcParameterValue(pie.t1));
-		trim2->push(new Ifc2x3::IfcParameterValue(pie.t2));
+		trim1->push(new IfcWrite::IfcSelectHelper(pie.t1, Ifc2x3::Type::IfcParameterValue));
+		trim2->push(new IfcWrite::IfcSelectHelper(pie.t2, Ifc2x3::Type::IfcParameterValue));
 	} else {
 		trim1->push(p2);
 		trim2->push(p3);
@@ -79,7 +79,7 @@ void create_testcase_for(IfcHierarchyHelper& file, const EllipsePie& pie, Ifc2x3
 	Ifc2x3::IfcTrimmedCurve* trim = new Ifc2x3::IfcTrimmedCurve(ellipse, trim1, trim2, true, pref);
 	file.addEntity(trim);
 	
-	Ifc2x3::IfcCompositeCurveSegment::list::ptr segments(new Ifc2x3::IfcCompositeCurveSegment::list());
+	Ifc2x3::IfcCompositeCurveSegment::list segments(new IfcTemplatedEntityList<Ifc2x3::IfcCompositeCurveSegment>());
 	Ifc2x3::IfcCompositeCurveSegment* s2 = new Ifc2x3::IfcCompositeCurveSegment(Ifc2x3::IfcTransitionCode::IfcTransitionCode_CONTINUOUS, true, trim);
 	
 	Ifc2x3::IfcPolyline* poly = new Ifc2x3::IfcPolyline(points);	
@@ -100,22 +100,22 @@ void create_testcase_for(IfcHierarchyHelper& file, const EllipsePie& pie, Ifc2x3
 	file.addBuildingProduct(product);
 	product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());

-	product->setObjectPlacement(file.addLocalPlacement(0, 200 * i++));
+	product->setObjectPlacement(file.addLocalPlacement(200 * i++));

 	IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(profile,
 		file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 20.0);

 	file.addEntity(solid);
 		
-	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list());
-	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list());
+	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
+	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
 		
 	items->push(solid);
 	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
 		file.getSingle<IfcSchema::IfcRepresentationContext>(), S("Body"), S("SweptSolid"), items);
 	reps->push(rep);

-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
+	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
 	file.addEntity(rep);
 	file.addEntity(shape);
 		
@@ -1,207 +0,0 @@
-/********************************************************************************
- *                                                                              *
- * This file is part of IfcOpenShell.                                           *
- *                                                                              *
- * IfcOpenShell is free software: you can redistribute it and/or modify         *
- * it under the terms of the Lesser GNU General Public License as published by  *
- * the Free Software Foundation, either version 3.0 of the License, or          *
- * (at your option) any later version.                                          *
- *                                                                              *
- * IfcOpenShell is distributed in the hope that it will be useful,              *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
- * Lesser GNU General Public License for more details.                          *
- *                                                                              *
- * You should have received a copy of the Lesser GNU General Public License     *
- * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * Example that generates various forms of IfcFace                              *
- *                                                                              *
- ********************************************************************************/
-
-#include "../ifcparse/Ifc2x3.h"
-#include "../ifcparse/IfcUtil.h"
-#include "../ifcparse/IfcHierarchyHelper.h"
-
-typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
-boost::none_t const null = (static_cast<boost::none_t>(0));
-
-static int x = 0;
-
-void create_testcase(IfcHierarchyHelper& file, IfcSchema::IfcFace* face, const std::string& name) {
-	IfcSchema::IfcFace::list::ptr faces(new IfcSchema::IfcFace::list);
-	faces->push(face);
-	IfcSchema::IfcOpenShell* shell = new IfcSchema::IfcOpenShell(faces);
-
-	IfcSchema::IfcConnectedFaceSet::list::ptr shells(new IfcSchema::IfcConnectedFaceSet::list);
-	shells->push(shell);
-	IfcSchema::IfcFaceBasedSurfaceModel* model = new IfcSchema::IfcFaceBasedSurfaceModel(shells);
-	
-	IfcSchema::IfcBuildingElementProxy* product = new IfcSchema::IfcBuildingElementProxy(
-		guid(), 0, name, null, null, 0, 0, null, null);
-	file.addBuildingProduct(product);
-	product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
-
-	product->setObjectPlacement(file.addLocalPlacement(0, 1000 * x++, 0));
-
-	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list);
-	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list);
-		
-	items->push(model);
-	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
-		file.getRepresentationContext("Model"), S("Body"), S("SurfaceModel"), items);
-	reps->push(rep);
-
-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
-	file.addEntity(shape);
-		
-	product->setRepresentation(shape);
-}
-
-int main(int argc, char** argv) {
-	IfcHierarchyHelper file;
-	{ 
-		IfcSchema::IfcCartesianPoint::list::ptr points (new IfcSchema::IfcCartesianPoint::list);
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, -400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+400, -400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+400, +400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, +400, 0));
-		IfcSchema::IfcPolyLoop* loop = new IfcSchema::IfcPolyLoop(points);
-		IfcSchema::IfcFaceOuterBound* bound = new IfcSchema::IfcFaceOuterBound(loop, true);
-		
-		IfcSchema::IfcFaceBound::list::ptr bounds (new IfcSchema::IfcFaceBound::list);
-		bounds->push(bound);
-		IfcSchema::IfcFace* face = new IfcSchema::IfcFace(bounds);
-		create_testcase(file, face, "polyloop");
-	}
-	{ 
-		IfcSchema::IfcCartesianPoint* point1 = file.addTriplet<IfcSchema::IfcCartesianPoint>(+400, 0., 0.);
-		IfcSchema::IfcCartesianPoint* point2 = file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, 0., 0.);
-		IfcSchema::IfcVertexPoint* vertex1 = new IfcSchema::IfcVertexPoint(point1);
-		IfcSchema::IfcVertexPoint* vertex2 = new IfcSchema::IfcVertexPoint(point2);
-		IfcSchema::IfcCircle* circle = new IfcSchema::IfcCircle(file.addPlacement2d(), 400.);
-		IfcSchema::IfcEdgeCurve* edge1 = new IfcSchema::IfcEdgeCurve(vertex1, vertex2, circle, true);
-		IfcSchema::IfcEdgeCurve* edge2 = new IfcSchema::IfcEdgeCurve(vertex2, vertex1, circle, true);
-		IfcSchema::IfcOrientedEdge* oriented_edge1 = new IfcSchema::IfcOrientedEdge(edge1, true);
-		IfcSchema::IfcOrientedEdge* oriented_edge2 = new IfcSchema::IfcOrientedEdge(edge2, true);
-		IfcSchema::IfcOrientedEdge::list::ptr edges(new IfcSchema::IfcOrientedEdge::list);
-		edges->push(oriented_edge1);
-		edges->push(oriented_edge2);
-		IfcSchema::IfcEdgeLoop* loop = new IfcSchema::IfcEdgeLoop(edges);
-		IfcSchema::IfcFaceOuterBound* bound = new IfcSchema::IfcFaceOuterBound(loop, true);
-		
-		IfcSchema::IfcFaceBound::list::ptr bounds (new IfcSchema::IfcFaceBound::list);
-		bounds->push(bound);
-		IfcSchema::IfcFace* face = new IfcSchema::IfcFace(bounds);
-		create_testcase(file, face, "circle");
-	}
-	{ 
-		IfcSchema::IfcCartesianPoint::list::ptr points (new IfcSchema::IfcCartesianPoint::list);
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, -400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+400, -400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+400, +400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, +400, 0));
-		IfcSchema::IfcPolyLoop* loop = new IfcSchema::IfcPolyLoop(points);
-		IfcSchema::IfcFaceOuterBound* outer_bound = new IfcSchema::IfcFaceOuterBound(loop, true);
-
-		IfcSchema::IfcCartesianPoint::list::ptr points2 (new IfcSchema::IfcCartesianPoint::list);
-		points2->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-300, -300, 0));
-		points2->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-100, -300, 0));
-		points2->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-100, +300, 0));
-		points2->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-300, +300, 0));
-		IfcSchema::IfcPolyLoop* loop2 = new IfcSchema::IfcPolyLoop(points2);
-		IfcSchema::IfcFaceBound* inner_bound1 = new IfcSchema::IfcFaceBound(loop2, false);
-
-		IfcSchema::IfcCartesianPoint::list::ptr points3 (new IfcSchema::IfcCartesianPoint::list);
-		points3->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+100, +300, 0));
-		points3->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+300, +300, 0));
-		points3->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+300, -300, 0));
-		points3->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+100, -300, 0));
-		IfcSchema::IfcPolyLoop* loop3 = new IfcSchema::IfcPolyLoop(points3);
-		IfcSchema::IfcFaceBound* inner_bound2 = new IfcSchema::IfcFaceBound(loop3, true);
-		
-		IfcSchema::IfcFaceBound::list::ptr bounds (new IfcSchema::IfcFaceBound::list);
-		bounds->push(inner_bound1);
-		bounds->push(outer_bound);
-		bounds->push(inner_bound2);
-		IfcSchema::IfcFace* face = new IfcSchema::IfcFace(bounds);
-		create_testcase(file, face, "polyloop with holes");
-	}
-	{ 
-		IfcSchema::IfcCartesianPoint::list::ptr points (new IfcSchema::IfcCartesianPoint::list);
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, -400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-100, -400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-100, +400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, +400, 0));
-		IfcSchema::IfcPolyLoop* loop = new IfcSchema::IfcPolyLoop(points);
-		IfcSchema::IfcFaceOuterBound* bound1 = new IfcSchema::IfcFaceOuterBound(loop, true);
-
-		IfcSchema::IfcCartesianPoint::list::ptr points2 (new IfcSchema::IfcCartesianPoint::list);
-		points2->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+100, +400, 0));
-		points2->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+400, +400, 0));
-		points2->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+400, -400, 0));
-		points2->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+100, -400, 0));
-		IfcSchema::IfcPolyLoop* loop2 = new IfcSchema::IfcPolyLoop(points2);
-		IfcSchema::IfcFaceOuterBound* bound2 = new IfcSchema::IfcFaceOuterBound(loop2, false);
-
-		IfcSchema::IfcFaceBound::list::ptr bounds (new IfcSchema::IfcFaceBound::list);
-		bounds->push(bound1);
-		bounds->push(bound2);
-		IfcSchema::IfcFace* face = new IfcSchema::IfcFace(bounds);
-		create_testcase(file, face, "multiple outer boundaries (invalid)");
-	}
-	{ 
-		IfcSchema::IfcCartesianPoint::list::ptr points (new IfcSchema::IfcCartesianPoint::list);
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, -400, 1e-6));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+400, -400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(+400, +400, 0));
-		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, +400, 0));
-		IfcSchema::IfcPolyLoop* loop = new IfcSchema::IfcPolyLoop(points);
-		IfcSchema::IfcFaceOuterBound* bound = new IfcSchema::IfcFaceOuterBound(loop, true);
-		
-		IfcSchema::IfcFaceBound::list::ptr bounds (new IfcSchema::IfcFaceBound::list);
-		bounds->push(bound);
-		IfcSchema::IfcFace* face = new IfcSchema::IfcFace(bounds);
-		create_testcase(file, face, "imprecise polyloop");
-	}
-	{ 
-		IfcSchema::IfcCartesianPoint* point1 = file.addTriplet<IfcSchema::IfcCartesianPoint>(+400, 0., 0.);
-		IfcSchema::IfcCartesianPoint* point2 = file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, 0., 0.);
-		IfcSchema::IfcVertexPoint* vertex1 = new IfcSchema::IfcVertexPoint(point1);
-		IfcSchema::IfcVertexPoint* vertex2 = new IfcSchema::IfcVertexPoint(point2);
-		IfcSchema::IfcCircle* circle = new IfcSchema::IfcCircle(file.addPlacement2d(), 400.);
-		IfcSchema::IfcEdgeCurve* edge1 = new IfcSchema::IfcEdgeCurve(vertex1, vertex2, circle, true);
-		IfcSchema::IfcEdgeCurve* edge2 = new IfcSchema::IfcEdgeCurve(vertex2, vertex1, circle, true);
-		IfcSchema::IfcOrientedEdge* oriented_edge1 = new IfcSchema::IfcOrientedEdge(edge1, true);
-		IfcSchema::IfcOrientedEdge* oriented_edge2 = new IfcSchema::IfcOrientedEdge(edge2, true);
-		IfcSchema::IfcOrientedEdge::list::ptr edges(new IfcSchema::IfcOrientedEdge::list);
-		edges->push(oriented_edge1);
-		edges->push(oriented_edge2);
-		IfcSchema::IfcEdgeLoop* loop = new IfcSchema::IfcEdgeLoop(edges);
-		IfcSchema::IfcFaceOuterBound* bound = new IfcSchema::IfcFaceOuterBound(loop, true);
-		
-		IfcSchema::IfcFaceBound::list::ptr bounds (new IfcSchema::IfcFaceBound::list);
-		bounds->push(bound);
-
-		IfcSchema::IfcCartesianPoint::list::ptr trim1(new IfcSchema::IfcCartesianPoint::list);
-		IfcSchema::IfcCartesianPoint::list::ptr trim2(new IfcSchema::IfcCartesianPoint::list);
-		trim1->push(point1);
-		trim2->push(point2);
-		IfcSchema::IfcTrimmedCurve* trimmed_curve = new IfcSchema::IfcTrimmedCurve(circle, trim1->generalize(), trim2->generalize(), true, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);
-		IfcSchema::IfcArbitraryOpenProfileDef* profile = new IfcSchema::IfcArbitraryOpenProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_CURVE, boost::none, trimmed_curve);
-		IfcSchema::IfcAxis1Placement* place = new IfcSchema::IfcAxis1Placement(file.addTriplet<IfcSchema::IfcCartesianPoint>(0., 0., 0.), file.addTriplet<IfcSchema::IfcDirection>(1., 0., 0.));
-		IfcSchema::IfcSurfaceOfRevolution* surface = new IfcSchema::IfcSurfaceOfRevolution(profile, file.addPlacement3d(), place);
-
-		IfcSchema::IfcFace* face = new IfcSchema::IfcFaceSurface(bounds, surface, true);
-		create_testcase(file, face, "face surface");
-	}
-	const std::string filename = "faces.ifc";
-	file.header().file_name().name(filename);
-	std::ofstream f(filename.c_str());
-	f << file;
-}
@@ -1,143 +0,0 @@
-/********************************************************************************
-*                                                                              *
-* This file is part of IfcOpenShell.                                           *
-*                                                                              *
-* IfcOpenShell is free software: you can redistribute it and/or modify         *
-* it under the terms of the Lesser GNU General Public License as published by  *
-* the Free Software Foundation, either version 3.0 of the License, or          *
-* (at your option) any later version.                                          *
-*                                                                              *
-* IfcOpenShell is distributed in the hope that it will be useful,              *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
-* Lesser GNU General Public License for more details.                          *
-*                                                                              *
-* You should have received a copy of the Lesser GNU General Public License     *
-* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
-*                                                                              *
-********************************************************************************/
-
-/********************************************************************************
-*																				*
-* Example of curve rebar.														*
-*																				*
-********************************************************************************/
-
-#include <iostream>
-#include <string>
-#include <fstream>
-
-#include "ifcparse\Ifc2x3.h"
-#include "ifcparse\IfcUtil.h"
-#include "ifcparse\IfcHierarchyHelper.h"
-#include "ifcgeom\IfcGeom.h"
-
-typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
-boost::none_t const null = boost::none;
-
-void create_curve_rebar(IfcHierarchyHelper& file)
-{
-	int dia = 24;
-	int R = 3 * dia;
-	int length = 12 * dia;
-
-	double crossSectionarea = M_PI * (dia / 2) * 2;
-	IfcSchema::IfcReinforcingBar* rebar = new IfcSchema::IfcReinforcingBar(
-		guid(), 0, S("test"), null,
-		null, 0, 0,
-		null, S("SR24"),		//SteelGrade
-		dia,						//diameter
-		crossSectionarea,		//crossSectionarea = math.pi*(12.0/2)**2
-		0,
-		IfcSchema::IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum::IfcReinforcingBarRole_LIGATURE,
-		IfcSchema::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurface_PLAIN	//PLAIN or TEXTURED
-		);
-
-	file.addBuildingProduct(rebar);
-	rebar->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
-
-	IfcSchema::IfcCompositeCurveSegment::list::ptr segments(new IfcSchema::IfcCompositeCurveSegment::list());
-
-	IfcSchema::IfcCartesianPoint* p1 = file.addTriplet<IfcSchema::IfcCartesianPoint>(0, 0, 1000.);
-	IfcSchema::IfcCartesianPoint* p2 = file.addTriplet<IfcSchema::IfcCartesianPoint>(0, 0, 0);
-	IfcSchema::IfcCartesianPoint* p3 = file.addTriplet<IfcSchema::IfcCartesianPoint>(0, R, 0);
-	IfcSchema::IfcCartesianPoint* p4 = file.addTriplet<IfcSchema::IfcCartesianPoint>(0, R, -R);
-	IfcSchema::IfcCartesianPoint* p5 = file.addTriplet<IfcSchema::IfcCartesianPoint>(0, R + length, -R);
-
-	/*first segment - line */
-	IfcSchema::IfcCartesianPoint::list::ptr points1(new IfcSchema::IfcCartesianPoint::list());
-	points1->push(p1);
-	points1->push(p2);
-	file.addEntities(points1->generalize());
-	IfcSchema::IfcPolyline* poly1 = new IfcSchema::IfcPolyline(points1);
-	file.addEntity(poly1);
-
-	IfcSchema::IfcCompositeCurveSegment* segment1 = new IfcSchema::IfcCompositeCurveSegment(IfcSchema::IfcTransitionCode::IfcTransitionCode_CONTINUOUS, true, poly1);
-	file.addEntity(segment1);
-	segments->push(segment1);
-
-	/*second segment - arc */
-	IfcSchema::IfcAxis2Placement3D* axis1 = new IfcSchema::IfcAxis2Placement3D(p3, file.addTriplet<IfcSchema::IfcDirection>(1, 0, 0), file.addTriplet<IfcSchema::IfcDirection>(0, 1, 0));
-	file.addEntity(axis1);
-	IfcSchema::IfcCircle* circle = new IfcSchema::IfcCircle(axis1, R);
-	file.addEntity(circle);
-
-	IfcEntityList::ptr trim1(new IfcEntityList);
-	IfcEntityList::ptr trim2(new IfcEntityList);
-
-	trim1->push(new IfcSchema::IfcParameterValue(180));
-	trim1->push(p2);
-
-	trim2->push(new IfcSchema::IfcParameterValue(270));
-	trim2->push(p4);
-	IfcSchema::IfcTrimmedCurve* trimmed_curve = new IfcSchema::IfcTrimmedCurve(circle, trim1, trim2, false, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	file.addEntity(trimmed_curve);
-
-	IfcSchema::IfcCompositeCurveSegment* segment2 = new IfcSchema::IfcCompositeCurveSegment(IfcSchema::IfcTransitionCode::IfcTransitionCode_CONTSAMEGRADIENT, false, trimmed_curve);
-	file.addEntity(segment2);
-	segments->push(segment2);
-
-	/*third segment - line */
-	IfcSchema::IfcCartesianPoint::list::ptr points2(new IfcSchema::IfcCartesianPoint::list());
-	points2->push(p4);
-	points2->push(p5);
-	file.addEntities(points2->generalize());
-	IfcSchema::IfcPolyline* poly2 = new IfcSchema::IfcPolyline(points2);
-	file.addEntity(poly2);
-
-	IfcSchema::IfcCompositeCurveSegment* segment3 = new IfcSchema::IfcCompositeCurveSegment(IfcSchema::IfcTransitionCode::IfcTransitionCode_CONTINUOUS, true, poly2);
-	file.addEntity(segment3);
-	segments->push(segment3);
-
-	IfcSchema::IfcCompositeCurve* curve = new IfcSchema::IfcCompositeCurve(segments, false);
-	file.addEntity(curve);
-
-	IfcSchema::IfcSweptDiskSolid* solid = new IfcSchema::IfcSweptDiskSolid(curve, dia / 2, null, 0, 1);
-
-	IfcSchema::IfcRepresentation::list::ptr reps(new IfcSchema::IfcRepresentation::list());
-	IfcSchema::IfcRepresentationItem::list::ptr items(new IfcSchema::IfcRepresentationItem::list());
-	items->push(solid);
-	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
-		file.getSingle<IfcSchema::IfcRepresentationContext>(), S("Body"), S("AdvancedSweptSolid"), items);
-	reps->push(rep);
-
-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(null, null, reps);
-	file.addEntity(shape);
-
-	rebar->setRepresentation(shape);
-
-	IfcSchema::IfcObjectPlacement* storey_placement = file.getSingle<IfcSchema::IfcBuildingStorey>()->ObjectPlacement();
-	rebar->setObjectPlacement(file.addLocalPlacement(storey_placement, 0, 0, 0));
-}
-
-int main()
-{
-	IfcHierarchyHelper file;
-	file.header().file_name().name("ifc_curve_rebar.ifc");
-	create_curve_rebar(file);
-	std::ofstream f("ifc_curve_rebar.ifc");
-	f << file;
-
-	return 0;
-}
@@ -1,85 +0,0 @@
-/********************************************************************************
- *                                                                              *
- * This file is part of IfcOpenShell.                                           *
- *                                                                              *
- * IfcOpenShell is free software: you can redistribute it and/or modify         *
- * it under the terms of the Lesser GNU General Public License as published by  *
- * the Free Software Foundation, either version 3.0 of the License, or          *
- * (at your option) any later version.                                          *
- *                                                                              *
- * IfcOpenShell is distributed in the hope that it will be useful,              *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
- * Lesser GNU General Public License for more details.                          *
- *                                                                              *
- * You should have received a copy of the Lesser GNU General Public License     *
- * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * Example that generates an IfcTriangulatedFaceSet                             *
- *                                                                              *
- ********************************************************************************/
-
-#include "../ifcparse/Ifc4.h"
-#include "../ifcparse/IfcUtil.h"
-#include "../ifcparse/IfcHierarchyHelper.h"
-
-#include "suzanne_geometry.h"
-
-typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
-boost::none_t const null = (static_cast<boost::none_t>(0));
-
-template <typename T>
-std::vector< std::vector<T> > create_vector_from_array(const T* arr, unsigned size) {
-	std::vector< std::vector<T> > result;
-	result.reserve(size);	
-	
-	for (unsigned i = 0; i < size; ) {
-		std::vector<T> ts; ts.reserve(3);
-		for (unsigned j = 0; j < 3; ++i, ++j) {
-			ts.push_back(arr[i]);
-		}
-		result.push_back(ts);
-	}
-
-	return result;
-}
-
-int main(int argc, char** argv) {
-	IfcHierarchyHelper file;
-
-	IfcSchema::IfcBuildingElementProxy* product = new IfcSchema::IfcBuildingElementProxy(
-		guid(), 0, S("Blender's Suzanne"), null, null, 0, 0, null, null);
-	file.addBuildingProduct(product);
-	product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
-
-	product->setObjectPlacement(file.addLocalPlacement());
-
-	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list);
-	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list);
-
-	std::vector< std::vector< double > > vertices_vector = create_vector_from_array(vertices, sizeof(vertices) / sizeof(vertices[0]));
-	std::vector< std::vector< int > > indices_vector = create_vector_from_array(indices, sizeof(indices) / sizeof(indices[0]));
-
-	IfcSchema::IfcCartesianPointList3D* coordinates = new IfcSchema::IfcCartesianPointList3D(vertices_vector);	
-	IfcSchema::IfcTriangulatedFaceSet* faceset = new IfcSchema::IfcTriangulatedFaceSet(coordinates, null, null, indices_vector, null);
-		
-	items->push(faceset);
-	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
-		file.getRepresentationContext("Model"), S("Body"), S("SurfaceModel"), items);
-	reps->push(rep);
-
-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
-	file.addEntity(shape);
-		
-	product->setRepresentation(shape);
-
-	const std::string filename = "tesselated_faceset.ifc";
-	file.header().file_name().name(filename);
-	std::ofstream f(filename.c_str());
-	f << file;
-}
@@ -27,51 +27,46 @@

 bl_info = {
    "name": "IfcBlender",
-    "description": "Import files in the "
+    "description": "Import files in the "\
        "Industry Foundation Classes (.ifc) file format",
    "author": "Thomas Krijnen, IfcOpenShell",
-    "blender": (2, 80, 0),
+    "blender": (2, 73, 0),
    "location": "File > Import",
-    "tracker_url": "https://sourceforge.net/p/ifcopenshell/"
+    "tracker_url": "https://sourceforge.net/p/ifcopenshell/"\
        "_list/tickets?source=navbar",
    "category": "Import-Export"}

 if "bpy" in locals():
-    import importlib
+    import imp
    if "ifcopenshell" in locals():
-        importlib.reload(ifcopenshell)
+        imp.reload(ifcopenshell)

 import bpy
 import mathutils
 from bpy.props import StringProperty, IntProperty, BoolProperty
 from bpy_extras.io_utils import ImportHelper

-major, minor = bpy.app.version[0:2]
+major,minor = bpy.app.version[0:2]
 transpose_matrices = minor >= 62

-bpy.types.Object.ifc_id = IntProperty(
-    name="IFC Entity ID",
+bpy.types.Object.ifc_id = IntProperty(name="IFC Entity ID",
    description="The STEP entity instance name")
-bpy.types.Object.ifc_guid = StringProperty(
-    name="IFC Entity GUID",
+bpy.types.Object.ifc_guid = StringProperty(name="IFC Entity GUID",
    description="The IFC Globally Unique Identifier")
-bpy.types.Object.ifc_name = StringProperty(
-    name="IFC Entity Name",
+bpy.types.Object.ifc_name = StringProperty(name="IFC Entity Name",
    description="The optional name attribute")
-bpy.types.Object.ifc_type = StringProperty(
-    name="IFC Entity Type",
+bpy.types.Object.ifc_type = StringProperty(name="IFC Entity Type",
    description="The STEP Datatype keyword")


 def import_ifc(filename, use_names, process_relations, blender_booleans):
    from . import ifcopenshell
    from .ifcopenshell import geom as ifcopenshell_geom
-    print(f"Reading {bpy.path.basename(filename)}...")
+    print("Reading %s..."%bpy.path.basename(filename))
    settings = ifcopenshell_geom.settings()
    settings.set(settings.DISABLE_OPENING_SUBTRACTIONS, blender_booleans)
-    file = ifcopenshell.open(filename)
-    iterator = ifcopenshell_geom.iterator(settings, file)
-    valid_file = iterator.initialize()
+    iterator = ifcopenshell_geom.iterator(settings, filename)
+    valid_file = iterator.findContext()
    if not valid_file:
        return False
    print("Done reading file")
@@ -81,14 +76,9 @@ def import_ifc(filename, use_names, process_relations, blender_booleans):
    openings = []
    old_progress = -1
    print("Creating geometry...")
-    collection = bpy.data.collections.new(f"{bpy.path.basename(filename)}")
-    bpy.context.scene.collection.children.link(collection)
-    if  process_relations:
-        rel_collection = bpy.data.collections.new("Relations")
-        collection.children.link(rel_collection)
    while True:
        ob = iterator.get()
-
+ 
        f = ob.geometry.faces
        v = ob.geometry.verts
        mats = ob.geometry.materials
@@ -96,77 +86,52 @@ def import_ifc(filename, use_names, process_relations, blender_booleans):
        m = ob.transformation.matrix.data
        t = ob.type[0:21]
        nm = ob.name if len(ob.name) and use_names else ob.guid
-        # MESH CREATION
-        # Depending on version, geometry.id will be either int or str
-        mesh_name = 'mesh-%r' % ob.geometry.id
-        if mesh_name in bpy.data.meshes:
-            me = bpy.data.meshes[mesh_name]
-        else:
-            verts = [[v[i], v[i + 1], v[i + 2]]
-                     for i in range(0, len(v), 3)]
-            faces = [[f[i], f[i + 1], f[i + 2]]
-                     for i in range(0, len(f), 3)]

-            me = bpy.data.meshes.new(mesh_name)
-            me.from_pydata(verts, [], faces)
-            me.validate()
-            # MATERIAL CREATION
-            def add_material(mname, props):
-                if mname in bpy.data.materials:
-                    mat = bpy.data.materials[mname]
-                    mat.use_fake_user = True
-                else:
-                    mat = bpy.data.materials.new(mname)
-                    for k, v in props.items():
-                        if k == 'transparency':
-                            mat.blend_method = 'HASHED'
-                            mat.use_screen_refraction = True
-                            mat.refraction_depth = 0.1
-                            mat.use_nodes = True
-                            mat.node_tree.nodes["Principled BSDF"].inputs[15].default_value = v
-                        else:
-                            setattr(mat, k, v)
-                me.materials.append(mat)
+        verts = [[v[i], v[i + 1], v[i + 2]] \
+            for i in range(0, len(v), 3)]
+        faces = [[f[i], f[i + 1], f[i + 2]] \
+            for i in range(0, len(f), 3)]

-            needs_default = -1 in matids
-            if needs_default:
-                add_material(t, {})
+        me = bpy.data.meshes.new('mesh%d' % ob.geometry.id)
+        me.from_pydata(verts, [], faces)
+        
+        def add_material(mname, props):
+            if mname in bpy.data.materials:
+                mat = bpy.data.materials[mname]
+                mat.use_fake_user = True
+            else:
+                mat = bpy.data.materials.new(mname)
+                for k,v in props.items():
+                    setattr(mat, k, v)
+            me.materials.append(mat)
+                
+        needs_default = -1 in matids
+        if needs_default: add_material(t, {})
+        
+        for mat in mats:
+            props = {}
+            if mat.has_diffuse: props['diffuse_color'] = mat.diffuse
+            if mat.has_specular: props['specular_color'] = mat.specular
+            if mat.has_transparency and mat.transparency > 0:
+                props['alpha'] = 1.0 - mat.transparency
+                props['use_transparency'] = True
+            if mat.has_specularity: props['specular_hardness'] = mat.specularity
+            add_material(mat.name, props)

-            for mat in mats:
-                props = {}
-                if mat.has_diffuse:
-                    alpha = 1.
-                    if mat.has_transparency and mat.transparency > 0:
-                        alpha = 1. - mat.transparency
-                    props['diffuse_color'] = mat.diffuse + (alpha,)
-                # @todo
-                # if mat.has_specular:
-                #     props['specular_color'] = mat.specular
-                # if mat.has_specularity:
-                #     props['specular_intensity'] = mat.specularity
-                add_material(mat.name, props)
-
-            faces = me.polygons if hasattr(me, 'polygons') else me.faces
-            if len(faces) == len(matids):
-                for face, matid in zip(faces, matids):
-                    face.material_index = matid + (1 if needs_default else 0)
-
-        # OBJECT CREATION
        bob = bpy.data.objects.new(nm, me)
        mat = mathutils.Matrix(([m[0], m[1], m[2], 0],
-                                [m[3], m[4], m[5], 0],
-                                [m[6], m[7], m[8], 0],
-                                [m[9], m[10], m[11], 1]))
-        if transpose_matrices:
-            mat.transpose()
-
+            [m[3], m[4], m[5], 0],
+            [m[6], m[7], m[8], 0],
+            [m[9], m[10], m[11], 1]))
+        if transpose_matrices: mat.transpose()
+        
        if process_relations:
            id_to_matrix[ob.id] = mat
        else:
            bob.matrix_world = mat
-        collection.objects.link(bob)
+        bpy.context.scene.objects.link(bob)

-        bpy.context.view_layer.objects.active = bob
+        bpy.context.scene.objects.active = bob
        bpy.ops.object.mode_set(mode='EDIT')
        bpy.ops.mesh.normals_make_consistent()
        bpy.ops.object.mode_set(mode='OBJECT')
@@ -176,19 +141,23 @@ def import_ifc(filename, use_names, process_relations, blender_booleans):

        if ob.type == 'IfcSpace' or ob.type == 'IfcOpeningElement':
            if not (ob.type == 'IfcOpeningElement' and blender_booleans):
-                bob.hide_viewport = bob.hide_render = True
-            bob.display_type = 'WIRE'
-
-        if ob.id not in id_to_object:
-            id_to_object[ob.id] = []
+                bob.hide = bob.hide_render = True
+            bob.draw_type = 'WIRE'
+        
+        if ob.id not in id_to_object: id_to_object[ob.id] = []
        id_to_object[ob.id].append(bob)

        if ob.parent_id > 0:
            id_to_parent[ob.id] = ob.parent_id
-
+            
        if blender_booleans and ob.type == 'IfcOpeningElement':
            openings.append(ob.id)
-
+            
+        faces = me.polygons if hasattr(me, 'polygons') else me.faces
+        if len(faces) == len(matids):
+            for face, matid in zip(faces, matids):
+                face.material_index = matid + (1 if needs_default else 0)
+            
        progress = iterator.progress() // 2
        if progress > old_progress:
            print("\r[" + "#" * progress + " " * (50 - progress) + "]", end="")
@@ -199,13 +168,13 @@ def import_ifc(filename, use_names, process_relations, blender_booleans):
    print("\rDone creating geometry" + " " * 30)

    id_to_parent_temp = dict(id_to_parent)
-
+    
    if process_relations:
        print("Processing relations...")

    while len(id_to_parent_temp) and process_relations:
        id, parent_id = id_to_parent_temp.popitem()
-
+        
        if parent_id in id_to_object:
            bob = id_to_object[parent_id][0]
        else:
@@ -217,17 +186,16 @@ def import_ifc(filename, use_names, process_relations, blender_booleans):
                nm = parent_ob.name if len(parent_ob.name) and use_names \
                    else parent_ob.guid
                bob = bpy.data.objects.new(nm, None)
-
+                
                mat = mathutils.Matrix((
                    [m[0], m[1], m[2], 0],
                    [m[3], m[4], m[5], 0],
                    [m[6], m[7], m[8], 0],
                    [m[9], m[10], m[11], 1]))
-                if transpose_matrices:
-                    mat.transpose()
+                if transpose_matrices: mat.transpose()
                id_to_matrix[parent_ob.id] = mat
-
-                rel_collection.objects.link(bob)
+                
+                bpy.context.scene.objects.link(bob)

                bob.ifc_id = parent_ob.id
                bob.ifc_name, bob.ifc_type, bob.ifc_guid = \
@@ -250,13 +218,13 @@ def import_ifc(filename, use_names, process_relations, blender_booleans):
        parent_matrix = id_to_matrix.get(parent_id, None)
        for ob in id_to_object[id]:
            if parent_matrix:
-                ob.matrix_local = parent_matrix.inverted() @ matrix
+                ob.matrix_local = parent_matrix.inverted() * matrix
            else:
                ob.matrix_world = matrix
-
+            
    if process_relations:
        print("Done processing relations")
-
+        
    for opening_id in openings:
        parent_id = id_to_parent[opening_id]
        if parent_id in id_to_object:
@@ -265,11 +233,9 @@ def import_ifc(filename, use_names, process_relations, blender_booleans):
                mod = parent_ob.modifiers.new("opening", "BOOLEAN")
                mod.operation = "DIFFERENCE"
                mod.object = opening_ob
-
-    if hasattr(iterator, 'getLog'):
-        # @todo
-        txt = bpy.data.texts.new(f"{bpy.path.basename(filename)}.log")
-        txt.from_string(iterator.getLog())
+        
+    txt = bpy.data.texts.new("%s.log"%bpy.path.basename(filename))
+    txt.from_string(iterator.getLog())

    return True

@@ -279,51 +245,42 @@ class ImportIFC(bpy.types.Operator, ImportHelper):
    bl_label = "Import .ifc file"

    filename_ext = ".ifc"
-    filter_glob: StringProperty(default="*.ifc", options={'HIDDEN'})
+    filter_glob = StringProperty(default="*.ifc", options={'HIDDEN'})

-    use_names: BoolProperty(name="Use entity names",
-                            description="Use entity names rather than "
-                            "GlobalIds for objects",
-                            default=True)
-    process_relations: BoolProperty(name="Process relations",
-                                    description="Convert containment and "
-                                    "aggregation relations to parenting"
-                                    " (warning: may be slow on large files)",
-                                    default=False)
-    blender_booleans: BoolProperty(name="Use Blender booleans",
-                                   description="Use Blender boolean modifiers "
-                                   "for opening elements",
-                                   default=False)
+    use_names = BoolProperty(name="Use entity names",
+        description="Use entity names rather than GlobalIds for objects",
+        default=True)
+    process_relations = BoolProperty(name="Process relations",
+        description="Convert containment and aggregation" \
+            " relations to parenting" \
+            " (warning: may be slow on large files)",
+        default=False)
+    blender_booleans = BoolProperty(name="Use Blender booleans",
+        description="Use Blender boolean modifiers for opening" \
+            " elements",
+        default=False)

    def execute(self, context):
-        if not import_ifc(self.filepath, self.use_names,
-                          self.process_relations, self.blender_booleans):
+        if not import_ifc(self.filepath, self.use_names, self.process_relations, self.blender_booleans):
            self.report({'ERROR'},
-                        'Unable to parse .ifc file or no geometrical entities found'
-                        )
+                'Unable to parse .ifc file or no geometrical entities found'
+            )
        return {'FINISHED'}


 def menu_func_import(self, context):
    self.layout.operator(ImportIFC.bl_idname,
-                         text="Industry Foundation Classes (.ifc)")
-
-
-classes = (
-    ImportIFC,
-)
+        text="Industry Foundation Classes (.ifc)")


 def register():
-    for cls in classes:
-        bpy.utils.register_class(cls)
-    bpy.types.TOPBAR_MT_file_import.append(menu_func_import)
+    bpy.utils.register_module(__name__)
+    bpy.types.INFO_MT_file_import.append(menu_func_import)


 def unregister():
-    for cls in reversed(classes):
-        bpy.utils.unregister_class(cls)
-    bpy.types.TOPBAR_MT_file_import.remove(menu_func_import)
+    bpy.utils.unregister_module(__name__)
+    bpy.types.INFO_MT_file_import.remove(menu_func_import)


 if __name__ == "__main__":
@@ -0,0 +1,278 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifdef WITH_OPENCOLLADA
+
+#include <string>
+
+#include "ColladaSerializer.h"
+
+std::string collada_id(const std::string& s) {
+	std::string id;
+	id.reserve(s.size());
+	for (std::string::const_iterator it = s.begin(); it != s.end(); ++it) {
+		const std::string::value_type c = *it;
+		if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c == '_')) {
+			id.push_back(c);
+		}
+	}
+	return id;
+}
+
+void ColladaSerializer::ColladaExporter::ColladaGeometries::addFloatSource(const std::string& mesh_id, const std::string& suffix, const std::vector<double>& floats, const char* coords /* = "XYZ" */) {
+	COLLADASW::FloatSource source(mSW);
+	source.setId(mesh_id + suffix);
+	source.setArrayId(mesh_id + suffix + COLLADASW::LibraryGeometries::ARRAY_ID_SUFFIX);
+	source.setAccessorStride(strlen(coords));
+	source.setAccessorCount(floats.size() / 3);
+	for (unsigned int i = 0; i < source.getAccessorStride(); ++i) {
+		source.getParameterNameList().push_back(std::string(1, coords[i]));
+	}
+	source.prepareToAppendValues();
+	for (std::vector<double>::const_iterator it = floats.begin(); it != floats.end(); ++it) {
+		source.appendValues(*it);
+	}
+	source.finish();
+}
+			
+void ColladaSerializer::ColladaExporter::ColladaGeometries::write(const std::string mesh_id, const std::string& default_material_name, const std::vector<double>& positions, const std::vector<double>& normals, const std::vector<int>& indices, const std::vector<int> material_ids, const std::vector<IfcGeom::Material>& materials) {
+	// The goal of the IfcGeom::Iterator is to filter out empty geometries, but
+	// since this function would crash trying to deference the material_ids in
+	// that case, a hard return statement is added just in case.
+	if (indices.empty()) return;
+
+	openMesh(mesh_id);
+
+	// The normals vector can be empty for example when the WELD_VERTICES setting is used.
+	// IfcOpenShell does not provide them with multiple face normals collapsed into a single vertex.
+	const bool has_normals = !normals.empty();
+
+	addFloatSource(mesh_id, COLLADASW::LibraryGeometries::POSITIONS_SOURCE_ID_SUFFIX, positions);
+	if (has_normals) {
+		addFloatSource(mesh_id, COLLADASW::LibraryGeometries::NORMALS_SOURCE_ID_SUFFIX, normals);
+	}
+
+	COLLADASW::VerticesElement vertices(mSW);
+	vertices.setId(mesh_id + COLLADASW::LibraryGeometries::VERTICES_ID_SUFFIX );
+	vertices.getInputList().push_back(COLLADASW::Input(COLLADASW::InputSemantic::POSITION, "#" + mesh_id + COLLADASW::LibraryGeometries::POSITIONS_SOURCE_ID_SUFFIX));
+	vertices.add();
+	
+	std::vector<int>::const_iterator index_range_start = indices.begin();
+	std::vector<int>::const_iterator material_it = material_ids.begin();
+	int previous_material_id = -1;
+	for (std::vector<int>::const_iterator it = indices.begin(); ; it += 3) {
+		const int current_material_id = *(material_it++);
+		const int num_triangles = std::distance(index_range_start, it) / 3;
+		if ((previous_material_id != current_material_id && num_triangles > 0) || (it == indices.end())) {
+			COLLADASW::Triangles triangles(mSW);
+			triangles.setMaterial(materials[previous_material_id].name());
+			triangles.setCount(num_triangles);
+			int offset = 0;
+			triangles.getInputList().push_back(COLLADASW::Input(COLLADASW::InputSemantic::VERTEX,"#" + mesh_id + COLLADASW::LibraryGeometries::VERTICES_ID_SUFFIX, offset++ ) );
+			if (has_normals) {
+				triangles.getInputList().push_back(COLLADASW::Input(COLLADASW::InputSemantic::NORMAL,"#" + mesh_id + COLLADASW::LibraryGeometries::NORMALS_SOURCE_ID_SUFFIX, offset++ ) );
+			}
+			triangles.prepareToAppendValues();
+			for (std::vector<int>::const_iterator jt = index_range_start; jt != it; ++jt) {
+				const int idx = *jt;
+				if (has_normals) {
+					triangles.appendValues(idx, idx);
+				} else {
+					triangles.appendValues(idx);
+				}
+			}
+			triangles.finish();
+			index_range_start = it;
+		}
+		previous_material_id = current_material_id;
+		if (it == indices.end()) {
+			break;
+		}
+	}
+
+	closeMesh();
+	closeGeometry();
+}
+
+void ColladaSerializer::ColladaExporter::ColladaGeometries::close() {
+	closeLibrary();
+}
+			
+void ColladaSerializer::ColladaExporter::ColladaScene::add(const std::string& node_id, const std::string& node_name, const std::string& geom_name, const std::vector<std::string>& material_ids, const std::vector<double>& matrix) {
+	if (!scene_opened) {
+		openVisualScene(scene_id);
+		scene_opened = true;
+	}
+			
+	COLLADASW::Node node(mSW);
+	node.setNodeId(node_id);
+	node.setNodeName(node_name);
+	node.setType(COLLADASW::Node::NODE);
+
+	// The matrix attribute of an entity is basically a 4x3 representation of its ObjectPlacement.
+	// Note that this placement is absolute, ie it is multiplied with all parent placements.
+	double matrix_array[4][4] = {
+		{matrix[0], matrix[3], matrix[6], matrix[ 9]},
+		{matrix[1], matrix[4], matrix[7], matrix[10]},
+		{matrix[2], matrix[5], matrix[8], matrix[11]},
+		{        0,         0,         0,          1}
+	};
+
+	node.start();
+	node.addMatrix(matrix_array);
+	COLLADASW::InstanceGeometry instanceGeometry(mSW);
+	instanceGeometry.setUrl ("#" + geom_name);
+	for (std::vector<std::string>::const_iterator it = material_ids.begin(); it != material_ids.end(); ++it) {
+		COLLADASW::InstanceMaterial material (*it, "#" + *it);
+		instanceGeometry.getBindMaterial().getInstanceMaterialList().push_back(material);
+	}
+	instanceGeometry.add();
+	node.end();
+}
+
+void ColladaSerializer::ColladaExporter::ColladaScene::write() {
+	if (scene_opened) {
+		closeVisualScene();
+		closeLibrary();
+
+		COLLADASW::Scene scene (mSW, COLLADASW::URI ("#" + scene_id));
+		scene.add();		
+	}
+}
+		
+void ColladaSerializer::ColladaExporter::ColladaMaterials::ColladaEffects::write(const IfcGeom::Material& material) {
+	openEffect(collada_id(material.name()) + "-fx");
+	COLLADASW::EffectProfile effect(mSW);
+	effect.setShaderType(COLLADASW::EffectProfile::LAMBERT);
+	if (material.hasDiffuse()) {
+		const double* diffuse = material.diffuse();
+		effect.setDiffuse(COLLADASW::ColorOrTexture(COLLADASW::Color(diffuse[0],diffuse[1],diffuse[2])));
+	}
+	if (material.hasSpecular()) {
+		const double* specular = material.specular();
+		effect.setSpecular(COLLADASW::ColorOrTexture(COLLADASW::Color(specular[0],specular[1],specular[2])));
+	}
+	if (material.hasSpecularity()) {
+		effect.setShininess(material.specularity());
+	}
+	if (material.hasTransparency()) {
+		const double transparency = material.transparency();
+		if (transparency > 0) {
+			// The default opacity mode for Collada is A_ONE, which apparently indicates a
+			// transparency value of 1 to be fully opaque. Hence transparency is inverted.
+			effect.setTransparency(1.0 - transparency);
+		}
+	}
+	addEffectProfile(effect);
+	closeEffect();
+}
+
+void ColladaSerializer::ColladaExporter::ColladaMaterials::ColladaEffects::close() {
+	closeLibrary();
+}
+			
+void ColladaSerializer::ColladaExporter::ColladaMaterials::add(const IfcGeom::Material& material) {
+	if (!contains(material)) {
+		effects.write(material);
+		materials.push_back(material);
+	}
+}
+
+bool ColladaSerializer::ColladaExporter::ColladaMaterials::contains(const IfcGeom::Material& material) {
+	return std::find(materials.begin(), materials.end(), material) != materials.end();
+}
+
+void ColladaSerializer::ColladaExporter::ColladaMaterials::write() {
+	effects.close();
+	for (std::vector<IfcGeom::Material>::const_iterator it = materials.begin(); it != materials.end(); ++it) {
+		const std::string& material_name = collada_id((*it).name());
+		openMaterial(material_name);
+		addInstanceEffect("#" + material_name + "-fx");
+		closeMaterial();
+	}
+	closeLibrary();
+}
+		
+void ColladaSerializer::ColladaExporter::startDocument(const std::string& unit_name, float unit_magnitude) {
+	stream.startDocument();
+
+	COLLADASW::Asset asset(&stream);
+	asset.getContributor().mAuthoringTool = std::string("IfcOpenShell ") + IFCOPENSHELL_VERSION;
+	asset.setUnit(unit_name, unit_magnitude);
+	asset.setUpAxisType(COLLADASW::Asset::Z_UP);
+	asset.add();
+}
+
+void ColladaSerializer::ColladaExporter::write(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<double>& matrix, const std::vector<double>& vertices, const std::vector<double>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, const std::vector<IfcGeom::Material>& _materials) {
+	std::vector<std::string> material_references;
+	for (std::vector<IfcGeom::Material>::const_iterator it = _materials.begin(); it != _materials.end(); ++it) {
+		const IfcGeom::Material& material = *it;
+		if (!materials.contains(material)) {
+			materials.add(material);
+		}
+		material_references.push_back(collada_id(material.name()));
+	}
+	deferreds.push_back(DeferredObject(guid, name, type, obj_id, matrix, vertices, normals, indices, material_ids, _materials, material_references));
+}
+
+const std::string ColladaSerializer::ColladaExporter::DeferredObject::Name() const {
+	std::stringstream ss;
+	if (!this->name.empty()) {
+		ss << this->obj_id << "_" << this->name;
+	} else {
+		ss << this->guid;
+	}
+	return collada_id(ss.str());
+}
+
+void ColladaSerializer::ColladaExporter::endDocument() {
+	// In fact due the XML based nature of Collada and its dependency on library nodes,
+	// only at this point all objects are written to the stream.
+	materials.write();
+	for (std::vector<DeferredObject>::const_iterator it = deferreds.begin(); it != deferreds.end(); ++it) {
+		const std::string object_name = it->Name();
+		geometries.write(object_name, it->type, it->vertices, it->normals, it->indices, it->material_ids, it->materials);
+	}
+	geometries.close();
+	for (std::vector<DeferredObject>::const_iterator it = deferreds.begin(); it != deferreds.end(); ++it) {
+		const std::string object_name = it->Name();
+		scene.add(object_name + "-instance", object_name, object_name, it->material_references, it->matrix);
+	}
+	scene.write();
+	stream.endDocument();
+}
+	
+bool ColladaSerializer::ready() {
+	return true;
+}
+
+void ColladaSerializer::writeHeader() {
+	exporter.startDocument(unit_name, unit_magnitude);
+}
+
+void ColladaSerializer::write(const IfcGeom::TriangulationElement<double>* o) {
+	const IfcGeom::Representation::Triangulation<double>& mesh = o->geometry();
+	exporter.write(o->guid(), o->name(), o->type(), o->id(), o->transformation().matrix().data(), mesh.verts(), mesh.normals(), mesh.faces(), mesh.material_ids(), mesh.materials());
+}
+
+void ColladaSerializer::finalize() {
+	exporter.endDocument();
+}
+
+#endif
@@ -0,0 +1,165 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifdef WITH_OPENCOLLADA
+
+#ifndef COLLADASERIALIZER_H
+#define COLLADASERIALIZER_H
+
+#include <COLLADASWStreamWriter.h>
+#include <COLLADASWPrimitves.h>
+#include <COLLADASWLibraryGeometries.h>
+#include <COLLADASWSource.h>
+#include <COLLADASWScene.h>
+#include <COLLADASWNode.h>
+#include <COLLADASWInstanceGeometry.h>
+#include <COLLADASWLibraryVisualScenes.h>
+#include <COLLADASWLibraryEffects.h>
+#include <COLLADASWLibraryMaterials.h>
+#include <COLLADASWBaseInputElement.h>
+#include <COLLADASWAsset.h>
+
+#include "../ifcgeom/IfcGeomIterator.h"
+
+#include "../ifcconvert/GeometrySerializer.h"
+
+class ColladaSerializer : public GeometrySerializer
+{
+private:
+	class ColladaExporter
+	{
+	private:
+		class ColladaGeometries : public COLLADASW::LibraryGeometries
+		{
+		public:
+			explicit ColladaGeometries(COLLADASW::StreamWriter& stream)
+				: COLLADASW::LibraryGeometries(&stream)
+			{}
+			void addFloatSource(const std::string& mesh_id, const std::string& suffix, const std::vector<double>& floats, const char* coords = "XYZ");
+			void write(const std::string mesh_id, const std::string& default_material_name, const std::vector<double>& positions, const std::vector<double>& normals, const std::vector<int>& indices, const std::vector<int> material_ids, const std::vector<IfcGeom::Material>& materials);
+			void close();
+		};
+		class ColladaScene : public COLLADASW::LibraryVisualScenes
+		{
+		private:
+			const std::string scene_id;
+			bool scene_opened;
+		public:
+			ColladaScene(const std::string& scene_id, COLLADASW::StreamWriter& stream)
+				: COLLADASW::LibraryVisualScenes(&stream)
+				, scene_id(scene_id)
+				, scene_opened(false)			
+			{}
+			void add(const std::string& node_id, const std::string& node_name, const std::string& geom_name, const std::vector<std::string>& material_ids, const std::vector<double>& matrix);
+			void write();
+		};
+		class ColladaMaterials : public COLLADASW::LibraryMaterials
+		{
+		private:
+			class ColladaEffects : public COLLADASW::LibraryEffects
+			{
+			public:
+				explicit ColladaEffects(COLLADASW::StreamWriter& stream)
+					: COLLADASW::LibraryEffects(&stream)
+				{}
+				void write(const IfcGeom::Material& material);
+				void close();
+			};
+			std::vector<IfcGeom::Material> materials;
+			ColladaEffects effects;
+		public:
+			explicit ColladaMaterials(COLLADASW::StreamWriter& stream)
+				: COLLADASW::LibraryMaterials(&stream)
+				, effects(stream)
+			{}
+			void add(const IfcGeom::Material& material);
+			bool contains(const IfcGeom::Material& material);
+			void write();
+		};
+		class DeferredObject {
+		public:
+			std::string guid, name, type;
+			int obj_id;
+			std::vector<double> matrix;
+			std::vector<double> vertices;
+			std::vector<double> normals;
+			std::vector<int> indices;
+			std::vector<int> material_ids;
+			std::vector<IfcGeom::Material> materials;
+			std::vector<std::string> material_references;
+			DeferredObject(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<double>& matrix, const std::vector<double>& vertices,
+				const std::vector<double>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, 
+				const std::vector<IfcGeom::Material>& materials, const std::vector<std::string>& material_references)
+				: guid(guid)
+				, name(name)
+				, type(type)
+				, obj_id(obj_id)
+				, matrix(matrix)
+				, vertices(vertices)
+				, normals(normals)
+				, indices(indices)
+				, material_ids(material_ids)
+				, materials(materials)
+				, material_references(material_references)
+			{}
+			const std::string Name() const;
+		};
+		COLLADABU::NativeString filename;
+		COLLADASW::StreamWriter stream;
+		ColladaGeometries geometries;
+		ColladaScene scene;
+		ColladaMaterials materials;
+	public:
+		ColladaExporter(const std::string& scene_name, const std::string& fn)
+			: filename(fn.c_str())
+			, stream(filename)
+			, geometries(stream)
+			, scene(scene_name, stream)
+			, materials(stream)
+		{}
+		std::vector<DeferredObject> deferreds;
+		virtual ~ColladaExporter() {}
+		void startDocument(const std::string& unit_name, float unit_magnitude);
+		void write(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<double>& matrix, const std::vector<double>& vertices, const std::vector<double>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, const std::vector<IfcGeom::Material>& materials);
+		void endDocument();
+	};
+	ColladaExporter exporter;
+	std::string unit_name;
+	float unit_magnitude;
+public:
+	ColladaSerializer(const std::string& dae_filename)
+		: GeometrySerializer()
+		, exporter("IfcOpenShell", dae_filename)
+	{}
+	bool ready();
+	void writeHeader();
+	void write(const IfcGeom::TriangulationElement<double>* o);
+	void write(const IfcGeom::BRepElement<double>* o) {}
+	void finalize();
+	bool isTesselated() const { return true; }
+	void setUnitNameAndMagnitude(const std::string& name, float magnitude) {
+		unit_name = name;
+		unit_magnitude = magnitude;
+	}
+	void setFile(IfcParse::IfcFile*) {}
+};
+
+#endif
+
+#endif
@@ -17,30 +17,20 @@
 *                                                                              *
 ********************************************************************************/

-#ifndef IFCGLOBALID_H
-#define IFCGLOBALID_H
+#ifndef GEOMETRYSERIALIZER_H
+#define GEOMETRYSERIALIZER_H

-#include <string>
-#include <boost/uuid/uuid.hpp>
+#include "../ifcconvert/Serializer.h"
+#include "../ifcgeom/IfcGeomIterator.h"

-#include "ifc_parse_api.h"
+class GeometrySerializer : public Serializer {
+public:
+	virtual ~GeometrySerializer() {} 

-namespace IfcParse {
-
-	/// A helper class for the creation of IFC GlobalIds.
-	class IFC_PARSE_API IfcGlobalId {
-	private:
-		std::string string_data, formatted_string;
-		boost::uuids::uuid uuid_data;
-	public:
-		static const unsigned int length = 22;
-		IfcGlobalId();
-		IfcGlobalId(const std::string&);
-		operator const std::string&() const;
-		operator const boost::uuids::uuid&() const;
-		const std::string& formatted() const;
-	};
-
-}
+	virtual bool isTesselated() const = 0;
+	virtual void write(const IfcGeom::TriangulationElement<double>* o) = 0;
+	virtual void write(const IfcGeom::BRepElement<double>* o) = 0;
+	virtual void setUnitNameAndMagnitude(const std::string& name, float magnitude) = 0;
+};

 #endif
@@ -20,45 +20,35 @@
 #ifndef IGESSERIALIZER_H
 #define IGESSERIALIZER_H

-#include "OpenCascadeBasedSerializer.h"
-#include "../ifcparse/IfcLogger.h"
-
+#include <IGESControl_Controller.hxx>
 #include <IGESControl_Writer.hxx>
-
-#ifndef HAVE_CONFIG_H
-/// @note this is brittle, but apparently the only way to differentiate OCCT
-/// from OCE. In the latter including this header fails for some versions.
 #include <Interface_Static.hxx>
-#endif
+
+#include "../ifcgeom/IfcGeomIterator.h"
+
+#include "../ifcconvert/OpenCascadeBasedSerializer.h"

 class IgesSerializer : public OpenCascadeBasedSerializer
 {
 private:
-	IGESControl_Writer writer;
+	IGESControl_Writer writer;	
 public:
-    /// @note IGESControl_Controller::Init() must be called prior to instantiating IgesSerializer.
-    /// See http://tracker.dev.opencascade.org/view.php?id=23679 for more information.
-    IgesSerializer(const std::string& out_filename, const SerializerSettings& settings)
-        : OpenCascadeBasedSerializer(out_filename, settings)
+	explicit IgesSerializer(const std::string& out_filename) 
+		: OpenCascadeBasedSerializer(out_filename) 
 	{}
 	virtual ~IgesSerializer() {}
-	void writeShape(const IfcGeom::ConversionResultShape* shape) {
-		writer.AddShape(*(IfcGeom::OpenCascadeShape*)shape);
+	void writeShape(const TopoDS_Shape& shape) {
+		writer.AddShape(shape);
 	}
 	void finalize() {
 		writer.Write(out_filename.c_str());
 	}
-	void setUnitNameAndMagnitude(const std::string& /*name*/, float magnitude) {
+	void setUnitNameAndMagnitude(const std::string& name, float magnitude) {
 		const char* symbol = getSymbolForUnitMagnitude(magnitude);
 		if (symbol) {
-#ifdef HAVE_CONFIG_H
-			Logger::Warning("Setting IGES units not supported on OCE");
-#else
-			Interface_Static::SetCVal("xstep.cascade.unit", symbol);
 			Interface_Static::SetCVal("write.iges.unit", symbol);
-#endif
 		}
 	}
 };

-#endif
+#endif
@@ -17,39 +17,59 @@
 *                                                                              *
 ********************************************************************************/

-#include "OpenCascadeBasedSerializer.h"
-
-#include "../ifcparse/utils.h"
-
 #include <string>
 #include <fstream>
 #include <cstdio>

-#include <Standard_Version.hxx>
+#include <BRepBuilderAPI_GTransform.hxx>
 #include <BRepBuilderAPI_Transform.hxx>

+#include <Standard_Version.hxx>
+
+#include "OpenCascadeBasedSerializer.h"
+
 bool OpenCascadeBasedSerializer::ready() {
-	std::ofstream test_file(IfcUtil::path::from_utf8(out_filename).c_str(), std::ios_base::binary);
+	std::ofstream test_file(out_filename.c_str(), std::ios_base::binary);
 	bool succeeded = test_file.is_open();
 	test_file.close();
-	IfcUtil::path::delete_file(out_filename);
+	remove(out_filename.c_str());
 	return succeeded;
 }

-void OpenCascadeBasedSerializer::write(const IfcGeom::NativeElement<real_t>* o) {
-	IfcGeom::OpenCascadeShape* occt_shape = ((IfcGeom::OpenCascadeShape*) o->geometry().as_compound());
-        TopoDS_Shape compound = occt_shape->shape();
-        delete occt_shape;
+void OpenCascadeBasedSerializer::write(const IfcGeom::BRepElement<double>* o) {		
+	for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = o->geometry().begin(); it != o->geometry().end(); ++ it) {
+		gp_GTrsf gtrsf = it->Placement();

-	if (o->geometry().settings().get(IfcGeom::IteratorSettings::CONVERT_BACK_UNITS)) {
-		gp_Trsf scale;
-		scale.SetScaleFactor(1.0 / o->geometry().settings().unit_magnitude());
+		const std::vector<double>& matrix = o->transformation().matrix().data();
 		
-		compound = BRepBuilderAPI_Transform(compound, scale, true).Shape();
+		// Convert the matrix back into a transformation object. The tolerance values
+		// are taken into consideration to reconstruct the form of the transformation.
+		gp_Trsf o_trsf;
+		o_trsf.SetValues(
+			matrix[0], matrix[3], matrix[6], matrix[ 9],
+			matrix[1], matrix[4], matrix[7], matrix[10], 
+			matrix[2], matrix[5], matrix[8], matrix[11]
+#if OCC_VERSION_HEX < 0x60800
+			, Precision::Angular(), Precision::Confusion()
+#endif
+		);
+		gtrsf.PreMultiply(o_trsf);
+		
+		const TopoDS_Shape& s = it->Shape();			
+			
+		bool trsf_valid = false;
+		gp_Trsf trsf;
+		try {
+			trsf = gtrsf.Trsf();
+			trsf_valid = true;
+		} catch (...) {}
+			
+		const TopoDS_Shape moved_shape = trsf_valid
+			? BRepBuilderAPI_Transform(s, trsf, true).Shape()
+			: BRepBuilderAPI_GTransform(s, gtrsf, true).Shape();
+			
+		writeShape(moved_shape);
 	}
-
-	IfcGeom::OpenCascadeShape s(compound);
-	writeShape(&s);
 }

 #define RATHER_SMALL (1e-3)
@@ -20,29 +20,28 @@
 #ifndef OPENCASCADEBASEDSERIALIZER_H
 #define OPENCASCADEBASEDSERIALIZER_H

-#include "../ifcgeom/schema_agnostic/IfcGeomIterator.h"
-#include "../ifcgeom/schema_agnostic/opencascade/OpenCascadeConversionResult.h"
-#include "../serializers/GeometrySerializer.h"
+#include "../ifcgeom/IfcGeomIterator.h"
+
+#include "../ifcconvert/GeometrySerializer.h"

 class OpenCascadeBasedSerializer : public GeometrySerializer {
-	OpenCascadeBasedSerializer(const OpenCascadeBasedSerializer&); //N/A
-	OpenCascadeBasedSerializer& operator =(const OpenCascadeBasedSerializer&); //N/A
 protected:
-	const std::string out_filename;
+	const std::string& out_filename;
 	const char* getSymbolForUnitMagnitude(float mag);
 public:
-	explicit OpenCascadeBasedSerializer(const std::string& out_filename, const SerializerSettings& settings)
-		: GeometrySerializer(settings)
+	explicit OpenCascadeBasedSerializer(const std::string& out_filename)
+		: GeometrySerializer()
 		, out_filename(out_filename)
 	{}
 	virtual ~OpenCascadeBasedSerializer() {}
 	void writeHeader() {}
+	void writeMaterial(const IfcGeom::SurfaceStyle& style) {}
 	bool ready();
-	virtual void writeShape(const IfcGeom::ConversionResultShape* shape) = 0;
-	void write(const IfcGeom::TriangulationElement<real_t>* /*o*/) {}
-	void write(const IfcGeom::NativeElement<real_t>* o);
+	virtual void writeShape(const TopoDS_Shape& shape) = 0;
+	void write(const IfcGeom::TriangulationElement<double>* o) {}
+	void write(const IfcGeom::BRepElement<double>* o);
 	bool isTesselated() const { return false; }
 	void setFile(IfcParse::IfcFile*) {}
 };

-#endif
+#endif
@@ -20,26 +20,27 @@
 #ifndef STEPSERIALIZER_H
 #define STEPSERIALIZER_H

+#include <STEPControl_Controller.hxx>
 #include <STEPControl_Writer.hxx>
 #include <Interface_Static.hxx>

-#include "../ifcgeom/schema_agnostic/IfcGeomIterator.h"
+#include "../ifcgeom/IfcGeomIterator.h"

-#include "../serializers/OpenCascadeBasedSerializer.h"
+#include "../ifcconvert/OpenCascadeBasedSerializer.h"

 class StepSerializer : public OpenCascadeBasedSerializer
 {
 private:
 	STEPControl_Writer writer;	
 public:
-	explicit StepSerializer(const std::string& out_filename, const SerializerSettings& settings)
-		: OpenCascadeBasedSerializer(out_filename, settings)
+	explicit StepSerializer(const std::string& out_filename) 
+		: OpenCascadeBasedSerializer(out_filename) 
 	{}
 	virtual ~StepSerializer() {}
-	void writeShape(const IfcGeom::ConversionResultShape* shape) {
+	void writeShape(const TopoDS_Shape& shape) {
 		std::stringstream ss;
 		std::streambuf *sb = std::cout.rdbuf(ss.rdbuf());
-		writer.Transfer(((IfcGeom::OpenCascadeShape*)shape)->shape(), STEPControl_AsIs);
+		writer.Transfer(shape, STEPControl_AsIs);
 		std::cout.rdbuf(sb);
 	}
 	void finalize() {
@@ -48,10 +49,9 @@ public:
 		writer.Write(out_filename.c_str());
 		std::cout.rdbuf(sb);
 	}
-	void setUnitNameAndMagnitude(const std::string& /*name*/, float magnitude) {
+	void setUnitNameAndMagnitude(const std::string& name, float magnitude) {
 		const char* symbol = getSymbolForUnitMagnitude(magnitude);
 		if (symbol) {
-			Interface_Static::SetCVal("xstep.cascade.unit", symbol);
 			Interface_Static::SetCVal("write.step.unit", symbol);
 		}
 	}
@@ -0,0 +1,78 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * This file defines default materials for several IFC datatypes                *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef SURFACESTYLE_H
+#define SURFACESTYLE_H
+
+#include <string>
+#include <sstream>
+
+#include <array>
+
+class SurfaceStyle {
+public:
+	class ColorComponent {
+	private:
+		std::array<double, 3> data;
+	public:
+		ColorComponent(double r, double g, double b) {
+			data[0] = r; data[1] = g; data[2] = b;
+		}
+		const double& R() const { return data[0]; }
+		const double& G() const { return data[1]; }
+		const double& B() const { return data[2]; }
+		double& R() { return data[0]; }
+		double& G() { return data[1]; }
+		double& B() { return data[2]; }
+	};
+private:
+	std::string name;
+	ColorComponent diffuse, specular, ambient;
+	double transparency;
+	double specularity;
+public:
+	SurfaceStyle(const std::string& name,
+				 double dr = 0.7,  double dg = 0.7, double db = 0.7,
+			 	 double sr = 0.2,  double sg = 0.2, double sb = 0.2, 
+			 	 double ar = 0.1,  double ag = 0.1, double ab = 0.1,
+				 double Ns = 10.0, double Tr = 1.0)
+		: name(name) 
+		, diffuse(dr, dg, db)
+		, specular(sr, sg, sb)
+		, ambient(ar, ag, ab)
+		, transparency(Tr)
+		, specularity(Ns)
+	{}
+	const std::string& Name() const { return name; }
+	const ColorComponent& Diffuse() const { return diffuse; }
+	const ColorComponent& Specular() const { return specular; }
+	const ColorComponent& Ambient() const { return ambient; }
+	double Transparency() const { return transparency; }
+	double Specularity() const { return specularity; }
+};
+
+SurfaceStyle GetDefaultMaterial(const std::string& s);
+
+#endif
@@ -17,27 +17,12 @@
 *                                                                              *
 ********************************************************************************/

+#include "../ifcgeom/IfcGeomRenderStyles.h"

 #include "WavefrontObjSerializer.h"

-#include "../ifcgeom/schema_agnostic/IfcGeomRenderStyles.h"
-
-#include "../ifcparse/utils.h"
-
-#include <boost/lexical_cast.hpp>
 #include <iomanip>

-WaveFrontOBJSerializer::WaveFrontOBJSerializer(const std::string& obj_filename, const std::string& mtl_filename, const SerializerSettings& settings)
-	: GeometrySerializer(settings)
-	, mtl_filename(mtl_filename)
-	, obj_stream(IfcUtil::path::from_utf8(obj_filename).c_str())
-	, mtl_stream(IfcUtil::path::from_utf8(mtl_filename).c_str())
-	, vcount_total(1)
-{
-	obj_stream << std::setprecision(settings.precision);
-	mtl_stream << std::setprecision(settings.precision);
-}
-
 bool WaveFrontOBJSerializer::ready() {
 	return obj_stream.is_open() && mtl_stream.is_open();
 }
@@ -55,16 +40,11 @@ void WaveFrontOBJSerializer::writeHeader() {
 		mtl_basename = mtl_basename.substr(slash+1);
 	}
 	obj_stream << "mtllib " << mtl_basename << "\n";
-	mtl_stream << "# File generated by IfcOpenShell " << IFCOPENSHELL_VERSION << "\n";
+	mtl_stream << "# File generated by IfcOpenShell " << IFCOPENSHELL_VERSION << "\n";	
 }

-void WaveFrontOBJSerializer::writeMaterial(const IfcGeom::Material& style)
-{
-    std::string material_name = (settings().get(SerializerSettings::USE_MATERIAL_NAMES)
-        ? style.original_name() : style.name());
-    IfcUtil::sanitate_material_name(material_name);
-    mtl_stream << "newmtl " << material_name << "\n";
-
+void WaveFrontOBJSerializer::writeMaterial(const IfcGeom::Material& style) {			
+	mtl_stream << "newmtl " << style.name() << "\n";
 	if (style.hasDiffuse()) {
 		const double* diffuse = style.diffuse();
 		mtl_stream << "Kd " << diffuse[0] << " " << diffuse[1] << " " << diffuse[2] << "\n";
@@ -79,52 +59,46 @@ void WaveFrontOBJSerializer::writeMaterial(const IfcGeom::Material& style)
 	if (style.hasTransparency()) {
 		const double transparency = 1.0 - style.transparency();
 		if (transparency < 1) {
+			mtl_stream << "Tr " << transparency << "\n";
 			mtl_stream << "d "  << transparency << "\n";
+			mtl_stream << "D "  << transparency << "\n";
 		}
 	}
 }
+void WaveFrontOBJSerializer::write(const IfcGeom::TriangulationElement<double>* o) {

-void WaveFrontOBJSerializer::write(const IfcGeom::TriangulationElement<real_t>* o)
-{
-    obj_stream << "g " << object_id(o) << "\n";
+	std::string tmp = o->name().empty() ? o->guid() : o->name();
+
+	std::replace( tmp.begin(), tmp.end(), ' ', '_');
+	const std::string name = tmp;
+	obj_stream << "g " << name << "\n";
 	obj_stream << "s 1" << "\n";

-    const IfcGeom::Representation::Triangulation<real_t>& mesh = o->geometry();
-
-	const int vcount = (int)mesh.verts().size() / 3;
-    for ( std::vector<real_t>::const_iterator it = mesh.verts().begin(); it != mesh.verts().end(); ) {
-        const real_t x = *(it++) + (real_t)settings().offset[0];
-        const real_t y = *(it++) + (real_t)settings().offset[1];
-        const real_t z = *(it++) + (real_t)settings().offset[2];
+	const IfcGeom::Representation::Triangulation<double>& mesh = o->geometry();
+	
+	const int vcount = mesh.verts().size() / 3;
+	for ( std::vector<double>::const_iterator it = mesh.verts().begin(); it != mesh.verts().end(); ) {
+		const double x = *(it++);
+		const double y = *(it++);
+		const double z = *(it++);
 		obj_stream << "v " << x << " " << y << " " << z << "\n";
 	}
-
-    for ( std::vector<real_t>::const_iterator it = mesh.normals().begin(); it != mesh.normals().end(); ) {
-        const real_t x = *(it++);
-        const real_t y = *(it++);
-        const real_t z = *(it++);
+	for ( std::vector<double>::const_iterator it = mesh.normals().begin(); it != mesh.normals().end(); ) {
+		const double x = *(it++);
+		const double y = *(it++);
+		const double z = *(it++);
 		obj_stream << "vn " << x << " " << y << " " << z << "\n";
 	}

-    for (std::vector<real_t>::const_iterator it = mesh.uvs().begin(); it != mesh.uvs().end();) {
-        const real_t u = *it++;
-        const real_t v = *it++;
-        obj_stream << "vt " << u << " " << v << "\n";
-    }
-
 	int previous_material_id = -2;
 	std::vector<int>::const_iterator material_it = mesh.material_ids().begin();

-    const bool has_uvs = !mesh.uvs().empty();
-	const bool has_normals = !mesh.normals().empty();
 	for ( std::vector<int>::const_iterator it = mesh.faces().begin(); it != mesh.faces().end(); ) {
 		
 		const int material_id = *(material_it++);
 		if (material_id != previous_material_id) {
 			const IfcGeom::Material& material = mesh.materials()[material_id];
-            std::string material_name = (settings().get(SerializerSettings::USE_MATERIAL_NAMES)
-                ? material.original_name() : material.name());
-            IfcUtil::sanitate_material_name(material_name);
+			const std::string material_name = material.name();
 			obj_stream << "usemtl " << material_name << "\n";
 			if (materials.find(material_name) == materials.end()) {
 				writeMaterial(material);
@@ -136,52 +110,7 @@ void WaveFrontOBJSerializer::write(const IfcGeom::TriangulationElement<real_t>*
 		const int v1 = *(it++)+vcount_total;
 		const int v2 = *(it++)+vcount_total;
 		const int v3 = *(it++)+vcount_total;
-
-		if (has_normals && has_uvs) {
-			obj_stream << "f " << v1 << "/" << v1 << "/" << v1 << " "
-				<< v2 << "/" << v2 << "/" << v2 << " "
-				<< v3 << "/" << v3 << "/" << v3 << "\n";
-		} else if (has_normals) {
-			obj_stream << "f " << v1 << "//" << v1 << " "
-				<< v2 << "//" << v2 << " "
-				<< v3 << "//" << v3 << "\n";
-		} else {
-			obj_stream << "f " << v1 << " " << v2 << " " << v3 << "\n";
-		}
-
+		obj_stream << "f " << v1 << "//" << v1 << " " << v2 << "//" << v2 << " " << v3 << "//" << v3 << "\n";
 	}
-
-	std::set<int> faces_set (mesh.faces().begin(), mesh.faces().end());
-	const std::vector<int>& edges = mesh.edges();
-
-	for ( std::vector<int>::const_iterator it = edges.begin(); it != edges.end(); ) {
-		const int i1 = *(it++);
-		const int i2 = *(it++);
-
-		if (faces_set.find(i1) != faces_set.end() || faces_set.find(i2) != faces_set.end()) {
-			continue;
-		}
-
-		const int material_id = *(material_it++);
-
-		if (material_id != previous_material_id) {
-			const IfcGeom::Material& material = mesh.materials()[material_id];
-            std::string material_name = (settings().get(SerializerSettings::USE_MATERIAL_NAMES)
-                ? material.original_name() : material.name());
-            IfcUtil::sanitate_material_name(material_name);
-			obj_stream << "usemtl " << material_name << "\n";
-			if (materials.find(material_name) == materials.end()) {
-				writeMaterial(material);
-				materials.insert(material_name);
-			}
-			previous_material_id = material_id;
-		}
-
-		const int v1 = i1 + vcount_total;
-		const int v2 = i2 + vcount_total;
-
-		obj_stream << "l " << v1 << " " << v2 << "\n";
-	}
-
-	vcount_total += vcount;
+    vcount_total += vcount;
 }
@@ -24,9 +24,8 @@
 #include <string>
 #include <fstream>

-#include "../serializers/GeometrySerializer.h"
+#include "../ifcconvert/GeometrySerializer.h"

-// http://people.sc.fsu.edu/~jburkardt/txt/obj_format.txt
 class WaveFrontOBJSerializer : public GeometrySerializer {
 private:
 	const std::string mtl_filename;
@@ -35,17 +34,23 @@ private:
 	unsigned int vcount_total;
 	std::set<std::string> materials;
 public:
-	WaveFrontOBJSerializer(const std::string& obj_filename, const std::string& mtl_filename, const SerializerSettings& settings);
+	WaveFrontOBJSerializer(const std::string& obj_filename, const std::string& mtl_filename)
+		: GeometrySerializer()
+		, obj_stream(obj_filename.c_str())
+		, mtl_filename(mtl_filename)
+		, mtl_stream(mtl_filename.c_str())		
+		, vcount_total(1)
+	{}
 	virtual ~WaveFrontOBJSerializer() {}
 	bool ready();
 	void writeHeader();
 	void writeMaterial(const IfcGeom::Material& style);
-	void write(const IfcGeom::TriangulationElement<real_t>* o);
-	void write(const IfcGeom::NativeElement<real_t>* /*o*/) {}
+	void write(const IfcGeom::TriangulationElement<double>* o);
+	void write(const IfcGeom::BRepElement<double>* o) {}
 	void finalize() {}
 	bool isTesselated() const { return true; }
-	void setUnitNameAndMagnitude(const std::string& /*name*/, float /*magnitude*/) {}
+	void setUnitNameAndMagnitude(const std::string& name, float magnitude) {}
 	void setFile(IfcParse::IfcFile*) {}
 };

-#endif
+#endif
@@ -0,0 +1,262 @@
+#include <map>
+
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/foreach.hpp>
+#include <boost/version.hpp>
+
+#include "XmlSerializer.h"
+
+using boost::property_tree::ptree;
+using namespace IfcSchema;
+
+static std::map<std::string, std::string> argument_name_map;
+
+// Format an IFC attribute and maybe returns as string. Only literal scalar 
+// values are converted. Things like entity instances and lists are omitted.
+boost::optional<std::string> format_attribute(const Argument* argument, IfcUtil::ArgumentType argument_type) {
+	boost::optional<std::string> value;
+	switch(argument_type) {
+		case IfcUtil::Argument_BOOL: {
+			const bool b = *argument;
+			value = b ? "true" : "false";
+			break; }
+		case IfcUtil::Argument_DOUBLE: {
+			const double d = *argument;
+			std::stringstream stream;
+			stream << d;
+			value = stream.str();
+			break; }
+		case IfcUtil::Argument_STRING:
+		case IfcUtil::Argument_ENUMERATION: {
+			value = static_cast<std::string>(*argument);
+			break; }
+		case IfcUtil::Argument_INT: {
+			const int v = *argument;
+			std::stringstream stream;
+			stream << v;
+			value = stream.str();
+			break; }
+		case IfcUtil::Argument_ENTITY: {
+			IfcUtil::IfcBaseClass* e = *argument;
+			if (Type::IsSimple(e->type())) {
+				IfcUtil::IfcBaseType* f = (IfcUtil::IfcBaseType*) e;
+				value = format_attribute(f->getArgument(0), f->getArgumentType(0));
+			} else if (e->is(IfcSchema::Type::IfcSIUnit) || e->is(IfcSchema::Type::IfcConversionBasedUnit)) {
+				// Some string concatenation to have a unit name as a XML attribute.
+
+				std::string unit_name;
+
+				if (e->is(IfcSchema::Type::IfcSIUnit)) {
+					IfcSchema::IfcSIUnit* unit = (IfcSchema::IfcSIUnit*) e;
+					unit_name = IfcSchema::IfcSIUnitName::ToString(unit->Name());
+					if (unit->Prefix()) {
+						unit_name = IfcSchema::IfcSIPrefix::ToString(*unit->Prefix()) + unit_name;
+					}
+				} else {
+					IfcSchema::IfcConversionBasedUnit* unit = (IfcSchema::IfcConversionBasedUnit*) e;
+					unit_name = unit->Name();
+				}
+
+				for (std::string::iterator c = unit_name.begin(); c != unit_name.end(); ++c) *c = tolower(*c);
+
+				value = unit_name;
+			}
+			break; }
+	}
+	return value;
+}
+
+// Formats an entity instances as a ptree node, and insert into the DOM. Recurses
+// over the entity attributes and writes them as xml attributes of the node.
+ptree& format_entity_instance(IfcUtil::IfcBaseEntity* instance, ptree& tree, bool as_link = false) {
+	ptree child;
+	const unsigned n = instance->getArgumentCount();
+	for (unsigned i = 0; i < n; ++i) {
+		const Argument* argument = instance->getArgument(i);
+		if (argument->isNull()) continue;
+
+		std::string argument_name = instance->getArgumentName(i);
+		std::map<std::string, std::string>::const_iterator argument_name_it;
+		argument_name_it = argument_name_map.find(argument_name);
+		if (argument_name_it != argument_name_map.end()) {
+			argument_name = argument_name_it->second;
+		}
+		const IfcUtil::ArgumentType argument_type = instance->getArgumentType(i);
+
+		boost::optional<std::string> value;
+		try {
+			value = format_attribute(argument, argument_type);
+		} catch (...) {}
+
+		if (value) {
+			if (as_link) {
+				if (argument_name == "id") {
+					child.put("<xmlattr>.xlink:href", std::string("#") + *value);
+				}
+			} else {
+				std::stringstream stream;
+				stream << "<xmlattr>." << argument_name;
+				child.put(stream.str(), *value);
+			}
+		}
+	}
+	return tree.add_child(Type::ToString(instance->type()), child);
+}
+
+// A function to be called recursively. Template specialization is used 
+// to descend into decomposition, containment and property relationships.
+template <typename A>
+void descend(A* instance, ptree& tree) {
+	format_entity_instance(instance, tree);
+}
+
+// Returns related entity instances using IFC's objectified relationship
+// model. The second and third argument require a member function pointer.
+template <typename T, typename U, typename V, typename F, typename G>
+typename V::list::ptr get_related(T* t, F f, G g) {
+	typename U::list::ptr li = (*t.*f)()->template as<U>();
+	typename V::list::ptr acc(new typename V::list);
+	for (typename U::list::it it = li->begin(); it != li->end(); ++it) {
+		U* u = *it;
+		acc->push((*u.*g)());
+	}
+	return acc;
+}
+
+// Member functions for IFC attributes have identical names for getters and setters. Hence a full member function signature is needed to identify them.
+typedef IfcTemplatedEntityList<IfcProduct>::ptr (IfcRelContainedInSpatialStructure::*get_related_elements) (void) const;
+typedef IfcTemplatedEntityList<IfcObjectDefinition>::ptr (IfcRelDecomposes::*get_related_objects) (void) const;
+typedef IfcPropertySetDefinition* (IfcRelDefinesByProperties::*get_related_properties) (void) const;
+
+// Descends into the tree by recursing into IfcRelContainedInSpatialStructure,
+// IfcRelDecomposes and IfcRelDefinesByProperties relations.
+template <>
+void descend(IfcProduct* product, ptree& tree) {
+	ptree& child = format_entity_instance(product, tree);
+	
+	if (product->is(Type::IfcSpatialStructureElement)) {
+		IfcSpatialStructureElement* structure = (IfcSpatialStructureElement*) product;
+
+		IfcProduct::list::ptr elements = get_related
+			<IfcSpatialStructureElement, IfcRelContainedInSpatialStructure, IfcProduct>
+			(structure, &IfcSpatialStructureElement::ContainsElements, static_cast<get_related_elements>(&IfcRelContainedInSpatialStructure::RelatedElements));
+	
+		for (IfcProduct::list::it it = elements->begin(); it != elements->end(); ++it) {
+			descend(*it, child);
+		}
+	}
+
+	IfcObjectDefinition::list::ptr structures = get_related
+		<IfcProduct, IfcRelDecomposes, IfcObjectDefinition>
+		(product, &IfcProduct::IsDecomposedBy, static_cast<get_related_objects>(&IfcRelDecomposes::RelatedObjects));
+
+	for (IfcObjectDefinition::list::it it = structures->begin(); it != structures->end(); ++it) {
+		IfcObjectDefinition* ob = *it;
+		if (ob->is(Type::IfcSpatialStructureElement)) {
+			descend((IfcProduct*)ob, child);
+		} else {
+			descend(ob, child);
+		}
+	}
+
+	IfcPropertySetDefinition::list::ptr property_sets = get_related
+		<IfcProduct, IfcRelDefinesByProperties, IfcPropertySetDefinition>
+		(product, &IfcProduct::IsDefinedBy, static_cast<get_related_properties>(&IfcRelDefinesByProperties::RelatingPropertyDefinition));
+
+	for (IfcPropertySetDefinition::list::it it = property_sets->begin(); it != property_sets->end(); ++it) {
+		IfcPropertySetDefinition* pset = *it;
+		if (pset->is(Type::IfcPropertySet)) {
+			format_entity_instance(pset, child, true);
+		}
+	}
+}
+
+// Descends into the tree by recursing into IfcRelDecomposes relations.
+template <>
+void descend(IfcProject* project, ptree& tree) {
+	ptree& child = format_entity_instance(project, tree);
+	
+	IfcObjectDefinition::list::ptr structures = get_related
+		<IfcProject, IfcRelDecomposes, IfcObjectDefinition>
+		(project, &IfcProject::IsDecomposedBy, static_cast<get_related_objects>(&IfcRelDecomposes::RelatedObjects));
+	
+	for (IfcObjectDefinition::list::it it = structures->begin(); it != structures->end(); ++it) {
+		IfcObjectDefinition* ob = *it;
+		if (ob->is(Type::IfcSpatialStructureElement)) {
+			descend((IfcProduct*)ob, child);
+		} else {
+			descend(ob, child);
+		}
+	}
+}
+
+// Format IfcProperty instances and insert into the DOM. IfcComplexProperties are flattened out.
+void format_properties(IfcProperty::list::ptr properties, ptree& node) {
+	for (IfcProperty::list::it it = properties->begin(); it != properties->end(); ++it) {
+		IfcProperty* p = *it;
+		if (p->is(Type::IfcComplexProperty)) {
+			IfcComplexProperty* complex = (IfcComplexProperty*) p;
+			format_properties(complex->HasProperties(), node);
+		} else {
+			format_entity_instance(p, node);
+		}
+	}
+}
+
+void XmlSerializer::finalize() {
+	argument_name_map.insert(std::make_pair("GlobalId", "id"));
+
+	IfcProject::list::ptr projects = file->entitiesByType<IfcProject>();
+	if (projects->size() != 1) {
+		Logger::Message(Logger::LOG_ERROR, "Expected a single IfcProject");
+		return;
+	}
+	IfcProject* project = *projects->begin();
+
+	ptree root, header, decomposition, properties;
+	
+	// Write the SPF header as XML nodes.
+	BOOST_FOREACH(const std::string& s, file->header().file_description().description()) {
+		header.add_child("file_description.description", ptree(s));
+	}
+	BOOST_FOREACH(const std::string& s, file->header().file_name().author()) {
+		header.add_child("file_name.author", ptree(s));
+	}
+	BOOST_FOREACH(const std::string& s, file->header().file_name().organization()) {
+		header.add_child("file_name.organization", ptree(s));
+	}
+	BOOST_FOREACH(const std::string& s, file->header().file_schema().schema_identifiers()) {
+		header.add_child("file_schema.schema_identifiers", ptree(s));
+	}
+	header.put("file_description.implementation_level", file->header().file_description().implementation_level());
+	header.put("file_name.name",                        file->header().file_name().name());
+	header.put("file_name.time_stamp",                  file->header().file_name().time_stamp());
+	header.put("file_name.preprocessor_version",        file->header().file_name().preprocessor_version());
+	header.put("file_name.originating_system",          file->header().file_name().originating_system());
+	header.put("file_name.authorization",               file->header().file_name().authorization());
+	
+	// Descend into the decomposition structure of the IFC file.
+	descend(project, decomposition);
+
+	// Write all property sets and values as XML nodes.
+	IfcPropertySet::list::ptr psets = file->entitiesByType<IfcPropertySet>();
+	for (IfcPropertySet::list::it it = psets->begin(); it != psets->end(); ++it) {
+		IfcPropertySet* pset = *it;
+		ptree& node = format_entity_instance(pset, properties);
+		format_properties(pset->HasProperties(), node);
+	}
+
+	root.add_child("ifc.header",        header);
+	root.add_child("ifc.properties",    properties);
+	root.add_child("ifc.decomposition", decomposition);
+
+	root.put("ifc.<xmlattr>.xmlns:xlink", "http://www.w3.org/1999/xlink");
+
+#if BOOST_VERSION >= 105600
+	boost::property_tree::xml_writer_settings<ptree::key_type> settings = boost::property_tree::xml_writer_make_settings<ptree::key_type>('\t', 1);
+#else
+	boost::property_tree::xml_writer_settings<char> settings('\t', 1);
+#endif
+	boost::property_tree::write_xml(xml_filename, root, std::locale(), settings);
+}
@@ -17,29 +17,25 @@
 *                                                                              *
 ********************************************************************************/

-#ifndef XMLSERIALIZERIMPL_H
-#define XMLSERIALIZERIMPL_H
+#ifndef XMLSERIALIZER_H
+#define XMLSERIALIZER_H

-#include "../../ifcparse/macros.h"
-#include "../../serializers/XmlSerializer.h"
+#include "../ifcconvert/Serializer.h"

-#define INCLUDE_PARENT_PARENT_DIR(x) STRINGIFY(../../ifcparse/x.h)
-#include INCLUDE_PARENT_PARENT_DIR(IfcSchema)
-
-class MAKE_TYPE_NAME(XmlSerializer) : public XmlSerializer {
+class XmlSerializer : public Serializer {
 private:
 	IfcParse::IfcFile* file;
-
+	std::string xml_filename;
 public:
-	MAKE_TYPE_NAME(XmlSerializer)(IfcParse::IfcFile* file, const std::string& xml_filename)
-		: XmlSerializer(0, "")
-	{
-		this->file = file;
-		this->xml_filename = xml_filename;
-	}
+	XmlSerializer(const std::string& xml_filename)
+		: Serializer()
+		, xml_filename(xml_filename)
+	{}

+	bool ready() { return true; }
+	void writeHeader() {}
 	void finalize();
-	void setFile(IfcParse::IfcFile*) {}
+	void setFile(IfcParse::IfcFile* f) { file = f; }
 };

 #endif
@@ -4,8 +4,6 @@ the IFC schema and will most likely fail on any other Express schema.

 The code can be invoked in the following way and results in two header files
 and a single implementation file named according to the schema name in the 
-Express file. A python 3 interpreter with the pyparsing [1] library is required.
+Express file. A python 3 interpreter with the pyparsing library is required.

 $ python bootstrap.py express.bnf > express_parser.py && python express_parser.py IFC2X3_TC1.exp
-
-[1] http://pyparsing.wikispaces.com/Download+and+Installation
@@ -19,14 +19,8 @@

 import sys
 import string
-import operator
-import itertools
-
 from pyparsing import *

-try: from functools import reduce
-except: pass
-
 class Expression:
    def __init__(self, contents):
        self.contents = contents[0]
@@ -62,12 +56,12 @@ class Keyword:
 class Terminal:
    def __init__(self, contents):
        self.contents = contents[0]
-        s = self.contents
-        self.is_keyword = len(s) >= 4 and s[0::len(s)-1] == '""' and \
-            all(c in alphanums+"_" for c in s[1:-1])
    def __repr__(self):
-        ty = "CaselessKeyword" if self.is_keyword else "CaselessLiteral"
-        return "%s(%s)" % (ty, self.contents)
+        s = self.contents
+        is_keyword = len(s) >= 4 and s[0::len(s)-1] == '""' and \
+            all(c in alphanums+"_" for c in s[1:-1])
+        ty = "CaselessKeyword" if is_keyword else "CaselessLiteral"
+        return "%s(%s)" % (ty, s)


 LPAREN = Suppress("(")
@@ -100,16 +94,16 @@ grammar.ignore(HASH + restOfLine)

 express = grammar.parseFile(sys.argv[1])

-def find_bytype(expr, ty, li = None):
+def find_keywords(expr, li = None):
    if li is None: li = []
    if isinstance(expr, Term):
        expr = expr.contents
-    if isinstance(expr, ty):
-        li.append(expr)
-        return set(li)
+    if isinstance(expr, Keyword):
+        li.append(repr(expr))
+        return li
    elif isinstance(expr, Expression):
        for term in expr:
-            find_bytype(term, ty, li)
+            find_keywords(term, li)
    return set(li)

 actions = {
@@ -121,16 +115,13 @@ actions = {
    'general_aggregation_types' : "lambda t: AggregationType(t)",
    'select_type'               : "lambda t: SelectType(t)",
    'binary_type'               : "lambda t: BinaryType(t)",
-    'subtype_declaration'       : "lambda t: SubTypeExpression(t)",
-    'supertype_constraint'      : "lambda t: SuperTypeExpression(t)",
+    'subtype_declaration'       : "lambda t: SubtypeExpression(t)",
    'derive_clause'             : "lambda t: AttributeList('derive', t)",
    'derived_attr'              : "lambda t: DerivedAttribute(t)",
    'inverse_clause'            : "lambda t: AttributeList('inverse', t)",
    'inverse_attr'              : "lambda t: InverseAttribute(t)",
    'bound_spec'                : "lambda t: BoundSpecification(t)",
    'explicit_attr'             : "lambda t: ExplicitAttribute(t)",
-    'width_spec'                : "lambda t: WidthSpec(t)",
-    'string_type'               : "lambda t: StringType(t)",
 }

 to_emit = set(id for id, expr in express)
@@ -138,22 +129,18 @@ emitted = set()
 to_combine = set(["simple_id"])
 to_ignore = set(["where_clause", "supertype_constraint", "unique_clause"])
 statements = []
-    
-terminals = reduce(lambda x,y: x | y, (find_bytype(e, Terminal) for id, e in express))
-keywords = list(filter(operator.attrgetter('is_keyword'), terminals))
-negated_keywords = map(lambda s: "~%s" % s, keywords)

 while True:
    emitted_in_loop = set()
    for id, expr in express:
-        kws = map(repr, find_bytype(expr, Keyword))
+        kws = find_keywords(expr)
        found = [k in emitted for k in kws]
        if id in to_emit and all(found):
            emitted_in_loop.add(id)
            emitted.add(id)
            stmt = "(%s)" % expr
            if id in to_combine:
-                stmt = " + ".join(itertools.chain(negated_keywords, ("originalTextFor(Combine%s)" % stmt,)))
+                stmt = "originalTextFor(Combine%s)" % stmt
            if id in actions:
                stmt = "%s.setParseAction(%s)" % (stmt, actions[id])
            statements.append("%s = %s" % (id, stmt))
@@ -171,42 +158,29 @@ for id in to_emit:
        stmt = "Suppress%s" % stmt
    statements.append("%s << %s" % (id, stmt))

-print ("""import os
-import sys
-import pickle
+print ("""import sys
+from pyparsing import *
+from nodes import *

-cache_file = sys.argv[1] + ".cache.dat"
-if os.path.exists(cache_file):
-    with open(cache_file, "rb") as f:
-        mapping = pickle.load(f)
-        schema = mapping.schema
-else:
-    from pyparsing import *
-    from nodes import *
-    
-    import schema
-    import mapping
-    
-    %s
+%s

-    syntax.ignore("--" + restOfLine)
-    syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))"))
-    ast = syntax.parseFile(sys.argv[1])
-    schema = schema.Schema(ast)
-    mapping = mapping.Mapping(schema)
-
-    with open(cache_file, "wb") as f:
-        pickle.dump(mapping, f, protocol=0)    
+import schema
+import mapping

 import header
+import enum_header
 import implementation
-import schema_class
-import definitions
+import latebound_header
+import latebound_implementation
+
+syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))"))
+ast = syntax.parseFile(sys.argv[1])
+schema = schema.Schema(ast)
+mapping = mapping.Mapping(schema)

 header.Header(mapping).emit()
+enum_header.EnumHeader(mapping).emit()
 implementation.Implementation(mapping).emit()
-schema_class.SchemaClass(mapping).emit()
-definitions.Definitions(mapping).emit()
-
-sys.stdout.write(schema.name)
-"""%('\n    '.join(statements)))
+latebound_header.LateBoundHeader(mapping).emit()
+latebound_implementation.LateBoundImplementation(mapping).emit()
+"""%('\n'.join(statements)))
@@ -1,62 +0,0 @@
-###############################################################################
-#                                                                             #
-# This file is part of IfcOpenShell.                                          #
-#                                                                             #
-# IfcOpenShell is free software: you can redistribute it and/or modify        #
-# it under the terms of the Lesser GNU General Public License as published by #
-# the Free Software Foundation, either version 3.0 of the License, or         #
-# (at your option) any later version.                                         #
-#                                                                             #
-# IfcOpenShell is distributed in the hope that it will be useful,             #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
-# Lesser GNU General Public License for more details.                         #
-#                                                                             #
-# You should have received a copy of the Lesser GNU General Public License    #
-# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
-#                                                                             #
-###############################################################################
-
-import operator
-
-import nodes
-import codegen
-
-from collections import defaultdict
-
-class Definitions(codegen.Base):
-    def __init__(self, mapping):
-        
-        schema_name = mapping.schema.name
-        self.schema_name = schema_name_title = schema_name.capitalize()
-                    
-        statements = ['']
-        
-        def write_entity(schema_name, name, type):
-            attribute_names = list(map(lambda t: (t.name, t.optional), type.attributes))
-            for attr, is_optional in attribute_names:
-                statements.append("#define SCHEMA_%(name)s_HAS_%(attr)s" % locals())
-                if is_optional:
-                    statements.append("#define SCHEMA_%(name)s_%(attr)s_IS_OPTIONAL" % locals())
-            
-        def write(name):
-            statements.append("#define SCHEMA_HAS_%(name)s" % locals())
-            fn = None
-            if mapping.schema.is_entity(name):
-                fn = write_entity
-                
-            if fn is not None:
-                decl = mapping.schema[name]
-                if isinstance(decl, nodes.TypeDeclaration):
-                    decl = decl.type.type
-                fn(schema_name, name, decl) is not False
-        
-        for name in mapping.schema:
-            write(name)
-            
-        self.str = "\n".join(statements) + "\n"
-        
-        self.file_name = '%s-definitions.h' % self.schema_name
-
-    def __repr__(self):
-        return self.str
@@ -27,41 +27,34 @@
 #                                                                             #
 ###############################################################################

-import re
-import os
+import re,csv
 import csv
-
-from schema import OrderedCaseInsensitiveDict 
-
 try: from html.entities import entitydefs
 except: from htmlentitydefs import entitydefs

-make_absolute = lambda fn: os.path.join(os.path.dirname(os.path.realpath(__file__)), fn)
-
-name_to_oid = OrderedCaseInsensitiveDict()
+name_to_oid = {}
 oid_to_desc = {}
 oid_to_name = {}
 oid_to_pid = {}
 regices = list(zip([re.compile(s,re.M) for s in [r'<[\w\n=" \-/\.;_\t:%#,\?\(\)]+>',r'(\n[\t ]*){2,}',r'^[\t ]+']],['','\n\n','  ']))

 definition_files = ['DocEntity.csv', 'DocEnumeration.csv', 'DocDefined.csv', 'DocSelect.csv']
-definition_files = map(make_absolute, definition_files)
 for fn in definition_files:
-    with open(fn, encoding="utf8", errors='ignore') as f:
+    with open(fn) as f:
        for oid, name, desc in csv.reader(f, delimiter=';', quotechar='"'):
            name_to_oid[name] = oid
            oid_to_name[oid] = name
            oid_to_desc[oid] = desc

-with open(make_absolute('DocEntityAttributes.csv')) as f:
+with open('DocEntityAttributes.csv') as f:
    for pid, x, oid in csv.reader(f, delimiter=';', quotechar='"'):
        oid_to_pid[oid] = pid

-with open(make_absolute('DocAttribute.csv')) as f:
+with open('DocAttribute.csv') as f:
    for oid, name, desc in csv.reader(f, delimiter=';', quotechar='"'):
        pid = oid_to_pid[oid]
        pname = oid_to_name[pid]
-        name_to_oid[".".join((pname, name))] = oid
+        name_to_oid[(pname, name)] = oid
        oid_to_desc[oid] = desc

 def description(item):
@@ -74,4 +67,4 @@ def description(item):
        for r,s in regices: desc = r.sub(s,desc)
        desc = desc.strip()
        return desc.split("\n")
-    else: return []
+    else: return []
@@ -17,19 +17,22 @@
 #                                                                             #
 ###############################################################################

-class Base(object):
-    """
-    A base class for all code generation classes. Currently only working around
-    some python 2/3 incompatibilities in terms of unicode file handling.
-    """
+import templates
+
+class EnumHeader:
+    def __init__(self, mapping):
+        enumerable_types = sorted(set([name for name, type in mapping.schema.types.items()] + [name for name, type in mapping.schema.entities.items()]))
+        
+        self.str = templates.enum_header % {
+            'schema_name_upper' : mapping.schema.name.upper(),
+            'schema_name'       : mapping.schema.name.capitalize(),
+            'types'             : ', '.join(enumerable_types)
+        }
+        
+        self.schema_name = mapping.schema.name.capitalize()
+    def __repr__(self):
+        return self.str
    def emit(self):
-        import platform
-        if tuple(map(int, platform.python_version_tuple())) < (2, 8):
-            from io import open as unicode_open
-            unicode_type = unicode
-        else:
-            unicode_open = open
-            unicode_type = lambda x, *args, **kwargs: x
-        f = unicode_open(self.file_name, 'w', encoding='utf-8')
-        f.write(unicode_type(repr(self), encoding='utf-8', errors='ignore'))
+        f = open('%senum.h'%self.schema_name, 'w', encoding='utf-8')
+        f.write(str(self))
        f.close()
@@ -1,3 +1,5 @@
+# Taken from http://sourceforge.net/p/exp-engine/expresso/ci/master/tree/docs/iso-10303-11--2004.bnf
+
 ABS = "abs" .
 ABSTRACT = "abstract" .
 ACOS = "acos" .
@@ -200,7 +202,7 @@ constructed_types = enumeration_type | select_type .
 declaration = entity_decl | function_decl | procedure_decl | subtype_constraint_decl | type_decl .
 derived_attr = attribute_decl ":" parameter_type ":=" expression ";" .
 derive_clause = DERIVE derived_attr { derived_attr } .
-domain_rule = [ rule_label_id ":" ] expression .
+domain_rule = rule_label_id ":" expression .
 element = expression [ ":" repetition ] .
 entity_body = { explicit_attr } [ derive_clause ] [ inverse_clause ] [ unique_clause ] [ where_clause ] .
 entity_constructor = entity_ref "(" [ expression { "," expression } ] ")" .
@@ -332,7 +334,7 @@ type_label_id = simple_id .
 unary_op = "+" | "-" | NOT .
 underlying_type = constructed_types | concrete_types .
 unique_clause = UNIQUE unique_rule ";" { unique_rule ";" } .
-unique_rule = [ rule_label_id ":" ] referenced_attribute { "," referenced_attribute } .
+unique_rule = rule_label_id ":" referenced_attribute { "," referenced_attribute } .
 until_control = UNTIL logical_expression .
 use_clause = USE FROM schema_ref [ "(" named_type_or_rename { "," named_type_or_rename } ")" ] ";" .
 variable_id = simple_id .
@@ -17,13 +17,10 @@
 #                                                                             #
 ###############################################################################

-import operator
-
-import codegen
 import templates
 import documentation

-class Header(codegen.Base):
+class Header:
    def __init__(self, mapping):
        declarations = []

@@ -43,18 +40,15 @@ class Header(codegen.Base):
        emitted_simpletypes = set()
        while len(emitted_simpletypes) < len(mapping.schema.simpletypes):
            for name, type in mapping.schema.simpletypes.items():
-                if name.lower() in emitted_simpletypes: continue
+                if name in emitted_simpletypes: continue
                type_str = mapping.make_type_string(mapping.flatten_type_string(type))
                attr_type = mapping.make_argument_type(type)
                superclass = mapping.simple_type_parent(name)
                if superclass is None: 
                    superclass = "IfcUtil::IfcBaseType"
-                elif superclass.lower() not in emitted_simpletypes:
+                elif superclass not in emitted_simpletypes:
                    continue
-                else:
-                    # Case normalize
-                    superclass = [k for k in mapping.schema.simpletypes.keys() if k.lower() == superclass.lower()][0]
-                emitted_simpletypes.add(name.lower())
+                emitted_simpletypes.add(name)
                write(templates.simpletype, name=name, type=type_str, attr_type=attr_type, superclass=superclass)

        class_definitions = []
@@ -65,18 +59,15 @@ class Header(codegen.Base):
        emitted_entities = set()
        while len(emitted_entities) < len(mapping.schema.entities):
            for name, type in mapping.schema.entities.items():
-                if name.lower() in emitted_entities: continue
-                if len(type.supertypes) == 0 or set(map(str.lower, type.supertypes)) <= emitted_entities:
+                if name in emitted_entities: continue
+                if len(type.supertypes) == 0 or set(type.supertypes) < emitted_entities:
                    attr_lines = []
                    def write_method(attr):
-                        if attr.optional:
-                            attr_lines.append(templates.optional_attribute_description % (attr.name, name))
-                            attr_lines.append("bool has%s() const;"%(attr.name))
-                        attr_lines.extend(["/// %s"%d for d in documentation.description(".".join((name, attr.name)))])
-                        type_str = mapping.get_parameter_type(attr, allow_optional=False, allow_entities=False)
+                        attr_lines.extend(["/// %s"%d for d in documentation.description((name, attr.name))])
+                        type_str = mapping.get_parameter_type(attr, allow_optional=True, allow_entities=True)
                        if mapping.make_argument_type(attr) != "IfcUtil::Argument_UNKNOWN":
                            attr_lines.append("%s %s() const;"%(type_str, attr.name))
-                            attr_lines.append("void set%s(%s v);"%(attr.name, type_str))
+                            attr_lines.append("void %s(%s v);"%(attr.name, type_str))

                    [write_method(attr) for attr in type.attributes]

@@ -93,11 +84,7 @@ class Header(codegen.Base):
                    inverse = "\n".join(["%s%s"%(' '*4, a) for a in inv_lines])
                    if len(inverse): inverse += '\n'

-                    def case_norm(n):
-                        n = n.lower()
-                        return [k for k in mapping.schema.entities.keys() if k.lower() == n][0]
-                    
-                    supertypes = map(case_norm, type.supertypes) if len(type.supertypes) else ['IfcUtil::IfcBaseEntity']
+                    supertypes = type.supertypes if len(type.supertypes) else ['IfcUtil::IfcBaseEntity']
                    superclass = ": %s "%(", ".join(["public %s"%c for c in supertypes]))

                    argument_count = mapping.argument_count(type)
@@ -105,23 +92,17 @@ class Header(codegen.Base):
                    argument_start = argument_count - len(type.attributes)

                    argument_name_function_body_switch_stmt = " switch (i) {%s}"%("".join(['case %d: return "%s"; '%(i+argument_start, attr.name) for i, attr in enumerate(type.attributes)])) if len(type.attributes) else ""
-                    argument_name_function_body_tail = (" return %s::getArgumentName(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
+                    argument_name_function_body_tail = (" return %s::getArgumentName(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcException("argument out of range"); '

                    argument_name_function_body = argument_name_function_body_switch_stmt + argument_name_function_body_tail
-                    
-                    derived = mapping.derived_in_supertype(type)
-                    attribute_names = list(map(operator.attrgetter('name'), mapping.arguments(type)))
-                    derived_in_supertype = set(derived) & set(attribute_names)
-                    derived_in_supertype_indices = sorted(attribute_names.index(nm) for nm in derived_in_supertype)
-                    attribute_type_cases = ['case %d: return IfcUtil::Argument_DERIVED; ' % idx for idx in derived_in_supertype_indices]
-                    attribute_type_cases += ['case %d: return %s; '%(i+argument_start, mapping.make_argument_type(attr)) for i, attr in enumerate(type.attributes)]
-                    argument_type_function_body_switch_stmt = " switch (i) {%s}"%("".join(attribute_type_cases)) if len(type.attributes) else ""
-                    argument_type_function_body_tail = (" return %s::getArgumentType(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
+
+                    argument_type_function_body_switch_stmt = " switch (i) {%s}"%("".join(['case %d: return %s; '%(i+argument_start, mapping.make_argument_type(attr)) for i, attr in enumerate(type.attributes)])) if len(type.attributes) else ""
+                    argument_type_function_body_tail = (" return %s::getArgumentType(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcException("argument out of range"); '

                    argument_type_function_body = argument_type_function_body_switch_stmt + argument_type_function_body_tail
                    
                    argument_entity_function_body_switch_stmt = " switch (i) {%s}"%("".join(['case %d: return %s; '%(i+argument_start, mapping.make_argument_entity(attr)) for i, attr in enumerate(type.attributes)])) if len(type.attributes) else ""
-                    argument_entity_function_body_tail = (" return %s::getArgumentEntity(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
+                    argument_entity_function_body_tail = (" return %s::getArgumentEntity(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcException("argument out of range"); '

                    argument_entity_function_body = argument_entity_function_body_switch_stmt + argument_entity_function_body_tail

@@ -139,9 +120,10 @@ class Header(codegen.Base):
        }

        self.schema_name = mapping.schema.name.capitalize()
-        
-        self.file_name = '%s.h'%self.schema_name
-        
-        
    def __repr__(self):
        return self.str
+    def emit(self):
+        f = open('%s.h'%self.schema_name, 'w', encoding='utf-8')
+        f.write(str(self))
+        f.close()
+
@@ -17,19 +17,15 @@
 #                                                                             #
 ###############################################################################

-import codegen
 import templates

-from schema import OrderedCaseInsensitiveDict
-
-class Implementation(codegen.Base):
+class Implementation:
    def __init__(self, mapping):
        enumeration_functions = []
        entity_implementations = []
        schema_entity_statements = []

        schema_name = mapping.schema.name.capitalize()
-        schema_name_upper = mapping.schema.name.upper()

        stringify = lambda s: '"%s"'%s
        cat = lambda vs: "".join(vs)
@@ -47,8 +43,6 @@ class Implementation(codegen.Base):
                templates.enumeration_function,
                max_id = len(enum.values),
                name = name,
-                schema_name = schema_name,
-                schema_name_upper = schema_name_upper,
                values = catc(map(stringify, enum.values)),
                from_string_statements = catnl(templates.enum_from_string_stmt%dict(context,**locals()) for value in enum.values)
            )
@@ -58,7 +52,6 @@ class Implementation(codegen.Base):
        for name, type in mapping.schema.entities.items():
            parent_type_test = "" if not type.supertypes or len(type.supertypes) != 1 \
                else templates.parent_type_test%(type.supertypes[0])
-                
            constructor_arguments = mapping.get_assignable_arguments(type, include_derived = True)
            constructor_arguments_str = catc("%(full_type)s v%(index)d_%(name)s"%a for a in constructor_arguments if not a['is_derived'])
            attributes = []
@@ -66,27 +59,23 @@ class Implementation(codegen.Base):
            write_attr = lambda str, **kwargs: attributes.append(str%kwargs)
            for arg in constructor_arguments:
                if not arg['is_inherited'] and not arg['is_derived']:
-                    if arg['is_optional']:
-                        write_attr(
-                            templates.const_function,
-                            class_name  = name,
-                            schema_name = schema_name,
-                            schema_name_upper = schema_name_upper,
-                            name        = 'has%s'%arg['name'],
-                            arguments   = '',
-                            return_type = 'bool',
-                            body        = templates.optional_attr_stmt % {'index':arg['index']-1}
-                        )
-                        
+                    
                    def find_template(arg):
                        simple = mapping.schema.is_simpletype(arg['list_instance_type'])
                        select = arg['list_instance_type'] == "IfcUtil::IfcBaseClass"
-                        express = mapping.flatten_type_string(arg['list_instance_type']) in mapping.express_to_cpp_typemapping
-                        if arg['is_enum']: return templates.get_attr_stmt_enum
-                        elif arg['is_nested'] and arg['is_templated_list']: return templates.get_attr_stmt_nested_array
-                        elif arg['is_templated_list'] and not (select or simple or express): return templates.get_attr_stmt_array
-                        elif arg['non_optional_type'].endswith('*'): return templates.get_attr_stmt_entity
-                        else: return templates.get_attr_stmt
+                        express = arg['list_instance_type'] in mapping.express_to_cpp_typemapping
+                        if arg['is_optional']:
+                            if arg['is_enum']: return templates.get_attr_stmt_optional_enum
+                            elif arg['is_nested']: return templates.get_attr_stmt_optional_nested_array
+                            elif arg['is_array'] and not (select or simple or express): return templates.get_attr_stmt_optional_array
+                            elif arg['non_optional_type'].endswith('*'): return templates.get_attr_stmt_optional_entity
+                            else: return templates.get_attr_stmt_generic
+                        else:
+                            if arg['is_enum']: return templates.get_attr_stmt_enum
+                            elif arg['is_nested']: return templates.get_attr_stmt_nested_array
+                            elif arg['is_array'] and not (select or simple or express): return templates.get_attr_stmt_array
+                            elif arg['non_optional_type'].endswith('*'): return templates.get_attr_stmt_entity
+                            else: return templates.get_attr_stmt_generic

                    tmpl = find_template(arg)
                    write_attr(
@@ -94,11 +83,9 @@ class Implementation(codegen.Base):
                        class_name  = name,
                        name        = arg['name'],
                        arguments   = '',
-                        schema_name = schema_name,
-                        schema_name_upper = schema_name_upper,
-                        return_type = arg['non_optional_type'],
+                        return_type = arg['full_type'],
                        body        = tmpl % {'index': arg['index']-1,
-                                              'type' : arg['non_optional_type'].replace('::Value', ''),
+                                              'type' : arg['non_optional_type'].split('::')[0],
                                              'list_instance_type' : arg['list_instance_type']}
                    )
                    
@@ -106,37 +93,39 @@ class Implementation(codegen.Base):
                        simple = mapping.schema.is_simpletype(arg['list_instance_type'])
                        select = arg['list_instance_type'] == "IfcUtil::IfcBaseClass"
                        express = arg['list_instance_type'] in mapping.express_to_cpp_typemapping
-                        if arg['is_enum']: return templates.set_attr_stmt_enum
-                        elif arg['is_templated_list'] and not (select or simple or express): return templates.set_attr_stmt_array
-                        else: return templates.set_attr_stmt
+                        if arg['is_optional']:
+                            if arg['is_enum']: return templates.set_attr_stmt_optional_enum
+                            elif arg['is_array'] and not (select or simple or express): return templates.set_attr_stmt_optional_array
+                            else: return templates.set_attr_stmt_optional_generic
+                        else:
+                            if arg['is_enum']: return templates.set_attr_stmt_enum
+                            elif arg['is_array'] and not (select or simple or express): return templates.set_attr_stmt_array
+                            else: return templates.set_attr_stmt_generic

                    tmpl = find_template(arg)
                    write_attr(
                        templates.function,
                        class_name  = name,
-                        name        = 'set%s'%arg['name'],
-                        arguments   = '%s v'%arg['non_optional_type'],
+                        name        = arg['name'],
+                        arguments   = '%s v'%arg['full_type'],
                        return_type = 'void',
-                        schema_name = schema_name,
-                        schema_name_upper = schema_name_upper,
                        body        = tmpl % {'index': arg['index']-1,
-                                              'type' : arg['non_optional_type'].replace('::Value', '')}
+                                              'type' : arg['non_optional_type'].split('::')[0]}
                    )

                if arg['is_derived']:
                    constructor_implementations.append(templates.constructor_stmt_derived % {'index' : arg['index']-1})
                else:
-                    is_optional_non_naked_ptr = arg['is_optional'] and not arg['non_optional_type'].endswith('*')
                    arg_name = "v%(index)d_%(name)s"%arg
-                    deref_name = ("*%s"%arg_name) if is_optional_non_naked_ptr else arg_name
+                    deref_name = ("*%s"%arg_name) if arg['is_optional'] else arg_name

                    tmpl = templates.constructor_stmt_array if arg['is_templated_list'] \
                        else templates.constructor_stmt_enum if arg['is_enum'] \
                        else templates.constructor_stmt
                    impl = tmpl % {'name'  : deref_name,
                                   'index' : arg['index']-1,
-                                   'type'  : arg['non_optional_type'].replace('::Value', '')}
-                    if is_optional_non_naked_ptr:
+                                   'type'  : arg['non_optional_type'].split('::')[0]}
+                    if arg['is_optional']:
                        impl = templates.constructor_stmt_optional%{'name'  : arg_name,
                                                            'index' : arg['index']-1,
                                                            'stmt'  : impl}
@@ -144,19 +133,17 @@ class Implementation(codegen.Base):
                    
            def get_attribute_index(entity, attr_name):
                related_entity = mapping.schema.entities[entity]
-                return [a['name'].lower() for a in mapping.get_assignable_arguments(related_entity, include_derived=True)].index(attr_name.lower())
+                return [a['name'] for a in mapping.get_assignable_arguments(related_entity, include_derived=True)].index(attr_name)

            inverse = [templates.const_function % {
                'class_name'  : name,
-                'schema_name' : schema_name,
-                'schema_name_upper' : schema_name_upper,
                'name'        : i.name,
                'arguments'   : '',
-                'return_type' : '::%s::%s::list::ptr' % (schema_name, i.entity),
-                'body'        : templates.get_inverse % {'type': i.entity, 'index':get_attribute_index(i.entity, i.attribute), 'schema_name' : schema_name, 'schema_name_upper': schema_name_upper}
+                'return_type' : '%s::list::ptr' % i.entity,
+                'body'        : templates.get_inverse % {'type': i.entity, 'index':get_attribute_index(i.entity, i.attribute)}
            } for i in (type.inverse.elements if type.inverse else [])]

-            superclass = "%s((IfcEntityInstanceData*)0)" % type.supertypes[0] if len(type.supertypes) == 1 else 'IfcUtil::IfcBaseEntity()'
+            superclass = "%s((IfcAbstractEntity*)0)" % type.supertypes[0] if len(type.supertypes) == 1 else 'IfcUtil::IfcBaseEntity()'

            write(
                templates.entity_implementation,
@@ -166,12 +153,10 @@ class Implementation(codegen.Base):
                constructor_implementation = cat(constructor_implementations),
                attributes                 = nl(catnl(attributes)),
                inverse                    = nl(catnl(inverse)),
-                superclass                 = superclass,
-                schema_name                = schema_name,
-                schema_name_upper          = schema_name_upper
+                superclass                 = superclass
            )

-        selectable_simple_types = sorted(set(sum([b.values for a,b in mapping.schema.selects.items()], [])) & set(map(str, mapping.schema.types.keys())))
+        selectable_simple_types = sorted(set(sum([b.values for a,b in mapping.schema.selects.items()], [])) & set(mapping.schema.types.keys()))
        schema_entity_statements += [templates.schema_entity_stmt%locals() for name, type in mapping.schema.simpletypes.items()]
        schema_entity_statements += [templates.schema_entity_stmt%locals() for name, type in mapping.schema.entities.items()]

@@ -183,15 +168,12 @@ class Implementation(codegen.Base):
            'name'           : name,
            'padding'        : ' ' * (max_len - len(name))
        } for name in enumerable_types]
-        
-        enumeration_index_by_str = OrderedCaseInsensitiveDict((j,i) for i,j in enumerate(enumerable_types))
-        def get_parent_id(s):
-            e = mapping.schema.entities.get(s)
-            if e and e.supertypes:
-                return enumeration_index_by_str[e.supertypes[0]]
-            else: return -1

-        parent_type_statements = ",".join(map(str, map(get_parent_id, enumerable_types)))
+        parent_type_statements = [templates.parent_type_stmt % {
+            'name'    : name,
+            'parent'  : type.supertypes[0],
+            'padding' : ' ' * (max_len - len(name))
+        } for name, type in mapping.schema.entities.items() if type.supertypes and len(type.supertypes) == 1]

        max_id = len(enumerable_types)

@@ -209,51 +191,44 @@ class Implementation(codegen.Base):
            constructor = templates.constructor_single_initlist if superclass \
                else templates.constructor
            
-            simpletype_impl_cast = templates.simpletype_impl_cast_templated if mapping.is_templated_list(type) \
-                else templates.simpletype_impl_cast
-                
-            simpletype_impl_constructor = templates.simpletype_impl_constructor_templated if mapping.is_templated_list(type) \
-                else templates.simpletype_impl_constructor
-                
-            def compose(params, schema_name=schema_name, schema_name_upper=schema_name_upper):
+            def compose(params):
                class_name, attr_type, superclass, superclass_init, name, tmpl, return_type, args, body = params
-                underlying_type = mapping.list_instance_type(type)
                arguments = ",".join(args)
                body = body % locals()
                return tmpl % locals()
                
            simple_type_impl.append(templates.simpletype_impl_comment % {'name': class_name})
-            simple_type_impl.extend(map(compose, map(lambda x: (class_name, attr_type, superclass, "(IfcEntityInstanceData*)0")+x, (
-                ('Class',           templates.function,             'const IfcParse::type_declaration&', (),                templates.simpletype_impl_class               ),
-                ('declaration',     templates.const_function,       'const IfcParse::type_declaration&', (),                templates.simpletype_impl_declaration         ),
-                ('',                          constructor,          '',                      ('IfcEntityInstanceData* e',), templates.simpletype_impl_explicit_constructor),
-                ('',                          constructor,          '',                      ("%s v" % type_str,),          simpletype_impl_constructor                   ),
-                ('',                templates.cast_function,        type_str,                (),                            simpletype_impl_cast                          )
+            simple_type_impl.extend(map(compose, map(lambda x: (class_name, attr_type, superclass, "(IfcAbstractEntity*)0")+x, (
+                ('getArgumentType', templates.const_function,       'IfcUtil::ArgumentType', ('unsigned int i',),       templates.simpletype_impl_argument_type       ),
+                ('getArgument',     templates.const_function,       'Argument*',             ('unsigned int i',),       templates.simpletype_impl_argument            ),
+                ('is',              templates.const_function,       'bool',                  ('Type::Enum v',),                   simpletype_impl_is                  ),
+                ('type',            templates.const_function,       'Type::Enum',            (),                        templates.simpletype_impl_type                ),
+                ('Class',           templates.function,             'Type::Enum',            (),                        templates.simpletype_impl_class               ),
+                ('',                          constructor,          '',                      ('IfcAbstractEntity* e',), templates.simpletype_impl_explicit_constructor),
+                ('',                          constructor,          '',                      ("%s v" % type_str,),      templates.simpletype_impl_constructor         ),
+                ('',                templates.cast_function,        type_str,                (),                        templates.simpletype_impl_cast                )
            ))))
            simple_type_impl.append('')
-            
-        external_definitions = [("extern entity* %s_%%s_type;"           % schema_name_upper) % n for n in mapping.schema.entities.keys()   ] + \
-                               [("extern type_declaration* %s_%%s_type;" % schema_name_upper) % n for n in mapping.schema.simpletypes.keys()]

        self.str = templates.implementation % {
-            'schema_name_upper'        : schema_name_upper,
-            'schema_name'              : schema_name,
+            'schema_name_upper'        : mapping.schema.name.upper(),
+            'schema_name'              : mapping.schema.name.capitalize(),
            'max_id'                   : max_id,
            'enumeration_functions'    : cat(enumeration_functions),
            'schema_entity_statements' : catnl(schema_entity_statements),
            'type_name_strings'        : type_name_strings,
            'string_map_statements'    : catnl(string_map_statements),
            'simple_type_statement'    : simple_type_statements,
-            'parent_type_statements'   : parent_type_statements,
+            'parent_type_statements'   : catnl(parent_type_statements),
            'entity_implementations'   : catnl(entity_implementations),
-            'simple_type_impl'         : catnl(simple_type_impl),
-            'external_definitions'     : catnl(external_definitions)
+            'simple_type_impl'         : catnl(simple_type_impl)
        }

        self.schema_name = mapping.schema.name.capitalize()
-        
-        self.file_name = '%s.cpp'%self.schema_name
-        
-        
    def __repr__(self):
        return self.str
+    def emit(self):
+        f = open('%s.cpp'%self.schema_name, 'w', encoding='utf-8')
+        f.write(str(self))
+        f.close()
+
@@ -17,14 +17,19 @@
 #                                                                             #
 ###############################################################################

-set -e
+import templates

-export PATH=/mingw64/bin/:$PATH
-
-if [ -z "$IFCOS_NUM_BUILD_PROCS" ]; then
-IFCOS_NUM_BUILD_PROCS=$(expr $(sysctl -n hw.ncpu 2> /dev/null || cat /proc/cpuinfo | grep processor | wc -l) + 1)
-fi
-
-pushd ../build-msys
-/mingw64/bin/mingw32-make.exe -j$IFCOS_NUM_BUILD_PROCS
-popd
+class LateBoundHeader:
+    def __init__(self, mapping):
+        self.str = templates.lb_header % {
+            'schema_name_upper' : mapping.schema.name.upper(),
+            'schema_name'       : mapping.schema.name.capitalize()
+        }
+        
+        self.schema_name = mapping.schema.name.capitalize()
+    def __repr__(self):
+        return self.str
+    def emit(self):
+        f = open('%s-latebound.h'%self.schema_name, 'w', encoding='utf-8')
+        f.write(str(self))
+        f.close()
@@ -0,0 +1,119 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+import templates
+
+class LateBoundImplementation:
+    def __init__(self, mapping):
+        schema_name = mapping.schema.name.capitalize()
+        
+        entity_descriptors = []
+        enumeration_descriptors = []
+        derived_field_statements = []
+        inverse_implementations = []
+        
+        for name, type in mapping.schema.simpletypes.items():
+            entity_descriptors.append(templates.entity_descriptor % {
+                'type'                         : name,
+                'parent_statement'             : '0',
+                'entity_descriptor_attributes' : templates.entity_descriptor_attribute_without_entity % {
+                    'name'     : 'wrappedValue',
+                    'optional' : 'false',
+                    'type'     : mapping.make_argument_type(mapping.schema.types[name].type)
+                }
+            })
+            
+        emitted_entities = set()
+        entities_to_emit = mapping.schema.entities.keys()
+        while len(emitted_entities) < len(mapping.schema.entities):
+            for name, type in mapping.schema.entities.items():
+                if name in emitted_entities: continue
+                if len(type.supertypes) == 0 or set(type.supertypes) < emitted_entities:
+                    constructor_arguments = mapping.get_assignable_arguments(type, include_derived = True)
+                    entity_descriptor_attributes = []
+                    for arg in constructor_arguments:
+                        if not arg['is_inherited']:
+                            is_enumeration = arg['argument_type_enum'] == 'IfcUtil::Argument_ENUMERATION'
+                            tmpl = templates.entity_descriptor_attribute_with_entity
+                            entity_name = arg['argument_type'] if is_enumeration else arg['argument_entity'].split('::')[1]
+                            entity_descriptor_attributes.append(tmpl % {
+                                'name'       : arg['name'],
+                                'optional'   : 'true' if arg['is_optional'] else 'false',
+                                'type'       : arg['argument_type_enum'],
+                                'entity_name': entity_name
+                            })
+                        
+                    emitted_entities.add(name)
+                    parent_statement = '0' if len(type.supertypes) != 1 else templates.entity_descriptor_parent % {
+                        'type' : type.supertypes[0]
+                    }
+                    entity_descriptors.append(templates.entity_descriptor % {
+                        'type'                         : name,
+                        'parent_statement'             : parent_statement,
+                        'entity_descriptor_attributes' : '\n'.join(entity_descriptor_attributes)
+                    })
+                    
+        for name, enum in mapping.schema.enumerations.items():
+            enumeration_descriptor_values = '\n'.join([templates.enumeration_descriptor_value % {
+                'name' : v
+            } for v in enum.values])
+            enumeration_descriptors.append(templates.enumeration_descriptor % {
+                'type'                          : name,
+                'enumeration_descriptor_values' : enumeration_descriptor_values
+            })
+            
+        for name, type in mapping.schema.entities.items():
+            constructor_arguments = mapping.get_assignable_arguments(type, include_derived = True)
+            statements = ''.join(templates.derived_field_statement_attrs % (a['index']-1) for a in constructor_arguments if a['is_derived'])
+            if len(statements):
+                derived_field_statements.append(templates.derived_field_statement % {
+                    'type'       : name,
+                    'statements' : statements
+                })
+                
+        for name, type in mapping.schema.entities.items():
+            if type.inverse:
+                for attr in type.inverse.elements:
+                    related_entity = mapping.schema.entities[attr.entity]
+                    related_attrs = [a['name'] for a in mapping.get_assignable_arguments(related_entity, include_derived=True)]
+
+                    inverse_implementations.append(templates.inverse_implementation % {
+                        'type'         : name,
+                        'name'         : attr.name,
+                        'related_type' : attr.entity,
+                        'index'        : related_attrs.index(attr.attribute)
+                    })
+
+        self.str = templates.lb_implementation % {
+            'schema_name_upper'        : mapping.schema.name.upper(),
+            'schema_name'              : mapping.schema.name.capitalize(),
+            'entity_descriptors'       : '\n'.join(entity_descriptors),
+            'enumeration_descriptors'  : '\n'.join(enumeration_descriptors),
+            'derived_field_statements' : '\n'.join(derived_field_statements),
+            'inverse_implementations'  : '\n'.join(inverse_implementations)
+        }
+
+        self.schema_name = mapping.schema.name.capitalize()
+    def __repr__(self):
+        return self.str
+    def emit(self):
+        f = open('%s-latebound.cpp'%self.schema_name, 'w', encoding='utf-8')
+        f.write(str(self))
+        f.close()
+
@@ -17,9 +17,6 @@
 #                                                                             #
 ###############################################################################

-from __future__ import print_function
-
-import sys
 import nodes
 import templates

@@ -31,15 +28,8 @@ class Mapping:
        'integer' : 'int',
        'real'    : 'double',
        'number'  : 'double',
-        'string'  : 'std::string',
-        'binary'  : 'boost::dynamic_bitset<>'
+        'string'  : 'std::string'
    }
-    
-    supported_argument_types = set([
-        'INT', 'BOOL', 'DOUBLE', 'STRING', 'BINARY', 'ENUMERATION', 'ENTITY_INSTANCE',
-        'AGGREGATE_OF_INT', 'AGGREGATE_OF_DOUBLE', 'AGGREGATE_OF_STRING', 'AGGREGATE_OF_BINARY', 'AGGREGATE_OF_ENTITY_INSTANCE',
-        'AGGREGATE_OF_AGGREGATE_OF_INT', 'AGGREGATE_OF_AGGREGATE_OF_DOUBLE', 'AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE',
-    ])

    def __init__(self, schema):
        self.schema = schema
@@ -54,17 +44,17 @@ class Mapping:
    def simple_type_parent(self, type):
        parent = self.schema.types[type].type.type
        if isinstance(parent, nodes.AggregationType): parent = None
-        return None if str(parent) in self.express_to_cpp_typemapping else parent
+        return None if parent in self.express_to_cpp_typemapping else parent

    def make_type_string(self, type):
-        if isinstance(type, (str, nodes.BinaryType, nodes.StringType)):
-            return self.express_to_cpp_typemapping.get(str(type), "::%s::%s" % (self.schema.name.capitalize(), type))
+        if isinstance(type, str):
+            return self.express_to_cpp_typemapping.get(type, type)
        else:
            is_list = self.schema.is_entity(type.type)
            is_nested_list = isinstance(type.type, nodes.AggregationType)
            tmpl = templates.list_list_type if is_nested_list else templates.list_type if is_list else templates.array_type
            return tmpl % {
-                'instance_type' : self.make_type_string(self.flatten_type_string(type.type)),
+                'instance_type' : self.make_type_string(type.type),
                'lower'         : type.bounds.lower,
                'upper'         : type.bounds.upper,
            }
@@ -80,76 +70,67 @@ class Mapping:
    def make_argument_entity(self, attr):
        type = attr.type if hasattr(attr, 'type') else attr
        while isinstance(type, nodes.AggregationType): type = type.type
-        if str(type) in self.express_to_cpp_typemapping: return "Type::UNDEFINED"
+        if type in self.express_to_cpp_typemapping or isinstance(type, nodes.BinaryType): return "Type::UNDEFINED"
        else: return "Type::%s" % type        

    def make_argument_type(self, attr):
        def _make_argument_type(type):
-            if self.schema.is_entity(type) or isinstance(type, nodes.SelectType):
-                return "ENTITY_INSTANCE"
+            if type in self.express_to_cpp_typemapping:
+                return self.express_to_cpp_typemapping.get(type, type).split('::')[-1].upper()
+            elif self.schema.is_entity(type):
+                return "ENTITY"
+            elif self.schema.is_type(type):
+                return _make_argument_type(self.schema.types[type].type.type)
            elif isinstance(type, nodes.BinaryType):
-                return "BINARY"
-            elif isinstance(type, nodes.StringType):
-                return "STRING"
+                return "UNKNOWN"
            elif isinstance(type, nodes.EnumerationType):
                return "ENUMERATION"
+            elif isinstance(type, nodes.SelectType):
+                return "ENTITY"
            elif isinstance(type, nodes.AggregationType):
                ty = _make_argument_type(type.type)
                if ty == "UNKNOWN": return "UNKNOWN"
-                return "AGGREGATE_OF_" + ty
-            elif str(type) in self.express_to_cpp_typemapping:
-                return self.express_to_cpp_typemapping.get(str(type), type).split('::')[-1].upper()
-            elif self.schema.is_type(type):
-                return _make_argument_type(self.schema.types[type].type.type)
-            else:
-                raise ValueError("Unable to map type %r for attribute %r" % (type, attr))
+                return "%s_LIST"%ty if ty.startswith("ENTITY") else ("VECTOR_%s"%ty)
+            else: raise ValueError
+        supported = {'INT', 'BOOL', 'DOUBLE', 'STRING', 'VECTOR_INT', 'VECTOR_DOUBLE', 'VECTOR_STRING', 'ENTITY', 'ENTITY_LIST', 'ENTITY_LIST_LIST', 'ENUMERATION'}
        ty = _make_argument_type(attr.type if hasattr(attr, 'type') else attr)
-        if ty not in self.supported_argument_types:
-            print("Attribute %r mapped as 'unknown'" % (attr), file=sys.stderr)
-            ty = 'UNKNOWN'
+        if ty not in supported: ty = 'UNKNOWN'
        return "IfcUtil::Argument_%s" % ty

    def get_type_dep(self, type):
        if isinstance(type, str):
-            return self.express_to_cpp_typemapping.get(str(type), type)
+            return self.express_to_cpp_typemapping.get(type, type)
        else:
            return self.get_type_dep(type.type)

    def get_parameter_type(self, attr, allow_optional, allow_entities, allow_pointer = True):
+        
        attr_type = self.flatten_type(attr.type)
        type_str = self.express_to_cpp_typemapping.get(str(attr_type), attr_type)
        
-        is_ptr = False
-        
        if self.schema.is_enumeration(attr_type):
-            type_str = '::%s::%s::Value' % (self.schema.name.capitalize(), attr_type)
+            type_str = '%s::%s'%(attr_type, attr_type)
        elif isinstance(type_str, nodes.AggregationType):
            is_nested_list = isinstance(attr_type.type, nodes.AggregationType)
            ty = self.get_parameter_type(attr_type.type if is_nested_list else attr_type, False, allow_entities, False)
-            if self.schema.is_select(attr_type.type):
+            if True and self.schema.is_select(attr_type.type):
                type_str = templates.untyped_list
-            elif self.schema.is_simpletype(ty) or str(ty) in self.express_to_cpp_typemapping.values():
-                tmpl = templates.nested_array_type if is_nested_list else templates.array_type
-                bounds = (attr_type.bounds.lower, attr_type.bounds.upper) if attr_type.bounds else (-1, -1)
-                type_str = tmpl % {
+            elif self.schema.is_simpletype(ty) or ty in self.express_to_cpp_typemapping.values():
+                type_str = templates.array_type % {
                    'instance_type' : ty,
-                    'lower'         : bounds[0],
-                    'upper'         : bounds[1]
+                    'lower'         : attr_type.bounds.lower,
+                    'upper'         : attr_type.bounds.upper
                }
            else:
                tmpl = templates.list_list_type if is_nested_list else templates.list_type
                type_str = tmpl % {
                    'instance_type': ty
                }
-        elif (self.schema.is_entity(type_str) or self.schema.is_select(type_str)):
-            type_str = '::%s::%s' % (self.schema.name.capitalize(), attr_type)
-            if allow_pointer:
-                type_str += "*"
-            is_ptr = True
+        elif allow_pointer and (self.schema.is_entity(type_str) or self.schema.is_select(type_str)):
+            type_str += '*'
        elif not allow_pointer and self.schema.is_select(type_str):
            type_str = "IfcUtil::IfcBaseClass*"
-            is_ptr = True
-        if allow_optional and attr.optional and not is_ptr:
+        if allow_optional and attr.optional:# and not is_ptr:
            type_str = "boost::optional< %s >"%type_str
        return type_str

@@ -166,34 +147,23 @@ class Mapping:
        return c + ([str(s) for s in t.derive.elements] if t.derive else [])

    def list_instance_type(self, attr):
-        attr_type = attr.type if isinstance(attr, nodes.ExplicitAttribute) else attr
-        if isinstance(attr_type, str): return None
-        def f(v):
-            v = self.flatten_type(v)
-            if self.schema.is_select(v):
-                return 'IfcUtil::IfcBaseClass'
-            elif str(v) in self.schema.types or str(v) in self.schema.entities:
-                return "::%s::%s" % (self.schema.name.capitalize(), v)
-            else: return str(v)
-        if self.is_array(attr_type):
-            if not isinstance(attr_type, str) and self.is_array(attr_type.type):
-                if isinstance(attr_type.type, str):
-                    return f(attr_type.type)
-                else: return f(attr_type.type.type)
+        f = lambda v : 'IfcUtil::IfcBaseClass' if self.schema.is_select(v) else v
+        if self.is_array(attr.type):
+            if not isinstance(attr.type, str) and self.is_array(attr.type.type):
+                if isinstance(attr.type.type, str):
+                    return f(attr.type.type)
+                else: return f(attr.type.type.type)
            else:
-                if isinstance(attr_type, str):
-                    return f(attr_type)
-                else: return f(attr_type.type)
+                if isinstance(attr.type, str):
+                    return f(attr.type)
+                else: return f(attr.type.type)
        return None

    def is_templated_list(self, attr):
-        attr_type = attr.type if isinstance(attr, nodes.ExplicitAttribute) else attr
-        if isinstance(attr, str): return False
        ty = self.list_instance_type(attr)
-        if ty is None: return False
-        arr = self.is_array(attr_type)
+        arr = self.is_array(attr.type)
        simple = self.schema.is_simpletype(ty)
-        express = self.flatten_type_string(ty) in self.express_to_cpp_typemapping
+        express = ty in self.express_to_cpp_typemapping
        select = ty == 'IfcUtil::IfcBaseClass'
        return arr and not simple and not express and not select

@@ -21,8 +21,8 @@ import string
 import collections

 class Node:
-    def __init__(self, tokens = None):
-        self.tokens = tokens or []
+    def __init__(self, tokens):
+        self.tokens = tokens
        self.init()
    def tokens_of_type(self, cls):
        return [t for t in self.tokens if isinstance(t, cls)]
@@ -44,17 +44,15 @@ class TypeDeclaration(Node):
 class EntityDeclaration(Node):
    name = property(lambda self: self.tokens[1])
    attributes = property(lambda self: self.tokens_of_type(ExplicitAttribute))
-    abstract = property(lambda self: self.single_token_of_type(SuperTypeExpression) is not None and \
-        self.single_token_of_type(SuperTypeExpression).abstract)
    def init(self):
        assert self.tokens[0] == 'entity'
-        s = self.single_token_of_type(SubTypeExpression)
+        s = self.single_token_of_type(SubtypeExpression)
        self.inverse = self.single_token_of_type(AttributeList, 'type', 'inverse')
        self.derive = self.single_token_of_type(AttributeList, 'type', 'derive')
        self.supertypes = s.types if s else []
    def __repr__(self):
        builder = ""
-        builder += "%sEntity(%s)" % ("Abstract " if self.abstract else "", self.name)
+        builder += "Entity(%s)" % (self.name)
        if len(self.supertypes):
            builder += "\n  Supertypes: %s"%(",".join(self.supertypes))
        if len(self.attributes):
@@ -108,20 +106,12 @@ class SelectType(Node):
 class SubSuperTypeExpression(Node):
    type = property(lambda self: self.tokens[0])
    types = property(lambda self: self.tokens[3::2])
-    abstract = False
    def init(self):
-        if self.tokens[0] == 'abstract':
-            self.tokens = self.tokens[1:]
-            self.abstract = True
-        assert self.type == self.type_relationship
+        assert self.type == self.class_type


-class SubTypeExpression(SubSuperTypeExpression):
-    type_relationship = 'subtype'
-
-
-class SuperTypeExpression(SubSuperTypeExpression):
-    type_relationship = 'supertype'
+class SubtypeExpression(SubSuperTypeExpression):
+    class_type = 'subtype'


 class AttributeList(Node):
@@ -137,8 +127,8 @@ class AttributeList(Node):

 class InverseAttribute(Node):
    name = property(lambda self: self.tokens[0])
-    type = property(lambda self: self.tokens[2] if self.tokens[2] != self.tokens[-4] else None)
-    bounds = property(lambda self: None if len(self.tokens) != 9 else self.tokens[3])
+    type = property(lambda self: self.tokens[2])
+    bounds = property(lambda self: None if len(self.tokens) == 6 else self.tokens[3])
    entity = property(lambda self: self.tokens[-4])
    attribute = property(lambda self: self.tokens[-2])
    def init(self):
@@ -159,7 +149,7 @@ class BinaryType(Node):
    def init(self):
        pass
    def __repr__(self):
-        return "binary"
+        return "BINARY"


 class BoundSpecification(Node):
@@ -180,23 +170,6 @@ class ExplicitAttribute(Node):
    def init(self):
        # NB: This assumes a single name per attribute
        # definition, which is not necessarily the case.
-        if self.tokens[0] == "self":
-            i = list(self.tokens).index(":")
-            self.tokens = self.tokens[i-1:]
        assert self.tokens[1] == ':'
    def __repr__(self):
        return "%s : %s%s" % (self.name, self.type, " ?" if self.optional else "")
-
-        
-class WidthSpec(Node):
-    def init(self):
-        if self.tokens[-1] == "fixed":
-            self.tokens[-1:] = []
-        assert (self.tokens[0], self.tokens[-1]) == ("(", ")")
-        self.width = int("".join(self.tokens[1:-1]))
-        
-class StringType(Node):
-    def init(self):
-        pass
-    def __repr__(self):
-        return "string"
@@ -18,67 +18,29 @@
 ###############################################################################

 import nodes
-import platform
 import collections

-if tuple(map(int, platform.python_version_tuple())) < (2, 7):
-    import ordereddict
-    collections.OrderedDict = ordereddict.OrderedDict
-    
-# According to ISO 10303-11 7.1.2: Letters: "... The case of 
-# letters is significant only within explicit string literals."
-class OrderedCaseInsensitiveDict_KeyObject(str):
-    def __eq__(self, other):
-        return self.lower() == other.lower()
-    def __hash__(self):
-        return hash(self.lower())
-
-
-class OrderedCaseInsensitiveDict(collections.OrderedDict):
-    def __init__(self, *args, **kwargs):
-        collections.OrderedDict.__init__(self)
-        for key, value in collections.OrderedDict(*args, **kwargs).items():
-            self[OrderedCaseInsensitiveDict_KeyObject(key)] = value
-    def __setitem__(self, key, value):
-        return collections.OrderedDict.__setitem__(self, OrderedCaseInsensitiveDict_KeyObject(key), value)
-    def __getitem__(self, key):
-        return collections.OrderedDict.__getitem__(self, OrderedCaseInsensitiveDict_KeyObject(key))
-    def get(self, key, *args, **kwargs):
-        return collections.OrderedDict.get(self, OrderedCaseInsensitiveDict_KeyObject(key), *args, **kwargs)
-    def __contains__(self, key):
-        return collections.OrderedDict.__contains__(self, OrderedCaseInsensitiveDict_KeyObject(key))
-
-
 class Schema:
    def is_enumeration(self, v):
-        return str(v) in self.enumerations
+        return v in self.enumerations
    def is_select(self, v):
-        return str(v) in self.selects
+        return v in self.selects
    def is_simpletype(self, v):
-        return str(v) in self.simpletypes
+        return v in self.simpletypes
    def is_type(self, v):
-        return str(v) in self.types
+        return v in self.types
    def is_entity(self, v):
-        return str(v) in self.entities
-    def __len__(self):
-        return len(self.types) + len(self.entities)
-    def __iter__(self):
-        return iter(self.keys)
-    def __getitem__(self, key):
-        return self.types_entities[key]
+        return v in self.entities
    def __init__(self, parsetree):
        self.name = parsetree[1]

-        sort = lambda d: OrderedCaseInsensitiveDict(sorted(d))
+        sort = lambda d: collections.OrderedDict(sorted(d.items()))

-        self.types = sort([(t.name,t) for t in parsetree if isinstance(t, nodes.TypeDeclaration)])
-        self.entities = sort([(t.name,t) for t in parsetree if isinstance(t, nodes.EntityDeclaration)])
-        
-        self.keys = list(self.types.keys()) + list(self.entities.keys())
-        self.types_entities = {k: v for d in (self.types, self.entities) for k, v in d.items()}
+        self.types = sort({t.name:t for t in parsetree if isinstance(t, nodes.TypeDeclaration)})
+        self.entities = sort({t.name:t for t in parsetree if isinstance(t, nodes.EntityDeclaration)})

-        of_type = lambda *types: sort([(a, b.type.type) for a,b in self.types.items() if any(isinstance(b.type.type, ty) for ty in types)])
+        of_type = lambda *types: sort({a: b.type.type for a,b in self.types.items() if any(isinstance(b.type.type, ty) for ty in types)})

        self.enumerations = of_type(nodes.EnumerationType)
        self.selects = of_type(nodes.SelectType)
-        self.simpletypes = of_type(str, nodes.AggregationType, nodes.BinaryType, nodes.StringType)
+        self.simpletypes = of_type(str, nodes.AggregationType)
@@ -1,268 +0,0 @@
-###############################################################################
-#                                                                             #
-# This file is part of IfcOpenShell.                                          #
-#                                                                             #
-# IfcOpenShell is free software: you can redistribute it and/or modify        #
-# it under the terms of the Lesser GNU General Public License as published by #
-# the Free Software Foundation, either version 3.0 of the License, or         #
-# (at your option) any later version.                                         #
-#                                                                             #
-# IfcOpenShell is distributed in the hope that it will be useful,             #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
-# Lesser GNU General Public License for more details.                         #
-#                                                                             #
-# You should have received a copy of the Lesser GNU General Public License    #
-# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
-#                                                                             #
-###############################################################################
-
-import operator
-
-import nodes
-import codegen
-import templates
-
-from collections import defaultdict
-
-class SchemaClass(codegen.Base):
-    def __init__(self, mapping):
-        
-        class UnmetDependenciesException(Exception): pass
-        
-        schema_name = mapping.schema.name
-        self.schema_name = schema_name_title = schema_name.capitalize()
-
-        declared_types = []
-        
-        def get_declared_type(type, emitted_names=None):
-            if isinstance(type, nodes.AggregationType):
-                aggr_type = type.aggregate_type
-                make_bound = lambda b: -1 if b == '?' else int(b)
-                bound1, bound2 = map(make_bound, (type.bounds.lower, type.bounds.upper))
-                decl_type = get_declared_type(type.type, emitted_names)
-                return "new aggregation_type(aggregation_type::%(aggr_type)s_type, %(bound1)d, %(bound2)d, %(decl_type)s)" % locals()
-            elif isinstance(type, nodes.BinaryType):
-                return "new simple_type(simple_type::binary_type)"
-            elif isinstance(type, nodes.StringType):
-                return "new simple_type(simple_type::string_type)"
-            elif isinstance(type, str):
-                if mapping.schema.is_type(type) or mapping.schema.is_entity(type):
-                    if emitted_names is None or type.lower() in emitted_names:
-                        return "new named_type(%s_%s_type)" % (schema_name, type)
-                    else:
-                        raise UnmetDependenciesException(type)
-                else:
-                    return "new simple_type(simple_type::%s_type)" % type
-
-        def find_inverse_name_and_index(entity_name, attribute_name):
-            attributes_per_subtype = []
-            while True:
-                entity = mapping.schema.entities[entity_name]
-                attr_names = list(map(operator.attrgetter('name'), entity.attributes))
-                if len(attr_names):
-                    attributes_per_subtype.append((entity_name, attr_names))
-                if len(entity.supertypes) != 1: break
-                entity_name = entity.supertypes[0]
-            index = 0
-            for et, attrs in attributes_per_subtype[::-1]:
-                try: return et, attrs.index(attribute_name)
-                except: pass
-    
-            else:
-                raise Exception("No declared type for <%r>" % type)
-                    
-        statements = ['',
-                      '#include "../ifcparse/IfcSchema.h"',
-                      '#include "../ifcparse/%(schema_name_title)s.h"' % locals(),
-                      '',
-                      'using namespace IfcParse;',
-                      '']
-
-        collections_by_type = (('entity',           mapping.schema.entities    ),
-                               ('type_declaration', mapping.schema.simpletypes ),
-                               ('select_type',      mapping.schema.selects     ),
-                               ('enumeration_type', mapping.schema.enumerations))
-
-        for cpp_type, collection in collections_by_type:
-            for name in collection.keys():
-                statements.append('%(cpp_type)s* %(schema_name)s_%(name)s_type = 0;' % locals())
-                
-        declarations_by_index = []
-        
-        statements.append("{factory_placeholder}")
-                      
-        statements.append("""
-#if defined(__clang__)
-__attribute__((optnone))
-#elif defined(__GNUC__) || defined(__GNUG__)
-#pragma GCC push_options
-#pragma GCC optimize ("O0")
-#elif defined(_MSC_VER)
-#pragma optimize("", off)
-#endif
-        """)
-        statements.append('IfcParse::schema_definition* %(schema_name)s_populate_schema() {' % locals())
-        
-        emitted = set()
-        len_to_emit = len(mapping.schema)
-        
-        def write_simpletype(schema_name, name, type):   
-            try:
-                declared_type = get_declared_type(type, emitted)
-            except UnmetDependenciesException:
-                # @todo?
-                # print("Unmet", repr(name))
-                return False
-
-            statements.append('    %(schema_name)s_%(name)s_type = new type_declaration("%(name)s", %%(index_in_schema_%(name)s)d, %(declared_type)s);' % locals())
-            
-        def write_enumeration(schema_name, name, enum):
-            statements.append('    {')
-            statements.append('        std::vector<std::string> items; items.reserve(%d);' % len(enum.values))
-            statements.extend(map(lambda v: '        items.push_back("%s");' % v, sorted(enum.values)))
-            statements.append('        %(schema_name)s_%(name)s_type = new enumeration_type("%(name)s", %%(index_in_schema_%(name)s)d, items);' % locals())
-            statements.append('    }')
-            
-        def write_entity(schema_name, name, type):
-            if len(type.supertypes) == 0 or set(map(lambda s: s.lower(), type.supertypes)) < emitted:
-                supertype = '0' if len(type.supertypes) == 0 else '%s_%s_type' % (schema_name, type.supertypes[0])
-                is_abstract = "true" if type.abstract else "false"
-                statements.append('    %(schema_name)s_%(name)s_type = new entity("%(name)s", %(is_abstract)s, %%(index_in_schema_%(name)s)d, %(supertype)s);' % locals())
-            else: return False
-                
-        def write_select(schema_name, name, type):
-            if set(map(lambda s: s.lower(),type.values)) < emitted:
-                statements.append('    {')
-                statements.append('        std::vector<const declaration*> items; items.reserve(%d);' % len(type.values))
-                statements.extend(map(lambda v: '        items.push_back(%s_%s_type);' % (schema_name, v), sorted(type.values)))
-                statements.append('        %(schema_name)s_%(name)s_type = new select_type("%(name)s", %%(index_in_schema_%(name)s)d, items);' % locals())
-                statements.append('    }')
-            else: return False
-                                
-        def write(name):
-            if mapping.schema.is_simpletype(name):
-                fn = write_simpletype
-            elif mapping.schema.is_enumeration(name):
-                fn = write_enumeration
-            elif mapping.schema.is_entity(name):
-                fn = write_entity
-            elif mapping.schema.is_select(name):
-                fn = write_select
-                
-            decl = mapping.schema[name]
-            if isinstance(decl, nodes.TypeDeclaration):
-                decl = decl.type.type
-            return fn(schema_name, name, decl) is not False
-        
-        while len(emitted) < len_to_emit:
-            for name in mapping.schema:
-                if name.lower() in emitted: continue                                
-                if write(name):
-                    emitted.add(name.lower())
-                    declarations_by_index.append(name)
-                    declared_types.append('%(schema_name)s_%(name)s_type' % locals())
-
-        num_declarations = len(declared_types)
-                    
-        for name, type in mapping.schema.entities.items():
-            derived = set(mapping.derived_in_supertype(type))
-            attribute_names = list(map(operator.attrgetter('name'), mapping.arguments(type)))
-            
-            statements.append('    {')
-            statements.append('        std::vector<const attribute*> attributes; attributes.reserve(%d);' % len(type.attributes))
-            for attr in type.attributes:
-                attr_name, optional = attr.name, str(attr.optional).lower()
-                decl_type = get_declared_type(attr.type)
-                statements.append('        attributes.push_back(new attribute("%(attr_name)s", %(decl_type)s, %(optional)s));' % locals())
-            statements.append('        std::vector<bool> derived; derived.reserve(%d);' % len(attribute_names))
-            statements.append('        ' + " ".join(map(lambda b: 'derived.push_back(%s);' % str(b in derived).lower(), attribute_names)))
-            statements.append('        %(schema_name)s_%(name)s_type->set_attributes(attributes, derived);' % locals())
-            statements.append('    }')
-            
-        for name, type in mapping.schema.entities.items():
-            if type.inverse:
-                statements.append('    {')
-                statements.append('        std::vector<const inverse_attribute*> attributes; attributes.reserve(%d);' % len(type.inverse.elements))
-                for attr in type.inverse.elements:
-                    if attr.bounds:
-                        make_bound = lambda b: -1 if b == '?' else int(b)
-                        bound1, bound2 = map(make_bound, (attr.bounds.lower, attr.bounds.upper))
-                    else:
-                        bound1, bound2 = -1, -1
-                    attr_name, aggr_type, entity_ref = attr.name, attr.type, attr.entity
-                    if aggr_type is None: aggr_type = 'unspecified'
-                    attribute_entity, attribute_entity_index = find_inverse_name_and_index(entity_ref, attr.attribute)
-                    statements.append('        attributes.push_back(new inverse_attribute("%(attr_name)s", inverse_attribute::%(aggr_type)s_type, %(bound1)d, %(bound2)d, %(schema_name)s_%(entity_ref)s_type, %(schema_name)s_%(attribute_entity)s_type->attributes()[%(attribute_entity_index)d]));' % locals())
-                statements.append('        %(schema_name)s_%(name)s_type->set_inverse_attributes(attributes);' % locals())
-                statements.append('    }')
-                
-        subtypes = defaultdict(list)
-        
-        for name, type in mapping.schema.entities.items():
-            for ty in type.supertypes:
-                subtypes[ty].append(name)
-                
-        for name, tys in subtypes.items():
-            statements.append('    {')
-            statements.append('        std::vector<const entity*> defs; defs.reserve(%d);' % len(tys))
-            statements.append(('        ' + "".join(map(lambda t: ("defs.push_back(%%(schema_name)s_%s_type);" % t), tys))) % locals())
-            statements.append('        %(schema_name)s_%(name)s_type->set_subtypes(defs);' % locals())
-            statements.append('    }')
-            
-        statements.append('')
-        statements.append('    std::vector<const declaration*> declarations; declarations.reserve(%(num_declarations)d);' % locals())
-        for type_name in declared_types:
-            statements.append('    declarations.push_back(%(type_name)s);' % locals())
-            
-        statements.append('    return new schema_definition("%(schema_name)s", declarations, new %(schema_name)s_instance_factory());' % locals())
-        
-        statements.extend(('}',''))
-        
-        statements.append("""
-#if defined(__clang__)
-#elif defined(__GNUC__) || defined(__GNUG__)
-#pragma GCC pop_options
-#elif defined(_MSC_VER)
-#pragma optimize("", on)
-#endif
-        """)
-        
-        statements.extend(('const schema_definition& %s::get_schema() {' % schema_name_title,
-                           '',
-                           '    static const schema_definition* s = %(schema_name)s_populate_schema();' % locals(),
-                           '    return *s;',
-                           '}','',''))
-                           
-        declarations_by_index.sort(key=str.lower)
-        declarations_by_index_map = dict(("index_in_schema_%s" % j,i) for i,j in enumerate(declarations_by_index))
-        
-        def bind(s):
-            if "%" in s: return s % declarations_by_index_map
-            else: return s
-            
-        can_be_instantiated_set = set(list(mapping.schema.entities.keys()) + list(mapping.schema.simpletypes.keys()))
-        def can_be_instantiated(idx_name):
-            name = idx_name[1]
-            return name in can_be_instantiated_set
-                           
-        instance_mapping = """switch(data->type()->index_in_schema()) {
-            %s
-            default: throw IfcParse::IfcException(data->type()->name() + " cannot be instantiated");
-        }
-""" % "\n            ".join(map(lambda tup: ("case %%d: return new ::%s::%%s(data);" % schema_name_title) % tup, filter(can_be_instantiated, enumerate(declarations_by_index))))
-
-        statements[statements.index("{factory_placeholder}")] = """
-class %(schema_name)s_instance_factory : public IfcParse::instance_factory {
-    virtual IfcUtil::IfcBaseClass* operator()(IfcEntityInstanceData* data) const {
-        %(instance_mapping)s
-    }
-};
-""" % locals()
-                           
-        self.str = "\n".join(map(bind, statements))
-        
-        self.file_name = '%s-schema.cpp'%self.schema_name
-
-    def __repr__(self):
-        return self.str
@@ -23,22 +23,19 @@ header = """

 #include <string>
 #include <vector>
+#include <map>

 #include <boost/optional.hpp>

-#include "../ifcparse/ifc_parse_api.h"
-
-#include "../ifcparse/IfcEntityList.h"
-#include "../ifcparse/IfcBaseClass.h"
-#include "../ifcparse/IfcSchema.h"
+#include "../ifcparse/IfcUtil.h"
 #include "../ifcparse/IfcException.h"
-#include "../ifcparse/Argument.h"
+#include "../ifcparse/%(schema_name)senum.h"

-struct %(schema_name)s {
+#define IfcSchema %(schema_name)s

-static const IfcParse::schema_definition& get_schema();
+namespace %(schema_name)s {

-static const char* const Identifier;
+const char* const Identifier = "%(schema_name_upper)s";

 // Forward definitions
 %(forward_definitions)s
@@ -46,7 +43,9 @@ static const char* const Identifier;
 %(declarations)s

 %(class_definitions)s
-};
+void InitStringMap();
+IfcUtil::IfcBaseClass* SchemaEntity(IfcAbstractEntity* e = 0);
+}

 #endif
 """
@@ -55,31 +54,97 @@ enum_header = """
 #ifndef %(schema_name_upper)sENUM_H
 #define %(schema_name_upper)sENUM_H

-#include "../ifcparse/ifc_parse_api.h"
+#define IfcSchema %(schema_name)s

-#include <string>
-#include <boost/optional.hpp>
+namespace %(schema_name)s {
+
+namespace Type {
+    typedef enum {
+        %(types)s, UNDEFINED
+    } Enum;
+    Enum Parent(Enum v);
+    Enum FromString(const std::string& s);
+    std::string ToString(Enum v);
+    bool IsSimple(Enum v);
+}
+
+}

 #endif
 """

-lb_header = """"""
+lb_header = """
+#ifndef %(schema_name_upper)sRT_H
+#define %(schema_name_upper)sRT_H
+
+#define IfcSchema %(schema_name)s
+
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/IfcEntityDescriptor.h"
+#include "../ifcparse/IfcWritableEntity.h"
+
+namespace %(schema_name)s {
+namespace Type {
+    int GetAttributeCount(Enum t);
+    int GetAttributeIndex(Enum t, const std::string& a);
+    IfcUtil::ArgumentType GetAttributeType(Enum t, unsigned char a);
+    Enum GetAttributeEntity(Enum t, unsigned char a);
+    const std::string& GetAttributeName(Enum t, unsigned char a);
+    bool GetAttributeOptional(Enum t, unsigned char a);
+    bool GetAttributeDerived(Enum t, unsigned char a);
+    std::pair<const char*, int> GetEnumerationIndex(Enum t, const std::string& a);
+    std::pair<Enum, unsigned> GetInverseAttribute(Enum t, const std::string& a);
+    std::set<std::string> GetInverseAttributeNames(Enum t);
+    void PopulateDerivedFields(IfcWrite::IfcWritableEntity* e);
+}}
+
+#endif
+"""

 implementation= """
 #include "../ifcparse/%(schema_name)s.h"
-#include "../ifcparse/IfcSchema.h"
 #include "../ifcparse/IfcException.h"
 #include "../ifcparse/IfcWrite.h"
+#include "../ifcparse/IfcWritableEntity.h"

-#include <map>
-
-const char* const %(schema_name)s::Identifier = "%(schema_name_upper)s";
-
+using namespace %(schema_name)s;
 using namespace IfcParse;
 using namespace IfcWrite;

-// External definitions
-%(external_definitions)s
+IfcUtil::IfcBaseClass* %(schema_name)s::SchemaEntity(IfcAbstractEntity* e) {
+    switch(e->type()) {
+%(schema_entity_statements)s
+        default: throw IfcException("Unable to find find keyword in schema"); break;
+    }
+}
+
+std::string Type::ToString(Enum v) {
+    if (v < 0 || v >= %(max_id)d) throw IfcException("Unable to find find keyword in schema");
+    const char* names[] = { %(type_name_strings)s };
+    return names[v];
+}
+
+static std::map<std::string,Type::Enum> string_map;
+void %(schema_name)s::InitStringMap() {
+%(string_map_statements)s
+}
+
+Type::Enum Type::FromString(const std::string& s) {
+    if (string_map.empty()) InitStringMap();
+    std::map<std::string,Type::Enum>::const_iterator it = string_map.find(s);
+    if ( it == string_map.end() ) throw IfcException("Unable to find find keyword in schema");
+    else return it->second;
+}
+
+Type::Enum Type::Parent(Enum v){
+    if (v < 0 || v >= %(max_id)d) return (Enum)-1;
+%(parent_type_statements)s
+    return (Enum)-1;
+}
+
+bool Type::IsSimple(Enum v) {
+    return %(simple_type_statement)s;
+}

 %(enumeration_functions)s

@@ -88,7 +153,150 @@ using namespace IfcWrite;
 %(entity_implementations)s
 """

-lb_implementation = """"""
+lb_implementation = """
+#include <set>
+
+#include "../ifcparse/%(schema_name)s.h"
+#include "../ifcparse/%(schema_name)s-latebound.h"
+#include "../ifcparse/IfcException.h"
+#include "../ifcparse/IfcWrite.h"
+#include "../ifcparse/IfcWritableEntity.h"
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/IfcEntityDescriptor.h"
+
+using namespace %(schema_name)s;
+using namespace IfcParse;
+using namespace IfcWrite;
+using namespace IfcUtil;
+
+typedef std::map<Type::Enum,IfcEntityDescriptor*> entity_descriptor_map_t;
+typedef std::map<Type::Enum,IfcEnumerationDescriptor*> enumeration_descriptor_map_t;
+typedef std::map<Type::Enum, std::map<std::string, std::pair<Type::Enum, int> > > inverse_map_t;
+typedef std::map<Type::Enum,std::set<int> > derived_map_t;
+
+entity_descriptor_map_t entity_descriptor_map;
+enumeration_descriptor_map_t enumeration_descriptor_map;
+inverse_map_t inverse_map;
+derived_map_t derived_map;
+
+void InitDescriptorMap() {
+    IfcEntityDescriptor* current;
+%(entity_descriptors)s
+    // Enumerations
+    IfcEnumerationDescriptor* current_enum;
+    std::vector<std::string> values;
+%(enumeration_descriptors)s
+}
+
+void InitInverseMap() {
+%(inverse_implementations)s
+}
+
+void InitDerivedMap() {
+%(derived_field_statements)s
+}
+
+int Type::GetAttributeIndex(Enum t, const std::string& a) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentIndex(a);
+}
+
+int Type::GetAttributeCount(Enum t) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentCount();
+}
+
+ArgumentType Type::GetAttributeType(Enum t, unsigned char a) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentType(a);
+}
+
+Type::Enum Type::GetAttributeEntity(Enum t, unsigned char a) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentEntity(a);
+}
+
+const std::string& Type::GetAttributeName(Enum t, unsigned char a) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentName(a);
+}
+
+bool Type::GetAttributeOptional(Enum t, unsigned char a) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentOptional(a);
+}
+
+bool Type::GetAttributeDerived(Enum t, unsigned char a) {
+    if (derived_map.empty()) ::InitDerivedMap();
+    std::map<Type::Enum,std::set<int> >::const_iterator i = derived_map.find(t);
+    return i != derived_map.end() && i->second.find(a) != i->second.end();
+}
+
+std::pair<const char*, int> Type::GetEnumerationIndex(Enum t, const std::string& a) {
+    if (enumeration_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEnumerationDescriptor*>::const_iterator i = enumeration_descriptor_map.find(t);
+    if ( i == enumeration_descriptor_map.end() ) throw IfcException("Value not found");
+    else return i->second->getIndex(a);
+}
+
+std::pair<Type::Enum, unsigned> Type::GetInverseAttribute(Enum t, const std::string& a) {
+	if (inverse_map.empty()) ::InitInverseMap();
+	inverse_map_t::const_iterator it;
+	inverse_map_t::mapped_type::const_iterator jt;
+    while (true) {
+        it = inverse_map.find(t);
+        if (it != inverse_map.end()) {
+			jt = it->second.find(a);
+			if (jt != it->second.end()) {
+				return jt->second;
+			}
+		}
+        if ((t = Parent(t)) == -1) break;
+    }
+    throw IfcException("Attribute not found");
+}
+
+std::set<std::string> Type::GetInverseAttributeNames(Enum t) {
+	if (inverse_map.empty()) ::InitInverseMap();
+	inverse_map_t::const_iterator it;
+	inverse_map_t::mapped_type::const_iterator jt;
+
+	std::set<std::string> return_value;
+
+    while (true) {
+        it = inverse_map.find(t);
+        if (it != inverse_map.end()) {
+			for (jt = it->second.begin(); jt != it->second.end(); ++jt) {
+				return_value.insert(jt->first);
+			}
+		}
+        if ((t = Parent(t)) == -1) break;
+    }
+    
+	return return_value;
+}
+
+void Type::PopulateDerivedFields(IfcWrite::IfcWritableEntity* e) {
+    std::map<Type::Enum, std::set<int> >::const_iterator i = derived_map.find(e->type());
+	if (i != derived_map.end()) {
+		for (std::set<int>::const_iterator it = i->second.begin(); it != i->second.end(); ++it) {
+			e->setArgumentDerived(*it);
+		}
+	}
+}
+"""

 entity_descriptor = """    current = entity_descriptor_map[Type::%(type)s] = new IfcEntityDescriptor(Type::%(type)s,%(parent_statement)s);
 %(entity_descriptor_attributes)s"""
@@ -99,7 +307,7 @@ entity_descriptor_attribute_with_entity = '    current->add("%(name)s",%(optiona

 enumeration_descriptor = """    values.clear(); values.reserve(128);
 %(enumeration_descriptor_values)s
-    enumeration_descriptor_map[Type::%(type)s] = new IfcEnumerationDescriptor(Type::%(type)s, values);"""
+    current_enum = enumeration_descriptor_map[Type::%(type)s] = new IfcEnumerationDescriptor(Type::%(type)s, values);"""

 enumeration_descriptor_value = '    values.push_back("%(name)s");'

@@ -107,85 +315,89 @@ derived_field_statement = '    {std::set<int> idxs; %(statements)sderived_map[Ty
 derived_field_statement_attrs = 'idxs.insert(%d); '

 simpletype = """%(documentation)s
-class IFC_PARSE_API %(name)s : public %(superclass)s {
+class %(name)s : public %(superclass)s {
 public:
-    virtual const IfcParse::type_declaration& declaration() const;
-    static const IfcParse::type_declaration& Class();
-    explicit %(name)s (IfcEntityInstanceData* e);
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const;
+    virtual Argument* getArgument(unsigned int i) const;
+    bool is(Type::Enum v) const;
+    Type::Enum type() const;
+    static Type::Enum Class();
+    explicit %(name)s (IfcAbstractEntity* e);
    %(name)s (%(type)s v);
    operator %(type)s() const;
 };
 """

 simpletype_impl_comment = "// Function implementations for %(name)s"
-simpletype_impl_argument_type = "if (i == 0) { return %(attr_type)s; } else { throw IfcParse::IfcAttributeOutOfRangeException(\"Argument index out of range\"); }"
-simpletype_impl_argument = "return data_->getArgument(i);"
-simpletype_impl_is_with_supertype = "return v == %(class_name)s_type || %(superclass)s::is(v);"
-simpletype_impl_is_without_supertype = "return v == %(class_name)s_type;"
-simpletype_impl_type = "return *%(schema_name_upper)s_%(class_name)s_type;"
-simpletype_impl_class = "return *%(schema_name_upper)s_%(class_name)s_type;"
-simpletype_impl_explicit_constructor = "data_ = e;"
-simpletype_impl_constructor           = "data_ = new IfcEntityInstanceData(%(schema_name_upper)s_%(class_name)s_type); {IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument(); attr->set(v"           +"); data_->setArgument(0, attr);}"
-simpletype_impl_constructor_templated = "data_ = new IfcEntityInstanceData(%(schema_name_upper)s_%(class_name)s_type); {IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument(); attr->set(v->generalize()); data_->setArgument(0, attr);}"
-simpletype_impl_cast = "return *data_->getArgument(0);"
-simpletype_impl_cast_templated = "IfcEntityList::ptr es = *data_->getArgument(0); return es->as< %(underlying_type)s >();"
-simpletype_impl_declaration = "return *%(schema_name_upper)s_%(class_name)s_type;"
+simpletype_impl_argument_type = "if (i == 0) { return %(attr_type)s; } else { throw IfcParse::IfcException(\"argument out of range\"); }"
+simpletype_impl_argument = "return entity->getArgument(i);"
+simpletype_impl_is_with_supertype = "return v == Type::%(class_name)s || %(superclass)s::is(v);"
+simpletype_impl_is_without_supertype = "return v == %(class_name)s::Class();"
+simpletype_impl_type = "return Type::%(class_name)s;"
+simpletype_impl_class = "return Type::%(class_name)s;"
+simpletype_impl_explicit_constructor = "entity = e;"
+simpletype_impl_constructor = "IfcWritableEntity* e = new IfcWritableEntity(Type::%(class_name)s); e->setArgument(0, v); entity = e;"
+simpletype_impl_cast = "return *entity->getArgument(0);"    
    
 select = """%(documentation)s
 typedef IfcUtil::IfcBaseClass %(name)s;
 """

-enumeration = """struct %(name)s {
+enumeration = """namespace %(name)s {
 %(documentation)s
-typedef enum {%(values)s} Value;
-IFC_PARSE_API static const char* ToString(Value v);
-IFC_PARSE_API static Value FromString(const std::string& s);
-};
+typedef enum {%(values)s} %(name)s;
+const char* ToString(%(name)s v);
+%(name)s FromString(const std::string& s);
+}
 """

 entity = """%(documentation)s
-class IFC_PARSE_API %(name)s %(superclass)s{
+class %(name)s %(superclass)s{
 public:
-%(attributes)s    %(inverse)s    virtual const IfcParse::entity& declaration() const;
-    static const IfcParse::entity& Class();
-    %(name)s (IfcEntityInstanceData* e);
+%(attributes)s    virtual unsigned int getArgumentCount() const { return %(argument_count)d; }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const {%(argument_type_function_body)s}
+    virtual Type::Enum getArgumentEntity(unsigned int i) const {%(argument_entity_function_body)s}
+    virtual const char* getArgumentName(unsigned int i) const {%(argument_name_function_body)s}
+    virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
+%(inverse)s    bool is(Type::Enum v) const;
+    Type::Enum type() const;
+    static Type::Enum Class();
+    %(name)s (IfcAbstractEntity* e);
    %(name)s (%(constructor_arguments)s);
    typedef IfcTemplatedEntityList< %(name)s > list;
 };
 """

 enumeration_function="""
-const char* %(schema_name)s::%(name)s::ToString(Value v) {
+const char* %(name)s::ToString(%(name)s v) {
    if ( v < 0 || v >= %(max_id)d ) throw IfcException("Unable to find find keyword in schema");
    const char* names[] = { %(values)s };
    return names[v];
 }

-%(schema_name)s::%(name)s::Value %(schema_name)s::%(name)s::FromString(const std::string& s) {
+%(name)s::%(name)s %(name)s::FromString(const std::string& s) {
 %(from_string_statements)s
    throw IfcException("Unable to find find keyword in schema");
 }
 """

 entity_implementation = """// Function implementations for %(name)s
-%(attributes)s
-%(inverse)s
-const IfcParse::entity& %(schema_name)s::%(name)s::declaration() const { return *%(schema_name_upper)s_%(name)s_type; }
-const IfcParse::entity& %(schema_name)s::%(name)s::Class() { return *%(schema_name_upper)s_%(name)s_type; }
-%(schema_name)s::%(name)s::%(name)s(IfcEntityInstanceData* e) : %(superclass)s { if (!e) return; if (e->type() != %(schema_name_upper)s_%(name)s_type) throw IfcException("Unable to find find keyword in schema"); data_ = e; }
-%(schema_name)s::%(name)s::%(name)s(%(constructor_arguments)s) : %(superclass)s {data_ = new IfcEntityInstanceData(%(schema_name_upper)s_%(name)s_type); %(constructor_implementation)s }
+%(attributes)s%(inverse)sbool %(name)s::is(Type::Enum v) const { return v == Type::%(name)s%(parent_type_test)s; }
+Type::Enum %(name)s::type() const { return Type::%(name)s; }
+Type::Enum %(name)s::Class() { return Type::%(name)s; }
+%(name)s::%(name)s(IfcAbstractEntity* e) : %(superclass)s { if (!e) return; if (!e->is(Type::%(name)s)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
+%(name)s::%(name)s(%(constructor_arguments)s) : %(superclass)s { IfcWritableEntity* e = new IfcWritableEntity(Class());%(constructor_implementation)s entity = e; EntityBuffer::Add(this); }
 """

 optional_attribute_description = "/// Whether the optional attribute %s is defined for this %s"

-function = "%(return_type)s %(schema_name)s::%(class_name)s::%(name)s(%(arguments)s) { %(body)s }"
-const_function = "%(return_type)s %(schema_name)s::%(class_name)s::%(name)s(%(arguments)s) const { %(body)s }"
-constructor = "%(schema_name)s::%(class_name)s::%(class_name)s(%(arguments)s) { %(body)s }"
-constructor_single_initlist = "%(schema_name)s::%(class_name)s::%(class_name)s(%(arguments)s) : %(superclass)s(%(superclass_init)s) { %(body)s }"
-cast_function = "%(schema_name)s::%(class_name)s::operator %(return_type)s() const { %(body)s }"
+function = "%(return_type)s %(class_name)s::%(name)s(%(arguments)s) { %(body)s }"
+const_function = "%(return_type)s %(class_name)s::%(name)s(%(arguments)s) const { %(body)s }"
+constructor = "%(class_name)s::%(class_name)s(%(arguments)s) { %(body)s }"
+constructor_single_initlist = "%(class_name)s::%(class_name)s(%(arguments)s) : %(superclass)s(%(superclass_init)s) { %(body)s }"
+cast_function = "%(class_name)s::operator %(return_type)s() const { %(body)s }"

 array_type = "std::vector< %(instance_type)s > /*[%(lower)s:%(upper)s]*/"
-nested_array_type = "std::vector< std::vector< %(instance_type)s > >"
 list_type = "IfcTemplatedEntityList< %(instance_type)s >::ptr"
 list_list_type = "IfcTemplatedEntityListList< %(instance_type)s >::ptr"
 untyped_list = "IfcEntityList::ptr"
@@ -194,31 +406,40 @@ inverse_attr = "IfcTemplatedEntityList< %(entity)s >::ptr %(name)s() const; // I
 enum_from_string_stmt = '    if (s == "%(value)s") return ::%(schema_name)s::%(name)s::%(short_name)s_%(value)s;'

 schema_entity_stmt = '        case Type::%(name)s: return new %(name)s(e); break;'
+schema_simple_stmt = '        case Type::%(name)s: return new IfcUtil::IfcEntitySelect(e); break;'
 string_map_statement = '    string_map["%(uppercase_name)s"%(padding)s] = Type::%(name)s;'
 parent_type_stmt = '    if(v==%(name)s%(padding)s) { return %(parent)s; }'

 parent_type_test = " || %s::is(v)"

-optional_attr_stmt = "return !data_->getArgument(%(index)d)->isNull();"
+get_attr_stmt_generic               = "return *entity->getArgument(%(index)d);"
+get_attr_stmt_enum                  = "return %(type)s::FromString(*entity->getArgument(%(index)d));"
+get_attr_stmt_entity                = "return (%(type)s)((IfcUtil::IfcBaseClass*)(*entity->getArgument(%(index)d)));"
+get_attr_stmt_array                 = "IfcEntityList::ptr es = *entity->getArgument(%(index)d); return es->as<%(list_instance_type)s>();"
+get_attr_stmt_nested_array          = "IfcEntityListList::ptr es = *entity->getArgument(%(index)d); return es->as<%(list_instance_type)s>();"
+get_attr_stmt_optional              = "Argument* arg = entity->getArgument(%%(index)d); if (arg->isNull()) { return boost::none; } else { %s }"
+get_attr_stmt_optional_generic      = get_attr_stmt_optional % "return *arg;"
+get_attr_stmt_optional_enum         = get_attr_stmt_optional % "return %(type)s::FromString(*arg);"
+get_attr_stmt_optional_entity       = get_attr_stmt_optional % "return (%(type)s)((IfcUtil::IfcBaseClass*)(*arg));"
+get_attr_stmt_optional_array        = get_attr_stmt_optional % "IfcEntityList::ptr es = *arg; return es->as<%(list_instance_type)s>();"
+get_attr_stmt_optional_nested_array = get_attr_stmt_optional % "IfcEntityListList::ptr es = *arg; return es->as<%(list_instance_type)s>();"

-get_attr_stmt = "return *data_->getArgument(%(index)d);"
-get_attr_stmt_enum = "return %(type)s::FromString(*data_->getArgument(%(index)d));"
-get_attr_stmt_entity = "return (%(type)s)((IfcUtil::IfcBaseClass*)(*data_->getArgument(%(index)d)));"
-get_attr_stmt_array = "IfcEntityList::ptr es = *data_->getArgument(%(index)d); return es->as< %(list_instance_type)s >();"
-get_attr_stmt_nested_array = "IfcEntityListList::ptr es = *data_->getArgument(%(index)d); return es->as< %(list_instance_type)s >();"
+set_attr_stmt                  = "IfcWritableEntity* w = entity->isWritable(); if (!w) { entity = w = new IfcWritableEntity(entity); } %s;"
+set_attr_stmt_optional         = "IfcWritableEntity* w = entity->isWritable(); if (!w) { entity = w = new IfcWritableEntity(entity); } if (v) { %s; } else { w->setArgument(%%(index)d); }"
+set_attr_stmt_generic          = set_attr_stmt % "w->setArgument(%(index)d,v)"
+set_attr_stmt_enum             = set_attr_stmt % "w->setArgument(%(index)d,v,%(type)s::ToString(v));"
+set_attr_stmt_array            = set_attr_stmt % "w->setArgument(%(index)d,v->generalize());"
+set_attr_stmt_optional_generic = set_attr_stmt_optional % "w->setArgument(%(index)d,*v)"
+set_attr_stmt_optional_enum    = set_attr_stmt_optional % "w->setArgument(%(index)d,*v,%(type)s::ToString(*v));"
+set_attr_stmt_optional_array   = set_attr_stmt_optional % "w->setArgument(%(index)d,(*v)->generalize());"

-get_inverse = "return data_->getInverse(%(schema_name_upper)s_%(type)s_type, %(index)d)->as<%(type)s>();"
+get_inverse = "return entity->getInverse(Type::%(type)s, %(index)d)->as<%(type)s>();"

-set_attr_stmt       = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(v"                                                                     +");data_->setArgument(%(index)d,attr);}"
-set_attr_stmt_enum  = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(IfcWrite::IfcWriteArgument::EnumerationReference(v,%(type)s::ToString(v)));data_->setArgument(%(index)d,attr);}"
-set_attr_stmt_array = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(v->generalize()"                                                       +");data_->setArgument(%(index)d,attr);}"
-
-constructor_stmt          = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set((%(name)s)"                                                                                +");data_->setArgument(%(index)d,attr);}"
-constructor_stmt_enum     = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set((IfcWrite::IfcWriteArgument::EnumerationReference(%(name)s,%(type)s::ToString(%(name)s)))" +");data_->setArgument(%(index)d,attr);}"
-constructor_stmt_array    = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set((%(name)s)->generalize()"                                                                  +");data_->setArgument(%(index)d,attr);}"
-constructor_stmt_derived  = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(IfcWrite::IfcWriteArgument::Derived()"                                                     +");data_->setArgument(%(index)d,attr);}"
-
-constructor_stmt_optional = " if (%(name)s) {%(stmt)s } else { IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument(); attr->set(boost::blank()); data_->setArgument(%(index)d, attr); }"
+constructor_stmt = " e->setArgument(%(index)d,(%(name)s));"
+constructor_stmt_enum = " e->setArgument(%(index)d,%(name)s,%(type)s::ToString(%(name)s));"
+constructor_stmt_array = " e->setArgument(%(index)d,(%(name)s)->generalize());"
+constructor_stmt_optional = " if (%(name)s) {%(stmt)s } else { e->setArgument(%(index)d); }"
+constructor_stmt_derived = " e->setArgumentDerived(%(index)d);"

 inverse_implementation = "    inverse_map[Type::%(type)s].insert(std::make_pair(\"%(name)s\", std::make_pair(Type::%(related_type)s, %(index)d)));"

@@ -0,0 +1,184 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCGEOM_H
+#define IFCGEOM_H
+
+#define ALMOST_ZERO (1e-9)
+#define ALMOST_THE_SAME(a,b) (fabs(a-b) < ALMOST_ZERO)
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Mat.hxx>
+#include <gp_Mat2d.hxx>
+#include <gp_GTrsf.hxx>
+#include <gp_GTrsf2d.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <Geom_Curve.hxx>
+#include <gp_Pln.hxx>
+#include <TColgp_SequenceOfPnt.hxx>
+
+#include "../ifcparse/IfcParse.h"
+#include "../ifcparse/IfcUtil.h"
+
+#include "../ifcgeom/IfcGeomElement.h" 
+#include "../ifcgeom/IfcGeomRepresentation.h" 
+#include "../ifcgeom/IfcRepresentationShapeItem.h"
+
+#define IN_CACHE(T,E,t,e) std::map<int,t>::const_iterator it = cache.T.find(E->entity->id());\
+if ( it != cache.T.end() ) { e = it->second; return true; }
+#define CACHE(T,E,e) cache.T[E->entity->id()] = e;
+
+namespace IfcGeom {
+
+class Cache {
+public:
+#include "IfcRegisterCreateCache.h"
+	std::map<int, SurfaceStyle> Style;
+	std::map<int, TopoDS_Shape> Shape;
+};
+
+class Kernel {
+private:
+	Cache cache;
+public:
+	// Tolerances and settings for various geometrical operations:
+	enum GeomValue {
+		// Specifies the deflection of the mesher
+		// Default: 0.001m / 1mm
+		GV_DEFLECTION_TOLERANCE, 
+		// Specifies the tolerance of the wire builder, most notably for trimmed curves
+		// Defailt: 0.0001m / 0.1mm
+		GV_WIRE_CREATION_TOLERANCE,
+		// Specifies the minimal area of a face to be included in an IfcConnectedFaceset
+		// Default: 0.000001m 0.01cm2
+		GV_MINIMAL_FACE_AREA,
+		// Specifies the treshold distance under which cartesian points are deemed equal
+		// Default: 0.00001m / 0.01mm
+		GV_POINT_EQUALITY_TOLERANCE,
+		// Specifies maximum number of faces for a shell to be sewed. Sewing shells
+		// that consist of many faces is really detrimental for the performance.
+		// Default: 1000
+		GV_MAX_FACES_TO_SEW,
+		// By default singular faces have no explicitly defined orientation, to
+		// force faces to be defined CounterClockWise, set this value greater than zero.
+		GV_FORCE_CCW_FACE_ORIENTATION,
+		// The length unit used the creation of TopoDS_Shapes, primarily affects the
+		// interpretation of IfcCartesianPoints and IfcVector magnitudes
+		// DefaultL 1.0
+		GV_LENGTH_UNIT,
+		// The plane angle unit used for the creation of TopoDS_Shapes, primarily affects
+		// the interpretation of IfcParamaterValues of IfcTrimmedCurves
+		// Default: -1.0 (= not set, fist try degrees, then radians)
+		GV_PLANEANGLE_UNIT,
+		// The precision used in boolean operations, setting this value too low results
+		// in artefacts and potentially modelling failures
+		// Default: 0.00001 (obtained from IfcGeometricRepresentationContext if available)
+		GV_PRECISION
+	};
+
+	bool convert_wire_to_face(const TopoDS_Wire& wire, TopoDS_Face& face);
+	bool convert_curve_to_wire(const Handle(Geom_Curve)& curve, TopoDS_Wire& wire);
+	bool convert_shapes(const IfcUtil::IfcBaseClass* L, IfcRepresentationShapeItems& result);
+	bool is_shape_collection(const IfcUtil::IfcBaseClass* L);
+	bool convert_shape(const IfcUtil::IfcBaseClass* L, TopoDS_Shape& result);
+	bool flatten_shape_list(const IfcGeom::IfcRepresentationShapeItems& shapes, TopoDS_Shape& result, bool fuse);
+	bool convert_wire(const IfcUtil::IfcBaseClass* L, TopoDS_Wire& result);
+	bool convert_curve(const IfcUtil::IfcBaseClass* L, Handle(Geom_Curve)& result);
+	bool convert_face(const IfcUtil::IfcBaseClass* L, TopoDS_Shape& result);
+	bool convert_openings(const IfcSchema::IfcProduct* entity, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
+	bool convert_openings_fast(const IfcSchema::IfcProduct* entity, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
+	IfcSchema::IfcSurfaceStyleShading* get_surface_style(IfcSchema::IfcRepresentationItem* item);
+	bool create_solid_from_compound(const TopoDS_Shape& compound, TopoDS_Shape& solid);
+	bool is_compound(const TopoDS_Shape& shape);
+	bool is_convex(const TopoDS_Wire& wire);
+	TopoDS_Shape halfspace_from_plane(const gp_Pln& pln,const gp_Pnt& cent);
+	gp_Pln plane_from_face(const TopoDS_Face& face);
+	gp_Pnt point_above_plane(const gp_Pln& pln, bool agree=true);
+	const TopoDS_Shape& ensure_fit_for_subtraction(const TopoDS_Shape& shape, TopoDS_Shape& solid);
+	bool profile_helper(int numVerts, double* verts, int numFillets, int* filletIndices, double* filletRadii, gp_Trsf2d trsf, TopoDS_Shape& face); 
+	double shape_volume(const TopoDS_Shape& s);
+	double face_area(const TopoDS_Face& f);
+	void apply_tolerance(TopoDS_Shape& s, double t);
+	void setValue(GeomValue var, double value);
+	double getValue(GeomValue var);
+	bool fill_nonmanifold_wires_with_planar_faces(TopoDS_Shape& shape);
+	void remove_redundant_points_from_loop(TColgp_SequenceOfPnt& polygon, bool closed, double tol=-1.);
+
+	std::pair<std::string, double> initializeUnits(IfcSchema::IfcUnitAssignment*);
+
+	IfcSchema::IfcObjectDefinition* get_decomposing_entity(IfcSchema::IfcProduct*);
+
+	template <typename P>
+	IfcGeom::BRepElement<P>* create_brep_for_representation_and_product(const IteratorSettings&, IfcSchema::IfcRepresentation*, IfcSchema::IfcProduct*);
+
+	const SurfaceStyle* get_style(const IfcSchema::IfcRepresentationItem* representation_item);
+	
+	template <typename T> std::pair<IfcSchema::IfcSurfaceStyle*, T*> get_surface_style(const IfcSchema::IfcRepresentationItem* representation_item) {
+		IfcSchema::IfcStyledItem::list::ptr styled_items = representation_item->StyledByItem();
+		for (IfcSchema::IfcStyledItem::list::it jt = styled_items->begin(); jt != styled_items->end(); ++jt) {
+#ifdef USE_IFC4
+			IfcUtil::IfcAbstractSelect::list::ptr style_assignments = (*jt)->Styles();
+			for (IfcUtil::IfcAbstractSelect::list::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
+				if (!(*kt)->is(IfcSchema::Type::IfcPresentationStyleAssignment)) {
+					continue;
+				}
+				IfcSchema::IfcPresentationStyleAssignment* style_assignment = (IfcSchema::IfcPresentationStyleAssignment*) *kt;
+#else
+			IfcSchema::IfcPresentationStyleAssignment::list::ptr style_assignments = (*jt)->Styles();
+			for (IfcSchema::IfcPresentationStyleAssignment::list::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
+				IfcSchema::IfcPresentationStyleAssignment* style_assignment = *kt;
+#endif
+				IfcEntityList::ptr styles = style_assignment->Styles();
+				for (IfcEntityList::it lt = styles->begin(); lt != styles->end(); ++lt) {
+					IfcUtil::IfcBaseClass* style = *lt;
+					if (style->is(IfcSchema::Type::IfcSurfaceStyle)) {
+						IfcSchema::IfcSurfaceStyle* surface_style = (IfcSchema::IfcSurfaceStyle*) style;
+						if (surface_style->Side() != IfcSchema::IfcSurfaceSide::IfcSurfaceSide_NEGATIVE) {
+							IfcEntityList::ptr styles_elements = surface_style->Styles();
+							for (IfcEntityList::it mt = styles_elements->begin(); mt != styles_elements->end(); ++mt) {
+								if ((*mt)->is(T::Class())) {
+									return std::make_pair(surface_style, (T*) *mt);
+								}
+							}
+						}
+					}
+				}
+			}
+
+			// StyledByItem is a SET [0:1] OF IfcStyledItem, so we
+			// break after encountering the first IfcStyledItem
+			break;
+		}
+
+		return std::make_pair<IfcSchema::IfcSurfaceStyle*, T*>(0,0);
+	}
+
+#include "IfcRegisterGeomHeader.h"
+
+};
+
+IfcSchema::IfcProductDefinitionShape* tesselate(TopoDS_Shape& shape, double deflection, IfcEntityList::ptr es);
+
+}
+#endif
@@ -77,23 +77,17 @@

 #include <TopLoc_Location.hxx>

-#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
-
-#ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
-#include <Geom_BSplineCurve.hxx>
-#endif
-
-#define Kernel MAKE_TYPE_NAME(Kernel)
+#include "../ifcgeom/IfcGeom.h"

 bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircle* l, Handle(Geom_Curve)& curve) {
 	const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
 	if ( r < ALMOST_ZERO ) { 
-		Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l);
+		Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l->entity);
 		return false;
 	}
 	gp_Trsf trsf;
 	IfcSchema::IfcAxis2Placement* placement = l->Position();
-	if (placement->declaration().is(IfcSchema::IfcAxis2Placement3D::Class())) {
+	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
 		IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf2d;
@@ -108,7 +102,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipse* l, Handle(Geom_Curve)
 	double x = l->SemiAxis1() * getValue(GV_LENGTH_UNIT);
 	double y = l->SemiAxis2() * getValue(GV_LENGTH_UNIT);
 	if (x < ALMOST_ZERO || y < ALMOST_ZERO) { 
-		Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l);
+		Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l->entity);
 		return false;
 	}
 	// Open Cascade does not allow ellipses of which the minor radius
@@ -118,7 +112,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipse* l, Handle(Geom_Curve)
 	const bool rotated = y > x;
 	gp_Trsf trsf;
 	IfcSchema::IfcAxis2Placement* placement = l->Position();
-	if (placement->declaration().is(IfcSchema::IfcAxis2Placement3D::Class())) {
+	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
 		convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf2d;
@@ -141,58 +135,4 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcLine* l, Handle(Geom_Curve)& c
 	// See note at IfcGeomWires.cpp:237
 	curve = new Geom_Line(pnt,vec);
 	return true;
-}
-
-#ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcBSplineCurveWithKnots* l, Handle(Geom_Curve)& curve) {
-
-	const bool is_rational = l->declaration().is(IfcSchema::IfcRationalBSplineCurveWithKnots::Class());
-
-	const IfcSchema::IfcCartesianPoint::list::ptr cps = l->ControlPointsList();
-	const std::vector<int> mults = l->KnotMultiplicities();
-	const std::vector<double> knots = l->Knots();
-
-	TColgp_Array1OfPnt      Poles(0,  cps->size() - 1);
-	TColStd_Array1OfReal    Weights(0, cps->size() - 1);
-	TColStd_Array1OfReal    Knots(0, (int)knots.size() - 1);
-	TColStd_Array1OfInteger Mults(0, (int)mults.size() - 1);
-	Standard_Integer        Degree = l->Degree();
-	Standard_Boolean        Periodic = l->ClosedCurve();
-	
-	int i;
-
-	if (is_rational) {
-		IfcSchema::IfcRationalBSplineCurveWithKnots* rl = (IfcSchema::IfcRationalBSplineCurveWithKnots*)l;
-		std::vector<double> weights = rl->WeightsData();
-
-		i = 0;
-		for (std::vector<double>::const_iterator it = weights.begin(); it != weights.end(); ++it, ++i) {
-			Weights(i) = *it;
-		}
-	}
-
-	i = 0;
-	for (IfcSchema::IfcCartesianPoint::list::it it = cps->begin(); it != cps->end(); ++it, ++i) {
-		gp_Pnt pnt;
-		if (!convert(*it, pnt)) return false;
-		Poles(i) = pnt;
-	}
-	
-	i = 0;
-	for (std::vector<int>::const_iterator it = mults.begin(); it != mults.end(); ++it, ++i) {
-		Mults(i) = *it;
-	}
-
-	i = 0;
-	for (std::vector<double>::const_iterator it = knots.begin(); it != knots.end(); ++it, ++i) {
-		Knots(i) = *it;
-	}
-	
-	if (is_rational) {
-		curve = new Geom_BSplineCurve(Poles, Weights, Knots, Mults, Degree, Periodic);
-	} else {
-		curve = new Geom_BSplineCurve(Poles, Knots, Mults, Degree, Periodic);
-	}
-	return true;
-}
-#endif
+}
@@ -0,0 +1,144 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCGEOMELEMENT_H
+#define IFCGEOMELEMENT_H
+
+#include "../ifcgeom/IfcGeomRepresentation.h"
+#include "../ifcgeom/IfcGeomIteratorSettings.h"
+
+
+namespace IfcGeom {
+
+	template <typename P>
+	class Matrix {
+	private:
+		std::vector<P> _data;
+	public:
+		Matrix(const ElementSettings& settings, const gp_Trsf& trsf) {
+			// Convert the gp_Trsf into a 4x3 Matrix
+			// Note that in case the CONVERT_BACK_UNITS setting is enabled
+			// the translation component of the matrix needs to be divided
+			// by the magnitude of the IFC model length unit because
+			// internally in IfcOpenShell everything is measured in meters.
+			for(int i = 1; i < 5; ++i) {
+				for (int j = 1; j < 4; ++j) {
+					const double trsf_value = trsf.Value(j,i);
+					const double matrix_value = i == 4 && settings.convert_back_units()
+						? trsf_value / settings.unit_magnitude()
+						: trsf_value;
+					_data.push_back(static_cast<P>(matrix_value));
+				}
+			}
+		}
+		const std::vector<P>& data() const { return _data; }
+	};
+
+	template <typename P>
+	class Transformation {
+	private:
+		gp_Trsf trsf;
+		Matrix<P> _matrix;
+	public:
+		Transformation(const ElementSettings& settings, const gp_Trsf& trsf)
+			: trsf(trsf)
+			, _matrix(settings, trsf) 
+		{}
+		const gp_Trsf& data() const { return trsf; }
+		const Matrix<P>& matrix() const { return _matrix; }
+	};
+
+	template <typename P>
+	class Element {
+	private:
+		int _id;
+		int _parent_id;
+		std::string _name;
+		std::string _type;
+		std::string _guid;
+		Transformation<P> _transformation;
+	public:
+		int id() const { return _id; }
+		int parent_id() const { return _parent_id; }
+		const std::string& name() const { return _name; }
+		const std::string& type() const { return _type; }
+		const std::string& guid() const { return _guid; }
+		const Transformation<P>& transformation() const { return _transformation; }
+		Element(const ElementSettings& settings, int id, int parent_id, const std::string& name, const std::string& type, const std::string& guid, const gp_Trsf& trsf)
+			: _id(id), _parent_id(parent_id), _name(name), _type(type), _guid(guid), _transformation(settings, trsf)
+		{}
+		virtual ~Element() {}
+	};
+
+	template <typename P>
+	class BRepElement : public Element<P> {
+	private:
+		Representation::BRep* _geometry;
+	public:
+		const Representation::BRep& geometry() const { return *_geometry; }
+		BRepElement(int id, int parent_id, const std::string& name, const std::string& type, const std::string& guid, const gp_Trsf& trsf, Representation::BRep* geometry)
+			: Element<P>(geometry->settings(),id,parent_id,name,type,guid,trsf)
+			, _geometry(geometry)
+		{}
+		virtual ~BRepElement() {
+			delete _geometry;
+		}
+	private:
+		BRepElement(const BRepElement& other);
+		BRepElement& operator=(const BRepElement& other);		
+	};
+
+	template <typename P>
+	class TriangulationElement : public Element<P> {
+	private:
+		Representation::Triangulation<P>* _geometry;
+	public:
+		const Representation::Triangulation<P>& geometry() const { return *_geometry; }
+		TriangulationElement(const BRepElement<P>& shape_model)
+			: Element<P>(shape_model)
+			, _geometry(new Representation::Triangulation<P>(shape_model.geometry()))
+		{}
+		virtual ~TriangulationElement() {
+			delete _geometry;
+		}
+	private:
+		TriangulationElement(const TriangulationElement& other);
+		TriangulationElement& operator=(const TriangulationElement& other);
+	};
+
+	template <typename P>
+	class SerializedElement : public Element<P> {
+	private:
+		Representation::Serialization* _geometry;
+	public:
+		const Representation::Serialization& geometry() const { return *_geometry; }
+		SerializedElement(const BRepElement<P>& shape_model)
+			: Element<P>(shape_model)
+			, _geometry(new Representation::Serialization(shape_model.geometry()))
+		{}
+		virtual ~SerializedElement() {
+			delete _geometry;
+		}
+	private:
+		SerializedElement(const SerializedElement& other);
+		SerializedElement& operator=(const SerializedElement& other);
+	};
+}
+
+#endif
@@ -75,59 +75,7 @@

 #include <TopLoc_Location.hxx>

-#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
-
-#define Kernel MAKE_TYPE_NAME(Kernel)
-
-namespace {
-
-	// Helper functions (re)set gp_(G)Trsf(2d) forms explicitly to 'Identity'
-	// so that it can be easily identified in the IfcMappedItem processing
-
-	// For axis placements detect equality early in order for the
-	// relatively computionaly expensive gp_Trsf calculation to be skipped
-	template <typename T>
-	bool axis_equal(const T& a, const T& b, double tolerance);
-	template <>
-	bool axis_equal(const gp_Ax3& a, const gp_Ax3& b, double tolerance) {
-		if (!a.Location().IsEqual(b.Location(), tolerance)) return false;
-		// Note that the tolerance below is angular, above is linear. Since architectural
-		// objects are about 1m'ish in scale, it should be somewhat equivalent. Besides,
-		// this is mostly a filter for NULL or default values in the placements.
-		if (!a.Direction().IsEqual(b.Direction(), tolerance)) return false;
-		if (!a.XDirection().IsEqual(b.XDirection(), tolerance)) return false;
-		if (!a.YDirection().IsEqual(b.YDirection(), tolerance)) return false;
-		return true;
-	}
-
-	bool axis_equal(const gp_Ax2d& a, const gp_Ax2d& b, double tolerance) {
-		if (!a.Location().IsEqual(b.Location(), tolerance)) return false;
-		if (!a.Direction().IsEqual(b.Direction(), tolerance)) return false;
-		return true;
-	}
-
-	template <typename T> struct dimension_count {};
-	template <>           struct dimension_count <gp_Trsf2d > { static const int n = 2; };
-	template <>           struct dimension_count <gp_GTrsf2d> { static const int n = 2; };
-	template <>           struct dimension_count < gp_Trsf  > { static const int n = 3; };
-	template <>           struct dimension_count < gp_GTrsf > { static const int n = 3; };
-
-	template <typename T>
-	bool is_identity(const T& t, double tolerance) {
-		// Note the {1, n+1} range due to Open Cascade's 1-based indexing
-		// Note the {1, n+2} range due to the translation part of the matrix
-		for (int i = 1; i < dimension_count<T>::n + 2; ++i) {
-			for (int j = 1; j < dimension_count<T>::n + 1; ++j) {
-				const double iden_value = i == j ? 1. : 0.;
-				const double trsf_value = t.Value(j, i);
-				if (fabs(trsf_value - iden_value) > tolerance) {
-					return false;
-				}
-			}
-		}
-		return true;
-	}
-}
+#include "../ifcgeom/IfcGeom.h"

 bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianPoint* l, gp_Pnt& point) {
 	IN_CACHE(IfcCartesianPoint,l,gp_Pnt,point)
@@ -163,43 +111,16 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcVector* l, gp_Vec& v) {
 }

 bool IfcGeom::Kernel::convert(const IfcSchema::IfcAxis2Placement3D* l, gp_Trsf& trsf) {
-	IN_CACHE(IfcAxis2Placement3D, l, gp_Trsf, trsf)
-
-	gp_Pnt o;
-	gp_Dir axis(0, 0, 1);
-	gp_Dir refDirection;
-
-	IfcGeom::Kernel::convert(l->Location(), o);
-	const bool hasAxis = l->hasAxis();
-	const bool hasRef = l->hasRefDirection();
-
-	if (hasAxis != hasRef) {
-		Logger::Warning("Axis and RefDirection should be specified together", l);
-	}
-
-	if (hasAxis) {
-		IfcGeom::Kernel::convert(l->Axis(), axis);
-	}
-
-	if (hasRef) {
-		IfcGeom::Kernel::convert(l->RefDirection(), refDirection);
-	} else {
-		if (!axis.IsParallel(gp::DX(), 1.e-5)) {
-			refDirection = gp::DX();
-		} else {
-			refDirection = gp::DZ();
-		}
-		gp_Vec Xvec = axis.Dot(refDirection) * axis;
-		gp_Vec Xaxis = refDirection.XYZ() - Xvec.XYZ();
-		refDirection = Xaxis;
-	}
-
-	gp_Ax3 ax3(o, axis, refDirection);
-
-	if (!axis_equal(ax3, (gp_Ax3) gp::XOY(), getValue(GV_PRECISION))) {
-		trsf.SetTransformation(ax3, gp::XOY());
-	}
-	
+	IN_CACHE(IfcAxis2Placement3D,l,gp_Trsf,trsf)
+	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
+	IfcGeom::Kernel::convert(l->Location(),o);
+	bool hasRef = l->RefDirection() ? true : false;
+	if ( l->Axis() ) IfcGeom::Kernel::convert(*l->Axis(),axis);
+	if ( hasRef ) IfcGeom::Kernel::convert(*l->RefDirection(),refDirection);
+	gp_Ax3 ax3;
+	if ( hasRef ) ax3 = gp_Ax3(o,axis,refDirection);
+	else ax3 = gp_Ax3(o,axis);
+	trsf.SetTransformation(ax3, gp_Ax3(gp_Pnt(),gp_Dir(0,0,1),gp_Dir(1,0,0)));
 	CACHE(IfcAxis2Placement3D,l,trsf)
 	return true;
 }
@@ -208,7 +129,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcAxis1Placement* l, gp_Ax1& ax)
 	IN_CACHE(IfcAxis1Placement,l,gp_Ax1,ax)
 	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);
 	IfcGeom::Kernel::convert(l->Location(),o);
-	if ( l->hasAxis() ) IfcGeom::Kernel::convert(l->Axis(), axis);
+	if ( l->Axis() ) IfcGeom::Kernel::convert(*l->Axis(), axis);
 	ax = gp_Ax1(o, axis);
 	CACHE(IfcAxis1Placement,l,ax)
 	return true;
@@ -221,21 +142,14 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianTransformationOperato
 	gp_Dir axis1 (1.,0.,0.);
 	gp_Dir axis2 (0.,1.,0.);
 	gp_Dir axis3 (0.,0.,1.);
-	if ( l->hasAxis1() ) IfcGeom::Kernel::convert(l->Axis1(),axis1);
-	if ( l->hasAxis2() ) IfcGeom::Kernel::convert(l->Axis2(),axis2);
-	if ( l->hasAxis3() ) IfcGeom::Kernel::convert(l->Axis3(),axis3);
+	if ( l->Axis1() ) IfcGeom::Kernel::convert(*l->Axis1(),axis1);
+	if ( l->Axis2() ) IfcGeom::Kernel::convert(*l->Axis2(),axis2);
+	if ( l->Axis3() ) IfcGeom::Kernel::convert(*l->Axis3(),axis3);
 	gp_Ax3 ax3 (origin,axis3,axis1);
 	if ( axis2.Dot(ax3.YDirection()) < 0 ) ax3.YReverse();
-	
-	if (!axis_equal(ax3, (gp_Ax3) gp::XOY(), getValue(GV_PRECISION))) {
-		trsf.SetTransformation(ax3);
-		trsf.Invert();
-	}
-	
-	if (l->hasScale() && !ALMOST_THE_SAME(l->Scale(), 1.)) {
-		trsf.SetScaleFactor(l->Scale());
-	}
-
+	trsf.SetTransformation(ax3);
+	trsf.Invert();
+	if ( l->Scale() ) trsf.SetScaleFactor(*l->Scale());
 	CACHE(IfcCartesianTransformationOperator3D,l,trsf)
 	return true;
 }
@@ -248,8 +162,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianTransformationOperato
 	gp_Dir axis2 (0.,1.,0.);
 	
 	IfcGeom::Kernel::convert(l->LocalOrigin(),origin);
-	if ( l->hasAxis1() ) IfcGeom::Kernel::convert(l->Axis1(),axis1);
-	if ( l->hasAxis2() ) IfcGeom::Kernel::convert(l->Axis2(),axis2);
+	if ( l->Axis1() ) IfcGeom::Kernel::convert(*l->Axis1(),axis1);
+	if ( l->Axis2() ) IfcGeom::Kernel::convert(*l->Axis2(),axis2);
 	
 	const gp_Pnt2d origin2d(origin.X(), origin.Y());
 	const gp_Dir2d axis12d(axis1.X(), axis1.Y());
@@ -269,12 +183,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianTransformationOperato
 	}

 	trsf.Invert();
-	if ( l->hasScale() && !ALMOST_THE_SAME(l->Scale(), 1.) ) trsf.SetScaleFactor(l->Scale());
-
-	if (is_identity(trsf, getValue(GV_PRECISION))) {
-		trsf = gp_Trsf2d();
-	}
-
+	if ( l->Scale() ) trsf.SetScaleFactor(*l->Scale());
 	CACHE(IfcCartesianTransformationOperator2D,l,trsf)
 	return true;
 }
@@ -287,26 +196,21 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianTransformationOperato
 	gp_Dir axis1 (1.,0.,0.);
 	gp_Dir axis2 (0.,1.,0.);
 	gp_Dir axis3 (0.,0.,1.);
-	if ( l->hasAxis1() ) IfcGeom::Kernel::convert(l->Axis1(),axis1);
-	if ( l->hasAxis2() ) IfcGeom::Kernel::convert(l->Axis2(),axis2);
-	if ( l->hasAxis3() ) IfcGeom::Kernel::convert(l->Axis3(),axis3);
+	if ( l->Axis1() ) IfcGeom::Kernel::convert(*l->Axis1(),axis1);
+	if ( l->Axis2() ) IfcGeom::Kernel::convert(*l->Axis2(),axis2);
+	if ( l->Axis3() ) IfcGeom::Kernel::convert(*l->Axis3(),axis3);
 	gp_Ax3 ax3 (origin,axis3,axis1);
 	if ( axis2.Dot(ax3.YDirection()) < 0 ) ax3.YReverse();
 	trsf.SetTransformation(ax3);
 	trsf.Invert();
-	const double scale1 = l->hasScale() ? l->Scale() : 1.0f;
-	const double scale2 = l->hasScale2() ? l->Scale2() : scale1;
-	const double scale3 = l->hasScale3() ? l->Scale3() : scale1;
+	const double scale1 = l->Scale() ? *l->Scale() : 1.0f;
+	const double scale2 = l->Scale2() ? *l->Scale2() : scale1;
+	const double scale3 = l->Scale3() ? *l->Scale3() : scale1;
 	gtrsf = gp_GTrsf();
 	gtrsf.SetValue(1,1,scale1);
 	gtrsf.SetValue(2,2,scale2);
 	gtrsf.SetValue(3,3,scale3);
 	gtrsf.PreMultiply(trsf);
-
-	if (is_identity(gtrsf, getValue(GV_PRECISION))) {
-		gtrsf = gp_GTrsf();
-	}
-
 	CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gtrsf)
 	return true;
 }
@@ -320,8 +224,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianTransformationOperato
 	gp_Dir axis2 (0.,1.,0.);
 	
 	IfcGeom::Kernel::convert(l->LocalOrigin(),origin);
-	if ( l->hasAxis1() ) IfcGeom::Kernel::convert(l->Axis1(),axis1);
-	if ( l->hasAxis2() ) IfcGeom::Kernel::convert(l->Axis2(),axis2);
+	if ( l->Axis1() ) IfcGeom::Kernel::convert(*l->Axis1(),axis1);
+	if ( l->Axis2() ) IfcGeom::Kernel::convert(*l->Axis2(),axis2);

 	const gp_Pnt2d origin2d(origin.X(), origin.Y());
 	const gp_Dir2d axis12d(axis1.X(), axis1.Y());
@@ -337,17 +241,12 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianTransformationOperato

 	trsf.Invert();
 	
-	const double scale1 = l->hasScale() ? l->Scale() : 1.0f;
-	const double scale2 = l->hasScale2() ? l->Scale2() : scale1;
+	const double scale1 = l->Scale() ? *l->Scale() : 1.0f;
+	const double scale2 = l->Scale2() ? *l->Scale2() : scale1;
 	gtrsf = gp_GTrsf2d();
 	gtrsf.SetValue(1,1,scale1);
 	gtrsf.SetValue(2,2,scale2);
 	gtrsf.Multiply(trsf);
-
-	if (is_identity(gtrsf, getValue(GV_PRECISION))) {
-		gtrsf = gp_GTrsf2d();
-	}
-
 	CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gtrsf)
 	return true;
 }
@@ -357,9 +256,9 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPlane* pln, gp_Pln& plane) {
 	IfcSchema::IfcAxis2Placement3D* l = pln->Position();
 	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
 	IfcGeom::Kernel::convert(l->Location(),o);
-	bool hasRef = l->hasRefDirection();
-	if ( l->hasAxis() ) IfcGeom::Kernel::convert(l->Axis(),axis);
-	if ( hasRef ) IfcGeom::Kernel::convert(l->RefDirection(),refDirection);
+	bool hasRef = l->RefDirection();
+	if ( l->Axis() ) IfcGeom::Kernel::convert(*l->Axis(),axis);
+	if ( hasRef ) IfcGeom::Kernel::convert(*l->RefDirection(),refDirection);
 	gp_Ax3 ax3;
 	if ( hasRef ) ax3 = gp_Ax3(o,axis,refDirection);
 	else ax3 = gp_Ax3(o,axis);
@@ -372,48 +271,36 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcAxis2Placement2D* l, gp_Trsf2d
 	IN_CACHE(IfcAxis2Placement2D,l,gp_Trsf2d,trsf)
 	gp_Pnt P; gp_Dir V (1,0,0);
 	IfcGeom::Kernel::convert(l->Location(),P);
-	if ( l->hasRefDirection() )
-		IfcGeom::Kernel::convert(l->RefDirection(),V);
-
-	gp_Ax2d axis(gp_Pnt2d(P.X(),P.Y()), gp_Dir2d(V.X(),V.Y()));
-	
-	if (!axis_equal(axis, gp_Ax2d(), getValue(GV_PRECISION))) {
-		trsf.SetTransformation(axis, gp_Ax2d());
-	}
+	if ( l->RefDirection() )
+		IfcGeom::Kernel::convert(*l->RefDirection(),V);

+	gp_Ax2d axis(gp_Pnt2d(P.X(),P.Y()),gp_Dir2d(V.X(),V.Y()));
+	trsf.SetTransformation(axis,gp_Ax2d());
 	CACHE(IfcAxis2Placement2D,l,trsf)
 	return true;
 }

 bool IfcGeom::Kernel::convert(const IfcSchema::IfcObjectPlacement* l, gp_Trsf& trsf) {
 	IN_CACHE(IfcObjectPlacement,l,gp_Trsf,trsf)
-	if ( ! l->declaration().is(IfcSchema::IfcLocalPlacement::Class()) ) {
-		Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l);
+	if ( ! l->is(IfcSchema::Type::IfcLocalPlacement) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l->entity);
 		return false; 		
 	}
 	IfcSchema::IfcLocalPlacement* current = (IfcSchema::IfcLocalPlacement*)l;
-	for (;;) {
+	while (1) {
 		gp_Trsf trsf2;
 		IfcSchema::IfcAxis2Placement* relplacement = current->RelativePlacement();
-		if ( relplacement->declaration().is(IfcSchema::IfcAxis2Placement3D::Class()) ) {
+		if ( relplacement->is(IfcSchema::Type::IfcAxis2Placement3D) ) {
 			IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)relplacement,trsf2);
 			trsf.PreMultiply(trsf2);
 		}
-		if ( current->hasPlacementRelTo() ) {
-			IfcSchema::IfcObjectPlacement* parent = current->PlacementRelTo();
-			IfcSchema::IfcProduct::list::ptr parentPlaces = parent->PlacesObject();
-			bool parentPlacesType = false;
-			for ( IfcSchema::IfcProduct::list::it iter = parentPlaces->begin();
-				  iter != parentPlaces->end(); ++iter) {
-				if ( (*iter)->declaration().is(*placement_rel_to) ) parentPlacesType = true;
-			}
-
-			if ( parentPlacesType ) break;
-			else if ( parent->declaration().is(IfcSchema::IfcLocalPlacement::Class()) )
-				current = (IfcSchema::IfcLocalPlacement*)current->PlacementRelTo();
-			else break;
+		if ( current->PlacementRelTo() ) {
+			IfcSchema::IfcObjectPlacement* relto = *current->PlacementRelTo();
+			if ( relto->is(IfcSchema::Type::IfcLocalPlacement) )
+				current = (IfcSchema::IfcLocalPlacement*) relto;
+			else break;			
 		} else break;
 	}
 	CACHE(IfcObjectPlacement,l,trsf)
 	return true;
-}
+}
@@ -0,0 +1,493 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * Geometrical data in an IFC file consists of shapes (IfcShapeRepresentation)  *
+ * and instances (SUBTYPE OF IfcBuildingElement e.g. IfcWindow).                *
+ *                                                                              *
+ * IfcGeom::Representation::Triangulation is a class that represents a          *
+ * triangulated IfcShapeRepresentation.                                         *
+ *   Triangulation.verts is a 1 dimensional vector of float defining the        *
+ *      cartesian coordinates of the vertices of the triangulated shape in the  *
+ *      format of [x1,y1,z1,..,xn,yn,zn]                                        *
+ *   Triangulation.faces is a 1 dimensional vector of int containing the        *
+ *     indices of the triangles referencing positions in Triangulation.verts    *
+ *   Triangulation.edges is a 1 dimensional vector of int in {0,1} that dictates*
+ *	   the visibility of the edges that span the faces in Triangulation.faces   *
+ *                                                                              *
+ * IfcGeom::Element represents the actual IfcBuildingElements.                  *
+ *   IfcGeomObject.name is the GUID of the element                              *
+ *   IfcGeomObject.type is the datatype of the element e.g. IfcWindow           *
+ *   IfcGeomObject.mesh is a pointer to an IfcMesh                              *
+ *   IfcGeomObject.transformation.matrix is a 4x3 matrix that defines the       *
+ *     orientation and translation of the mesh in relation to the world origin  *
+ *                                                                              *
+ * IfcGeom::Iterator::findContext()                                             *
+ *   finds the most suitable representation contexts. Returns true iff          *
+ *   at least a single representation will process successfully                 *
+ *                                                                              *
+ * IfcGeom::Iterator::get()                                                     *
+ *   returns a pointer to the current IfcGeom::Element                          *
+ *                                                                              * 
+ * IfcGeom::Iterator::next()                                                    *
+ *   returns true iff a following entity is available for a successive call to  *
+ *   IfcGeom::Iterator::get()                                                   *
+ *                                                                              *
+ * IfcGeom::Iterator::progress()                                                *
+ *   returns an int in [0..100] that indicates the overall progress             *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCGEOMITERATOR_H
+#define IFCGEOMITERATOR_H
+
+#include <map>
+#include <set>
+#include <vector>
+#include <limits>
+#include <algorithm>
+
+#include <gp_Mat.hxx>
+#include <gp_Mat2d.hxx>
+#include <gp_GTrsf.hxx>
+#include <gp_GTrsf2d.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+
+#include "../ifcparse/IfcFile.h"
+
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom/IfcGeomElement.h"
+#include "../ifcgeom/IfcGeomMaterial.h"
+#include "../ifcgeom/IfcGeomIteratorSettings.h"
+#include "../ifcgeom/IfcRepresentationShapeItem.h"
+
+namespace IfcGeom {
+	
+	template <typename P>
+	class Iterator {
+	private:
+		Kernel kernel;
+		IteratorSettings settings;
+
+		IfcParse::IfcFile* ifc_file;
+
+		// A container and iterator for IfcRepresentations
+		IfcSchema::IfcRepresentation::list::ptr representations;
+		IfcSchema::IfcRepresentation::list::it representation_iterator;
+
+		// The object is fetched beforehand to be sure that get() returns a valid element
+		TriangulationElement<P>* current_triangulation;
+		BRepElement<P>* current_shape_model;
+		SerializedElement<P>* current_serialization;
+		
+		// A container and iterator for IfcBuildingElements for the current IfcRepresentation referenced by *representation_iterator
+		IfcSchema::IfcProduct::list::ptr ifcproducts;
+		IfcSchema::IfcProduct::list::it ifcproduct_iterator;
+
+		int done;
+		int total;
+
+		std::string unit_name;
+		// double?
+		P unit_magnitude;
+
+		void initUnits() {
+			IfcSchema::IfcProject::list::ptr projects = ifc_file->entitiesByType<IfcSchema::IfcProject>();
+			if (projects->size() == 1) {
+				IfcSchema::IfcProject* project = *projects->begin();
+				std::pair<std::string, double> length_unit = kernel.initializeUnits(project->UnitsInContext());
+				unit_name = length_unit.first;
+				unit_magnitude = static_cast<P>(length_unit.second);
+			}
+		}
+
+		std::set<IfcSchema::Type::Enum> entities_to_include_or_exclude;
+		bool include_entities_in_processing;
+
+		void populate_set(const std::set<std::string>& include_or_ignore) {
+			entities_to_include_or_exclude.clear();
+			for (std::set<std::string>::const_iterator it = include_or_ignore.begin(); it != include_or_ignore.end(); ++it) {
+				std::string uppercase_type = *it;
+				for (std::string::iterator c = uppercase_type.begin(); c != uppercase_type.end(); ++c) {
+					*c = toupper(*c);
+				}
+				IfcSchema::Type::Enum ty;
+				try {
+					ty = IfcSchema::Type::FromString(uppercase_type);
+				} catch (const IfcParse::IfcException&) {
+					std::stringstream ss;
+					ss << "'" << *it << "' does not name a valid IFC entity";
+					throw IfcParse::IfcException(ss.str());
+				}
+				entities_to_include_or_exclude.insert(ty);
+				// TODO: Add child classes so that containment in set can be in O(log n)
+			}
+		}
+
+	public:
+		bool findContext() {
+			try {
+				initUnits();
+			} catch (...) {}
+
+			// Really this should only be 'Model', as per 
+			// the standard 'Design' is deprecated. So,
+			// just for backwards compatibility:
+			std::set<std::string> context_types;
+			context_types.insert("model");
+			context_types.insert("design");
+			// DDS likes to output 'model view'
+			context_types.insert("model view");
+
+			double lowest_precision_encountered = std::numeric_limits<double>::infinity();
+			bool any_precision_encountered = false;
+
+			representations = IfcSchema::IfcRepresentation::list::ptr(new IfcSchema::IfcRepresentation::list);
+
+			IfcSchema::IfcGeometricRepresentationContext::list::it it;
+			IfcSchema::IfcGeometricRepresentationSubContext::list::it jt;
+			IfcSchema::IfcGeometricRepresentationContext::list::ptr contexts = 
+				ifc_file->entitiesByType<IfcSchema::IfcGeometricRepresentationContext>();
+
+			IfcSchema::IfcGeometricRepresentationContext::list::ptr filtered_contexts (new IfcSchema::IfcGeometricRepresentationContext::list);
+
+ 			for (it = contexts->begin(); it != contexts->end(); ++it) {
+				IfcSchema::IfcGeometricRepresentationContext* context = *it;
+				if (context->is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) {
+					// Continue, as the list of subcontexts will be considered
+					// by the parent's context inverse attributes.
+					continue;
+				}
+				if (context->ContextType()) {
+					std::string context_type_lc = *context->ContextType();
+					for (std::string::iterator c = context_type_lc.begin(); c != context_type_lc.end(); ++c) {
+						*c = tolower(*c);
+					}
+					if (context_types.find(context_type_lc) != context_types.end()) {
+						filtered_contexts->push(context);
+					}
+				}
+			}
+
+			if (filtered_contexts->size() == 0) {
+				filtered_contexts = contexts;
+			}
+
+			for (it = filtered_contexts->begin(); it != filtered_contexts->end(); ++it) {
+				IfcSchema::IfcGeometricRepresentationContext* context = *it;
+
+				representations->push(context->RepresentationsInContext());
+				if (context->Precision() && *context->Precision() < lowest_precision_encountered) {
+					lowest_precision_encountered = *context->Precision();
+					any_precision_encountered = true;
+				}
+				IfcSchema::IfcGeometricRepresentationSubContext::list::ptr sub_contexts = context->HasSubContexts();
+				for (jt = sub_contexts->begin(); jt != sub_contexts->end(); ++jt) {
+					representations->push((*jt)->RepresentationsInContext());
+				}
+				// There is no need for full recursion as the following is governed by the schema:
+				// WR31: The parent context shall not be another geometric representation sub context. 
+			}
+
+			if (any_precision_encountered) {
+				// Some arbitrary factor that has proven to work better for the models in the set of test files.
+				lowest_precision_encountered *= 10.;
+
+				lowest_precision_encountered *= unit_magnitude;
+				if (lowest_precision_encountered < 1.e-7) {
+					Logger::Message(Logger::LOG_WARNING, "Precision lower than 0.0000001 meter not enforced");
+					kernel.setValue(IfcGeom::Kernel::GV_PRECISION, 1.e-7);
+				} else {
+					kernel.setValue(IfcGeom::Kernel::GV_PRECISION, lowest_precision_encountered);
+				}
+			} else {
+				kernel.setValue(IfcGeom::Kernel::GV_PRECISION, 1.e-5);
+			}
+
+			if (representations->size() == 0) return false;
+
+			representation_iterator = representations->begin();
+			ifcproducts.reset();
+
+			if (!create()) {
+				return false;
+			}
+
+			done = 0;
+			total = representations->size();
+
+			return true;
+		}
+
+		int progress() {
+			return 100 * done / total;
+		}
+
+		const std::string& getUnitName() {
+			return unit_name;
+		}
+
+		const P getUnitMagnitude() {
+			return unit_magnitude;
+		}
+	
+		const std::string getLog() {
+			return Logger::GetLog();
+		}
+
+		IfcParse::IfcFile* getFile() {
+			return ifc_file;
+		}
+
+		void includeEntities(const std::set<std::string>& entities) {
+			populate_set(entities);
+			include_entities_in_processing = true;
+		}
+
+		void excludeEntities(const std::set<std::string>& entities) {
+			populate_set(entities);
+			include_entities_in_processing = false;
+		}
+
+	private:
+		// Move to the next IfcRepresentation
+		void _nextShape() {
+			ifcproducts.reset();
+			++ representation_iterator;
+			++ done;
+		}
+
+		BRepElement<P>* create_shape_model_for_next_entity() {
+			while ( true ) {
+				IfcSchema::IfcRepresentation* representation;
+
+				// Have we reached the end of our list of representations?
+				if ( representation_iterator == representations->end() ) {
+					representations.reset();
+					return 0;
+				}
+				representation = *representation_iterator;
+
+				// Has the list of IfcProducts for this representation been initialized?
+				if (!ifcproducts) {
+					
+					IfcSchema::IfcProductRepresentation::list::ptr prodreps = representation->OfProductRepresentation();
+					ifcproducts = IfcSchema::IfcProduct::list::ptr(new IfcSchema::IfcProduct::list);
+					IfcSchema::IfcProduct::list::ptr unfiltered_products(new IfcSchema::IfcProduct::list);
+
+					for ( IfcSchema::IfcProductRepresentation::list::it it = prodreps->begin(); it != prodreps->end(); ++it ) {
+						if ( (*it)->is(IfcSchema::Type::IfcProductDefinitionShape) ) {
+							IfcSchema::IfcProductDefinitionShape* pds = (IfcSchema::IfcProductDefinitionShape*)*it;
+							unfiltered_products->push(pds->ShapeOfProduct());
+						} else {
+							// http://buildingsmart-tech.org/ifc/IFC2x3/TC1/html/ifcrepresentationresource/lexical/ifcproductrepresentation.htm
+							// IFC2x Edition 3 NOTE  Users should not instantiate the entity IfcProductRepresentation from IFC2x Edition 3 onwards. 
+							// It will be changed into an ABSTRACT supertype in future releases of IFC.
+
+							// IfcProductRepresentation also lacks the INVERSE relation to IfcProduct
+							// Let's find the IfcProducts that reference the IfcProductRepresentation anyway
+							unfiltered_products->push((*it)->entity->getInverse(IfcSchema::Type::IfcProduct, -1)->as<IfcSchema::IfcProduct>());
+						}
+
+						// Filter the products based on the set of entities being included or excluded for
+						// processing. The set is iterated over te able to filter on subtypes.
+						for ( IfcSchema::IfcProduct::list::it it = unfiltered_products->begin(); it != unfiltered_products->end(); ++it ) {
+							bool found = false;
+							for (std::set<IfcSchema::Type::Enum>::const_iterator jt = entities_to_include_or_exclude.begin(); jt != entities_to_include_or_exclude.end(); ++jt) {
+								if ((*it)->is(*jt)) {
+									found = true;
+									break;
+								}
+							}
+							if (found == include_entities_in_processing) {
+								ifcproducts->push(*it);
+							}
+						}
+
+					}
+					// Does this representation have any IfcProducts?
+					if (!ifcproducts->size()) {
+						_nextShape();
+						continue;
+					}
+					ifcproduct_iterator = ifcproducts->begin();
+				}
+				// Have we reached the end of our list of IfcProducts?
+				if ( ifcproduct_iterator == ifcproducts->end() ) {
+					_nextShape();
+					continue;
+				}
+
+				IfcSchema::IfcProduct* product = *ifcproduct_iterator;
+
+				BRepElement<P>* element = kernel.create_brep_for_representation_and_product<P>(settings, representation, product);
+
+				if ( !element ) {
+					_nextShape();
+					continue;
+				}
+
+				return element;
+			}	
+		}
+
+		public:
+
+		bool next() {
+			// Free all possible representations of the current geometrical entity
+			delete current_triangulation;
+			current_triangulation = 0;
+			delete current_serialization;
+			current_serialization = 0;
+			delete current_shape_model;
+			current_shape_model = 0;
+			
+			// Increment the iterator over the list of products using the current
+			// shape representation
+			if (ifcproducts) {
+				++ifcproduct_iterator;
+			}
+
+			return create();
+		}
+
+		Element<P>* get() {
+			// TODO: Test settings and throw
+			if (current_triangulation) return current_triangulation;
+			else if (current_serialization) return current_serialization;
+			else if (current_shape_model) return current_shape_model;
+			else return 0;
+		}
+
+		const Element<P>* getObject(int id) {
+
+			gp_Trsf trsf;
+			int parent_id = -1;
+			std::string instance_type, product_name, product_guid;
+			
+			try {
+				const IfcUtil::IfcBaseClass* ifc_entity = ifc_file->entityById(id);
+				instance_type = IfcSchema::Type::ToString(ifc_entity->type());
+				if ( ifc_entity->is(IfcSchema::Type::IfcProduct) ) {
+					IfcSchema::IfcProduct* ifc_product = (IfcSchema::IfcProduct*)ifc_entity;
+					
+					product_guid = ifc_product->GlobalId();
+					product_name = ifc_product->hasName() ? ifc_product->Name() : "";
+					
+					parent_id = -1;
+					try {
+						IfcSchema::IfcObjectDefinition* parent_object = kernel.get_decomposing_entity(ifc_product);
+						if (parent_object) {
+							parent_id = parent_object->entity->id();
+						}
+					} catch (...) {}
+					
+					try {
+						kernel.convert(ifc_product->ObjectPlacement(), trsf);
+					} catch (...) {}
+				}
+			} catch(...) {}
+
+			ElementSettings element_settings(settings, unit_magnitude, instance_type);
+			Element<P>* ifc_object = new Element<P>(element_settings, id, parent_id, product_name, instance_type, product_guid, trsf);
+			
+			return ifc_object;
+		}
+
+		bool create() {
+			try {
+				current_shape_model = create_shape_model_for_next_entity();
+			} catch (...) {}
+			if (!current_shape_model) return false;
+			if (settings.use_brep_data()) {
+				try {
+					current_serialization = new SerializedElement<P>(*current_shape_model);
+				} catch (...) {}
+				return !!current_serialization;
+			} else if (!settings.disable_triangulation()) {
+				try {
+					current_triangulation = new TriangulationElement<P>(*current_shape_model);
+				} catch (...) {}
+				return !!current_triangulation;
+			} else {
+				return true;
+			}
+		}
+	private:
+		void initialize() {
+			current_triangulation = 0;
+			current_shape_model = 0;
+			current_serialization = 0;
+
+			// Upon initialisation, the (empty) set of entity names,
+			// should be excluded, or no products would be processed.
+			include_entities_in_processing = false;
+		
+			unit_name = "METER";
+			unit_magnitude = 1.f;
+
+			kernel.setValue(IfcGeom::Kernel::GV_MAX_FACES_TO_SEW, settings.sew_shells() ? 1000 : -1);
+			kernel.setValue(IfcGeom::Kernel::GV_FORCE_CCW_FACE_ORIENTATION, settings.force_ccw_face_orientation() ? 1 : -1);
+		}
+	public:
+		Iterator(const IteratorSettings& settings, IfcParse::IfcFile* file)
+			: settings(settings)
+			, ifc_file(file)
+		{
+			initialize();
+		}
+		Iterator(const IteratorSettings& settings, const std::string& filename)
+			: settings(settings)
+			, ifc_file(new IfcParse::IfcFile)
+		{
+			ifc_file->Init(filename);
+			initialize();
+		}
+		Iterator(const IteratorSettings& settings, void* data, int length)
+			: settings(settings)
+			, ifc_file(new IfcParse::IfcFile)
+		{
+			ifc_file->Init(data, length);
+			initialize();
+		}
+		Iterator(const IteratorSettings& settings, std::istream& filestream, int length)
+			: settings(settings)
+			, ifc_file(new IfcParse::IfcFile)
+		{
+			ifc_file->Init(filestream, length);
+			initialize();
+		}
+
+		~Iterator() {
+			// TODO: Correctly implement destructor for IfcFile
+			delete ifc_file;
+
+			delete current_triangulation;
+			current_triangulation = 0;
+			delete current_serialization;
+			current_serialization = 0;
+			delete current_shape_model;
+			current_shape_model = 0;
+		}
+	};
+}
+
+#endif
@@ -0,0 +1,172 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCGEOMITERATORSETTINGS_H
+#define IFCGEOMITERATORSETTINGS_H
+
+#include <string>
+
+#include "../ifcparse/IfcException.h"
+
+namespace IfcGeom {
+
+	class IteratorSettings {
+	public:
+		// Enumeration of setting identifiers. These settings define the
+		// behaviour of various aspects of IfcOpenShell.
+
+		// Specifies whether vertices are welded, meaning that the coordinates
+		// vector will only contain unique xyz-triplets. This results in a 
+		// manifold mesh which is useful for modelling applications, but might 
+		// result in unwanted shading artifacts in rendering applications.
+		static const int WELD_VERTICES = 1;
+		// Specifies whether to apply the local placements of building elements
+		// directly to the coordinates of the representation mesh rather than
+		// to represent the local placement in the 4x3 matrix, which will in that
+		// case be the identity matrix.
+		static const int USE_WORLD_COORDS = 2;
+		// Internally IfcOpenShell measures everything in meters. This settings
+		// specifies whether to convert IfcGeomObjects back to the units in which
+		// the geometry in the IFC file is specified.
+		static const int CONVERT_BACK_UNITS = 3;
+		// Specifies whether to use the Open Cascade BREP format for representation
+		// items rather than to create triangle meshes. This is useful is IfcOpenShell
+		// is used as a library in an application that is also built on Open Cascade.
+		static const int USE_BREP_DATA = 4;
+		// Specifies whether to sew IfcConnectedFaceSets (open and closed shells) to
+		// TopoDS_Shells or whether to keep them as a loose collection of faces.
+		static const int SEW_SHELLS = 5;
+		// Specifies whether to compose IfcOpeningElements into a single compound
+		// in order to speed up the processing of opening subtractions.
+		static const int FASTER_BOOLEANS = 6;
+		// By default singular faces have no explicitly defined orientation, to
+		// force faces to be defined CounterClockWise set this to true.
+		static const int FORCE_CCW_FACE_ORIENTATION = 7;
+		// Disables the subtraction of IfcOpeningElement representations from
+		// the related building element representations.
+		static const int DISABLE_OPENING_SUBTRACTIONS = 8;
+		// Disables the triangulation of the topological representations. Useful if
+		// the client application understands Open Cascade's native format.
+		static const int DISABLE_TRIANGULATION = 9;
+		// Applies default materials to entity instances without a surface style.
+		static const int APPLY_DEFAULT_MATERIALS = 10;
+
+		// End of settings enumeration.
+
+	private:
+		bool _weld_vertices, _use_world_coords, _convert_back_units, _use_brep_data, _sew_shells, _faster_booleans, _force_ccw_face_orientation, _disable_opening_subtractions, _disable_triangulation, _apply_default_materials;
+		double _deflection_tolerance;
+	public:
+		IteratorSettings()
+			: _weld_vertices(true)
+			, _use_world_coords(false)
+			, _convert_back_units(false)
+			, _use_brep_data(false)
+			, _sew_shells(false)
+			, _faster_booleans(false)
+			, _force_ccw_face_orientation(false)
+			, _disable_opening_subtractions(false)
+			, _disable_triangulation(false)
+			, _apply_default_materials(false)
+			// TODO: Make deflection tolerance into a command line argument
+			// For now, stick to one millimeter. Note that this is independent of the IFC length unit.
+			, _deflection_tolerance(1.e-3)
+		{}
+
+		const bool& weld_vertices() const { return _weld_vertices; }
+		bool& weld_vertices() { return _weld_vertices; }
+		const bool& use_world_coords() const { return _use_world_coords; }
+		bool& use_world_coords() { return _use_world_coords; }
+		const bool& convert_back_units() const { return _convert_back_units; }
+		bool& convert_back_units() { return _convert_back_units; }
+		const bool& use_brep_data() const { return _use_brep_data; }
+		bool& use_brep_data() { return _use_brep_data; }
+		const bool& sew_shells() const { return _sew_shells; }
+		bool& sew_shells() { return _sew_shells; }
+		const bool& faster_booleans() const { return _faster_booleans; }
+		bool& faster_booleans() { return _faster_booleans; }
+		const bool& force_ccw_face_orientation() const { return _force_ccw_face_orientation; }
+		bool& force_ccw_face_orientation() { return _force_ccw_face_orientation; }
+		const bool& disable_opening_subtractions() const { return _disable_opening_subtractions; }
+		bool& disable_opening_subtractions() { return _disable_opening_subtractions; }
+		const bool& disable_triangulation() const { return _disable_triangulation; }
+		bool& disable_triangulation() { return _disable_triangulation; }
+		const bool& apply_default_materials() const { return _apply_default_materials; }
+		bool& apply_default_materials() { return _apply_default_materials; }
+		
+		const double& deflection_tolerance() const { return _deflection_tolerance; }
+		double& deflection_tolerance() { return _deflection_tolerance; }
+		
+		void set(int setting, bool value) {
+			switch (setting) {
+			case USE_WORLD_COORDS:
+				_use_world_coords = value;
+				break;
+			case WELD_VERTICES:
+				_weld_vertices = value;
+				break;
+			case CONVERT_BACK_UNITS:
+				_convert_back_units = value;
+				break;
+			case USE_BREP_DATA:
+				_use_brep_data = value;
+				break;
+			case FASTER_BOOLEANS:
+				_faster_booleans = value;
+				break;
+			case SEW_SHELLS:
+				_sew_shells = value;
+				break;
+			case FORCE_CCW_FACE_ORIENTATION:
+				_force_ccw_face_orientation = value;
+				break;
+			case DISABLE_OPENING_SUBTRACTIONS:
+				_disable_opening_subtractions = value;
+				break;
+			case DISABLE_TRIANGULATION:
+				_disable_triangulation = value;
+				break;
+			case APPLY_DEFAULT_MATERIALS:
+				_apply_default_materials = value;
+				break;
+			default: throw IfcParse::IfcException("Invalid IteratorSetting");
+			}
+		}
+	};
+	
+	class ElementSettings : public IteratorSettings {
+	private:
+		double _unit_magnitude;
+		std::string _element_type;
+	public:
+		ElementSettings(const IteratorSettings& settings,
+			double unit_magnitude,
+			const std::string& element_type)
+			: IteratorSettings(settings)
+			, _unit_magnitude(unit_magnitude)
+			, _element_type(element_type)
+		{}
+
+		const double& unit_magnitude() const { return _unit_magnitude; }
+		const std::string& element_type() const { return _element_type; }
+	};
+
+}
+
+#endif
@@ -30,6 +30,5 @@ const double* IfcGeom::Material::diffuse() const { if (hasDiffuse()) return &((*
 const double* IfcGeom::Material::specular() const { if (hasSpecular()) return &((*style->Specular()).R()); else return black; }
 double IfcGeom::Material::transparency() const { if (hasTransparency()) return *style->Transparency(); else return 0; }
 double IfcGeom::Material::specularity() const { if (hasSpecularity()) return *style->Specularity(); else return 0; }
-const std::string &IfcGeom::Material::name() const { return style->Name(); }
-const std::string &IfcGeom::Material::original_name() const { return style->original_name(); }
+const std::string IfcGeom::Material::name() const { return style->Name(); }
 bool IfcGeom::Material::operator==(const IfcGeom::Material& other) const { return style == other.style; }
@@ -22,11 +22,11 @@

 #include <string>

-#include "../../ifcgeom/schema_agnostic/IfcGeomRenderStyles.h"
+#include "../ifcgeom/IfcGeomRenderStyles.h"

 namespace IfcGeom {	

-	class IFC_GEOM_API Material {
+	class Material {
 	private:
 		const IfcGeom::SurfaceStyle* style;
 	public:
@@ -41,11 +41,10 @@ namespace IfcGeom {
 		const double* specular() const;
 		double transparency() const;
 		double specularity() const;
-		const std::string &name() const;
-		const std::string &original_name() const;
+		const std::string name() const;
 		bool operator==(const Material& other) const;
 	};

 }

-#endif
+#endif
@@ -0,0 +1,162 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <map>
+
+#include "IfcGeom.h"
+
+bool process_colour(IfcSchema::IfcColourRgb* colour, std::tr1::array<double, 3>& rgb) {
+	if (colour != 0) {
+		rgb[0] = colour->Red();
+		rgb[1] = colour->Green();
+		rgb[2] = colour->Blue();
+	}
+	return colour != 0;
+}
+
+bool process_colour(IfcSchema::IfcNormalisedRatioMeasure* factor, std::tr1::array<double, 3>& rgb) {
+	if (factor != 0) {
+		const double f = *factor;
+		rgb[0] = rgb[1] = rgb[2] = f;
+	}
+	return factor != 0;
+}
+
+bool process_colour(IfcSchema::IfcColourOrFactor* colour_or_factor, std::tr1::array<double, 3>& rgb) {
+	if (colour_or_factor == 0) {
+		return false;
+	} else if (colour_or_factor->is(IfcSchema::Type::IfcColourRgb)) {
+		return process_colour(static_cast<IfcSchema::IfcColourRgb*>(colour_or_factor), rgb);
+	} else if (colour_or_factor->is(IfcSchema::Type::IfcNormalisedRatioMeasure)) {
+		return process_colour(static_cast<IfcSchema::IfcNormalisedRatioMeasure*>(colour_or_factor), rgb);
+	} else {
+		return false;
+	}
+}
+
+const IfcGeom::SurfaceStyle* IfcGeom::Kernel::get_style(const IfcSchema::IfcRepresentationItem* item) {
+	std::pair<IfcSchema::IfcSurfaceStyle*, IfcSchema::IfcSurfaceStyleShading*> shading_styles = get_surface_style<IfcSchema::IfcSurfaceStyleShading>(item);
+	if (shading_styles.second == 0) {
+		return 0;
+	}
+	int surface_style_id = shading_styles.first->entity->id();
+	std::map<int,SurfaceStyle>::const_iterator it = cache.Style.find(surface_style_id);
+	if (it != cache.Style.end()) {
+		return &(it->second);
+	}
+	SurfaceStyle surface_style;
+	if (shading_styles.first->Name()) {
+		surface_style = SurfaceStyle(surface_style_id, *shading_styles.first->Name());
+	} else {
+		surface_style = SurfaceStyle(surface_style_id);
+	}
+	std::tr1::array<double, 3> rgb;
+	if (process_colour(shading_styles.second->SurfaceColour(), rgb)) {
+		surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]));
+	}
+	if (shading_styles.second->is(IfcSchema::Type::IfcSurfaceStyleRendering)) {
+		IfcSchema::IfcSurfaceStyleRendering* rendering_style = static_cast<IfcSchema::IfcSurfaceStyleRendering*>(shading_styles.second);
+		if (rendering_style->DiffuseColour() && process_colour(*rendering_style->DiffuseColour(), rgb)) {
+			SurfaceStyle::ColorComponent diffuse = surface_style.Diffuse().get_value_or(SurfaceStyle::ColorComponent(1,1,1));
+			surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(diffuse.R() * rgb[0], diffuse.G() * rgb[1], diffuse.B() * rgb[2]));
+		}
+		if (rendering_style->DiffuseTransmissionColour()) {
+			// Not supported
+		}
+		if (rendering_style->ReflectionColour()) {
+			// Not supported
+		}
+		if (rendering_style->SpecularColour() && process_colour(*rendering_style->SpecularColour(), rgb)) {
+			surface_style.Specular().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]));
+		}
+		if (rendering_style->SpecularHighlight()) {
+			IfcSchema::IfcSpecularHighlightSelect* highlight = *rendering_style->SpecularHighlight();
+			if (highlight->is(IfcSchema::Type::IfcSpecularRoughness)) {
+				double roughness = *((IfcSchema::IfcSpecularRoughness*)highlight);
+				if (roughness >= 1e-9) {
+					surface_style.Specularity().reset(1.0 / roughness);
+				}
+			} else if (highlight->is(IfcSchema::Type::IfcSpecularExponent)) {
+				surface_style.Specularity().reset(*((IfcSchema::IfcSpecularExponent*)highlight));
+			}
+		}
+		if (rendering_style->TransmissionColour()) {
+			// Not supported
+		}
+		if (rendering_style->Transparency()) {
+			const double d = *rendering_style->Transparency();
+			surface_style.Transparency().reset(d);
+		}
+	}
+	return &(cache.Style[surface_style_id] = surface_style);
+}
+
+static std::map<std::string, IfcGeom::SurfaceStyle> default_materials;
+static IfcGeom::SurfaceStyle default_material;
+static bool default_materials_initialized = false;
+
+void InitDefaultMaterials() {
+	default_materials.insert(std::make_pair("IfcSite", IfcGeom::SurfaceStyle("IfcSite")));
+	default_materials["IfcSite"            ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.75, 0.8, 0.65));
+
+	default_materials.insert(std::make_pair("IfcSlab", IfcGeom::SurfaceStyle("IfcSlab")));
+	default_materials["IfcSlab"            ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.4 , 0.4, 0.4 ));
+	
+	default_materials.insert(std::make_pair("IfcWallStandardCase", IfcGeom::SurfaceStyle("IfcWallStandardCase")));
+	default_materials["IfcWallStandardCase"].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.9 , 0.9, 0.9 ));
+	
+	default_materials.insert(std::make_pair("IfcWall", IfcGeom::SurfaceStyle("IfcWall")));
+	default_materials["IfcWall"            ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.9 , 0.9, 0.9 ));
+	
+	default_materials.insert(std::make_pair("IfcWindow", IfcGeom::SurfaceStyle("IfcWindow")));
+	default_materials["IfcWindow"          ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.75, 0.8, 0.75));
+	default_materials["IfcWindow"          ].Transparency().reset(0.3);
+	
+	default_materials.insert(std::make_pair("IfcDoor", IfcGeom::SurfaceStyle("IfcDoor")));
+	default_materials["IfcDoor"            ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.55, 0.3, 0.15));
+	
+	default_materials.insert(std::make_pair("IfcBeam", IfcGeom::SurfaceStyle("IfcBeam")));
+	default_materials["IfcBeam"            ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.75, 0.7, 0.7 ));
+	
+	default_materials.insert(std::make_pair("IfcRailing", IfcGeom::SurfaceStyle("IfcRailing")));
+	default_materials["IfcRailing"         ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.65, 0.6, 0.6 ));
+	
+	default_materials.insert(std::make_pair("IfcMember", IfcGeom::SurfaceStyle("IfcMember")));
+	default_materials["IfcMember"          ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.65, 0.6, 0.6 ));
+	
+	default_materials.insert(std::make_pair("IfcPlate", IfcGeom::SurfaceStyle("IfcPlate")));
+	default_materials["IfcPlate"           ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.8 , 0.8, 0.8 ));
+
+	default_material = IfcGeom::SurfaceStyle("DefaultMaterial");
+	default_material.Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.7, 0.7, 0.7));
+
+	default_materials_initialized = true;
+}
+
+const IfcGeom::SurfaceStyle* IfcGeom::get_default_style(const std::string& s) {
+	if (!default_materials_initialized) InitDefaultMaterials();
+	std::map<std::string, IfcGeom::SurfaceStyle>::const_iterator it = default_materials.find(s);
+	if (it == default_materials.end()) {
+		default_materials.insert(std::make_pair(s, IfcGeom::SurfaceStyle(s)));
+		default_materials[s].Diffuse().reset(*default_material.Diffuse());
+		it = default_materials.find(s);
+	}
+	const IfcGeom::SurfaceStyle& surface_style = it->second;
+	return &surface_style;
+}
@@ -20,20 +20,24 @@
 #ifndef IFCGEOMRENDERSTYLES_H
 #define IFCGEOMRENDERSTYLES_H

-#include "../../ifcgeom/schema_agnostic/ifc_geom_api.h"
+#ifdef __GNUC__
+#include <tr1/array>
+#else
+#include <array>
+#endif

-#include <boost/algorithm/string/case_conv.hpp>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/optional.hpp>
-
-#include <sstream>
+#ifdef USE_IFC4
+#include "../ifcparse/Ifc4.h"
+#else
+#include "../ifcparse/Ifc2x3.h"
+#endif

 namespace IfcGeom {
-	class IFC_GEOM_API SurfaceStyle {
+	class SurfaceStyle {
 	public:
 		class ColorComponent {
 		private:
-			double data[3];
+			std::tr1::array<double, 3> data;
 		public:
 			ColorComponent(double r, double g, double b) {
 				data[0] = r; data[1] = g; data[2] = b;
@@ -46,27 +50,24 @@ namespace IfcGeom {
 			double& B() { return data[2]; }
 		};
 	private:
-		std::string name;
-        std::string original_name_;
+		boost::optional<std::string> name;
 		boost::optional<int> id;
 		boost::optional<ColorComponent> diffuse, specular;
 		boost::optional<double> transparency;
 		boost::optional<double> specularity;
 	public:
-        SurfaceStyle() : name("surface-style") {}
+		SurfaceStyle() {
+			this->name = "IfcSurfaceStyleShading";
+		}
 		SurfaceStyle(int id) : id(id) {
 			std::stringstream sstr; 
-			sstr << "surface-style-" << id; 
+			sstr << "IfcSurfaceStyleShading_" << id; 
 			this->name = sstr.str(); 
 		}
-        SurfaceStyle(const std::string& name) : name(name), original_name_(name) {}
-        SurfaceStyle(int id, const std::string& name) : original_name_(name), id(id)
-        {
+		SurfaceStyle(const std::string& name) : name(name) {}
+		SurfaceStyle(int id, const std::string& name) : id(id) {
 			std::stringstream sstr; 
-			std::string sanitized = name;
-            boost::to_lower(sanitized);
-            boost::replace_all(sanitized, " ", "-");
-			sstr << "surface-style-" << id << "-" << sanitized;
+			sstr << id << "_" << name;
 			this->name = sstr.str(); 
 		}
 		
@@ -75,14 +76,16 @@ namespace IfcGeom {
 		// pointer addresses of the styles, as they are always referenced 
 		// from out of a global map of some sort.
 		bool operator==(const SurfaceStyle& other) {
-			return name == other.name;
+			if (name && other.name) {
+				return *name == *other.name;
+			} else if (id && other.id) {
+				return *id == *other.id;
+			} else {
+				return false;
+			}
 		}
 		
-        /// ID name, e.g. "surface-style-66675-metal---aluminium"
-		const std::string& Name() const { return name; }
-
-        /// Original name, if available, e.g. "Metal - Aluminium"
-        const std::string& original_name() const { return original_name_; }
+		const std::string& Name() const { return *name; }

 		const boost::optional<ColorComponent>& Diffuse() const { return diffuse; }
 		const boost::optional<ColorComponent>& Specular() const { return specular; }
@@ -94,8 +97,7 @@ namespace IfcGeom {
 		boost::optional<double>& Specularity() { return specularity; }
 	};

-  IFC_GEOM_API const SurfaceStyle* get_default_style(const std::string& ifc_type);
-	IFC_GEOM_API void set_default_style_file(const std::string& json_file);
+	const SurfaceStyle* get_default_style(const std::string& ifc_type);
 }

-#endif
+#endif
@@ -17,39 +17,43 @@
 *                                                                              *
 ********************************************************************************/

-#ifndef GLTFSERIALIZER_H
-#define GLTFSERIALIZER_H
+#include <BRep_Tool.hxx>
+#include <BRepTools.hxx>
+#include <BRep_Builder.hxx>

-#ifdef WITH_GLTF
+#include <TopoDS_Compound.hxx>
+#include <BRepBuilderAPI_GTransform.hxx>

-#include "../serializers/GeometrySerializer.h"
+#include "../ifcgeom/IfcGeom.h"

-#include <nlohmann/json.hpp>
-using json = nlohmann::json;
+#include "IfcGeomRepresentation.h"

-#include <map>
-
-class GltfSerializer : public GeometrySerializer {
-private:
-	std::string filename_, tmp_filename1_, tmp_filename2_;
-	std::ofstream fstream_, tmp_fstream1_, tmp_fstream2_;
-	std::map<std::string, int> materials_, meshes_;
-	json json_, node_array_;
-
-	int writeMaterial(const IfcGeom::Material& style);
-public:
-	GltfSerializer(const std::string& filename, const SerializerSettings& settings);
-	virtual ~GltfSerializer();
-	bool ready();
-	void writeHeader();
-	void write(const IfcGeom::TriangulationElement<real_t>* o);
-	void write(const IfcGeom::NativeElement<real_t>* /*o*/) {}
-	void finalize();
-	bool isTesselated() const { return true; }
-	void setUnitNameAndMagnitude(const std::string& /*name*/, float /*magnitude*/) {}
-	void setFile(IfcParse::IfcFile*) {}
-};
-
-#endif
-
-#endif
+IfcGeom::Representation::Serialization::Serialization(const BRep& brep)
+	: Representation(brep.settings())
+	, _id(brep.getId())
+{
+	TopoDS_Compound compound;
+	BRep_Builder builder;
+	builder.MakeCompound(compound);
+	for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = brep.begin(); it != brep.end(); ++ it) {
+		const TopoDS_Shape& s = it->Shape();
+		gp_GTrsf trsf = it->Placement();
+		if (settings().convert_back_units()) {
+			gp_Trsf scale;
+			scale.SetScaleFactor(1.0 / settings().unit_magnitude());
+			trsf.PreMultiply(scale);
+		}
+		bool trsf_valid = false;
+		gp_Trsf _trsf;
+		try {
+			_trsf = trsf.Trsf();
+			trsf_valid = true;
+		} catch (...) {}
+		const TopoDS_Shape moved_shape = trsf_valid ? s.Moved(_trsf) :
+			BRepBuilderAPI_GTransform(s,trsf,true).Shape();
+		builder.Add(compound,moved_shape);
+	}
+	std::stringstream sstream;
+	BRepTools::Write(compound,sstream);
+	_brep_data = sstream.str();
+}
@@ -0,0 +1,272 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCGEOMREPRESENTATION_H
+#define IFCGEOMREPRESENTATION_H
+
+#include <BRepMesh_IncrementalMesh.hxx>
+#include <BRepGProp_Face.hxx>
+
+#include <Poly_Triangulation.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
+
+#include <TopExp_Explorer.hxx>
+
+#include "../ifcgeom/IfcGeomIteratorSettings.h"
+#include "../ifcgeom/IfcGeomMaterial.h"
+#include "../ifcgeom/IfcRepresentationShapeItem.h"
+
+namespace IfcGeom {
+
+	namespace Representation {
+
+		class Representation {
+		protected:
+			const ElementSettings _settings;
+		public:
+			explicit Representation(const ElementSettings& settings)
+				: _settings(settings) 
+			{}
+			const ElementSettings& settings() const { return _settings; }
+			virtual ~Representation() {}
+		};
+
+		class BRep : public Representation {
+		private:
+			unsigned int id;
+			const IfcGeom::IfcRepresentationShapeItems shapes;
+			BRep(const BRep& other);
+			BRep& operator=(const BRep& other);
+		public:
+			BRep(const ElementSettings& settings, unsigned int id, const IfcGeom::IfcRepresentationShapeItems& shapes)
+				: Representation(settings)
+				, id(id)
+				, shapes(shapes)
+			{}
+			virtual ~BRep() {}
+			IfcGeom::IfcRepresentationShapeItems::const_iterator begin() const { return shapes.begin(); }
+			IfcGeom::IfcRepresentationShapeItems::const_iterator end() const { return shapes.end(); }
+			const unsigned int& getId() const { return id; }
+		};
+
+		class Serialization : public Representation  {
+		private:
+			int _id;
+			std::string _brep_data;
+		public:
+			int id() const { return _id; }
+			const std::string& brep_data() const { return _brep_data; }
+			Serialization(const BRep& brep);
+			virtual ~Serialization() {}
+		private:
+			Serialization();
+			Serialization(const Serialization&);
+			Serialization& operator=(const Serialization&);
+		};
+
+		template <typename P>
+		class Triangulation : public Representation {
+		private:
+			// A nested pair of floats and a material index to be able to store an XYZ coordinate in a map.
+			// TODO: Make this a std::tuple when compilers add support for that.
+			typedef typename std::pair<P, std::pair<P, P> > Coordinate;
+			typedef typename std::pair<int, Coordinate> VertexKey;
+			typedef std::map<VertexKey, int> VertexKeyMap;
+			typedef std::pair<int, int> Edge;
+
+			int _id;
+			std::vector<P> _verts;
+			std::vector<int> _faces;
+			std::vector<int> _edges;
+			std::vector<P> _normals;
+			std::vector<int> _material_ids;
+			std::vector<Material> _materials;
+			VertexKeyMap welds;
+
+		public:
+			int id() const { return _id; }
+			const std::vector<P>& verts() const { return _verts; }
+			const std::vector<int>& faces() const { return _faces; }
+			const std::vector<int>& edges() const { return _edges; }
+			const std::vector<P>& normals() const { return _normals; }
+			const std::vector<int>& material_ids() const { return _material_ids; }
+			const std::vector<Material>& materials() const { return _materials; }
+			Triangulation(const BRep& shape_model)
+					: Representation(shape_model.settings())
+					, _id(shape_model.getId())
+			{
+				for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it = shape_model.begin(); it != shape_model.end(); ++ it ) {
+
+					int surface_style_id = -1;
+					if (it->hasStyle()) {
+						Material adapter(&it->Style());
+						std::vector<Material>::const_iterator jt = std::find(_materials.begin(), _materials.end(), adapter);
+						if (jt == _materials.end()) {
+							surface_style_id = _materials.size();
+							_materials.push_back(adapter);
+						} else {
+							surface_style_id = jt - _materials.begin();
+						}
+					}
+
+					if (settings().apply_default_materials() && surface_style_id == -1) {
+						Material material(IfcGeom::get_default_style(settings().element_type()));
+						std::vector<Material>::const_iterator it = std::find(_materials.begin(), _materials.end(), material);
+						if (it == _materials.end()) {
+							surface_style_id = _materials.size();
+							_materials.push_back(material);
+						} else {
+							surface_style_id = it - _materials.begin();
+						}
+					}
+
+					const TopoDS_Shape& s = it->Shape();
+					const gp_GTrsf& trsf = it->Placement();
+
+					// Triangulate the shape
+					try {
+						BRepMesh_IncrementalMesh(s, settings().deflection_tolerance());
+					} catch(...) {
+
+						// TODO: Catch outside
+						// Logger::Message(Logger::LOG_ERROR,"Failed to triangulate shape:",ifc_file->entityById(_id)->entity);
+						Logger::Message(Logger::LOG_ERROR,"Failed to triangulate shape");
+						continue;
+					}
+					TopExp_Explorer exp;
+
+					// Iterates over the faces of the shape
+					for ( exp.Init(s,TopAbs_FACE); exp.More(); exp.Next() ) {
+						TopoDS_Face face = TopoDS::Face(exp.Current());
+						TopLoc_Location loc;
+						Handle_Poly_Triangulation tri = BRep_Tool::Triangulation(face,loc);
+
+						if ( ! tri.IsNull() ) {
+
+							// A 3x3 matrix to rotate the vertex normals
+							const gp_Mat rotation_matrix = trsf.VectorialPart();
+			
+							// Keep track of the number of times an edge is used
+							// Manifold edges (i.e. edges used twice) are deemed invisible
+							std::map<std::pair<int,int>,int> edgecount;
+							std::vector<std::pair<int,int> > edges_temp;
+
+							const TColgp_Array1OfPnt& nodes = tri->Nodes();
+							const TColgp_Array1OfPnt2d& uvs = tri->UVNodes();
+							std::vector<gp_XYZ> coords;
+							BRepGProp_Face prop(face);
+							std::map<int,int> dict;
+
+							// Vertex normals are only calculated if vertices are not welded
+							const bool calculate_normals = !settings().weld_vertices();
+
+							for( int i = 1; i <= nodes.Length(); ++ i ) {
+								coords.push_back(nodes(i).Transformed(loc).XYZ());
+								trsf.Transforms(*coords.rbegin());
+								dict[i] = addVertex(surface_style_id, *coords.rbegin());
+					
+								if ( calculate_normals ) {
+									const gp_Pnt2d& uv = uvs(i);
+									gp_Pnt p;
+									gp_Vec normal_direction;
+									prop.Normal(uv.X(),uv.Y(),p,normal_direction);
+									gp_Vec normal(0., 0., 0.);
+									if (normal_direction.Magnitude() > ALMOST_ZERO) {
+										normal = gp_Dir(normal_direction.XYZ() * rotation_matrix);
+									}
+									_normals.push_back((float)normal.X());
+									_normals.push_back((float)normal.Y());
+									_normals.push_back((float)normal.Z());
+								}
+							}
+
+							const Poly_Array1OfTriangle& triangles = tri->Triangles();			
+							for( int i = 1; i <= triangles.Length(); ++ i ) {
+								int n1,n2,n3;
+								if ( face.Orientation() == TopAbs_REVERSED )
+									triangles(i).Get(n3,n2,n1);
+								else triangles(i).Get(n1,n2,n3);
+
+								/* An alternative would be to calculate normals based
+									* on the coordinates of the mesh vertices */
+								/*
+								const gp_XYZ pt1 = coords[n1-1];
+								const gp_XYZ pt2 = coords[n2-1];
+								const gp_XYZ pt3 = coords[n3-1];
+								const gp_XYZ v1 = pt2-pt1;
+								const gp_XYZ v2 = pt3-pt2;
+								gp_Dir normal = gp_Dir(v1^v2);
+								_normals.push_back((float)normal.X());
+								_normals.push_back((float)normal.Y());
+								_normals.push_back((float)normal.Z());
+								*/
+
+								_faces.push_back(dict[n1]);
+								_faces.push_back(dict[n2]);
+								_faces.push_back(dict[n3]);
+
+								_material_ids.push_back(surface_style_id);
+
+								addEdge(n1,n2,edgecount,edges_temp);
+								addEdge(n2,n3,edgecount,edges_temp);
+								addEdge(n3,n1,edgecount,edges_temp);
+							}
+							for ( std::vector<std::pair<int,int> >::const_iterator it = edges_temp.begin(); it != edges_temp.end(); ++it ) {
+								_edges.push_back(edgecount[*it]==1);
+							}
+						}
+					}
+				}
+			}
+			virtual ~Triangulation() {}
+		private:
+			// Welds vertices that belong to different faces
+			int addVertex(int material_index, const gp_XYZ& p) {
+				const P X = static_cast<P>(settings().convert_back_units() ? (p.X() / settings().unit_magnitude()) : p.X());
+				const P Y = static_cast<P>(settings().convert_back_units() ? (p.Y() / settings().unit_magnitude()) : p.Y());
+				const P Z = static_cast<P>(settings().convert_back_units() ? (p.Z() / settings().unit_magnitude()) : p.Z());
+				int i = (int) _verts.size() / 3;
+				if (settings().weld_vertices()) {
+					const VertexKey key = std::make_pair(material_index, std::make_pair(X, std::make_pair(Y, Z)));
+					typename VertexKeyMap::const_iterator it = welds.find(key);
+					if ( it != welds.end() ) return it->second;
+					i = (int) welds.size();
+					welds[key] = i;
+				}
+				_verts.push_back(X);
+				_verts.push_back(Y);
+				_verts.push_back(Z);
+				return i;
+			}
+			inline void addEdge(int n1, int n2, std::map<std::pair<int,int>,int>& edgecount, std::vector<std::pair<int,int> >& edges_temp) {
+				const Edge e = Edge( (std::min)(n1,n2),(std::max)(n1,n2) );
+				if ( edgecount.find(e) == edgecount.end() ) edgecount[e] = 1;
+				else edgecount[e] ++;
+				edges_temp.push_back(e);
+			}
+			Triangulation();
+			Triangulation(const Triangulation&);
+			Triangulation& operator=(const Triangulation&);
+		};
+
+	}
+}
+
+#endif
@@ -0,0 +1,818 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * Implementations of the various conversion functions defined in IfcRegister.h *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Vec2d.hxx>
+#include <gp_Dir2d.hxx>
+#include <gp_Mat.hxx>
+#include <gp_Mat2d.hxx>
+#include <gp_GTrsf.hxx>
+#include <gp_GTrsf2d.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Ax1.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Ax2d.hxx>
+#include <gp_Pln.hxx>
+#include <gp_Circ.hxx>
+
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_Array1OfInteger.hxx>
+
+#include <Geom_Line.hxx>
+#include <Geom_Circle.hxx>
+#include <Geom_Ellipse.hxx>
+#include <Geom_TrimmedCurve.hxx>
+#include <Geom_CylindricalSurface.hxx>
+
+#include <BRepOffsetAPI_Sewing.hxx>
+#include <BRepOffsetAPI_MakePipe.hxx>
+#include <BRepOffsetAPI_MakePipeShell.hxx>
+
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <BRepBuilderAPI_MakePolygon.hxx>
+#include <BRepBuilderAPI_MakeVertex.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopExp_Explorer.hxx>
+
+#include <BRepPrimAPI_MakePrism.hxx>
+#include <BRepPrimAPI_MakeRevol.hxx>
+#include <BRepPrimAPI_MakeBox.hxx>
+#include <BRepPrimAPI_MakeCone.hxx>
+#include <BRepPrimAPI_MakeCylinder.hxx>
+#include <BRepPrimAPI_MakeSphere.hxx>
+#include <BRepPrimAPI_MakeWedge.hxx>
+
+#include <BRepBuilderAPI_Transform.hxx>
+#include <BRepBuilderAPI_MakeShell.hxx>
+#include <BRepBuilderAPI_MakeSolid.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+
+#include <BRepAlgoAPI_Cut.hxx>
+#include <BRepAlgoAPI_Fuse.hxx>
+#include <BRepAlgoAPI_Common.hxx>
+
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <ShapeFix_Solid.hxx>
+
+#include <TopLoc_Location.hxx>
+
+#include <BRepCheck_Analyzer.hxx>
+#include <BRepClass3d_SolidClassifier.hxx>
+
+#include <Standard_Version.hxx>
+
+#include "../ifcgeom/IfcGeom.h"
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolid* l, TopoDS_Shape& shape) {
+	TopoDS_Shape face;
+	if ( !convert_face(l->SweptArea(),face) ) return false;
+
+	const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+
+	gp_Dir dir;
+	convert(l->ExtrudedDirection(),dir);
+
+	shape.Nullify();
+
+	if (face.ShapeType() == TopAbs_COMPOUND) {
+		
+		// For compounds (most likely the result of a IfcCompositeProfileDef) 
+		// create a compound solid shape.
+		
+		TopExp_Explorer exp(face, TopAbs_FACE);
+		
+		TopoDS_CompSolid compound;
+		BRep_Builder builder;
+		builder.MakeCompSolid(compound);
+		
+		int num_faces_extruded = 0;
+		for (; exp.More(); exp.Next(), ++num_faces_extruded) {
+			builder.Add(compound, BRepPrimAPI_MakePrism(exp.Current(), height*dir));
+		}
+
+		if (num_faces_extruded) {
+			shape = compound;
+		}
+
+	}
+	
+	if (shape.IsNull()) {	
+		shape = BRepPrimAPI_MakePrism(face, height*dir);
+	}
+
+	shape.Move(trsf);
+	return ! shape.IsNull();
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceOfLinearExtrusion* l, TopoDS_Shape& shape) {
+	TopoDS_Wire wire;
+	if ( !convert_wire(l->SweptCurve(), wire) ) {
+		TopoDS_Face face;
+		if ( !convert_face(l->SweptCurve(),face) ) return false;
+		TopExp_Explorer exp(face, TopAbs_WIRE);
+		wire = TopoDS::Wire(exp.Current());
+	}
+	const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+
+	gp_Dir dir;
+	convert(l->ExtrudedDirection(),dir);
+
+	shape = BRepPrimAPI_MakePrism(wire, height*dir);
+	shape.Move(trsf);
+	return !shape.IsNull();
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceOfRevolution* l, TopoDS_Shape& shape) {
+	TopoDS_Wire wire;
+	if ( !convert_wire(l->SweptCurve(), wire) ) {
+		TopoDS_Face face;
+		if ( !convert_face(l->SweptCurve(),face) ) return false;
+		TopExp_Explorer exp(face, TopAbs_WIRE);
+		wire = TopoDS::Wire(exp.Current());
+	}
+
+	gp_Ax1 ax1;
+	IfcGeom::Kernel::convert(l->AxisPosition(), ax1);
+
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+	
+	shape = BRepPrimAPI_MakeRevol(wire, ax1);
+
+	shape.Move(trsf);
+	return !shape.IsNull();
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRevolvedAreaSolid* l, TopoDS_Shape& shape) {
+	const double ang = l->Angle() * getValue(GV_PLANEANGLE_UNIT);
+
+	TopoDS_Face face;
+	if ( ! convert_face(l->SweptArea(),face) ) return false;
+
+	gp_Ax1 ax1;
+	IfcGeom::Kernel::convert(l->Axis(), ax1);
+
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+
+	if (ang >= M_PI * 2. - ALMOST_ZERO) {
+		shape = BRepPrimAPI_MakeRevol(face, ax1);
+	} else {
+		shape = BRepPrimAPI_MakeRevol(face, ax1, ang);
+	}
+
+	shape.Move(trsf);
+	return !shape.IsNull();
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcFacetedBrep* l, IfcRepresentationShapeItems& shape) {
+	TopoDS_Shape s;
+	const SurfaceStyle* collective_style = get_style(l);
+	if (convert_shape(l->Outer(),s) ) {
+		const SurfaceStyle* indiv_style = get_style(l->Outer());
+		shape.push_back(IfcRepresentationShapeItem(s, indiv_style ? indiv_style : collective_style));
+		return true;
+	}
+	return false;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcFaceBasedSurfaceModel* l, IfcRepresentationShapeItems& shapes) {
+	IfcSchema::IfcConnectedFaceSet::list::ptr facesets = l->FbsmFaces();
+	const SurfaceStyle* collective_style = get_style(l);
+	for( IfcSchema::IfcConnectedFaceSet::list::it it = facesets->begin(); it != facesets->end(); ++ it ) {
+		TopoDS_Shape s;
+		const SurfaceStyle* shell_style = get_style(*it);
+		if (convert_shape(*it,s)) {
+			shapes.push_back(IfcRepresentationShapeItem(s, shell_style ? shell_style : collective_style));
+		}
+	}
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcHalfSpaceSolid* l, TopoDS_Shape& shape) {
+	IfcSchema::IfcSurface* surface = l->BaseSurface();
+	if ( ! surface->is(IfcSchema::Type::IfcPlane) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface->entity);
+		return false;
+	}
+	gp_Pln pln;
+	IfcGeom::Kernel::convert((IfcSchema::IfcPlane*)surface,pln);
+	const gp_Pnt pnt = pln.Location().Translated( l->AgreementFlag() ? -pln.Axis().Direction() : pln.Axis().Direction());
+	shape = BRepPrimAPI_MakeHalfSpace(BRepBuilderAPI_MakeFace(pln),pnt).Solid();
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolygonalBoundedHalfSpace* l, TopoDS_Shape& shape) {
+	TopoDS_Shape halfspace;
+	if ( ! IfcGeom::Kernel::convert((IfcSchema::IfcHalfSpaceSolid*)l,halfspace) ) return false;	
+	TopoDS_Wire wire;
+	if ( ! convert_wire(l->PolygonalBoundary(),wire) || ! wire.Closed() ) return false;	
+	gp_Trsf trsf;
+	convert(l->Position(),trsf);
+	TopoDS_Shape prism = BRepPrimAPI_MakePrism(BRepBuilderAPI_MakeFace(wire),gp_Vec(0,0,200));
+	gp_Trsf down; down.SetTranslation(gp_Vec(0,0,-100.0));
+	prism.Move(trsf*down);
+	shape = BRepAlgoAPI_Common(halfspace,prism);
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, IfcRepresentationShapeItems& shapes) {
+	IfcEntityList::ptr shells = l->SbsmBoundary();
+	const SurfaceStyle* collective_style = get_style(l);
+	for( IfcEntityList::it it = shells->begin(); it != shells->end(); ++ it ) {
+		TopoDS_Shape s;
+		const SurfaceStyle* shell_style = 0;
+		if ((*it)->is(IfcSchema::Type::IfcRepresentationItem)) {
+			shell_style = get_style((IfcSchema::IfcRepresentationItem*)*it);
+		}
+		if (convert_shape(*it,s)) {
+			shapes.push_back(IfcRepresentationShapeItem(s, shell_style ? shell_style : collective_style));
+		}
+	}
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape& shape) {
+	TopoDS_Shape s1, s2;
+	IfcRepresentationShapeItems items1, items2;
+	TopoDS_Wire boundary_wire;
+	IfcSchema::IfcBooleanOperand* operand1 = l->FirstOperand();
+	IfcSchema::IfcBooleanOperand* operand2 = l->SecondOperand();
+	bool is_halfspace = operand2->is(IfcSchema::Type::IfcHalfSpaceSolid);
+
+	if ( is_shape_collection(operand1) ) {
+		if (!(convert_shapes(operand1, items1) && flatten_shape_list(items1, s1, true))) {
+			return false;
+		}
+	} else {
+		if ( ! convert_shape(operand1, s1) ) {
+			return false;
+		}
+		{ TopoDS_Solid temp_solid;
+		s1 = ensure_fit_for_subtraction(s1, temp_solid); }
+	}
+
+	const double first_operand_volume = shape_volume(s1);
+	if ( first_operand_volume <= ALMOST_ZERO )
+		Logger::Message(Logger::LOG_WARNING,"Empty solid for:",l->FirstOperand()->entity);
+
+	bool shape2_processed = false;
+	if ( is_shape_collection(operand2) ) {
+		shape2_processed = convert_shapes(operand2, items2) && flatten_shape_list(items2, s2, true);
+	} else {
+		shape2_processed = convert_shape(operand2,s2);
+		if (shape2_processed && !is_halfspace) {
+			TopoDS_Solid temp_solid;
+			s2 = ensure_fit_for_subtraction(s2, temp_solid);
+		}
+	}
+
+	if (!shape2_processed) {
+		shape = s1;
+		Logger::Message(Logger::LOG_ERROR,"Failed to convert SecondOperand of:",l->entity);
+		return true;
+	}
+
+	if (!is_halfspace) {
+		const double second_operand_volume = shape_volume(s2);
+		if ( second_operand_volume <= ALMOST_ZERO )
+			Logger::Message(Logger::LOG_WARNING,"Empty solid for:",operand2->entity);
+	}
+
+	const IfcSchema::IfcBooleanOperator::IfcBooleanOperator op = l->Operator();
+
+	if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_DIFFERENCE) {
+
+		bool valid_cut = false;
+		BRepAlgoAPI_Cut brep_cut(s1,s2);
+		if ( brep_cut.IsDone() ) {
+			TopoDS_Shape result = brep_cut;
+
+			ShapeFix_Shape fix(result);
+			try {
+				fix.Perform();
+				result = fix.Shape();
+			} catch (...) {
+				Logger::Message(Logger::LOG_WARNING, "Shape healing failed on boolean result", l->entity);
+			}
+		
+			bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
+			if ( is_valid ) {
+				shape = result;
+				valid_cut = true;
+			} 
+		}
+
+		if ( valid_cut ) {
+			const double volume_after_subtraction = shape_volume(shape);
+			if ( ALMOST_THE_SAME(first_operand_volume,volume_after_subtraction) )
+				Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",l->entity);
+		} else {
+			Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",l->entity);
+			shape = s1;
+		}
+
+		return true;
+
+	} else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_UNION) {
+
+		BRepAlgoAPI_Fuse brep_fuse(s1,s2);
+		if ( brep_fuse.IsDone() ) {
+			TopoDS_Shape result = brep_fuse;
+
+			ShapeFix_Shape fix(result);
+			fix.Perform();
+			result = fix.Shape();
+		
+			bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
+			if ( is_valid ) {
+				shape = result;
+				return true;
+			} 
+		}	
+
+	} else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_INTERSECTION) {
+
+		BRepAlgoAPI_Common brep_common(s1,s2);
+		if ( brep_common.IsDone() ) {
+			TopoDS_Shape result = brep_common;
+
+			ShapeFix_Shape fix(result);
+			fix.Perform();
+			result = fix.Shape();
+		
+			bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
+			if ( is_valid ) {
+				shape = result;
+				return true;
+			} 
+		}
+
+	}
+	return false;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Shape& shape) {
+	IfcSchema::IfcFace::list::ptr faces = l->CfsFaces();
+	bool facesAdded = false;
+	const unsigned int num_faces = faces->size();
+	bool valid_shell = false;
+	if ( num_faces < getValue(GV_MAX_FACES_TO_SEW) ) {
+		BRepOffsetAPI_Sewing builder;
+		builder.SetTolerance(getValue(GV_POINT_EQUALITY_TOLERANCE));
+		builder.SetMaxTolerance(getValue(GV_POINT_EQUALITY_TOLERANCE));
+		builder.SetMinTolerance(getValue(GV_POINT_EQUALITY_TOLERANCE));
+		for( IfcSchema::IfcFace::list::it it = faces->begin(); it != faces->end(); ++ it ) {
+			TopoDS_Face face;
+			bool converted_face = false;
+			try {
+				converted_face = convert_face(*it,face);
+			} catch (...) {}
+			if ( converted_face && face_area(face) > getValue(GV_MINIMAL_FACE_AREA) ) {
+				builder.Add(face);
+				facesAdded = true;
+			} else {
+				Logger::Message(Logger::LOG_WARNING,"Invalid face:",(*it)->entity);
+			}
+		}
+		if ( ! facesAdded ) return false;
+		try {
+			builder.Perform();
+			shape = builder.SewedShape();
+			valid_shell = BRepCheck_Analyzer(shape).IsValid();
+		} catch(...) {}
+		if (valid_shell) {
+			try {
+				ShapeFix_Solid solid;
+				solid.LimitTolerance(getValue(GV_POINT_EQUALITY_TOLERANCE));
+				TopoDS_Solid solid_shape = solid.SolidFromShell(TopoDS::Shell(shape));
+				if (!solid_shape.IsNull()) {
+					try {
+						BRepClass3d_SolidClassifier classifier(solid_shape);
+						shape = solid_shape;
+					} catch (...) {}
+				}
+			} catch(...) {}
+		} else {
+			Logger::Message(Logger::LOG_WARNING,"Failed to sew faceset:",l->entity);
+		}
+	}
+	if (!valid_shell) {
+		TopoDS_Compound compound;
+		BRep_Builder builder;
+		builder.MakeCompound(compound);
+		for( IfcSchema::IfcFace::list::it it = faces->begin(); it != faces->end(); ++ it ) {
+			TopoDS_Face face;
+			bool converted_face = false;
+			try {
+				converted_face = convert_face(*it,face);
+			} catch (...) {}
+			if ( converted_face && face_area(face) > getValue(GV_MINIMAL_FACE_AREA) ) {
+				builder.Add(compound,face);
+				facesAdded = true;
+			} else {
+				Logger::Message(Logger::LOG_WARNING,"Invalid face:",(*it)->entity);
+			}
+		}
+		if ( ! facesAdded ) return false;
+		shape = compound;
+	}
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, IfcRepresentationShapeItems& shapes) {
+	gp_GTrsf gtrsf;
+	IfcSchema::IfcCartesianTransformationOperator* transform = l->MappingTarget();
+	if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3DnonUniform) ) {
+		IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator3DnonUniform*)transform,gtrsf);
+	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported MappingTarget:", transform->entity);
+		return false;
+	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3D) ) {
+		gp_Trsf trsf;
+		IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator3D*)transform,trsf);
+		gtrsf = trsf;
+	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2D) ) {
+		gp_Trsf2d trsf_2d;
+		IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator2D*)transform,trsf_2d);
+		gtrsf = (gp_Trsf) trsf_2d;
+	}
+	IfcSchema::IfcRepresentationMap* map = l->MappingSource();
+	IfcSchema::IfcAxis2Placement* placement = map->MappingOrigin();
+	gp_Trsf trsf;
+	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
+		IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
+	} else {
+		gp_Trsf2d trsf_2d;
+		IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf_2d);
+		trsf = trsf_2d;
+	}
+	gtrsf.Multiply(trsf);
+	const unsigned int previous_size = (const unsigned int) shapes.size();
+	bool b = convert_shapes(map->MappedRepresentation(),shapes);
+	for ( unsigned int i = previous_size; i < shapes.size(); ++ i ) {
+		shapes[i].append(gtrsf);
+	}
+	return b;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcShapeRepresentation* l, IfcRepresentationShapeItems& shapes) {
+	IfcSchema::IfcRepresentationItem::list::ptr items = l->Items();
+	bool part_succes = false;
+	if ( items->size() ) {
+		for ( IfcSchema::IfcRepresentationItem::list::it it = items->begin(); it != items->end(); ++ it ) {
+			IfcSchema::IfcRepresentationItem* representation_item = *it;
+			if ( is_shape_collection(representation_item) ) {
+				part_succes |= convert_shapes(*it, shapes);
+			} else {
+				TopoDS_Shape s;
+				if (convert_shape(representation_item,s)) {
+					shapes.push_back(IfcRepresentationShapeItem(s, get_style(representation_item)));
+					part_succes |= true;
+				}
+			}
+		}
+	}
+	return part_succes;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcGeometricSet* l, IfcRepresentationShapeItems& shapes) {
+	IfcEntityList::ptr elements = l->Elements();
+	if ( !elements->size() ) return false;
+	bool part_succes = false;
+	const IfcGeom::SurfaceStyle* parent_style = get_style(l);
+	for ( IfcEntityList::it it = elements->begin(); it != elements->end(); ++ it ) {
+		IfcSchema::IfcGeometricSetSelect* element = *it;
+		if (element->is(IfcSchema::Type::IfcSurface)) {
+			IfcSchema::IfcSurface* surface = (IfcSchema::IfcSurface*) element;
+			TopoDS_Shape s;
+			if (convert_shape(surface, s)) {
+				part_succes = true;
+				const IfcGeom::SurfaceStyle* style = get_style(surface);
+				shapes.push_back(IfcRepresentationShapeItem(s, style ? style : parent_style));
+			}
+		}
+	}
+	return part_succes;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcBlock* l, TopoDS_Shape& shape) {
+	const double dx = l->XLength() * getValue(GV_LENGTH_UNIT);
+	const double dy = l->YLength() * getValue(GV_LENGTH_UNIT);
+	const double dz = l->ZLength() * getValue(GV_LENGTH_UNIT);
+
+	BRepPrimAPI_MakeBox builder(dx, dy, dz);
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+	shape = builder.Solid().Moved(trsf);
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangularPyramid* l, TopoDS_Shape& shape) {
+	const double dx = l->XLength() * getValue(GV_LENGTH_UNIT);
+	const double dy = l->YLength() * getValue(GV_LENGTH_UNIT);
+	const double dz = l->Height() * getValue(GV_LENGTH_UNIT);
+	
+	BRepPrimAPI_MakeWedge builder(dx, dz, dy, dx / 2., dy / 2., dx / 2., dy / 2.);
+	
+	gp_Trsf trsf1, trsf2;
+	trsf2.SetValues(
+		1, 0, 0, 0,
+		0, 0, 1, 0,
+		0, 1, 0, 0
+#if OCC_VERSION_HEX < 0x60800
+		, Precision::Angular(), Precision::Confusion()
+#endif			
+	);
+	
+	IfcGeom::Kernel::convert(l->Position(), trsf1);
+	shape = BRepBuilderAPI_Transform(builder.Solid(), trsf1 * trsf2);
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRightCircularCylinder* l, TopoDS_Shape& shape) {
+	const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
+	const double h = l->Height() * getValue(GV_LENGTH_UNIT);
+
+	BRepPrimAPI_MakeCylinder builder(r, h);
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+	shape = builder.Solid().Moved(trsf);
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRightCircularCone* l, TopoDS_Shape& shape) {
+	const double r = l->BottomRadius() * getValue(GV_LENGTH_UNIT);
+	const double h = l->Height() * getValue(GV_LENGTH_UNIT);
+
+	BRepPrimAPI_MakeCone builder(r, 0., h);
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+	shape = builder.Solid().Moved(trsf);
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSphere* l, TopoDS_Shape& shape) {
+	const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
+	
+	BRepPrimAPI_MakeSphere builder(r);
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+	shape = builder.Solid().Moved(trsf);
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCsgSolid* l, TopoDS_Shape& shape) {
+	return convert_shape(l->TreeRootExpression(), shape);
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCurveBoundedPlane* l, TopoDS_Shape& face) {
+	gp_Pln pln;
+	IfcGeom::Kernel::convert(l->BasisSurface(), pln);
+
+	gp_Trsf trsf;
+	trsf.SetTransformation(pln.Position());
+	
+	TopoDS_Wire outer;
+	convert_wire(l->OuterBoundary(), outer);
+	
+	BRepBuilderAPI_MakeFace mf (outer);
+	mf.Add(outer);
+
+	IfcSchema::IfcCurve::list::ptr inner = l->InnerBoundaries();
+
+	for (IfcSchema::IfcCurve::list::it it = inner->begin(); it != inner->end(); ++it) {
+		TopoDS_Wire inner;
+		convert_wire(*it, inner);
+		
+		mf.Add(inner);
+	}
+
+	ShapeFix_Shape sfs(mf.Face());
+	sfs.Perform();
+	face = TopoDS::Face(sfs.Shape()).Moved(trsf);
+	
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangularTrimmedSurface* l, TopoDS_Shape& face) {
+	if (!l->BasisSurface()->is(IfcSchema::Type::IfcPlane)) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported BasisSurface:", l->BasisSurface()->entity);
+		return false;
+	}
+	gp_Pln pln;
+	IfcGeom::Kernel::convert((IfcSchema::IfcPlane*) l->BasisSurface(), pln);
+
+	BRepBuilderAPI_MakeFace mf(pln, l->U1(), l->U2(), l->V1(), l->V2());
+
+	face = mf.Face();
+
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceCurveSweptAreaSolid* l, TopoDS_Shape& shape) {
+	gp_Trsf directrix, position;
+	TopoDS_Shape face;
+	TopoDS_Wire wire, section;
+
+	if (!l->ReferenceSurface()->is(IfcSchema::Type::IfcPlane)) {
+		Logger::Message(Logger::LOG_WARNING, "Reference surface not supported", l->ReferenceSurface()->entity);
+		return false;
+	}
+	
+	if (!IfcGeom::Kernel::convert(l->Position(), position)   || 
+		!convert_face(l->SweptArea(), face) || 
+		!convert_wire(l->Directrix(), wire)    ) {
+		return false;
+	}
+
+	gp_Pln pln;
+	gp_Pnt directrix_origin;
+	gp_Vec directrix_tangent;
+	bool directrix_on_plane = true;
+	IfcGeom::Kernel::convert((IfcSchema::IfcPlane*) l->ReferenceSurface(), pln);
+
+	// As per Informal propositions 2: The Directrix shall lie on the ReferenceSurface.
+	// This is not always the case with the test files in the repository. I am not sure
+	// how to deal with this and whether my interpretation of the propositions is
+	// correct. However, if it has been asserted that the vertices of the directrix do
+	// not conform to the ReferenceSurface, the ReferenceSurface is ignored.
+	{ 
+		for (TopExp_Explorer exp(wire, TopAbs_VERTEX); exp.More(); exp.Next()) {
+			if (pln.Distance(BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()))) > ALMOST_ZERO) {
+				directrix_on_plane = false;
+				Logger::Message(Logger::LOG_WARNING, "The Directrix does not lie on the ReferenceSurface", l->entity);
+				break;
+			}
+		}
+	}
+
+	{ 
+		TopExp_Explorer exp(wire, TopAbs_EDGE);
+		TopoDS_Edge edge = TopoDS::Edge(exp.Current());
+		double u0, u1;
+		Handle(Geom_Curve) crv = BRep_Tool::Curve(edge, u0, u1);
+		crv->D1(u0, directrix_origin, directrix_tangent);
+	}
+
+	if (pln.Axis().Direction().IsNormal(directrix_tangent, Precision::Approximation()) && directrix_on_plane) {
+		directrix.SetTransformation(gp_Ax3(directrix_origin, directrix_tangent, pln.Axis().Direction()), gp::XOY());
+	} else {
+		directrix.SetTransformation(gp_Ax3(directrix_origin, directrix_tangent), gp::XOY());
+	}
+	face = BRepBuilderAPI_Transform(face, directrix);
+
+	// NB: Note that StartParam and EndParam param are ignored and the assumption is
+	// made that the parametric range over which to be swept matches the IfcCurve in
+	// its entirety.
+	BRepOffsetAPI_MakePipeShell builder(wire);
+
+	{ TopExp_Explorer exp(face, TopAbs_WIRE);
+	section = TopoDS::Wire(exp.Current()); }
+
+	builder.Add(section);
+	builder.SetTransitionMode(BRepBuilderAPI_RightCorner);
+	if (directrix_on_plane) {
+		builder.SetMode(pln.Axis().Direction());
+	}
+	builder.Build();
+	builder.MakeSolid();
+	shape = builder.Shape();
+	shape.Move(position);
+
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSweptDiskSolid* l, TopoDS_Shape& shape) {
+	TopoDS_Wire wire, section1, section2;
+
+	bool hasInnerRadius = l->InnerRadius() ? true : false;
+
+	if (!convert_wire(l->Directrix(), wire)) {
+		return false;
+	}
+	
+	gp_Ax2 directrix;
+	{
+		gp_Pnt directrix_origin;
+		gp_Vec directrix_tangent;
+		TopExp_Explorer exp(wire, TopAbs_EDGE);
+		TopoDS_Edge edge = TopoDS::Edge(exp.Current());
+		double u0, u1;
+		Handle(Geom_Curve) crv = BRep_Tool::Curve(edge, u0, u1);
+		crv->D1(u0, directrix_origin, directrix_tangent);
+		directrix = gp_Ax2(directrix_origin, directrix_tangent);
+	}
+
+	const double r1 = l->Radius() * getValue(GV_LENGTH_UNIT);
+	Handle(Geom_Circle) circle = new Geom_Circle(directrix, r1);
+	section1 = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(circle));
+
+	if (hasInnerRadius) {
+		const double r2 = (*l->InnerRadius()) * getValue(GV_LENGTH_UNIT);
+		if (r2 < getValue(GV_PRECISION)) {
+			// Subtraction of pipes with small radii is unstable.
+			hasInnerRadius = false;
+		} else {
+			Handle(Geom_Circle) circle = new Geom_Circle(directrix, r2);
+			section2 = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(circle));
+		}
+	}
+
+	// NB: Note that StartParam and EndParam param are ignored and the assumption is
+	// made that the parametric range over which to be swept matches the IfcCurve in
+	// its entirety.
+	// NB2: Contrary to IfcSurfaceCurveSweptAreaSolid the transition mode has been
+	// set to create round corners as this has proven to work better with the types
+	// of directrices encountered, which do not necessarily conform to a surface.
+	{ BRepOffsetAPI_MakePipeShell builder(wire);
+	builder.Add(section1);
+	builder.SetTransitionMode(BRepBuilderAPI_RoundCorner);
+	builder.Build();
+	builder.MakeSolid();
+	shape = builder.Shape(); }
+
+	if (hasInnerRadius) {
+		BRepOffsetAPI_MakePipeShell builder(wire);
+		builder.Add(section2);
+		builder.SetTransitionMode(BRepBuilderAPI_RoundCorner);
+		builder.Build();
+		builder.MakeSolid();
+		TopoDS_Shape inner = builder.Shape();
+
+		BRepAlgoAPI_Cut brep_cut(shape, inner);
+		bool is_valid = false;
+		if (brep_cut.IsDone()) {
+			TopoDS_Shape result = brep_cut;
+
+			ShapeFix_Shape fix(result);
+			fix.Perform();
+			result = fix.Shape();
+		
+			is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
+			if (is_valid) {
+				shape = result;
+			}
+		}
+
+		if (!is_valid) {
+			Logger::Message(Logger::LOG_WARNING, "Failed to subtract inner radius void for:", l->entity);
+		}
+	}
+
+	return true;
+}
+
+#ifdef USE_IFC4
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCylindricalSurface* l, TopoDS_Shape& face) {
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+	
+	face = BRepBuilderAPI_MakeFace(new Geom_CylindricalSurface(gp::XOY(), l->Radius()), getValue(GV_PRECISION)).Face().Moved(trsf);
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcAdvancedBrep* l, TopoDS_Shape& shape) {
+	return convert(l->Outer(), shape);
+}
+
+#endif
@@ -0,0 +1,437 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * Implementations of the various conversion functions defined in IfcRegister.h *
+ *                                                                              *
+ ********************************************************************************/
+
+#define _USE_MATH_DEFINES
+#include <cmath>
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Vec2d.hxx>
+#include <gp_Dir2d.hxx>
+#include <gp_Mat.hxx>
+#include <gp_Mat2d.hxx>
+#include <gp_GTrsf.hxx>
+#include <gp_GTrsf2d.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Ax2d.hxx>
+#include <gp_Pln.hxx>
+#include <gp_Circ.hxx>
+
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_Array1OfInteger.hxx>
+
+#include <Geom_Line.hxx>
+#include <Geom_Circle.hxx>
+#include <Geom_Ellipse.hxx>
+#include <Geom_TrimmedCurve.hxx>
+
+#include <BRepBuilderAPI_MakeVertex.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <BRepBuilderAPI_MakeShell.hxx>
+#include <BRepBuilderAPI_MakeSolid.hxx>
+#include <BRepBuilderAPI_MakePolygon.hxx>
+#include <BRepBuilderAPI_MakeVertex.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopLoc_Location.hxx>
+#include <TopTools_ListOfShape.hxx>
+
+#include <BRepAlgoAPI_Cut.hxx>
+#include <BRepOffsetAPI_Sewing.hxx>
+#include <BRepPrimAPI_MakePrism.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+#include <BRepFilletAPI_MakeFillet2d.hxx>
+
+#include <BRep_Tool.hxx>
+
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <ShapeFix_Solid.hxx>
+
+#include "../ifcgeom/IfcGeom.h"
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire& wire) {
+	if ( getValue(GV_PLANEANGLE_UNIT)<0 ) {
+		Logger::Message(Logger::LOG_WARNING,"Creating a composite curve without unit information:",l->entity);
+
+		// Temporarily pretend we do have unit information
+		setValue(GV_PLANEANGLE_UNIT,1.0);
+		
+		bool succes_radians = false;
+        bool succes_degrees = false;
+        bool use_radians = false;
+        bool use_degrees = false;
+
+		// First try radians
+		TopoDS_Wire wire_radians, wire_degrees;
+        try {
+		    succes_radians = IfcGeom::Kernel::convert(l,wire_radians);
+        } catch (...) {}
+
+		// Now try degrees
+		setValue(GV_PLANEANGLE_UNIT,0.0174532925199433);
+        try {
+		    succes_degrees = IfcGeom::Kernel::convert(l,wire_degrees);
+        } catch (...) {}
+
+		// Restore to unknown unit state
+		setValue(GV_PLANEANGLE_UNIT,-1.0);
+
+		if ( succes_degrees && ! succes_radians ) {
+			use_degrees = true;
+		} else if ( succes_radians && ! succes_degrees ) {
+			use_radians = true;
+		} else if ( succes_radians && succes_degrees ) {
+			if ( wire_degrees.Closed() && ! wire_radians.Closed() ) {
+				use_degrees = true;
+			} else if ( wire_radians.Closed() && ! wire_degrees.Closed() ) {
+				use_radians = true;
+			} else {
+				// No heuristic left to prefer the one over the other,
+				// apparently both variants are equally succesful.
+				// The curve might be composed of only straight segments.
+				// Let's go with the wire created using radians as that
+				// at least is a SI unit.
+				use_radians = true;
+			}
+		}
+
+		if ( use_radians ) {
+			Logger::Message(Logger::LOG_NOTICE,"Used radians to create composite curve");
+            wire = wire_radians;
+		} else if ( use_degrees ) {
+			Logger::Message(Logger::LOG_NOTICE,"Used degrees to create composite curve");
+            wire = wire_degrees;
+		}
+
+		return use_radians || use_degrees;
+	}
+	IfcSchema::IfcCompositeCurveSegment::list::ptr segments = l->Segments();
+	BRepBuilderAPI_MakeWire w;
+	//TopoDS_Vertex last_vertex;
+	for( IfcSchema::IfcCompositeCurveSegment::list::it it = segments->begin(); it != segments->end(); ++ it ) {
+		IfcSchema::IfcCurve* curve = (*it)->ParentCurve();
+		TopoDS_Wire wire2;
+		if ( !convert_wire(curve,wire2) ) {
+			Logger::Message(Logger::LOG_ERROR,"Failed to convert curve:",curve->entity);
+			continue;
+		}
+		if ( ! (*it)->SameSense() ) wire2.Reverse();
+		ShapeFix_ShapeTolerance FTol;
+		FTol.SetTolerance(wire2, getValue(GV_WIRE_CREATION_TOLERANCE), TopAbs_WIRE);
+		/*if ( it != segments->begin() ) {
+			TopExp_Explorer exp (wire2,TopAbs_VERTEX);
+			const TopoDS_Vertex& first_vertex = TopoDS::Vertex(exp.Current());
+			gp_Pnt first = BRep_Tool::Pnt(first_vertex);
+			gp_Pnt last = BRep_Tool::Pnt(last_vertex);
+			Standard_Real distance = first.Distance(last);
+			if ( distance > ALMOST_ZERO ) {
+				w.Add( BRepBuilderAPI_MakeEdge( last_vertex, first_vertex ) );
+			}
+		}*/
+		w.Add(wire2);
+		//last_vertex = w.Vertex();
+		if ( w.Error() != BRepBuilderAPI_WireDone ) {
+			Logger::Message(Logger::LOG_ERROR,"Failed to join curve segments:",l->entity);
+			return false;
+		}
+	}
+	wire = w.Wire();
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire& wire) {
+	IfcSchema::IfcCurve* basis_curve = l->BasisCurve();
+	bool isConic = basis_curve->is(IfcSchema::Type::IfcConic);
+	double parameterFactor = isConic ? getValue(GV_PLANEANGLE_UNIT) : getValue(GV_LENGTH_UNIT);
+	Handle(Geom_Curve) curve;
+	if ( !convert_curve(basis_curve,curve) ) return false;
+	bool trim_cartesian = l->MasterRepresentation() == IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN;
+	IfcEntityList::ptr trims1 = l->Trim1();
+	IfcEntityList::ptr trims2 = l->Trim2();
+	bool trimmed1 = false;
+	bool trimmed2 = false;
+	unsigned sense_agreement = l->SenseAgreement() ? 0 : 1;
+	double flts[2];
+	gp_Pnt pnts[2];
+	bool has_flts[2] = {false,false};
+	bool has_pnts[2] = {false,false};
+	BRepBuilderAPI_MakeWire w;
+	for ( IfcEntityList::it it = trims1->begin(); it != trims1->end(); it ++ ) {
+		IfcUtil::IfcBaseClass* i = *it;
+		if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) {
+			IfcGeom::Kernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[sense_agreement] );
+			has_pnts[sense_agreement] = true;
+		} else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
+			const double value = *((IfcSchema::IfcParameterValue*)i);
+			flts[sense_agreement] = value * parameterFactor;
+			has_flts[sense_agreement] = true;
+		}
+	}
+	for ( IfcEntityList::it it = trims2->begin(); it != trims2->end(); it ++ ) {
+		IfcUtil::IfcBaseClass* i = *it;
+		if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) {
+			IfcGeom::Kernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[1-sense_agreement] );
+			has_pnts[1-sense_agreement] = true;
+		} else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
+			const double value = *((IfcSchema::IfcParameterValue*)i);
+			flts[1-sense_agreement] = value * parameterFactor;
+			has_flts[1-sense_agreement] = true;
+		}
+	}
+	trim_cartesian &= has_pnts[0] && has_pnts[1];
+	bool trim_cartesian_failed = !trim_cartesian;
+	if ( trim_cartesian ) {
+		if ( pnts[0].Distance(pnts[1]) < getValue(GV_WIRE_CREATION_TOLERANCE) ) {
+			Logger::Message(Logger::LOG_WARNING,"Skipping segment with length below tolerance level:",l->entity);
+			return false;
+		}
+		ShapeFix_ShapeTolerance FTol;
+		TopoDS_Vertex v1 = BRepBuilderAPI_MakeVertex(pnts[0]);
+		TopoDS_Vertex v2 = BRepBuilderAPI_MakeVertex(pnts[1]);
+		FTol.SetTolerance(v1, getValue(GV_WIRE_CREATION_TOLERANCE), TopAbs_VERTEX);
+		FTol.SetTolerance(v2, getValue(GV_WIRE_CREATION_TOLERANCE), TopAbs_VERTEX);
+		BRepBuilderAPI_MakeEdge e (curve,v1,v2);
+		if ( ! e.IsDone() ) {
+			BRepBuilderAPI_EdgeError err = e.Error();
+			if ( err == BRepBuilderAPI_PointProjectionFailed ) {
+				Logger::Message(Logger::LOG_WARNING,"Point projection failed for:",l->entity);
+				trim_cartesian_failed = true;
+			}
+		} else {
+			w.Add(e.Edge());
+		}
+	}
+	if ( (!trim_cartesian || trim_cartesian_failed) && (has_flts[0] && has_flts[1]) ) {
+		// The Geom_Line is constructed from a gp_Pnt and gp_Dir, whereas the IfcLine
+		// is defined by an IfcCartesianPoint and an IfcVector with Magnitude. Because
+		// the vector is normalised when passed to Geom_Line constructor the magnitude
+		// needs to be factored in with the IfcParameterValue here.
+		if ( basis_curve->is(IfcSchema::Type::IfcLine) ) {
+			IfcSchema::IfcLine* line = static_cast<IfcSchema::IfcLine*>(basis_curve);
+			const double magnitude = line->Dir()->Magnitude();
+			flts[0] *= magnitude; flts[1] *= magnitude;
+		}
+		if ( basis_curve->is(IfcSchema::Type::IfcEllipse) ) {
+			IfcSchema::IfcEllipse* ellipse = static_cast<IfcSchema::IfcEllipse*>(basis_curve);
+			double x = ellipse->SemiAxis1() * getValue(GV_LENGTH_UNIT);
+			double y = ellipse->SemiAxis2() * getValue(GV_LENGTH_UNIT);
+			const bool rotated = y > x;
+			if (rotated) {
+				flts[0] -= M_PI / 2.;
+				flts[1] -= M_PI / 2.;
+			}
+		}
+		if ( isConic && ALMOST_THE_SAME(fmod(flts[1]-flts[0],(double)(M_PI*2.0)),0.0f) ) {
+			w.Add(BRepBuilderAPI_MakeEdge(curve));
+		} else {
+			BRepBuilderAPI_MakeEdge e (curve,flts[0],flts[1]);
+			w.Add(e.Edge());
+		}			
+	} else if ( trim_cartesian_failed && (has_pnts[0] && has_pnts[1]) ) {
+		w.Add(BRepBuilderAPI_MakeEdge(pnts[0],pnts[1]));
+	}
+	if ( w.IsDone() ) {
+		wire = w.Wire();
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyline* l, TopoDS_Wire& result) {
+	IfcSchema::IfcCartesianPoint::list::ptr points = l->Points();
+
+	// Parse and store the points in a sequence
+	TColgp_SequenceOfPnt polygon;
+	for(IfcSchema::IfcCartesianPoint::list::it it = points->begin(); it != points->end(); ++ it) {
+		gp_Pnt pnt;
+		IfcGeom::Kernel::convert(*it, pnt);
+		polygon.Append(pnt);
+	}
+
+	// Remove points that are too close to one another
+	remove_redundant_points_from_loop(polygon, false);
+	
+	BRepBuilderAPI_MakePolygon w;
+	for (int i = 1; i <= polygon.Length(); ++i) {
+		w.Add(polygon.Value(i));
+	}
+
+	result = w.Wire();
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyLoop* l, TopoDS_Wire& result) {
+	IfcSchema::IfcCartesianPoint::list::ptr points = l->Polygon();
+
+	// Parse and store the points in a sequence
+	TColgp_SequenceOfPnt polygon;
+	for(IfcSchema::IfcCartesianPoint::list::it it = points->begin(); it != points->end(); ++ it) {
+		gp_Pnt pnt;
+		IfcGeom::Kernel::convert(*it, pnt);
+		polygon.Append(pnt);
+	}
+
+	// A loop should consist of at least three vertices
+	int original_count = polygon.Length();
+	if (original_count < 3) {
+		Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l->entity);
+		return false;
+	}
+
+	// Remove points that are too close to one another
+	remove_redundant_points_from_loop(polygon, true);
+
+	int count = polygon.Length();
+	if (original_count - count != 0) {
+		std::stringstream ss; ss << (original_count - count) << " edges removed for:"; 
+		Logger::Message(Logger::LOG_WARNING, ss.str(), l->entity);
+	}
+
+	if (count < 3) {
+		Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l->entity);
+		return false;
+	}
+
+	BRepBuilderAPI_MakePolygon w;
+	for (int i = 1; i <= polygon.Length(); ++i) {
+		w.Add(polygon.Value(i));
+	}
+	w.Close();
+
+	result = w.Wire();	
+	return true;
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcArbitraryOpenProfileDef* l, TopoDS_Wire& result) {
+	return convert_wire(l->Curve(), result);
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeCurve* l, TopoDS_Wire& result) {
+	IfcSchema::IfcPoint* pnt1 = ((IfcSchema::IfcVertexPoint*) l->EdgeStart())->VertexGeometry();
+	IfcSchema::IfcPoint* pnt2 = ((IfcSchema::IfcVertexPoint*) l->EdgeEnd())->VertexGeometry();
+	if (!pnt1->is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->is(IfcSchema::Type::IfcCartesianPoint)) {
+		Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l->entity);
+		return false;
+	}
+	
+	gp_Pnt p1, p2;
+	if (!IfcGeom::Kernel::convert(((IfcSchema::IfcCartesianPoint*)pnt1), p1) ||
+		!IfcGeom::Kernel::convert(((IfcSchema::IfcCartesianPoint*)pnt2), p2))
+	{
+		return false;
+	}
+	
+	BRepBuilderAPI_MakeWire mw;
+	Handle_Geom_Curve crv;
+
+	// The lack of a clear separation between topological and geometrical entities
+	// is starting to get problematic. If the underlying curve is bounded it is
+	// assumed that a topological wire can be crafted from it. After which an
+	// attempt is made to reconstruct it from the individual curves and the vertices
+	// of the IfcEdgeCurve.
+	const bool is_bounded = l->EdgeGeometry()->is(IfcSchema::Type::IfcBoundedCurve);
+
+	if (!is_bounded && convert_curve(l->EdgeGeometry(), crv)) {
+		mw.Add(BRepBuilderAPI_MakeEdge(crv, p1, p2));
+		result = mw;
+		return true;
+	} else if (is_bounded && convert_wire(l->EdgeGeometry(), result)) {
+		if (!l->SameSense()) std::swap(pnt1, pnt2);
+		TopExp_Explorer exp(result, TopAbs_EDGE);
+		bool first = true;
+		while (exp.More()) {
+			const TopoDS_Edge& ed = TopoDS::Edge(exp.Current());
+			Standard_Real u1, u2;
+			Handle(Geom_Curve) ecrv = BRep_Tool::Curve(ed, u1, u2);
+			exp.Next();
+			const bool last = !exp.More();
+			first = false;
+			if (first && last) {
+				mw.Add(BRepBuilderAPI_MakeEdge(ecrv, p1, p2));
+			} else if (first) {
+				gp_Pnt pu;
+				ecrv->D0(u2, pu);
+				mw.Add(BRepBuilderAPI_MakeEdge(ecrv, p1, pu));
+			} else if (last) {
+				gp_Pnt pu;
+				ecrv->D0(u1, pu);
+				mw.Add(BRepBuilderAPI_MakeEdge(ecrv, pu, p2));
+			} else {
+				mw.Add(BRepBuilderAPI_MakeEdge(ecrv, u1, u2));
+			}
+		}
+		result = mw;
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeLoop* l, TopoDS_Wire& result) {
+	IfcSchema::IfcOrientedEdge::list::ptr li = l->EdgeList();
+	BRepBuilderAPI_MakeWire mw;
+	for (IfcSchema::IfcOrientedEdge::list::it it = li->begin(); it != li->end(); ++it) {
+		IfcSchema::IfcOrientedEdge* e = *it;
+
+		IfcSchema::IfcPoint* pnt1 = ((IfcSchema::IfcVertexPoint*) e->EdgeStart())->VertexGeometry();
+		IfcSchema::IfcPoint* pnt2 = ((IfcSchema::IfcVertexPoint*) e->EdgeEnd())->VertexGeometry();
+		if (!pnt1->is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->is(IfcSchema::Type::IfcCartesianPoint)) {
+			Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l->entity);
+			return false;
+		}
+	
+		gp_Pnt p1, p2;
+		if (!IfcGeom::Kernel::convert(((IfcSchema::IfcCartesianPoint*)pnt1), p1) ||
+			!IfcGeom::Kernel::convert(((IfcSchema::IfcCartesianPoint*)pnt2), p2))
+		{
+			return false;
+		}
+
+		mw.Add(BRepBuilderAPI_MakeEdge(p1, p2));
+		continue;
+		
+		IfcSchema::IfcEdge* base = e->EdgeElement();
+		TopoDS_Wire w;
+		if (convert_wire(e->EdgeElement(), w)) {
+			if (!e->Orientation()) w.Reverse();
+			mw.Add(w);
+		}
+	}
+	result = mw;
+	return true;
+}
@@ -18,84 +18,34 @@
 ********************************************************************************/

 #include "IfcGeom.h"
-#include "IfcGeomShapeType.h"
-
-#define Kernel MAKE_TYPE_NAME(Kernel)

+using namespace IfcSchema;
 using namespace IfcUtil;

-bool IfcGeom::Kernel::convert_shapes(const IfcBaseClass* l, ConversionResults& r) {
-	if (shape_type(l) != ST_SHAPELIST) {
-		TopoDS_Shape shp;
-		if (convert_shape(l, shp)) {
-			r.push_back(IfcGeom::ConversionResult(l->data().id(), new OpenCascadeShape(shp), get_style(l->as<IfcSchema::IfcRepresentationItem>())));
-			return true;
-		}
-		return false;
-	}
-
+bool IfcGeom::Kernel::convert_shapes(const IfcBaseClass* l, IfcRepresentationShapeItems& r) {
 #include "IfcRegisterConvertShapes.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
 	return false;
 }

-IfcGeom::ShapeType IfcGeom::Kernel::shape_type(const IfcBaseClass* l) {
-#include "IfcRegisterShapeType.h"
-	return ST_OTHER;
+bool IfcGeom::Kernel::is_shape_collection(const IfcBaseClass* l) {
+#include "IfcRegisterIsShapeCollection.h"
+	return false;
 }

 bool IfcGeom::Kernel::convert_shape(const IfcBaseClass* l, TopoDS_Shape& r) {
-	const unsigned int id = l->data().id();
+	const unsigned int id = l->entity->id();
 	bool success = false;
 	bool processed = false;
-	bool ignored = false;
-
-#ifndef NO_CACHE
 	std::map<int,TopoDS_Shape>::const_iterator it = cache.Shape.find(id);
 	if ( it != cache.Shape.end() ) { r = it->second; return true; }
-#endif
-	const bool include_curves = getValue(GV_DIMENSIONALITY) != +1;
-	const bool include_solids_and_surfaces = getValue(GV_DIMENSIONALITY) != -1;
-
-	IfcGeom::ShapeType st = shape_type(l);
-	ignored = (!include_solids_and_surfaces && (st == ST_SHAPE || st == ST_FACE)) || (!include_curves && (st == ST_WIRE || st == ST_CURVE));
-	if (st == ST_SHAPELIST) {
-		processed = true;
-		ConversionResults items;
-		success = convert_shapes(l, items) && flatten_shape_list(items, r, false);
-	} else if (st == ST_SHAPE && include_solids_and_surfaces) {
 #include "IfcRegisterConvertShape.h"
-	} else if (st == ST_FACE && include_solids_and_surfaces) {
-		processed = true;
-		success = convert_face(l, r);
-	} else if (st == ST_WIRE && include_curves) {
-		processed = true;
-		TopoDS_Wire w;
-		success = convert_wire(l, w);
-		if (success) {
-			r = w;
-		}
-	} else if (st == ST_CURVE && include_curves) {
-		processed = true;
-		Handle(Geom_Curve) crv;
-		TopoDS_Wire w;
-		success = convert_curve(l, crv) && convert_curve_to_wire(crv, w);
-		if (success) {
-			r = w;
-		}
-	}
-
-	if ( processed && success ) { 
+	if ( processed ) { 
 		const double precision = getValue(GV_PRECISION);
 		apply_tolerance(r, precision);
-#ifndef NO_CACHE
 		cache.Shape[id] = r;
-#endif
-	} else if (!ignored) {
-		const char* const msg = processed
-			? "Failed to convert:"
-			: "No operation defined for:";
-		Logger::Message(Logger::LOG_ERROR, msg, l);
+	} else {
+		Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
 	}
 	return success;
 }
@@ -106,18 +56,18 @@ bool IfcGeom::Kernel::convert_wire(const IfcBaseClass* l, TopoDS_Wire& r) {
 	if (IfcGeom::Kernel::convert_curve(l, curve)) {
 		return IfcGeom::Kernel::convert_curve_to_wire(curve, r);
 	}
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
 	return false;
 }

 bool IfcGeom::Kernel::convert_face(const IfcBaseClass* l, TopoDS_Shape& r) {
 #include "IfcRegisterConvertFace.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
 	return false;
 }

 bool IfcGeom::Kernel::convert_curve(const IfcBaseClass* l, Handle(Geom_Curve)& r) {
 #include "IfcRegisterConvertCurve.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
 	return false;
 }
@@ -38,44 +38,26 @@
 #include <gp_Trsf.hxx>
 #include <gp_Trsf2d.hxx>

-#include "../../../ifcparse/IfcBaseClass.h"
-#include "../../../ifcparse/IfcParse.h"
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/IfcParse.h"

 SHAPES(IfcShellBasedSurfaceModel);
 SHAPES(IfcFaceBasedSurfaceModel);
-SHAPES(IfcRepresentation);
+SHAPES(IfcShapeRepresentation);
 SHAPES(IfcMappedItem);
-// IfcFacetedBrep included
-// IfcAdvancedBrep included
-// IfcFacetedBrepWithVoids included
-// IfcAdvancedBrepWithVoids included
-SHAPES(IfcManifoldSolidBrep);
+SHAPES(IfcFacetedBrep);
 SHAPES(IfcGeometricSet);

-#ifdef SCHEMA_HAS_IfcCylindricalSurface
+#ifdef USE_IFC4
 SHAPE(IfcCylindricalSurface);
-#endif
-#ifdef SCHEMA_HAS_IfcAdvancedBrep
 SHAPE(IfcAdvancedBrep);
 #endif
-// FIXME: Surfaces should have a shape type of their own
-#ifdef SCHEMA_HAS_IfcBSplineSurfaceWithKnots
-SHAPE(IfcBSplineSurfaceWithKnots);
-#endif
-#ifdef SCHEMA_HAS_IfcTriangulatedFaceSet
-SHAPE(IfcTriangulatedFaceSet);
-#endif
-#ifdef SCHEMA_HAS_IfcExtrudedAreaSolidTapered
-SHAPE(IfcExtrudedAreaSolidTapered);
-#endif
-SHAPE(IfcPlane);
 SHAPE(IfcExtrudedAreaSolid);
 SHAPE(IfcRevolvedAreaSolid);
 SHAPE(IfcConnectedFaceSet);
 SHAPE(IfcBooleanResult);
 SHAPE(IfcPolygonalBoundedHalfSpace);
 SHAPE(IfcHalfSpaceSolid);
-// FIXME: Surfaces should have a shape type of their own
 SHAPE(IfcSurfaceOfLinearExtrusion);
 SHAPE(IfcSurfaceOfRevolution);
 SHAPE(IfcBlock);
@@ -89,6 +71,9 @@ SHAPE(IfcRectangularTrimmedSurface);
 SHAPE(IfcSurfaceCurveSweptAreaSolid);
 SHAPE(IfcSweptDiskSolid);

+#ifdef USE_IFC4
+FACE(IfcAdvancedFace);
+#endif
 FACE(IfcArbitraryProfileDefWithVoids);
 FACE(IfcArbitraryClosedProfileDef);
 FACE(IfcRoundedRectangleProfileDef);
@@ -108,31 +93,19 @@ FACE(IfcEllipseProfileDef);
 FACE(IfcCenterLineProfileDef);
 FACE(IfcCompositeProfileDef);
 FACE(IfcDerivedProfileDef);
-// IfcFaceSurface included
-// IfcAdvancedFace included in case of IFC4
 FACE(IfcFace);

 WIRE(IfcEdgeCurve);
-WIRE(IfcSubedge);
-WIRE(IfcOrientedEdge);
-WIRE(IfcEdge);
 WIRE(IfcEdgeLoop);
 WIRE(IfcPolyline);
 WIRE(IfcPolyLoop);
 WIRE(IfcCompositeCurve);
 WIRE(IfcTrimmedCurve);
 WIRE(IfcArbitraryOpenProfileDef);
-#ifdef SCHEMA_HAS_IfcIndexedPolyCurve
-WIRE(IfcIndexedPolyCurve)
-#endif

 CURVE(IfcCircle);
 CURVE(IfcEllipse);
 CURVE(IfcLine);
-#ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
-// IfcRationalBSplineCurveWithKnots included
-CURVE(IfcBSplineCurveWithKnots);
-#endif

 CLASS(IfcCartesianPoint,gp_Pnt);
 CLASS(IfcDirection,gp_Dir);
@@ -1,6 +1,6 @@
 #include "IfcRegisterUndef.h"
 #define CURVE(T) \
-	if ( l->declaration().is(IfcSchema::T::Class()) ) return convert((IfcSchema::T*)l,r);
+	if ( l->is(T::Class()) ) return convert((T*)l,r);
 #include "IfcRegisterDef.h"

 #include "IfcRegister.h"
@@ -1,6 +1,6 @@
 #include "IfcRegisterUndef.h"
 #define FACE(T) \
-	if ( l->declaration().is(IfcSchema::T::Class()) ) return convert((IfcSchema::T*)l,r);
+	if ( l->is(T::Class()) ) return convert((T*)l,r);
 #include "IfcRegisterDef.h"

 #include "IfcRegister.h"
@@ -0,0 +1,17 @@
+#include "IfcRegisterUndef.h"
+#define SHAPE(T) \
+	if ( !processed && l->is(T::Class()) ) { \
+		processed = true; \
+		try { \
+			if ( convert((T*)l,r) ) { \
+				success = true; \
+			} \
+		} catch(...) {  } \
+		if ( !success) { \
+			Logger::Message(Logger::LOG_ERROR,"Failed to convert:",l->entity); \
+			return false; \
+		} \
+	}
+#include "IfcRegisterDef.h"
+
+#include "IfcRegister.h"
@@ -0,0 +1,12 @@
+#include "IfcRegisterUndef.h"
+#define SHAPES(T) \
+	if ( l->is(T::Class()) ) { \
+		try { \
+			return convert((T*)l,r); \
+		} catch (...) { } \
+		Logger::Message(Logger::LOG_ERROR,"Failed to convert:",l->entity); \
+		return false; \
+	}
+#include "IfcRegisterDef.h"
+
+#include "IfcRegister.h"
@@ -1,6 +1,6 @@
 #include "IfcRegisterUndef.h"
 #define WIRE(T) \
-	if ( l->declaration().is(IfcSchema::T::Class()) ) return convert((IfcSchema::T*)l,r);
+	if ( l->is(T::Class()) ) return convert((T*)l,r);
 #include "IfcRegisterDef.h"

 #include "IfcRegister.h"
@@ -1,6 +1,6 @@
 #include "IfcRegisterUndef.h"
 #define CLASS(T,V) bool convert(const IfcSchema::T* L, V& r);
-#define SHAPES(T) CLASS(T,ConversionResults)
+#define SHAPES(T) CLASS(T,IfcRepresentationShapeItems)
 #define SHAPE(T) CLASS(T,TopoDS_Shape)
 #define WIRE(T) CLASS(T,TopoDS_Wire)
 #define FACE(T) CLASS(T,TopoDS_Shape)
@@ -0,0 +1,6 @@
+#include "IfcRegisterUndef.h"
+#define SHAPES(T) \
+	if ( l->is(T::Class()) ) return true;
+#include "IfcRegisterDef.h"
+
+#include "IfcRegister.h"
@@ -1,4 +1,4 @@
-/********************************************************************************
+/********************************************************************************
 *                                                                              *
 * This file is part of IfcOpenShell.                                           *
 *                                                                              *
@@ -17,51 +17,36 @@
 *                                                                              *
 ********************************************************************************/

-#ifndef IFCCONVERT_UTIL_H
-#define IFCCONVERT_UTIL_H
+#ifndef IFCSHAPELIST_H
+#define IFCSHAPELIST_H

-#include <sstream>
-#include <vector>
+#include <gp_GTrsf.hxx>
+#include <TopoDS_Shape.hxx>

-#include <boost/shared_ptr.hpp>
+#include "../ifcgeom/IfcGeomRenderStyles.h"

-namespace util {
-	class string_buffer {
-	public:
-		class item {
-		public:
-			virtual std::string str() const = 0;
-			virtual ~item() {};
-		};
-		class string_item : public item {
-			std::string s;
-		public:
-			string_item(const std::string& s) : s(s) {}
-			void assign(const std::string& s) { this->s = s; }
-			const std::string& value() const { return s; }
-			std::string& value() { return s; }
-			std::string str() const { return s; }
-			virtual ~string_item() {};
-		};
-		class float_item : public item {
-			double d;
-		public:
-			float_item(const double& d) : d(d) {}
-			void assign(const double& d) { this->d = d; }
-			const double& value() const { return d; }
-			double& value() { return d; }
-			std::string str() const { std::stringstream ss; ss << d; return ss.str(); }
-			virtual ~float_item() {};
-		};
+namespace IfcGeom {	
+	class IfcRepresentationShapeItem {
 	private:
-		std::vector< boost::shared_ptr<item> > items;
-		void clear();
-		void assign(const std::vector< boost::shared_ptr<item> >& other);
+		gp_GTrsf placement;
+		TopoDS_Shape shape;
+		const SurfaceStyle* style;
 	public:
-		boost::shared_ptr<string_item> add(const std::string& s);
-		boost::shared_ptr<float_item> add(const double& d);
-		std::string str() const;
+		IfcRepresentationShapeItem(const gp_GTrsf& placement, const TopoDS_Shape& shape, const SurfaceStyle* style)
+			: placement(placement), shape(shape), style(style) {}
+		IfcRepresentationShapeItem(const gp_GTrsf& placement, const TopoDS_Shape& shape)
+			: placement(placement), shape(shape), style(0) {}
+		IfcRepresentationShapeItem(const TopoDS_Shape& shape, const SurfaceStyle* style)
+			: shape(shape), style(style) {}
+		IfcRepresentationShapeItem(const TopoDS_Shape& shape)
+			: shape(shape), style(0) {}
+		void append(const gp_GTrsf& trsf) { placement.Multiply(trsf); }
+		void prepend(const gp_GTrsf& trsf) { placement.PreMultiply(trsf); }
+		const TopoDS_Shape& Shape() const { return shape; }
+		const gp_GTrsf& Placement() const { return placement; }
+		bool hasStyle() const { return style != 0; }
+		const SurfaceStyle& Style() const { return *style; }
 	};
+	typedef std::vector<IfcRepresentationShapeItem> IfcRepresentationShapeItems;
 }
-
 #endif
@@ -1,552 +0,0 @@
-#include "AbstractKernel.h"
-
-#include "../../ifcgeom/schema_agnostic/IfcGeomElement.h"
-
-#define AbstractKernel MAKE_TYPE_NAME(AbstractKernel)
-
-void IfcGeom::AbstractKernel::set_conversion_placement_rel_to(const IfcParse::declaration* type) {
-	placement_rel_to = type;
-}
-
-void IfcGeom::AbstractKernel::setValue(GeomValue var, double value) {
-	switch (var) {
-	case GV_DEFLECTION_TOLERANCE:
-		deflection_tolerance = value;
-		break;
-	case GV_POINT_EQUALITY_TOLERANCE:
-		point_equality_tolerance = value;
-		break;
-	case GV_LENGTH_UNIT:
-		ifc_length_unit = value;
-		break;
-	case GV_PLANEANGLE_UNIT:
-		ifc_planeangle_unit = value;
-		break;
-	case GV_PRECISION:
-		modelling_precision = value;
-		break;
-	case GV_DIMENSIONALITY:
-		dimensionality = value;
-		break;
-	default:
-		assert(!"never reach here");
-	}
-}
-
-double IfcGeom::AbstractKernel::getValue(GeomValue var) const {
-	switch (var) {
-	case GV_DEFLECTION_TOLERANCE:
-		return deflection_tolerance;
-	case GV_MINIMAL_FACE_AREA:
-		// Considering a right-angled triangle, this about the smallest
-		// area you can obtain without the vertices being confused.
-		return modelling_precision * modelling_precision / 2.;
-	case GV_POINT_EQUALITY_TOLERANCE:
-		return point_equality_tolerance;
-	case GV_LENGTH_UNIT:
-		return ifc_length_unit;
-		break;
-	case GV_PLANEANGLE_UNIT:
-		return ifc_planeangle_unit;
-		break;
-	case GV_PRECISION:
-		return modelling_precision;
-		break;
-	case GV_DIMENSIONALITY:
-		return dimensionality;
-		break;
-	}
-	assert(!"never reach here");
-	return 0;
-}
-
-const IfcSchema::IfcMaterial* IfcGeom::AbstractKernel::get_single_material_association(const IfcSchema::IfcProduct* product) {
-	IfcSchema::IfcMaterial* single_material = 0;
-	IfcSchema::IfcRelAssociatesMaterial::list::ptr associated_materials = product->HasAssociations()->as<IfcSchema::IfcRelAssociatesMaterial>();
-	if (associated_materials->size() == 1) {
-		IfcSchema::IfcMaterialSelect* associated_material = (*associated_materials->begin())->RelatingMaterial();
-		single_material = associated_material->as<IfcSchema::IfcMaterial>();
-
-		// NB: Single-layer layersets are also considered, regardless of --enable-layerset-slicing, this
-		// in accordance with other viewers.
-		if (!single_material && associated_material->as<IfcSchema::IfcMaterialLayerSetUsage>()) {
-			IfcSchema::IfcMaterialLayerSet* layerset = associated_material->as<IfcSchema::IfcMaterialLayerSetUsage>()->ForLayerSet();
-			if (layerset->MaterialLayers()->size() == 1) {
-				IfcSchema::IfcMaterialLayer* layer = (*layerset->MaterialLayers()->begin());
-				if (layer->hasMaterial()) {
-					single_material = layer->Material();
-				}
-			}
-		}
-	}
-	return single_material;
-}
-
-IfcSchema::IfcRepresentation* IfcGeom::AbstractKernel::representation_mapped_to(const IfcSchema::IfcRepresentation* representation) {
-	IfcSchema::IfcRepresentation* representation_mapped_to = 0;
-	IfcSchema::IfcRepresentationItem::list::ptr items = representation->Items();
-	if (items->size() == 1) {
-		IfcSchema::IfcRepresentationItem* item = *items->begin();
-		if (item->declaration().is(IfcSchema::IfcMappedItem::Class())) {
-			if (item->StyledByItem()->size() == 0) {
-				IfcSchema::IfcMappedItem* mapped_item = item->as<IfcSchema::IfcMappedItem>();
-				if (is_identity_transform(mapped_item->MappingTarget())) {
-					IfcSchema::IfcRepresentationMap* map = mapped_item->MappingSource();
-					if (is_identity_transform(map->MappingOrigin())) {
-						representation_mapped_to = map->MappedRepresentation();
-					}
-				}
-			}
-		}
-	}
-	return representation_mapped_to;
-}
-
-IfcSchema::IfcProduct::list::ptr IfcGeom::AbstractKernel::products_represented_by(const IfcSchema::IfcRepresentation* representation) {
-	IfcSchema::IfcProduct::list::ptr products(new IfcSchema::IfcProduct::list);
-
-	IfcSchema::IfcProductRepresentation::list::ptr prodreps = representation->OfProductRepresentation();
-
-	for (IfcSchema::IfcProductRepresentation::list::it it = prodreps->begin(); it != prodreps->end(); ++it) {
-		// http://buildingsmart-tech.org/ifc/IFC2x3/TC1/html/ifcrepresentationresource/lexical/ifcproductrepresentation.htm
-		// IFC2x Edition 3 NOTE  Users should not instantiate the entity IfcProductRepresentation from IFC2x Edition 3 onwards. 
-		// It will be changed into an ABSTRACT supertype in future releases of IFC.
-
-		// IfcProductRepresentation also lacks the INVERSE relation to IfcProduct
-		// Let's find the IfcProducts that reference the IfcProductRepresentation anyway
-		products->push((*it)->data().getInverse((&IfcSchema::IfcProduct::Class()), -1)->as<IfcSchema::IfcProduct>());
-	}
-
-	IfcSchema::IfcRepresentationMap::list::ptr maps = representation->RepresentationMap();
-	if (maps->size() == 1) {
-		IfcSchema::IfcRepresentationMap* map = *maps->begin();
-		if (is_identity_transform(map->MappingOrigin())) {
-			IfcSchema::IfcMappedItem::list::ptr items = map->MapUsage();
-			for (IfcSchema::IfcMappedItem::list::it it = items->begin(); it != items->end(); ++it) {
-				IfcSchema::IfcMappedItem* item = *it;
-				if (item->StyledByItem()->size() != 0) continue;
-
-				if (!is_identity_transform(item->MappingTarget())) {
-					continue;
-				}
-
-				IfcSchema::IfcRepresentation::list::ptr reps = item->data().getInverse((&IfcSchema::IfcRepresentation::Class()), -1)->as<IfcSchema::IfcRepresentation>();
-				for (IfcSchema::IfcRepresentation::list::it jt = reps->begin(); jt != reps->end(); ++jt) {
-					IfcSchema::IfcRepresentation* rep = *jt;
-					if (rep->Items()->size() != 1) continue;
-					IfcSchema::IfcProductRepresentation::list::ptr prodreps_mapped = rep->OfProductRepresentation();
-					for (IfcSchema::IfcProductRepresentation::list::it kt = prodreps_mapped->begin(); kt != prodreps_mapped->end(); ++kt) {
-						IfcSchema::IfcProduct::list::ptr ps = (*kt)->data().getInverse((&IfcSchema::IfcProduct::Class()), -1)->as<IfcSchema::IfcProduct>();
-						products->push(ps);
-					}
-				}
-			}
-		}
-	}
-
-	return products;
-}
-
-namespace {
-	const IfcSchema::IfcRepresentationItem* find_item_carrying_style(const IfcSchema::IfcRepresentationItem* item) {
-		if (item->StyledByItem()->size()) {
-			return item;
-		}
-
-		while (item->declaration().is(IfcSchema::IfcBooleanClippingResult::Class())) {
-			// All instantiations of IfcBooleanOperand (type of FirstOperand) are subtypes of
-			// IfcGeometricRepresentationItem
-			item = (IfcSchema::IfcGeometricRepresentationItem*) ((IfcSchema::IfcBooleanClippingResult*) item)->FirstOperand();
-			if (item->StyledByItem()->size()) {
-				return item;
-			}
-		}
-
-		// TODO: Ideally this would be done for other entities (such as IfcCsgSolid) as well.
-		// But neither are these very prevalent, nor does the current IfcOpenShell style
-		// mechanism enable to conveniently style subshapes, which would be necessary for
-		// distinctly styled union operands.
-
-		return item;
-	}
-
-
-	template <typename T>
-	std::pair<IfcSchema::IfcSurfaceStyle*, T*> _get_surface_style(const IfcSchema::IfcStyledItem* si) {
-#ifdef SCHEMA_HAS_IfcStyleAssignmentSelect
-		IfcEntityList::ptr style_assignments = si->Styles();
-		for (IfcEntityList::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
-			if (!(*kt)->declaration().is(IfcSchema::IfcPresentationStyleAssignment::Class())) {
-				continue;
-			}
-			IfcSchema::IfcPresentationStyleAssignment* style_assignment = (IfcSchema::IfcPresentationStyleAssignment*) *kt;
-#else
-		IfcSchema::IfcPresentationStyleAssignment::list::ptr style_assignments = si->Styles();
-		for (IfcSchema::IfcPresentationStyleAssignment::list::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
-			IfcSchema::IfcPresentationStyleAssignment* style_assignment = *kt;
-#endif
-			IfcEntityList::ptr styles = style_assignment->Styles();
-			for (IfcEntityList::it lt = styles->begin(); lt != styles->end(); ++lt) {
-				IfcUtil::IfcBaseClass* style = *lt;
-				if (style->declaration().is(IfcSchema::IfcSurfaceStyle::Class())) {
-					IfcSchema::IfcSurfaceStyle* surface_style = (IfcSchema::IfcSurfaceStyle*) style;
-					if (surface_style->Side() != IfcSchema::IfcSurfaceSide::IfcSurfaceSide_NEGATIVE) {
-						IfcEntityList::ptr styles_elements = surface_style->Styles();
-						for (IfcEntityList::it mt = styles_elements->begin(); mt != styles_elements->end(); ++mt) {
-							if ((*mt)->declaration().is(T::Class())) {
-								return std::make_pair(surface_style, (T*)*mt);
-							}
-						}
-					}
-				}
-			}
-		}
-
-		return std::make_pair<IfcSchema::IfcSurfaceStyle*, T*>(0, 0);
-	}
-
-	template <typename T>
-	std::pair<IfcSchema::IfcSurfaceStyle*, T*> get_surface_style(const IfcSchema::IfcRepresentationItem* representation_item) {
-		// For certain representation items, most notably boolean operands,
-		// a style definition might reside on one of its operands.
-		representation_item = find_item_carrying_style(representation_item);
-
-		if (representation_item->as<IfcSchema::IfcStyledItem>()) {
-			return _get_surface_style<T>(representation_item->as<IfcSchema::IfcStyledItem>());
-		}
-		IfcSchema::IfcStyledItem::list::ptr styled_items = representation_item->StyledByItem();
-		if (styled_items->size()) {
-			// StyledByItem is a SET [0:1] OF IfcStyledItem, so we return after the first IfcStyledItem:
-			return _get_surface_style<T>(*styled_items->begin());
-		}
-		return std::make_pair<IfcSchema::IfcSurfaceStyle*, T*>(0, 0);
-	}
-
-	bool process_colour(IfcSchema::IfcColourRgb* colour, double* rgb) {
-		if (colour != 0) {
-			rgb[0] = colour->Red();
-			rgb[1] = colour->Green();
-			rgb[2] = colour->Blue();
-		}
-		return colour != 0;
-	}
-
-	bool process_colour(IfcSchema::IfcNormalisedRatioMeasure* factor, double* rgb) {
-		if (factor != 0) {
-			const double f = *factor;
-			rgb[0] = rgb[1] = rgb[2] = f;
-		}
-		return factor != 0;
-	}
-
-	bool process_colour(IfcSchema::IfcColourOrFactor* colour_or_factor, double* rgb) {
-		if (colour_or_factor == 0) {
-			return false;
-		} else if (colour_or_factor->declaration().is(IfcSchema::IfcColourRgb::Class())) {
-			return process_colour(static_cast<IfcSchema::IfcColourRgb*>(colour_or_factor), rgb);
-		} else if (colour_or_factor->declaration().is(IfcSchema::IfcNormalisedRatioMeasure::Class())) {
-			return process_colour(static_cast<IfcSchema::IfcNormalisedRatioMeasure*>(colour_or_factor), rgb);
-		} else {
-			return false;
-		}
-	}
-}
-
-const IfcGeom::SurfaceStyle* IfcGeom::AbstractKernel::get_style(const IfcSchema::IfcRepresentationItem* item) {
-	return internalize_surface_style(get_surface_style<IfcSchema::IfcSurfaceStyleShading>(item));
-}
-
-const IfcGeom::SurfaceStyle* IfcGeom::AbstractKernel::get_style(const IfcSchema::IfcMaterial* material) {
-	IfcSchema::IfcMaterialDefinitionRepresentation::list::ptr defs = material->HasRepresentation();
-	for (IfcSchema::IfcMaterialDefinitionRepresentation::list::it jt = defs->begin(); jt != defs->end(); ++jt) {
-		IfcSchema::IfcRepresentation::list::ptr reps = (*jt)->Representations();
-		IfcSchema::IfcStyledItem::list::ptr styles(new IfcSchema::IfcStyledItem::list);
-		for (IfcSchema::IfcRepresentation::list::it it = reps->begin(); it != reps->end(); ++it) {
-			styles->push((**it).Items()->as<IfcSchema::IfcStyledItem>());
-		}
-		for (IfcSchema::IfcStyledItem::list::it it = styles->begin(); it != styles->end(); ++it) {
-			const std::pair<IfcSchema::IfcSurfaceStyle*, IfcSchema::IfcSurfaceStyleShading*> ss = get_surface_style<IfcSchema::IfcSurfaceStyleShading>(*it);
-			if (ss.second) {
-				return internalize_surface_style(ss);
-			}
-		}
-	}
-	IfcGeom::SurfaceStyle material_style = IfcGeom::SurfaceStyle(material->data().id(), material->Name());
-	return &(style_cache[material->data().id()] = material_style);
-}
-
-const IfcGeom::SurfaceStyle* IfcGeom::AbstractKernel::internalize_surface_style(const std::pair<IfcUtil::IfcBaseClass*, IfcUtil::IfcBaseClass*>& shading_styles) {
-	if (shading_styles.second == 0) {
-		return 0;
-	}
-	int surface_style_id = shading_styles.first->data().id();
-	std::map<int, SurfaceStyle>::const_iterator it = style_cache.find(surface_style_id);
-	if (it != style_cache.end()) {
-		return &(it->second);
-	}
-	SurfaceStyle surface_style;
-
-	IfcSchema::IfcSurfaceStyle* style = shading_styles.first->as<IfcSchema::IfcSurfaceStyle>();
-	IfcSchema::IfcSurfaceStyleShading* shading = shading_styles.second->as<IfcSchema::IfcSurfaceStyleShading>();
-
-	if (style->hasName()) {
-		surface_style = SurfaceStyle(surface_style_id, style->Name());
-	} else {
-		surface_style = SurfaceStyle(surface_style_id);
-	}
-	double rgb[3];
-	if (process_colour(shading->SurfaceColour(), rgb)) {
-		surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]));
-	}
-	if (shading_styles.second->declaration().is(IfcSchema::IfcSurfaceStyleRendering::Class())) {
-		IfcSchema::IfcSurfaceStyleRendering* rendering_style = static_cast<IfcSchema::IfcSurfaceStyleRendering*>(shading_styles.second);
-		if (rendering_style->hasDiffuseColour() && process_colour(rendering_style->DiffuseColour(), rgb)) {
-			SurfaceStyle::ColorComponent diffuse = surface_style.Diffuse().get_value_or(SurfaceStyle::ColorComponent(1, 1, 1));
-			surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(diffuse.R() * rgb[0], diffuse.G() * rgb[1], diffuse.B() * rgb[2]));
-		}
-		if (rendering_style->hasDiffuseTransmissionColour()) {
-			// Not supported
-		}
-		if (rendering_style->hasReflectionColour()) {
-			// Not supported
-		}
-		if (rendering_style->hasSpecularColour() && process_colour(rendering_style->SpecularColour(), rgb)) {
-			surface_style.Specular().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]));
-		}
-		if (rendering_style->hasSpecularHighlight()) {
-			IfcSchema::IfcSpecularHighlightSelect* highlight = rendering_style->SpecularHighlight();
-			if (highlight->declaration().is(IfcSchema::IfcSpecularRoughness::Class())) {
-				double roughness = *((IfcSchema::IfcSpecularRoughness*)highlight);
-				if (roughness >= 1e-9) {
-					surface_style.Specularity().reset(1.0 / roughness);
-				}
-			} else if (highlight->declaration().is(IfcSchema::IfcSpecularExponent::Class())) {
-				surface_style.Specularity().reset(*((IfcSchema::IfcSpecularExponent*)highlight));
-			}
-		}
-		if (rendering_style->hasTransmissionColour()) {
-			// Not supported
-		}
-		if (rendering_style->hasTransparency()) {
-			const double d = rendering_style->Transparency();
-			surface_style.Transparency().reset(d);
-		}
-	}
-	return &(style_cache[surface_style_id] = surface_style);
-}
-
-
-template <typename P, typename PP>
-IfcGeom::NativeElement<P, PP>* IfcGeom::AbstractKernel::create_brep_for_representation_and_product(
-	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product) {
-	std::stringstream representation_id_builder;
-
-	representation_id_builder << representation->data().id();
-
-	IfcGeom::Representation::BRep* shape;
-	IfcGeom::ConversionResults shapes;
-
-	if (!convert_shapes(representation, shapes)) {
-		return 0;
-	}
-
-	if (settings.get(IteratorSettings::APPLY_LAYERSETS)) {
-		if (apply_layerset(product, shapes)) {
-
-			IfcSchema::IfcRelAssociates::list::ptr associations = product->HasAssociations();
-			for (IfcSchema::IfcRelAssociates::list::it it = associations->begin(); it != associations->end(); ++it) {
-				IfcSchema::IfcRelAssociatesMaterial* associates_material = (**it).as<IfcSchema::IfcRelAssociatesMaterial>();
-				if (associates_material) {
-					unsigned layerset_id = associates_material->RelatingMaterial()->data().id();
-					representation_id_builder << "-layerset-" << layerset_id;
-					break;
-				}
-			}
-
-		}
-	}
-
-	bool material_style_applied = false;
-
-	const IfcSchema::IfcMaterial* single_material = get_single_material_association(product);
-	if (single_material) {
-		const IfcGeom::SurfaceStyle* s = get_style(single_material);
-		for (IfcGeom::ConversionResults::iterator it = shapes.begin(); it != shapes.end(); ++it) {
-			if (!it->hasStyle() && s) {
-				it->setStyle(s);
-				material_style_applied = true;
-			}
-		}
-	} else {
-		bool some_items_without_style = false;
-		for (IfcGeom::ConversionResults::iterator it = shapes.begin(); it != shapes.end(); ++it) {
-			if (!it->hasStyle()) {
-				some_items_without_style = true;
-				break;
-			}
-		}
-		if (some_items_without_style) {
-			Logger::Warning("No material and surface styles for:", product);
-		}
-	}
-
-	if (material_style_applied) {
-		representation_id_builder << "-material-" << single_material->data().id();
-	}
-
-	int parent_id = -1;
-	try {
-		IfcUtil::IfcBaseEntity* parent_object = get_decomposing_entity(product);
-		if (parent_object && parent_object->as<IfcSchema::IfcObjectDefinition>()) {
-			parent_id = parent_object->data().id();
-		}
-	} catch (const std::exception& e) {
-		Logger::Error(e);
-	}
-
-	const std::string name = product->hasName() ? product->Name() : "";
-	const std::string guid = product->GlobalId();
-
-	ConversionResultPlacement* trsf = nullptr;
-	try {
-		convert_placement(product->ObjectPlacement(), trsf);
-	} catch (const std::exception& e) {
-		Logger::Error(e);
-	} catch (...) {
-		Logger::Error("Failed to construct placement");
-	}
-
-	// Does the IfcElement have any IfcOpenings?
-	// Note that openings for IfcOpeningElements are not processed
-	IfcSchema::IfcRelVoidsElement::list::ptr openings = find_openings(product)->as<IfcSchema::IfcRelVoidsElement>();
-
-	const std::string product_type = product->declaration().name();
-	ElementSettings element_settings(settings, getValue(GV_LENGTH_UNIT), product_type);
-
-	if (!settings.get(IfcGeom::IteratorSettings::DISABLE_OPENING_SUBTRACTIONS) && openings && openings->size()) {
-		representation_id_builder << "-openings";
-		for (IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++it) {
-			representation_id_builder << "-" << (*it)->data().id();
-		}
-
-		IfcGeom::ConversionResults opened_shapes;
-		bool caught_error = false;
-		try {
-			convert_openings(product, openings, shapes, trsf, opened_shapes);
-		} catch (const std::exception& e) {
-			Logger::Message(Logger::LOG_ERROR, std::string("Error processing openings for: ") + e.what() + ":", product);
-			caught_error = true;
-		} catch (...) {
-			Logger::Message(Logger::LOG_ERROR, "Error processing openings for:", product);
-		}
-
-		if (caught_error && opened_shapes.size() < shapes.size()) {
-			opened_shapes = shapes;
-		}
-
-		if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
-			for (IfcGeom::ConversionResults::iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++it) {
-				it->prepend(trsf);
-			}
-			trsf = nullptr;
-			representation_id_builder << "-world-coords";
-		}
-		shape = new IfcGeom::Representation::BRep(element_settings, representation_id_builder.str(), opened_shapes);
-	} else if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
-		for (IfcGeom::ConversionResults::iterator it = shapes.begin(); it != shapes.end(); ++it) {
-			it->prepend(trsf);
-		}
-		trsf = nullptr;
-		representation_id_builder << "-world-coords";
-		shape = new IfcGeom::Representation::BRep(element_settings, representation_id_builder.str(), shapes);
-	} else {
-		shape = new IfcGeom::Representation::BRep(element_settings, representation_id_builder.str(), shapes);
-	}
-
-	std::string context_string = "";
-	if (representation->hasRepresentationIdentifier()) {
-		context_string = representation->RepresentationIdentifier();
-	} else if (representation->ContextOfItems()->hasContextType()) {
-		context_string = representation->ContextOfItems()->ContextType();
-	}
-
-	auto elem = new NativeElement<P, PP>(
-		product->data().id(),
-		parent_id,
-		name,
-		product_type,
-		guid,
-		context_string,
-		trsf,
-		boost::shared_ptr<IfcGeom::Representation::BRep>(shape),
-		product
-	);
-
-	if (settings.get(IteratorSettings::VALIDATE_QUANTITIES)) {
-		validate_quantities(product, elem->geometry());
-	}
-
-	return elem;
-}
-
-template <typename P, typename PP>
-IfcGeom::NativeElement<P, PP>* IfcGeom::AbstractKernel::create_brep_for_processed_representation(
-	const IteratorSettings& /*settings*/, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product,
-	IfcGeom::NativeElement<P, PP>* brep) {
-	int parent_id = -1;
-	try {
-		IfcUtil::IfcBaseEntity* parent_object = get_decomposing_entity(product);
-		if (parent_object && parent_object->as<IfcSchema::IfcObjectDefinition>()) {
-			parent_id = parent_object->data().id();
-		}
-	} catch (const std::exception& e) {
-		Logger::Error(e);
-	}
-
-	const std::string name = product->hasName() ? product->Name() : "";
-	const std::string guid = product->GlobalId();
-
-	ConversionResultPlacement* trsf = nullptr;
-	try {
-		convert_placement(product->ObjectPlacement(), trsf);
-	} catch (const std::exception& e) {
-		Logger::Error(e);
-	} catch (...) {
-		Logger::Error("Failed to construct placement");
-	}
-
-	std::string context_string = "";
-	if (representation->hasRepresentationIdentifier()) {
-		context_string = representation->RepresentationIdentifier();
-	} else if (representation->ContextOfItems()->hasContextType()) {
-		context_string = representation->ContextOfItems()->ContextType();
-	}
-
-	const std::string product_type = product->declaration().name();
-
-	return new NativeElement<P, PP>(
-		product->data().id(),
-		parent_id,
-		name,
-		product_type,
-		guid,
-		context_string,
-		trsf,
-		brep->geometry_pointer(),
-		product
-		);
-}
-
-template IFC_GEOM_API IfcGeom::NativeElement<float, float>* IfcGeom::AbstractKernel::create_brep_for_representation_and_product<float, float>(
-	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product);
-template IFC_GEOM_API IfcGeom::NativeElement<float, double>* IfcGeom::AbstractKernel::create_brep_for_representation_and_product<float, double>(
-	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product);
-template IFC_GEOM_API IfcGeom::NativeElement<double, double>* IfcGeom::AbstractKernel::create_brep_for_representation_and_product<double, double>(
-	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product);
-
-template IFC_GEOM_API IfcGeom::NativeElement<float, float>* IfcGeom::AbstractKernel::create_brep_for_processed_representation<float, float>(
-	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product, IfcGeom::NativeElement<float, float>* brep);
-template IFC_GEOM_API IfcGeom::NativeElement<float, double>* IfcGeom::AbstractKernel::create_brep_for_processed_representation<float, double>(
-	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product, IfcGeom::NativeElement<float, double>* brep);
-template IFC_GEOM_API IfcGeom::NativeElement<double, double>* IfcGeom::AbstractKernel::create_brep_for_processed_representation<double, double>(
-	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product, IfcGeom::NativeElement<double, double>* brep);
@@ -1,77 +0,0 @@
-#ifndef ABSTRACT_KERNEL_H
-#define ABSTRACT_KERNEL_H
-
-#include "../../ifcparse/macros.h"
-#include "../../ifcgeom/schema_agnostic/ifc_geom_api.h"
-#include "../../ifcgeom/schema_agnostic/Kernel.h"
-#include "../../ifcgeom/schema_agnostic/IfcGeomRepresentation.h"
-
-#define INCLUDE_SCHEMA(x) STRINGIFY(../../ifcparse/x.h)
-#include INCLUDE_SCHEMA(IfcSchema)
-#undef INCLUDE_SCHEMA
-#define INCLUDE_SCHEMA(x) STRINGIFY(../../ifcparse/x-definitions.h)
-#include INCLUDE_SCHEMA(IfcSchema)
-#undef INCLUDE_SCHEMA
-
-namespace IfcGeom {
-
-	class IFC_GEOM_API MAKE_TYPE_NAME(AbstractKernel) : public IfcGeom::Kernel {
-	protected:
-		// For stopping PlacementRelTo recursion in convert(const IfcSchema::IfcObjectPlacement* l, gp_Trsf& trsf)
-		const IfcParse::declaration* placement_rel_to;
-
-		double deflection_tolerance;
-		double wire_creation_tolerance;
-		double point_equality_tolerance;
-		double max_faces_to_sew;
-		double ifc_length_unit;
-		double ifc_planeangle_unit;
-		double modelling_precision;
-		double dimensionality;
-
-		std::map<int, SurfaceStyle> style_cache;
-
-	public:
-		MAKE_TYPE_NAME(AbstractKernel)(const std::string& geometry_library)
-			: IfcGeom::Kernel(geometry_library, nullptr)
-			, deflection_tolerance(0.001)
-			, wire_creation_tolerance(0.0001)
-			, point_equality_tolerance(0.00001)
-			, max_faces_to_sew(-1.0)
-			, ifc_length_unit(1.0)
-			, ifc_planeangle_unit(-1.0)
-			, modelling_precision(0.00001)
-			, dimensionality(1.)
-			, placement_rel_to(0) 
-		{}
-
-		void set_conversion_placement_rel_to(const IfcParse::declaration* type);
-		virtual void setValue(GeomValue var, double value);
-		virtual double getValue(GeomValue var) const;
-
-		const IfcSchema::IfcMaterial* get_single_material_association(const IfcSchema::IfcProduct*);
-		IfcSchema::IfcRepresentation* representation_mapped_to(const IfcSchema::IfcRepresentation* representation);
-		IfcSchema::IfcProduct::list::ptr products_represented_by(const IfcSchema::IfcRepresentation*);
-		const SurfaceStyle* get_style(const IfcSchema::IfcRepresentationItem*);
-		const SurfaceStyle* get_style(const IfcSchema::IfcMaterial*);
-
-		virtual bool is_identity_transform(const IfcUtil::IfcBaseClass*) = 0;
-		virtual bool convert_shapes(const IfcUtil::IfcBaseClass*, IfcGeom::ConversionResults&) = 0;
-		virtual bool apply_layerset(const IfcSchema::IfcProduct* product, IfcGeom::ConversionResults& shapes) = 0;
-		virtual bool validate_quantities(const IfcSchema::IfcProduct* product, const IfcGeom::Representation::BRep& brep) = 0;
-		virtual bool convert_openings(const IfcSchema::IfcProduct* product, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const IfcGeom::ConversionResults& shapes, const ConversionResultPlacement* trsf, IfcGeom::ConversionResults& opened_shapes) = 0;
-
-		const SurfaceStyle* internalize_surface_style(const std::pair<IfcUtil::IfcBaseClass*, IfcUtil::IfcBaseClass*>& shading_style);
-
-		template <typename P, typename PP>
-		IfcGeom::NativeElement<P, PP>* create_brep_for_representation_and_product(
-			const IteratorSettings&, IfcSchema::IfcRepresentation*, IfcSchema::IfcProduct*);
-
-		template <typename P, typename PP>
-		IfcGeom::NativeElement<P, PP>* create_brep_for_processed_representation(
-			const IteratorSettings&, IfcSchema::IfcRepresentation*, IfcSchema::IfcProduct*, IfcGeom::NativeElement<P, PP>*);
-	};
-
-}
-
-#endif
@@ -1,31 +0,0 @@
-#include "IfcGeomIteratorImplementation.h"
-
-namespace IfcGeom {
-	template class MAKE_TYPE_NAME(IteratorImplementation_)<float, float>;
-	template class MAKE_TYPE_NAME(IteratorImplementation_)<float, double>;
-	template class MAKE_TYPE_NAME(IteratorImplementation_)<double, double>;
-}
-
-#define MAKE_INIT_FN__(a, b) init_ ## a ## b
-#define MAKE_INIT_FN_(a, b) MAKE_INIT_FN__(a, b)
-#define MAKE_INIT_FN(t) MAKE_INIT_FN_(t, IfcSchema)
-
-namespace {
-	template <typename P, typename PP>
-	struct MAKE_TYPE_NAME(factory_t) {
-		IfcGeom::IteratorImplementation<P, PP>* operator()(const std::string& geometry_engine, const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters, int num_threads) const {
-			return new IfcGeom::MAKE_TYPE_NAME(IteratorImplementation_)<P, PP>(geometry_engine, settings, file, filters, num_threads);
-		}
-	};
-}
-
-template <typename P, typename PP>
-void MAKE_INIT_FN(IteratorImplementation_)(IteratorFactoryImplementation<P, PP>* mapping) {
-	static const std::string schema_name = STRINGIFY(IfcSchema);
-	MAKE_TYPE_NAME(factory_t)<P, PP> factory;
-	mapping->bind(schema_name, factory);
-}
-
-template void MAKE_INIT_FN(IteratorImplementation_)<float, float>(IteratorFactoryImplementation<float, float>*);
-template void MAKE_INIT_FN(IteratorImplementation_)<float, double>(IteratorFactoryImplementation<float, double>*);
-template void MAKE_INIT_FN(IteratorImplementation_)<double, double>(IteratorFactoryImplementation<double, double>*);
@@ -1,950 +0,0 @@
-/********************************************************************************
- *                                                                              *
- * This file is part of IfcOpenShell.                                           *
- *                                                                              *
- * IfcOpenShell is free software: you can redistribute it and/or modify         *
- * it under the terms of the Lesser GNU General Public License as published by  *
- * the Free Software Foundation, either version 3.0 of the License, or          *
- * (at your option) any later version.                                          *
- *                                                                              *
- * IfcOpenShell is distributed in the hope that it will be useful,              *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
- * Lesser GNU General Public License for more details.                          *
- *                                                                              *
- * You should have received a copy of the Lesser GNU General Public License     *
- * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * Geometrical data in an IFC file consists of shapes (IfcShapeRepresentation)  *
- * and instances (SUBTYPE OF IfcBuildingElement e.g. IfcWindow).                *
- *                                                                              *
- * IfcGeom::Representation::Triangulation is a class that represents a          *
- * triangulated IfcShapeRepresentation.                                         *
- *   Triangulation.verts is a 1 dimensional vector of float defining the        *
- *      cartesian coordinates of the vertices of the triangulated shape in the  *
- *      format of [x1,y1,z1,..,xn,yn,zn]                                        *
- *   Triangulation.faces is a 1 dimensional vector of int containing the        *
- *     indices of the triangles referencing positions in Triangulation.verts    *
- *   Triangulation.edges is a 1 dimensional vector of int in {0,1} that dictates*
- *	   the visibility of the edges that span the faces in Triangulation.faces   *
- *                                                                              *
- * IfcGeom::Element represents the actual IfcBuildingElements.                  *
- *   IfcGeomObject.name is the GUID of the element                              *
- *   IfcGeomObject.type is the datatype of the element e.g. IfcWindow           *
- *   IfcGeomObject.mesh is a pointer to an IfcMesh                              *
- *   IfcGeomObject.transformation.matrix is a 4x3 matrix that defines the       *
- *     orientation and translation of the mesh in relation to the world origin  *
- *                                                                              *
- * IfcGeom::Iterator::initialize()                                              *
- *   finds the most suitable representation contexts. Returns true iff          *
- *   at least a single representation will process successfully                 *
- *                                                                              *
- * IfcGeom::Iterator::get()                                                     *
- *   returns a pointer to the current IfcGeom::Element                          *
- *                                                                              * 
- * IfcGeom::Iterator::next()                                                    *
- *   returns true iff a following entity is available for a successive call to  *
- *   IfcGeom::Iterator::get()                                                   *
- *                                                                              *
- * IfcGeom::Iterator::progress()                                                *
- *   returns an int in [0..100] that indicates the overall progress             *
- *                                                                              *
- ********************************************************************************/
-
-#ifndef IFCGEOMITERATOR_H
-#define IFCGEOMITERATOR_H
-
-#include <map>
-#include <set>
-#include <vector>
-#include <limits>
-#include <algorithm>
-#include <atomic>
-
-#include <future>
-#include <thread>
-#include <chrono>
-
-#include <boost/algorithm/string.hpp>
-
-#include <gp_Mat.hxx>
-#include <gp_Mat2d.hxx>
-#include <gp_GTrsf.hxx>
-#include <gp_GTrsf2d.hxx>
-#include <gp_Trsf.hxx>
-#include <gp_Trsf2d.hxx>
-
-#include "../../ifcparse/macros.h"
-#include "../../ifcparse/IfcFile.h"
-
-#include "../../ifcgeom/schema_agnostic/IfcGeomElement.h"
-#include "../../ifcgeom/schema_agnostic/IfcGeomMaterial.h"
-#include "../../ifcgeom/schema_agnostic/IfcGeomIteratorSettings.h"
-#include "../../ifcgeom/schema_agnostic/ConversionResult.h"
-
-#include "../../ifcgeom/schema_agnostic/IfcGeomFilter.h"
-#include "../../ifcgeom/schema_agnostic/IteratorImplementation.h"
-
-#include "../../ifcgeom/kernel_agnostic/AbstractKernel.h"
-
-#define INCLUDE_SCHEMA(x) STRINGIFY(../../ifcparse/x.h)
-#include INCLUDE_SCHEMA(IfcSchema)
-#undef INCLUDE_SCHEMA
-
-#include <atomic>
-
-// The infamous min & max Win32 #defines can leak here from OCE depending on the build configuration
-#ifdef min
-#undef min
-#endif
-#ifdef max
-#undef max
-#endif
-
-namespace {
-	template <typename P, typename PP=P>
-	struct geometry_conversion_task {
-		int index;
-		IfcSchema::IfcRepresentation *representation;
-		IfcSchema::IfcProduct::list::ptr products;
-		std::vector<IfcGeom::NativeElement<P, PP>*> breps;
-		std::vector<IfcGeom::Element<P, PP>*> elements;
-	};
-
-	template <typename P, typename PP=P>
-	IfcGeom::Element<P, PP>* process_based_on_settings(
-		const IfcGeom::IteratorSettings& settings,
-		IfcGeom::NativeElement<P, PP>* elem, 
-		IfcGeom::TriangulationElement<P, PP>* previous=nullptr)
-	{
-		if (settings.get(IfcGeom::IteratorSettings::USE_BREP_DATA)) {
-			try {
-				return new IfcGeom::SerializedElement<P, PP>(*elem);
-			} catch (...) {
-				Logger::Message(Logger::LOG_ERROR, "Getting a serialized element from model failed.");
-				return nullptr;
-			}
-		} else if (!settings.get(IfcGeom::IteratorSettings::DISABLE_TRIANGULATION)) {
-			try {
-				if (!previous) {
-					return  new IfcGeom::TriangulationElement<P, PP>(*elem);
-				} else {
-					return  new IfcGeom::TriangulationElement<P, PP>(*elem, previous->geometry_pointer());
-				}
-			} catch (...) {
-				Logger::Message(Logger::LOG_ERROR, "Getting a triangulation element from model failed.");
-				return nullptr;
-			}
-		} else {
-			return elem;
-		}
-	}
-
-	template <typename P, typename PP = P>
-	void create_element(
-		IfcGeom::MAKE_TYPE_NAME(AbstractKernel)* kernel, 
-		const IfcGeom::IteratorSettings& settings,
-		geometry_conversion_task<P, PP>* rep) 
-	{
-		IfcSchema::IfcRepresentation *representation = rep->representation;
-		IfcSchema::IfcProduct *product = *rep->products->begin();
-		auto brep = kernel->create_brep_for_representation_and_product<P, PP>(settings, representation, product);
-		if (!brep) {
-			return;
-		}
-
-		auto elem = process_based_on_settings(settings, brep);
-		if (!elem) {
-			return;
-		}
-
-		rep->breps = { brep };
-		rep->elements = { elem };
-
-		for (auto it = rep->products->begin() + 1; it != rep->products->end(); ++it) {
-			auto brep2 = kernel->create_brep_for_processed_representation<P, PP>(settings, representation, *it, brep);
-			if (brep2) {
-				auto elem2 = process_based_on_settings(settings, brep, dynamic_cast<IfcGeom::TriangulationElement<P, PP>*>(elem));
-				if (elem2) {
-					rep->breps.push_back(brep2);
-					rep->elements.push_back(elem2);
-				}
-			}
-		}
-	}
-}
-
-namespace IfcGeom {
-	
-	template <typename P, typename PP>
-	class MAKE_TYPE_NAME(IteratorImplementation_) : public IteratorImplementation<P, PP> {
-	private:
-
-		int num_threads_;
-		std::atomic<int> progress_;
-		std::vector<geometry_conversion_task<P, PP>> tasks_;
-		std::vector<IfcGeom::Element<P, PP>*> all_processed_elements_;
-		std::vector<IfcGeom::NativeElement<P, PP>*> all_processed_native_elements_;
-		typename std::vector<IfcGeom::Element<P, PP>*>::const_iterator task_result_iterator_;
-		typename std::vector<IfcGeom::NativeElement<P, PP>*>::const_iterator native_task_result_iterator_;
-
-		std::string geometry_library_;
-
-		MAKE_TYPE_NAME(IteratorImplementation_)(const MAKE_TYPE_NAME(IteratorImplementation_)&); // N/I
-		MAKE_TYPE_NAME(IteratorImplementation_)& operator=(const MAKE_TYPE_NAME(IteratorImplementation_)&); // N/I
-
-		MAKE_TYPE_NAME(AbstractKernel)* kernel;
-		IteratorSettings settings;
-
-		IfcParse::IfcFile* ifc_file;
-
-		// A container and iterator for IfcRepresentations
-		IfcSchema::IfcRepresentation::list::ptr representations;
-		IfcSchema::IfcRepresentation::list::it representation_iterator;
-
-		// The object is fetched beforehand to be sure that get() returns a valid element
-		TriangulationElement<P, PP>* current_triangulation;
-		NativeElement<P, PP>* current_shape_model;
-		SerializedElement<P, PP>* current_serialization;
-		
-		// A container and iterator for IfcBuildingElements for the current IfcRepresentation referenced by *representation_iterator
-		IfcSchema::IfcProduct::list::ptr ifcproducts;
-		IfcSchema::IfcProduct::list::it ifcproduct_iterator;
-
-
-        IfcSchema::IfcRepresentation::list::ptr ok_mapped_representations;
-
-		int done;
-		int total;
-
-		std::string unit_name;
-		double unit_magnitude;
-
-        gp_XYZ bounds_min_;
-        gp_XYZ bounds_max_;
-
-        std::vector<filter_t> filters_;
-
-        struct filter_match
-        {
-            filter_match(IfcSchema::IfcProduct *prod) : product(prod) {}
-            bool operator()(const filter_t& filter) const { return filter(product);  }
-
-            IfcSchema::IfcProduct* product;
-        };
-
-        /// @todo public/private sections all over the place: move all public to the beginning of the class
-	public:
-		typedef P Precision;
-		typedef PP PlacementPrecision;
-
-		bool initialize() {
-
-			std::set<std::string> allowed_context_types;
-			allowed_context_types.insert("model");
-			allowed_context_types.insert("plan");
-			allowed_context_types.insert("notdefined");
-
-			std::set<std::string> context_types;
-            if (!settings.get(IteratorSettings::EXCLUDE_SOLIDS_AND_SURFACES)) {
-				// Really this should only be 'Model', as per 
-				// the standard 'Design' is deprecated. So,
-				// just for backwards compatibility:
-				context_types.insert("model");
-				context_types.insert("design");
-				// Some earlier (?) versions DDS-CAD output their own ContextTypes
-				context_types.insert("model view");
-				context_types.insert("detail view");
-			}
-            if (settings.get(IteratorSettings::INCLUDE_CURVES)) {
-				context_types.insert("plan");
-			}			
-
-			representations = IfcSchema::IfcRepresentation::list::ptr(new IfcSchema::IfcRepresentation::list);
-            ok_mapped_representations = IfcSchema::IfcRepresentation::list::ptr(new IfcSchema::IfcRepresentation::list);
-
-			IfcSchema::IfcGeometricRepresentationContext::list::it it;
-			IfcSchema::IfcGeometricRepresentationSubContext::list::it jt;
-			IfcSchema::IfcGeometricRepresentationContext::list::ptr contexts = 
-				ifc_file->instances_by_type<IfcSchema::IfcGeometricRepresentationContext>();
-
-			IfcSchema::IfcGeometricRepresentationContext::list::ptr filtered_contexts (new IfcSchema::IfcGeometricRepresentationContext::list);
-
- 			for (it = contexts->begin(); it != contexts->end(); ++it) {
-				IfcSchema::IfcGeometricRepresentationContext* context = *it;
-				if (context->declaration().is(IfcSchema::IfcGeometricRepresentationSubContext::Class())) {
-					// Continue, as the list of subcontexts will be considered
-					// by the parent's context inverse attributes.
-					continue;
-				}
-				try {
-					if (context->hasContextType()) {
-						std::string context_type = context->ContextType();
-						boost::to_lower(context_type);
-
-						if (allowed_context_types.find(context_type) == allowed_context_types.end()) {
-							Logger::Warning(std::string("ContextType '") + context->ContextType() + "' not allowed:", context);
-						}
-						if (context_types.find(context_type) != context_types.end()) {
-							filtered_contexts->push(context);
-						}
-					}
-				} catch (const std::exception& e) {
-					Logger::Error(e);
-				}
-			}
-
-			// In case no contexts are identified based on their ContextType, all contexts are
-			// considered. Note that sub contexts are excluded as they are considered later on.
-			if (filtered_contexts->size() == 0) {
-				for (it = contexts->begin(); it != contexts->end(); ++it) {
-					IfcSchema::IfcGeometricRepresentationContext* context = *it;
-					if (!context->declaration().is(IfcSchema::IfcGeometricRepresentationSubContext::Class())) {
-						filtered_contexts->push(context);
-					}
-				}
-			}
-
-			for (it = filtered_contexts->begin(); it != filtered_contexts->end(); ++it) {
-				IfcSchema::IfcGeometricRepresentationContext* context = *it;
-
-				representations->push(context->RepresentationsInContext());
-				
-				IfcSchema::IfcGeometricRepresentationSubContext::list::ptr sub_contexts = context->HasSubContexts();
-				for (jt = sub_contexts->begin(); jt != sub_contexts->end(); ++jt) {
-					representations->push((*jt)->RepresentationsInContext());
-				}
-				// There is no need for full recursion as the following is governed by the schema:
-				// WR31: The parent context shall not be another geometric representation sub context. 
-			}
-
-            if (representations->size() == 0) {
-                Logger::Warning("No representations encountered in relevant contexts, using all");
-				representations = ifc_file->instances_by_type<IfcSchema::IfcRepresentation>();
-            }
-
-			if (representations->size() == 0) {
-				Logger::Warning("No representations encountered, aborting");
-				return false;
-			}
-
-			representation_iterator = representations->begin();
-			ifcproducts.reset();
-
-			done = 0;
-			total = representations->size();
-
-			if (num_threads_ != 1) {
-				collect();
-				process_concurrently();
-			} else {
-				if (!create()) {
-					return false;
-				}
-			}
-			
-			return true;
-		}
-
-		void collect() {
-			int i = 0;
-			IfcSchema::IfcProduct::list* previous = nullptr;
-			while (auto rp = get_next_task()) {
-				// Note that get_next_task() mutates the state of the iterator
-				// we use that capture all products that can be processed as
-				// part of this representation and then keep iterating until
-				// the underlying list of products changes.
-				if (ifcproducts.get() != previous) {
-					previous = ifcproducts.get();
-					geometry_conversion_task<P, PP> t;
-					t.index = i++;
-					t.representation = *representation_iterator;
-					t.products = ifcproducts;
-					tasks_.emplace_back(t);
-				}
-
-				_nextShape();
-			}
-		}
-
-		void process_concurrently() {
-			size_t conc_threads = num_threads_;
-			if (conc_threads > tasks_.size()) {
-				conc_threads = tasks_.size();
-			}
-			
-			std::vector<MAKE_TYPE_NAME(AbstractKernel)*> kernel_pool;
-			kernel_pool.reserve(conc_threads);
-			for (unsigned i = 0; i < conc_threads; ++i) {
-				kernel_pool.push_back((MAKE_TYPE_NAME(AbstractKernel)*) impl::kernel_implementations().construct(ifc_file->schema()->name(), geometry_library_, ifc_file));
-			}
-
-			std::vector<std::future<void>> threadpool;
-
-			int old_progress = -1;
-			int processed = 0;
-
-			Logger::ProgressBar(0);
-
-			for (auto& rep : tasks_) {
-				MAKE_TYPE_NAME(AbstractKernel)* K = nullptr;
-				if (threadpool.size() < kernel_pool.size()) {
-					K = kernel_pool[threadpool.size()];
-				}
-
-				while (threadpool.size() == conc_threads) {
-					for (int i = 0; i < (int)threadpool.size(); i++) {
-						std::future<void> &fu = threadpool[i];
-						std::future_status status;
-						status = fu.wait_for(std::chrono::seconds(0));
-						if (status == std::future_status::ready) {
-							fu.get();
-							
-							processed += 1;
-							progress_ = processed * 50 / tasks_.size();
-							if (progress_ != old_progress) {
-								Logger::ProgressBar(progress_);
-								old_progress = progress_;
-							}
-								
-							std::swap(threadpool[i], threadpool.back());
-							threadpool.pop_back();
-							std::swap(kernel_pool[i], kernel_pool.back());
-							K = kernel_pool.back();
-							break;
-						} // if
-					}   // for
-				}     // while
-
-				std::future<void> fu = std::async(std::launch::async, create_element<P, PP>, K, std::ref(settings), &rep);
-				threadpool.emplace_back(std::move(fu));
-			}
-
-			for (std::future<void> &fu : threadpool) {
-				fu.get();
-
-				processed += 1;
-				progress_ = processed * 50 / tasks_.size();
-				if (progress_ != old_progress) {
-					Logger::ProgressBar(progress_);
-					old_progress = progress_;
-				}
-			}
-
-			for (auto& rep : tasks_) {
-				all_processed_elements_.insert(all_processed_elements_.end(), rep.elements.begin(), rep.elements.end());
-				all_processed_native_elements_.insert(all_processed_native_elements_.end(), rep.breps.begin(), rep.breps.end());
-			}
-
-			task_result_iterator_ = all_processed_elements_.begin();
-			native_task_result_iterator_ = all_processed_native_elements_.begin();
-
-			Logger::Status("\rDone creating geometry (" + boost::lexical_cast<std::string>(all_processed_elements_.size()) +
-				" objects)                                ");
-		}
-
-        /// Computes model's bounding box (bounds_min and bounds_max).
-        /// @note Can take several minutes for large files.
-        void compute_bounds()
-        {
-            for (int i = 1; i < 4; ++i) {
-                bounds_min_.SetCoord(i, std::numeric_limits<double>::infinity());
-                bounds_max_.SetCoord(i, -std::numeric_limits<double>::infinity());
-            }
-
-            IfcSchema::IfcProduct::list::ptr products = ifc_file->instances_by_type<IfcSchema::IfcProduct>();
-            for (IfcSchema::IfcProduct::list::it iter = products->begin(); iter != products->end(); ++iter) {
-                IfcSchema::IfcProduct* product = *iter;
-                if (product->hasObjectPlacement()) {
-                    // Use a fresh trsf every time in order to prevent the result to be concatenated
-                    ConversionResultPlacement* trsf; 
-                    bool success = false;
-
-                    try {
-                        success = kernel->convert_placement(product->ObjectPlacement(), trsf);
-                    } catch (const std::exception& e) {
-                        Logger::Error(e);
-                    } catch (...) {
-                        Logger::Error("Failed to construct placement");
-                    }
-
-                    if (!success) {
-                        continue;
-                    }
-
-					double X, Y, Z;
-                    trsf->TranslationPart(X, Y, Z);
-                    bounds_min_.SetX(std::min(bounds_min_.X(), X));
-                    bounds_min_.SetY(std::min(bounds_min_.Y(), Y));
-                    bounds_min_.SetZ(std::min(bounds_min_.Z(), Z));
-                    bounds_max_.SetX(std::max(bounds_max_.X(), X));
-                    bounds_max_.SetY(std::max(bounds_max_.Y(), Y));
-                    bounds_max_.SetZ(std::max(bounds_max_.Z(), Z));
-                }
-            }
-        }
-
-		int progress() const { 
-			if (num_threads_ == 1) {
-				return 100 * done / total;
-			} else {
-				return progress_;
-			}
-		}
-
-		const std::string& getUnitName() const { return unit_name; }
-
-        /// @note Double always as per IFC specification.
-        double getUnitMagnitude() const { return unit_magnitude; }
-	
-		std::string getLog() const { return Logger::GetLog(); }
-
-		IfcParse::IfcFile* file() const { return ifc_file; }
-
-        const std::vector<IfcGeom::filter_t>& filters() const { return filters_; }
-        std::vector<IfcGeom::filter_t>& filters() { return filters_; }
-
-        const gp_XYZ& bounds_min() const { return bounds_min_; }
-        const gp_XYZ& bounds_max() const { return bounds_max_; }
-
-	private:
-		// Move to the next IfcRepresentation
-		void _nextShape() {
-			ifcproducts.reset();
-			++ representation_iterator;
-			++ done;
-		}
-
-		bool geometry_reuse_ok_for_current_representation_;
-
-		bool reuse_ok_(const IfcSchema::IfcProduct::list::ptr& products) {
-			// With world coords enabled, object transformations are directly applied to
-			// the BRep. There is no way to re-use the geometry for multiple products.
-			if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
-				return false;
-			}
-
-			std::set<const IfcSchema::IfcMaterial*> associated_single_materials;
-
-			for (IfcSchema::IfcProduct::list::it it = products->begin(); it != products->end(); ++it) {
-				IfcSchema::IfcProduct* product = *it;
-
-				if (!settings.get(IteratorSettings::DISABLE_OPENING_SUBTRACTIONS) && kernel->find_openings(product)->size()) {
-					return false;
-				}
-
-				if (settings.get(IteratorSettings::APPLY_LAYERSETS)) {
-					IfcSchema::IfcRelAssociates::list::ptr associations = product->HasAssociations();
-					for (IfcSchema::IfcRelAssociates::list::it jt = associations->begin(); jt != associations->end(); ++jt) {
-						IfcSchema::IfcRelAssociatesMaterial* assoc = (*jt)->as<IfcSchema::IfcRelAssociatesMaterial>();
-						if (assoc) {
-							if (assoc->RelatingMaterial()->declaration().is(IfcSchema::IfcMaterialLayerSetUsage::Class())) {
-								// TODO: Check whether single layer? 
-								return false;
-							}
-						}
-					}
-				}
-
-				// Note that this can be a nullptr (!), but the fact that set size should be one still holds
-				associated_single_materials.insert(kernel->get_single_material_association(product));
-                if (associated_single_materials.size() > 1) return false;
-			}
-
-			return associated_single_materials.size() == 1;
-		}
-
-		boost::optional<std::pair<IfcSchema::IfcRepresentation*, IfcSchema::IfcProduct*>> get_next_task() {
-			for (;;) {
-				IfcSchema::IfcRepresentation* representation;
-
-				if (representation_iterator == representations->end()) {
-					representations.reset();
-					return boost::none; // reached the end of our list of representations
-				}
-				representation = *representation_iterator;
-
-				if (!ifcproducts) {
-					// Init. the list of filtered IfcProducts for this representation
-					ifcproducts = IfcSchema::IfcProduct::list::ptr(new IfcSchema::IfcProduct::list);
-					IfcSchema::IfcProduct::list::ptr unfiltered_products = kernel->products_represented_by(representation);
-                    // Include only the desired products for processing.
-                    for (IfcSchema::IfcProduct::list::it jt = unfiltered_products->begin(); jt != unfiltered_products->end(); ++jt) {
-                        IfcSchema::IfcProduct* prod = *jt;
-                        if (boost::all(filters_, filter_match(prod))) {
-                            ifcproducts->push(prod);
-                        }
-                    }
-
-					if (ifcproducts->size() == 0) {
-						_nextShape();
-						continue;
-					}
-
-					geometry_reuse_ok_for_current_representation_ = reuse_ok_(ifcproducts);
-
-					IfcSchema::IfcRepresentationMap::list::ptr maps = representation->RepresentationMap();
-
-					if (!geometry_reuse_ok_for_current_representation_ && maps->size() == 1) {
-						// unfiltered_products contains products represented by this representation by means of mapped items.
-						// For example because of openings applied to products, reuse might not be acceptable and then the
-						// products will be processed by means of their immediate representation and not the mapped representation.
-
-						// IfcRepresentationMaps are also used for IfcTypeProducts, so an additional check is performed whether the map
-						// is indeed used by IfcMappedItems.
-						IfcSchema::IfcRepresentationMap* map = *maps->begin();
-						if (map->MapUsage()->size() > 0) {
-							_nextShape();
-							continue;
-						}
-					}
-
-					// Check if this represenation has (or will be) processed as part its mapped representation
-					bool representation_processed_as_mapped_item = false;
-                    IfcSchema::IfcRepresentation* representation_mapped_to = kernel->representation_mapped_to(representation);
-					if (representation_mapped_to) {
-                        representation_processed_as_mapped_item = geometry_reuse_ok_for_current_representation_ && (
-                            ok_mapped_representations->contains(representation_mapped_to) || reuse_ok_(kernel->products_represented_by(representation_mapped_to)));
-					}
-
-					if (representation_processed_as_mapped_item) {
-						ok_mapped_representations->push(representation_mapped_to);
-						_nextShape();
-						continue;
-					}
-
-					ifcproduct_iterator = ifcproducts->begin();
-				}
-
-				// Have we reached the end of our list of IfcProducts?
-				if (ifcproduct_iterator == ifcproducts->end()) {
-					_nextShape();
-					continue;
-				}
-
-				IfcSchema::IfcProduct* product = *ifcproduct_iterator;
-
-
-				return std::make_pair(representation, product);
-			}
-		}
-
-		NativeElement<P, PP>* create_shape_model_for_next_entity() {
-			for (;;) {
-				auto rp = get_next_task();
-				if (!rp) {
-					return nullptr;
-				}
-				auto representation = rp->first;
-				auto product = rp->second;
-
-				Logger::SetProduct(product);
-
-				NativeElement<P, PP>* element;
-				if (ifcproduct_iterator == ifcproducts->begin() || !geometry_reuse_ok_for_current_representation_) {
-					element = kernel->create_brep_for_representation_and_product<P, PP>(settings, representation, product);
-				} else {
-					element = kernel->create_brep_for_processed_representation(settings, representation, product, current_shape_model);
-				}
-
-				Logger::SetProduct(boost::none);
-
-				if (!element) {
-					_nextShape();
-					continue;
-				}
-
-				return element;
-			}
-		}
-
-		void free_shapes() {
-			// Free all possible representations of the current geometrical entity
-			delete current_triangulation;
-			current_triangulation = 0;
-			delete current_serialization;
-			current_serialization = 0;
-			delete current_shape_model;
-			current_shape_model = 0;
-		}
-
-    public:
-        /// Returns what would be the product for the next shape representation
-        /// @todo Double-check and test the impl.
-        //IfcSchema::IfcProduct* peek_next() const
-        //{
-        //    if (ifcproducts && ifcproduct_iterator + 1 != ifcproducts->end()){
-        //        return *(ifcproduct_iterator + 1);
-        //    } else {
-        //        return 0;
-        //    }
-        //}
-
-        /// @todo Would this be as simple as the following code?
-        //void skip_next() { if (ifcproducts) { ++ifcproduct_iterator; } }
-
-        /// Moves to the next shape representation, create its geometry, and returns the associated product.
-        /// Use get() to retrieve the created geometry.
-		IfcUtil::IfcBaseClass* next() {
-			if (num_threads_ != 1) {
-				task_result_iterator_++;
-				native_task_result_iterator_++;
-				if (task_result_iterator_ == all_processed_elements_.end()) {
-					return nullptr;
-				} else {
-					return (*task_result_iterator_)->product();
-				}
-			} else {
-				// Increment the iterator over the list of products using the current
-				// shape representation
-				if (ifcproducts) {
-					++ifcproduct_iterator;
-				}
-
-				return create();
-			}
-		}
-
-        /// Gets the representation of the current geometrical entity.
-        Element<P, PP>* get()
-        {
-            // TODO: Test settings and throw
-            Element<P, PP>* ret = 0;
-
-			if (num_threads_ != 1) {
-				ret = *task_result_iterator_;
-			} else {
-				if (current_triangulation) { 
-					ret = current_triangulation; 
-				} else if (current_serialization) { 
-					ret = current_serialization; 
-				} else if (current_shape_model) { 
-					ret = current_shape_model; 
-				}
-			}
-
-			// If we want to organize the element considering their hierarchy
-			if (settings.get(IteratorSettings::SEARCH_FLOOR))
-			{
-				// We are going to build a vector with the element parents.
-				// First, create the parent vector
-				std::vector<const IfcGeom::Element<P, PP>*> parents;
-				
-				// if the element has a parent
-				if (ret->parent_id() != -1)
-				{
-					const IfcGeom::Element<P, PP>* parent_object = NULL;
-					bool hasParent = true;
-
-					// get the parent 
-					try {
-						parent_object = get_object(ret->parent_id());
-					} catch (const std::exception& e) {
-						Logger::Error(e);
-						hasParent = false;
-					}
-
-					// Add the previously found parent to the vector
-					if (hasParent) parents.insert(parents.begin(), parent_object);
-					
-					// We need to find all the parents
-					while (parent_object != NULL && hasParent && parent_object->parent_id() != -1)
-					{
-						// Find the next parent
-						try {
-							parent_object = get_object(parent_object->parent_id());
-						} catch (const std::exception& e) {
-							Logger::Error(e);
-							hasParent = false;
-						}
-
-						// Add the previously found parent to the vector
-						if (hasParent) parents.insert(parents.begin(), parent_object);
-
-						hasParent = hasParent && parent_object->parent_id() != -1;
-					}
-
-					// when done push the parent list in the Element object
-					ret->SetParents(parents);
-				}
-			}
-
-            return ret;
-        }
-
-		/// Gets the native (Open Cascade) representation of the current geometrical entity.
-		NativeElement<P, PP>* get_native()
-		{
-			// TODO: Test settings and throw
-			if (num_threads_ != 1) {
-				return *native_task_result_iterator_;
-			} else {
-				return current_shape_model;
-			}
-		}
-
-		const Element<P, PP>* get_object(int id) {
-			ConversionResultPlacement* trsf;
-			int parent_id = -1;
-			std::string instance_type, product_name, product_guid;
-            IfcSchema::IfcProduct* ifc_product = 0;
-
-			try {
-				IfcUtil::IfcBaseClass* ifc_entity = ifc_file->instance_by_id(id);
-				instance_type = ifc_entity->declaration().name();
-
-				if (ifc_entity->declaration().is(IfcSchema::IfcRoot::Class())) {
-					IfcSchema::IfcRoot* ifc_root = ifc_entity->as<IfcSchema::IfcRoot>();
-					product_guid = ifc_root->GlobalId();
-					product_name = ifc_root->hasName() ? ifc_root->Name() : "";
-				}
-
-				if (ifc_entity->declaration().is(IfcSchema::IfcProduct::Class())) {
-					ifc_product = ifc_entity->as<IfcSchema::IfcProduct>();
-					parent_id = -1;
-					try {
-						IfcSchema::IfcObjectDefinition* parent_object = kernel->get_decomposing_entity(ifc_product)->template as<IfcSchema::IfcObjectDefinition>();
-						if (parent_object) {
-							parent_id = parent_object->data().id();
-						}
-					} catch (const std::exception& e) {
-						Logger::Error(e);
-					} catch (...) {
-						Logger::Error("Failed to find decomposing entity");
-					}
-
-					try {
-						kernel->convert_placement(ifc_product->ObjectPlacement(), trsf);
-					} catch (const std::exception& e) {
-						Logger::Error(e);
-					} catch (...) {
-						Logger::Error("Failed to construct placement");
-					}
-				}
-			} catch (const std::exception& e) {
-				Logger::Error(e);
-			} catch (const Standard_Failure& e) {
-				if (e.GetMessageString() && strlen(e.GetMessageString())) {
-					Logger::Error(e.GetMessageString());
-				} else {
-					Logger::Error("Unknown error returning product");
-				}
-			} catch (...) {
-				Logger::Error("Unknown error returning product");
-			}
-
-			ElementSettings element_settings(settings, unit_magnitude, instance_type);
-
-			Element<P, PP>* ifc_object = new Element<P, PP>(element_settings, id, parent_id, product_name, instance_type, product_guid, "", trsf, ifc_product);
-			return ifc_object;
-		}
-
-		IfcUtil::IfcBaseClass* create() {
-			IfcGeom::NativeElement<P, PP>* next_shape_model = 0;
-			IfcGeom::SerializedElement<P, PP>* next_serialization = 0;
-			IfcGeom::TriangulationElement<P, PP>* next_triangulation = 0;
-
-			try {
-				next_shape_model = create_shape_model_for_next_entity();
-			} catch (const std::exception& e) {
-				Logger::Error(e);
-			} catch (const Standard_Failure& e) {
-				if (e.GetMessageString() && strlen(e.GetMessageString())) {
-					Logger::Error(e.GetMessageString());
-				} else {
-					Logger::Error("Unknown error creating geometry");
-				}
-			} catch (...) {
-				Logger::Error("Unknown error creating geometry");
-			}
-
-			if (next_shape_model) {
-				if (settings.get(IteratorSettings::USE_BREP_DATA)) {
-					try {
-						next_serialization = new SerializedElement<P, PP>(*next_shape_model);
-					} catch (...) {
-                        Logger::Message(Logger::LOG_ERROR, "Getting a serialized element from model failed.");
-					}
-				} else if (!settings.get(IteratorSettings::DISABLE_TRIANGULATION)) {
-					try {
-						if (ifcproduct_iterator == ifcproducts->begin() || !geometry_reuse_ok_for_current_representation_) {
-							next_triangulation = new TriangulationElement<P, PP>(*next_shape_model);
-						} else {
-							next_triangulation = new TriangulationElement<P, PP>(*next_shape_model, current_triangulation->geometry_pointer());
-						}
-					} catch (...) {
-                        Logger::Message(Logger::LOG_ERROR, "Getting a triangulation element from model failed.");
-					}
-				}
-			}
-
-			free_shapes();
-
-			current_shape_model = next_shape_model;
-			current_serialization = next_serialization;
-			current_triangulation = next_triangulation;
-
-            return next_shape_model ? next_shape_model->product() : 0;
-		}
-	private:
-		void _initialize() {
-			current_triangulation = 0;
-			current_shape_model = 0;
-			current_serialization = 0;
-
-			unit_name = "METER";
-			unit_magnitude = 1.f;
-
-            kernel->setValue(IfcGeom::Kernel::GV_MAX_FACES_TO_ORIENT, settings.get(IteratorSettings::SEW_SHELLS) ? std::numeric_limits<double>::infinity() : -1);
-            kernel->setValue(IfcGeom::Kernel::GV_DIMENSIONALITY, (settings.get(IteratorSettings::INCLUDE_CURVES)
-                ? (settings.get(IteratorSettings::EXCLUDE_SOLIDS_AND_SURFACES) ? -1. : 0.) : +1.));
-			if (settings.get(IteratorSettings::BUILDING_LOCAL_PLACEMENT)) {
-				if (settings.get(IteratorSettings::SITE_LOCAL_PLACEMENT)) {
-					Logger::Message(Logger::LOG_WARNING, "building-local-placement takes precedence over site-local-placement");
-				}
-				kernel->set_conversion_placement_rel_to(&IfcSchema::IfcBuilding::Class());
-			} else if (settings.get(IteratorSettings::SITE_LOCAL_PLACEMENT)) {
-				kernel->set_conversion_placement_rel_to(&IfcSchema::IfcSite::Class());
-			}
-		}
-
-		bool owns_ifc_file;
-	public:
-		MAKE_TYPE_NAME(IteratorImplementation_)(const std::string& geometry_library, const IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters, int num_threads)
-			: settings(settings)
-			, ifc_file(file)
-			, filters_(filters)
-			, owns_ifc_file(false)
-			, num_threads_(num_threads)
-			, geometry_library_(geometry_library)
-		{
-			kernel = (MAKE_TYPE_NAME(AbstractKernel)*) impl::kernel_implementations().construct(file->schema()->name(), geometry_library, file);
-			// kernel = new Kernel(geometry_library, file);
-			_initialize();
-		}
-
-		~MAKE_TYPE_NAME(IteratorImplementation_)() {
-			if (owns_ifc_file) {
-				delete ifc_file;
-			}
-
-			if (settings.get(IfcGeom::IteratorSettings::DISABLE_TRIANGULATION)) {
-				for (auto& p : all_processed_native_elements_) {
-					delete p;
-				}
-			}
-
-			for (auto& p : all_processed_elements_) {
-				delete p;
-			}
-
-			free_shapes();
-		}
-	};
-}
-
-#endif
@@ -1,118 +0,0 @@
-#include "CgalKernel.h"
-#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
-
-#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
-
-bool IfcGeom::CgalKernel::convert_wire_to_face(const cgal_wire_t& wire, cgal_face_t& face) {
-  face.outer = wire;
-  return true;
-}
-
-void IfcGeom::CgalKernel::remove_duplicate_points_from_loop(cgal_wire_t& polygon) {
-  std::set<cgal_point_t> points;
-  for (int i = 0; i < polygon.size(); ++i) {
-    if (points.count(polygon[i])) {
-      polygon.erase(polygon.begin()+i);
-      --i;
-    } else points.insert(polygon[i]);
-  }
-}
-
-CGAL::Polyhedron_3<Kernel_> IfcGeom::CgalKernel::create_polyhedron(std::list<cgal_face_t> &face_list) {
-  
-  // Naive creation
-  CGAL::Polyhedron_3<Kernel_> polyhedron;
-  PolyhedronBuilder builder(&face_list);
-  polyhedron.delegate(builder);
-  
-  // Stitch edges
-  //  std::cout << "Before: " << polyhedron.size_of_vertices() << " vertices and " << polyhedron.size_of_facets() << " facets" << std::endl;
-  CGAL::Polygon_mesh_processing::stitch_borders(polyhedron);
-  if (!polyhedron.is_valid()) {
-    Logger::Message(Logger::LOG_ERROR, "create_polyhedron: Polyhedron not valid!");
-    //    std::ofstream fresult;
-    //    fresult.open("/Users/ken/Desktop/invalid.off");
-    //    fresult << polyhedron << std::endl;
-    //    fresult.close();
-    return CGAL::Polyhedron_3<Kernel_>();
-  } if (polyhedron.is_closed()) {
-    if (!CGAL::Polygon_mesh_processing::is_outward_oriented(polyhedron)) {
-      CGAL::Polygon_mesh_processing::reverse_face_orientations(polyhedron);
-    }
-  }
-  
-  //  std::cout << "After: " << polyhedron.size_of_vertices() << " vertices and " << polyhedron.size_of_facets() << " facets" << std::endl;
-  
-  return polyhedron;
-}
-
-CGAL::Polyhedron_3<Kernel_> IfcGeom::CgalKernel::create_polyhedron(CGAL::Nef_polyhedron_3<Kernel_> &nef_polyhedron) {
-  if (nef_polyhedron.is_simple()) {
-    try {
-      CGAL::Polyhedron_3<Kernel_> polyhedron;
-      nef_polyhedron.convert_to_polyhedron(polyhedron);
-      return polyhedron;
-    } catch (...) {
-      Logger::Message(Logger::LOG_ERROR, "Conversion from Nef to polyhedron failed!");
-      return CGAL::Polyhedron_3<Kernel_>();
-    }
-  } else {
-    Logger::Message(Logger::LOG_ERROR, "Nef polyhedron not simple: cannot create polyhedron!");
-    return CGAL::Polyhedron_3<Kernel_>();
-  }
-}
-
-CGAL::Nef_polyhedron_3<Kernel_> IfcGeom::CgalKernel::create_nef_polyhedron(std::list<cgal_face_t> &face_list) {
-  CGAL::Polyhedron_3<Kernel_> polyhedron = create_polyhedron(face_list);
-  CGAL::Polygon_mesh_processing::triangulate_faces(polyhedron);
-  CGAL::Nef_polyhedron_3<Kernel_> nef_polyhedron;
-  try {
-    nef_polyhedron = CGAL::Nef_polyhedron_3<Kernel_>(polyhedron);
-  } catch (...) {
-    Logger::Message(Logger::LOG_ERROR, "Conversion to Nef polyhedron failed!");
-    return nef_polyhedron;
-  } return nef_polyhedron;
-}
-
-CGAL::Nef_polyhedron_3<Kernel_> IfcGeom::CgalKernel::create_nef_polyhedron(CGAL::Polyhedron_3<Kernel_> &polyhedron) {
-  if (polyhedron.is_valid()) {
-    CGAL::Polygon_mesh_processing::triangulate_faces(polyhedron);
-    CGAL::Nef_polyhedron_3<Kernel_> nef_polyhedron;
-    try {
-      nef_polyhedron = CGAL::Nef_polyhedron_3<Kernel_>(polyhedron);
-    } catch (...) {
-      Logger::Message(Logger::LOG_ERROR, "Conversion to Nef polyhedron failed!");
-      return nef_polyhedron;
-    } return nef_polyhedron;
-  } else {
-    Logger::Message(Logger::LOG_ERROR, "Polyhedron not valid: cannot create Nef polyhedron!");
-    return CGAL::Nef_polyhedron_3<Kernel_>();
-  }
-}
-
-//CGAL::Polyhedron_3<Kernel_> IfcGeom::CgalKernel::triangulate_faces(CGAL::Polyhedron_3<Kernel_> &polyhedron) {
-//  std::list<cgal_face_t> face_list;
-//  
-//  for (CGAL::Polyhedron_3<Kernel_>::Facet_const_iterator current_facet = polyhedron.facets_begin();
-//       current_facet != polyhedron.facets_end();
-//       ++current_facet) {
-//    
-//    // Triangle
-//    if (current_facet->is_triangle()) {
-//      face_list.push_back(cgal_face_t());
-//      CGAL::Polyhedron_3<Kernel_>::Halfedge_around_facet_const_circulator current_halfedge = current_facet->facet_begin();
-//      do {
-//        face_list.back().outer.push_back(current_halfedge->vertex()->point());
-//        ++current_halfedge;
-//      } while (current_halfedge != current_facet->facet_begin());
-//    }
-//    
-//    // Polygon
-//    else {
-//      std::list<Kernel_::Point_3> points_in_polygon;
-//      
-//    }
-//  }
-//  
-//  return create_polyhedron(face_list);
-//}
@@ -1,96 +0,0 @@
-/********************************************************************************
-*                                                                              *
-* This file is part of IfcOpenShell.                                           *
-*                                                                              *
-* IfcOpenShell is free software: you can redistribute it and/or modify         *
-* it under the terms of the Lesser GNU General Public License as published by  *
-* the Free Software Foundation, either version 3.0 of the License, or          *
-* (at your option) any later version.                                          *
-*                                                                              *
-* IfcOpenShell is distributed in the hope that it will be useful,              *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
-* Lesser GNU General Public License for more details.                          *
-*                                                                              *
-* You should have received a copy of the Lesser GNU General Public License     *
-* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
-*                                                                              *
-********************************************************************************/
-
-#include "CgalKernel.h"
-
-#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
-
-using namespace IfcUtil;
-
-bool IfcGeom::CgalKernel::convert_shapes(const IfcBaseClass* l, ConversionResults& r) {
-	if (shape_type(l) != ST_SHAPELIST) {
-		cgal_shape_t shp;
-		if (convert_shape(l, shp)) {
-			r.push_back(IfcGeom::ConversionResult(l->data().id(), new CgalShape(shp), get_style(l->as<IfcSchema::IfcRepresentationItem>())));
-			return true;
-		}
-		return false;
-	}
-
-#include "CgalEntityMappingShapes.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
-	return false;
-}
-
-IfcGeom::ShapeType IfcGeom::CgalKernel::shape_type(const IfcBaseClass* l) {
-#include "CgalEntityMappingShapeType.h"
-	return ST_OTHER;
-}
-
-bool IfcGeom::CgalKernel::convert_shape(const IfcBaseClass* l, cgal_shape_t& r) {
-	const unsigned int id = l->data().id();
-	bool success = false;
-	bool processed = false;
-	bool ignored = false;
-
-#ifndef NO_CACHE
-	std::map<int, cgal_shape_t>::const_iterator it = cache.Shape.find(id);
-	if ( it != cache.Shape.end() ) { r = it->second; return true; }
-#endif
-	const bool include_curves = getValue(GV_DIMENSIONALITY) != +1;
-	const bool include_solids_and_surfaces = getValue(GV_DIMENSIONALITY) != -1;
-
-	IfcGeom::ShapeType st = shape_type(l);
-	ignored = (!include_solids_and_surfaces && (st == ST_SHAPE || st == ST_FACE)) || (!include_curves && (st == ST_WIRE || st == ST_CURVE));
-	if (st == ST_SHAPE && include_solids_and_surfaces) {
-#include "CgalEntityMappingShape.h"
-	}
-
-	if ( processed && success ) { 
-//		const double precision = getValue(GV_PRECISION);
-		// apply_tolerance(r, precision);
-#ifndef NO_CACHE
-		cache.Shape[id] = r;
-#endif
-	} else if (!ignored) {
-		const char* const msg = processed
-			? "Failed to convert:"
-			: "No operation defined for:";
-		Logger::Message(Logger::LOG_ERROR, msg, l);
-	}
-	return success;
-}
-
-bool IfcGeom::CgalKernel::convert_wire(const IfcBaseClass* l, cgal_wire_t& r) {
-#include "CgalEntityMappingWire.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
-	return false;
-}
-
-bool IfcGeom::CgalKernel::convert_face(const IfcBaseClass* l, cgal_face_t& r) {
-#include "CgalEntityMappingFace.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
-	return false;
-}
-
-bool IfcGeom::CgalKernel::convert_curve(const IfcBaseClass* l, cgal_curve_t& r) {
-#include "CgalEntityMappingCurve.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
-	return false;
-}
@@ -1,121 +0,0 @@
-/********************************************************************************
-*                                                                              *
-* This file is part of IfcOpenShell.                                           *
-*                                                                              *
-* IfcOpenShell is free software: you can redistribute it and/or modify         *
-* it under the terms of the Lesser GNU General Public License as published by  *
-* the Free Software Foundation, either version 3.0 of the License, or          *
-* (at your option) any later version.                                          *
-*                                                                              *
-* IfcOpenShell is distributed in the hope that it will be useful,              *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
-* Lesser GNU General Public License for more details.                          *
-*                                                                              *
-* You should have received a copy of the Lesser GNU General Public License     *
-* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
-*                                                                              *
-********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * This file registers function prototypes for all supported IFC geometrical    *
- * entities. For entities of type CLASS an std::map is also created to cache    *
- * the output of the conversion functions                                       *
- *                                                                              *
- ********************************************************************************/
-
-#include "../../../ifcparse/IfcParse.h"
-
-SHAPES(IfcShellBasedSurfaceModel);
-SHAPES(IfcFaceBasedSurfaceModel);
-SHAPES(IfcRepresentation);
-SHAPES(IfcMappedItem);
-// IfcFacetedBrep included
-// IfcAdvancedBrep included
-// IfcFacetedBrepWithVoids included
-// IfcAdvancedBrepWithVoids included
-SHAPES(IfcManifoldSolidBrep);
-SHAPES(IfcGeometricSet);
-
-#ifdef USE_IFC4
-//SHAPE(IfcCylindricalSurface);
-//SHAPE(IfcAdvancedBrep);
-//SHAPE(IfcBSplineSurfaceWithKnots);
-SHAPE(IfcTriangulatedFaceSet);
-SHAPE(IfcExtrudedAreaSolidTapered);
-#endif
-//SHAPE(IfcPlane);
-SHAPE(IfcExtrudedAreaSolid);
-//SHAPE(IfcRevolvedAreaSolid);
-SHAPE(IfcConnectedFaceSet);
-SHAPE(IfcBooleanResult);
-//SHAPE(IfcPolygonalBoundedHalfSpace);
-SHAPE(IfcHalfSpaceSolid);
-//SHAPE(IfcSurfaceOfLinearExtrusion);
-//SHAPE(IfcSurfaceOfRevolution);
-SHAPE(IfcBlock);
-SHAPE(IfcRectangularPyramid);
-SHAPE(IfcRightCircularCylinder);
-SHAPE(IfcRightCircularCone);
-SHAPE(IfcSphere);
-SHAPE(IfcCsgSolid);
-//SHAPE(IfcCurveBoundedPlane);
-//SHAPE(IfcRectangularTrimmedSurface);
-//SHAPE(IfcSurfaceCurveSweptAreaSolid);
-//SHAPE(IfcSweptDiskSolid);
-
-FACE(IfcArbitraryProfileDefWithVoids);
-FACE(IfcArbitraryClosedProfileDef);
-FACE(IfcRoundedRectangleProfileDef);
-FACE(IfcRectangleHollowProfileDef);
-FACE(IfcRectangleProfileDef);
-FACE(IfcTrapeziumProfileDef)
-FACE(IfcCShapeProfileDef);
-// IfcAsymmetricIShapeProfileDef included
-FACE(IfcIShapeProfileDef);
-FACE(IfcLShapeProfileDef);
-FACE(IfcTShapeProfileDef);
-FACE(IfcUShapeProfileDef);
-FACE(IfcZShapeProfileDef);
-FACE(IfcCircleHollowProfileDef);
-FACE(IfcCircleProfileDef);
-FACE(IfcEllipseProfileDef);
-//FACE(IfcCenterLineProfileDef);
-//FACE(IfcCompositeProfileDef);
-FACE(IfcDerivedProfileDef);
-// IfcFaceSurface included
-// IfcAdvancedFace included in case of IFC4
-FACE(IfcFace);
-
-//WIRE(IfcEdgeCurve);
-//WIRE(IfcSubedge);
-WIRE(IfcOrientedEdge);
-WIRE(IfcEdge);
-WIRE(IfcEdgeLoop);
-WIRE(IfcPolyline);
-WIRE(IfcPolyLoop);
-WIRE(IfcCompositeCurve);
-WIRE(IfcTrimmedCurve);
-//WIRE(IfcArbitraryOpenProfileDef);
-
-CURVE(IfcCircle);
-CURVE(IfcEllipse);
-CURVE(IfcLine);
-#ifdef USE_IFC4
-// IfcRationalBSplineCurveWithKnots included
-//CURVE(IfcBSplineCurveWithKnots);
-#endif
-
-CLASS(IfcCartesianPoint,cgal_point_t);
-CLASS(IfcDirection,cgal_direction_t);
-CLASS(IfcAxis2Placement2D,cgal_placement_t);
-CLASS(IfcAxis2Placement3D,cgal_placement_t);
-CLASS(IfcAxis1Placement,cgal_placement_t);
-CLASS(IfcCartesianTransformationOperator2DnonUniform,cgal_placement_t);
-CLASS(IfcCartesianTransformationOperator3DnonUniform,cgal_placement_t);
-CLASS(IfcCartesianTransformationOperator2D,cgal_placement_t);
-CLASS(IfcCartesianTransformationOperator3D,cgal_placement_t);
-CLASS(IfcObjectPlacement,cgal_placement_t);
-CLASS(IfcVector,cgal_vector_t);
-CLASS(IfcPlane,cgal_plane_t);
@@ -1,6 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define CLASS(T,V) \
-	std::map<int,V> T;
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"
@@ -1,6 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define CURVE(T) \
-	if (l->declaration().is(IfcSchema::T::Class())) return convert((IfcSchema::T*)l,r);
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"
@@ -1,10 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define CLASS(T,V) bool convert(const IfcSchema::T* L, V& r);
-#define SHAPES(T) CLASS(T,ConversionResults)
-#define SHAPE(T) CLASS(T,cgal_shape_t)
-#define WIRE(T) CLASS(T,cgal_wire_t)
-#define FACE(T) CLASS(T,cgal_face_t)
-#define CURVE(T) CLASS(T,cgal_curve_t)
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"
@@ -1,18 +0,0 @@
-#ifndef SHAPES
-#define SHAPES(T)
-#endif
-#ifndef SHAPE
-#define SHAPE(T)
-#endif
-#ifndef WIRE
-#define WIRE(T)
-#endif
-#ifndef FACE
-#define FACE(T)
-#endif
-#ifndef CURVE
-#define CURVE(T)
-#endif
-#ifndef CLASS
-#define CLASS(T,V)
-#endif
@@ -1,6 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define FACE(T) \
-	if (l->declaration().is(IfcSchema::T::Class())) return convert((IfcSchema::T*)l,r);
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"
@@ -1,6 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define CLASS(T,V) \
-	T.clear();
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"
@@ -1,20 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define SHAPE(T) \
-	if ( !processed && l->declaration().is(IfcSchema::T::Class()) ) { \
-		processed = true; \
-		try { \
-			if (convert((IfcSchema::T*)l, r) ) { \
-				success = true; \
-			} \
-		} catch (const std::exception& e) { \
-			Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + "\nFailed to convert:", l); \
-			return false; \
-		} \
-		if (!success) { \
-			Logger::Message(Logger::LOG_ERROR,"Failed to convert:", l); \
-			return false; \
-		} \
-	}
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"
@@ -1,14 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define SHAPES(T) \
-	if (l->declaration().is(IfcSchema::T::Class())) return ST_SHAPELIST;
-#define SHAPE(T) \
-	if (l->declaration().is(IfcSchema::T::Class())) return ST_SHAPE;
-#define WIRE(T) \
-	if (l->declaration().is(IfcSchema::T::Class())) return ST_WIRE;
-#define FACE(T) \
-	if (l->declaration().is(IfcSchema::T::Class())) return ST_FACE;
-#define CURVE(T) \
-	if (l->declaration().is(IfcSchema::T::Class())) return ST_CURVE;
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"
@@ -1,13 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define SHAPES(T) \
-	if (l->declaration().is(IfcSchema::T::Class())) { \
-		try { \
-			return convert((IfcSchema::T*)l,r); \
-		} catch (const std::exception& e) { \
-			Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + "\nFailed to convert:", l); \
-		} \
-		return false; \
-	}
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"
--- a/Show More
+++ b/Show More