Fix ensure_fit_for_subtraction() function when input shape is a solid

- Flag shape representations, for which no item succeeds, as failed

.gitignore

@@ -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

.gitmodules

@@ -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/

.travis.yml

@@ -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

README

@@ -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
+

README.md

@@ -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"

cmake/CMakeLists.txt

@@ -1,803 +1,211 @@
-################################################################################
-#                                                                              #
-# 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.cpp
+  ../src/ifcparse/IfcUtil.cpp
+  ../src/ifcparse/IfcParse.cpp
+  ../src/ifcparse/IfcCharacterDecoder.cpp
+  
+  ../src/ifcparse/IfcWrite.cpp
+  ../src/ifcparse/IfcGuidHelper.cpp
+  
+  ../src/ifcparse/IfcHierarchyHelper.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/IfcGeomObjects.cpp
+  ../src/ifcgeom/IfcGeomRenderStyles.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   
 )
 
-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 ${Boost_LIBRARIES} ${OPENCOLLADA_LIBRARIES})
 
-IF(BUILD_IFCPYTHON)
-	ADD_SUBDIRECTORY(../src/ifcwrap ifcwrap)
-ENDIF()
+# Build python wrapper using separate CMakeLists.txt
+ADD_SUBDIRECTORY(../src/ifcwrap ifcwrap)
 
-IF(BUILD_EXAMPLES)
-	ADD_SUBDIRECTORY(../src/examples examples)
-ENDIF()
+# Build IfcParseExamples using separate CMakeLists.txt
+ADD_SUBDIRECTORY(../src/examples examples)
 
-IF(BUILD_IFCMAX)
-	ADD_SUBDIRECTORY(../src/ifcmax ifcmax)
-ENDIF()
+# 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/IfcGeomObjects.h
+    ../src/ifcgeom/IfcGeomRenderStyles.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.h
+    ../src/ifcparse/Ifc2x3enum.h
+    ../src/ifcparse/IfcCharacterDecoder.h
+    ../src/ifcparse/IfcException.h
+    ../src/ifcparse/IfcFile.h
+    ../src/ifcparse/IfcHierarchyHelper.h
+    ../src/ifcparse/IfcParse.h
+    ../src/ifcparse/IfcUtil.h
+    ../src/ifcparse/SharedPointer.h
+    
+    ../src/ifcparse/IfcWrite.h
+    ../src/ifcparse/IfcWritableEntity.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)

conda/bld.bat

@@ -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

conda/build.sh

@@ -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

conda/meta.yaml

@@ -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

nix/build-all.py

@@ -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")

nix/patches/occt/88af392.patch

@@ -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);
-     }
-     

nix/patches/occt/enable-exception-handling.patch

@@ -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")

src/examples/CMakeLists.txt

@@ -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)

src/examples/IfcAdvancedHouse.cpp

@@ -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
-}

src/examples/IfcOpenHouse.cpp

@@ -28,43 +28,32 @@
 
 #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"
 #include "../ifcparse/Ifc2x3.h"
-#include "../ifcparse/IfcBaseClass.h"
+#include "../ifcparse/IfcUtil.h"
 #include "../ifcparse/IfcHierarchyHelper.h"
-
-#include "../ifcgeom/schema_agnostic/Serialization.h"
-
-#if USE_VLD
-#include <vld.h>
-#endif
+#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;
-	file.header().file_name().name("IfcOpenHouse.ifc");
+	IfcHierarchyHelper file;
+	file.filename("IfcOpenHouse.ifc");
 
 	// Start by adding a wall to the file, initially leaving most attributes blank.
-	IfcSchema::IfcWallStandardCase* south_wall = new IfcSchema::IfcWallStandardCase(
+	Ifc2x3::IfcWallStandardCase* south_wall = new Ifc2x3::IfcWallStandardCase(
 		guid(), 			// GlobalId
 		0, 					// OwnerHistory
 		S("South wall"), 	// Name
@@ -73,9 +62,6 @@ int main() {
 		0, 					// ObjectPlacement
 		0, 					// Representation
 		null				// Tag
-#ifdef USE_IFC4
-		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
-#endif
 	);
 	file.addBuildingProduct(south_wall);
 
@@ -84,210 +70,125 @@ 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<Ifc2x3::IfcProject>()->setName("IfcOpenHouse");
 
 	// An IfcOwnerHistory has been initialized as well, which should be assigned to the wall.
-	south_wall->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+	south_wall->setOwnerHistory(file.getSingle<Ifc2x3::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
-	// that runs over the centerline of the box in the X-axis.
-	IfcSchema::IfcProductDefinitionShape* south_wall_shape = file.addAxisBox(10000, 360, 3000);
-
-	// 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();
+	// The wall will be shaped as a box, with the dimensions specified in millimeters.
+	Ifc2x3::IfcProductDefinitionShape* south_wall_shape = file.addBox(10000, 360, 3000);
 
 	// 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->setObjectPlacement(file.addLocalPlacement());
 
 	// A pale white colour is assigned to the wall.
-	IfcSchema::IfcPresentationStyleAssignment* wall_colour = file.setSurfaceColour(
-		south_wall_shape, 0.75, 0.73, 0.68);
+	Ifc2x3::IfcPresentationStyleAssignment* wall_colour = file.setSurfaceColour(
+		south_wall->Representation(), 0.75, 0.73, 0.68);
 
 	// 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);
+	Ifc2x3::IfcFooting* footing = new Ifc2x3::IfcFooting(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+		S("Footing"), null, null, 0, 0, null, Ifc2x3::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->setRepresentation(file.addBox(10100, 5460, 2000, 0, 0, 0, file.getSingle<Ifc2x3::IfcRepresentationContext>()));
+	footing->setObjectPlacement(file.addLocalPlacement(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);
+	Ifc2x3::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 
 	// with another element, for example a door or a window, an IfcOpeningElement is used instead.
-
-	// 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),
-		file.addBox(6000, 3630, 1600), null
-#ifdef USE_IFC4
-		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
-#endif
-	);
-	file.addEntity(west_opening);
+	// An opening element is created with rectangular geometry
+	Ifc2x3::IfcOpeningElement* west_opening = new Ifc2x3::IfcOpeningElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+		null, null, null, file.addLocalPlacement(-2500, 0, 400),
+		file.addBox(6000, 3630, 1600, 0, 0, 0, file.getSingle<Ifc2x3::IfcRepresentationContext>()), null);
+	file.AddEntity(west_opening);
 
 	// Relate the opening element to the wall.
-	IfcSchema::IfcRelVoidsElement* void_element = new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
+	Ifc2x3::IfcRelVoidsElement* void_element = new Ifc2x3::IfcRelVoidsElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
 		null, null, south_wall, west_opening);
-	file.addEntity(void_element);
+	file.AddEntity(void_element);
 
 	// Now create an additional opening
-	IfcSchema::IfcOpeningElement* south_opening = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(storey_placement, 3000, 0, 400),
-		file.addBox(1860, 3000, 1600), null
-#ifdef USE_IFC4
-		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
-#endif
-	);
-	file.addEntity(south_opening);
-	file.addEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, south_wall, south_opening));
+	Ifc2x3::IfcOpeningElement* south_opening = new Ifc2x3::IfcOpeningElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+		null, null, null, file.addLocalPlacement(3000, 0, 400),
+		file.addBox(1860, 3000, 1600, 0, 0, 0, file.getSingle<Ifc2x3::IfcRepresentationContext>()), null);
+	file.AddEntity(south_opening);
+	file.AddEntity(new Ifc2x3::IfcRelVoidsElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null, south_wall, south_opening));
+	
+	// Create a roof element
+	Ifc2x3::IfcRoof* south_roof = new Ifc2x3::IfcRoof(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), S("South roof"), null, null, 
+		0, 0, null, Ifc2x3::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
 	
-	// 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);
-
 	// The roof geometry is slanted 45 degrees by specifying a direction for the box extrusion
-	IfcSchema::IfcShapeRepresentation* roof_rep = file.addEmptyRepresentation();
-	file.addBox(roof_rep, 10200, 360, sqrt(2.0*2900*2900), 0, file.addPlacement3d(0, 0, 0, 0, 1, 0),
-		file.addTriplet<IfcSchema::IfcDirection>(0, -sqrt(0.5), sqrt(0.5)));
+	south_roof->setRepresentation(file.addBox(10200, 360, sqrt(2.0*2900*2900), 0, file.addPlacement3d(0, 0, 0, 0, 1, 0),
+		file.addTriplet<Ifc2x3::IfcDirection>(0, -sqrt(0.5), sqrt(0.5)), file.getSingle<Ifc2x3::IfcRepresentationContext>()));
+	south_roof->setObjectPlacement(file.addLocalPlacement(0, -400, 2700));
+	file.addBuildingProduct(south_roof);
 
-	// 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);
-	
-	// 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));
-	
 	// 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));
-	
-	IfcSchema::IfcObjectDefinition::list::ptr roof_parts(new IfcSchema::IfcObjectDefinition::list);
-	roof_parts->push(south_roof_part);
-	roof_parts->push(north_roof_part);
-	IfcSchema::IfcRelDecomposes* roof_decomposition = new IfcSchema::IfcRelAggregates(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-			null, null, roof, roof_parts);
-	file.addEntity(roof_decomposition);
+	Ifc2x3::IfcRoof* north_roof = new Ifc2x3::IfcRoof(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), S("North roof"),
+		null, null, 0, 0, null, Ifc2x3::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
+	north_roof->setOwnerHistory(file.getSingle<Ifc2x3::IfcOwnerHistory>());
+	north_roof->setRepresentation(south_roof->Representation());
+	north_roof->setObjectPlacement(file.addLocalPlacement(0, 5400, 2700, 0, 0, 1, -1, 0, 0));
+	file.addBuildingProduct(north_roof);
 
-	file.addBuildingProduct(south_roof_part);
-	file.addBuildingProduct(north_roof_part);
-	file.addBuildingProduct(roof);
-
-	file.setSurfaceColour(roof_rep, 0.24, 0.08, 0.04);
+	// By specifying a surface style for the south part of the roof, it gets assigned to the other 
+	// roof part as well, because they share the same representation.
+	file.setSurfaceColour(south_roof->Representation(), 0.24, 0.08, 0.04);
 
 	// Copy the south wall to the north
-	IfcSchema::IfcWallStandardCase* north_wall = new IfcSchema::IfcWallStandardCase(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("North wall"),
-		null, null, file.addLocalPlacement(storey_placement, 0, 5000, 0), file.addAxisBox(10000, 360, 3000), null
-#ifdef USE_IFC4
-		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
-#endif	
-	);
-	file.addBuildingProduct(north_wall);
-	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);
-	}
+	file.addBuildingProduct(new Ifc2x3::IfcWallStandardCase(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), S("North wall"),
+		null, null, file.addLocalPlacement(0, 5000, 0), south_wall->Representation(), null));
 
 	// 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
-#ifdef USE_IFC4
-		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
-#endif	
-	);
+	Ifc2x3::IfcWallStandardCase* east_wall = new Ifc2x3::IfcWallStandardCase(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+		S("East wall"), null, null, file.addLocalPlacement(4820, 2500, 0, 0, 0, 1, 0, 1, 0), file.addBox(5000, 360, 6000), null);
 	file.addBuildingProduct(east_wall);
 
+	// 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(east_wall->Representation(), file.addPlacement3d(-2500, 0, 3000, -1, 0, 1), false);
+	file.clipRepresentation(east_wall->Representation(), file.addPlacement3d(2500, 0, 3000, 1, 0, 1), false);
+
+	file.setSurfaceColour(east_wall->Representation(), 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
-#ifdef USE_IFC4
-		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
-#endif	
-	);
+	Ifc2x3::IfcWallStandardCase* west_wall = new Ifc2x3::IfcWallStandardCase(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+		S("West wall"), null, null, file.addLocalPlacement(-4820, 2500, 0, 0, 0, 1, 0, -1, 0), east_wall->Representation(), null);
 	file.addBuildingProduct(west_wall);
 
 	// 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
-
-	// 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),
-		file.addBox(6000, 3630, 1600), null
-#ifdef USE_IFC4
-		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
-#endif	
-	);
-	file.addEntity(west_opening_copy);
-	file.addEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, west_wall, west_opening_copy));
+	Ifc2x3::IfcOpeningElement* west_opening_copy = new Ifc2x3::IfcOpeningElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+		null, null, null, west_opening->ObjectPlacement(), west_opening->Representation(), null);
+	file.AddEntity(west_opening_copy);
+	file.AddEntity(new Ifc2x3::IfcRelVoidsElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null, west_wall, west_opening_copy));
 	
 	// Up until now we have only used simple extrusions for the creation of the geometry. For the 
 	// ground mesh of the IfcSite we will use a Nurbs surface created in Open Cascade. The surface 
 	// 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"));
+	IfcEntities geometrical_entities(new IfcEntityList());
+	Ifc2x3::IfcProductDefinitionShape* ground_representation = IfcGeom::tesselate(shape, 100., geometrical_entities);
+	file.getSingle<Ifc2x3::IfcSite>()->setRepresentation(ground_representation);
+	file.AddEntities(geometrical_entities);
+	Ifc2x3::IfcShapeRepresentation::list ground_reps = geometrical_entities->as<Ifc2x3::IfcShapeRepresentation>();
+	for (Ifc2x3::IfcShapeRepresentation::it it = ground_reps->begin(); it != ground_reps->end(); ++it) {
+		(*it)->setContextOfItems(file.getSingle<Ifc2x3::IfcRepresentationContext>());
 	}
-	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
@@ -297,58 +198,24 @@ int main() {
 	// Some BIM authoring applications, such as Autodesk Revit, ignore the geometrical representation
 	// by and large and construct native walls using the layer thickness and reference line offset 
 	// provided here.
-#ifdef USE_IFC4
-	IfcSchema::IfcMaterial* material = new IfcSchema::IfcMaterial("Brick", null, null);
-#else
-	IfcSchema::IfcMaterial* material = new IfcSchema::IfcMaterial("Brick");
-#endif
-	IfcSchema::IfcMaterialLayer* layer = new IfcSchema::IfcMaterialLayer(
-		material, 
-		360, 
-		null
-#ifdef USE_IFC4
-		, null
-		, null 
-		, null
-		, null
-#endif
-	);
-	IfcSchema::IfcMaterialLayer::list::ptr layers (new IfcTemplatedEntityList<IfcSchema::IfcMaterialLayer>());
+	Ifc2x3::IfcMaterial* material = new Ifc2x3::IfcMaterial("Brick");
+	Ifc2x3::IfcMaterialLayer* layer = new Ifc2x3::IfcMaterialLayer(material, 360, null);
+	Ifc2x3::IfcMaterialLayer::list layers (new IfcTemplatedEntityList<Ifc2x3::IfcMaterialLayer>());
 	layers->push(layer);
-	IfcSchema::IfcMaterialLayerSet* layer_set = new IfcSchema::IfcMaterialLayerSet(
-		layers, 
-		S("Wall")
-#ifdef USE_IFC4
-		, null
-#endif
-	);
-	IfcSchema::IfcMaterialLayerSetUsage* layer_usage = new IfcSchema::IfcMaterialLayerSetUsage(
-		layer_set,
-		IfcSchema::IfcLayerSetDirectionEnum::IfcLayerSetDirection_AXIS2,
-		IfcSchema::IfcDirectionSenseEnum::IfcDirectionSense_POSITIVE,
-		-180
-#ifdef USE_IFC4
-		, null
-#endif
-	);
+	Ifc2x3::IfcMaterialLayerSet* layer_set = new Ifc2x3::IfcMaterialLayerSet(layers, S("Wall"));
+	Ifc2x3::IfcMaterialLayerSetUsage* layer_usage = new Ifc2x3::IfcMaterialLayerSetUsage(layer_set,
+		Ifc2x3::IfcLayerSetDirectionEnum::IfcLayerSetDirection_AXIS2,
+		Ifc2x3::IfcDirectionSenseEnum::IfcDirectionSense_POSITIVE, -180);
 
-	IfcSchema::IfcRelAssociatesMaterial* associates_material = new IfcSchema::IfcRelAssociatesMaterial(
-		guid(),
-		file.getSingle<IfcSchema::IfcOwnerHistory>(), 
-		null, 
-		null,
-#ifdef USE_IFC4
-		file.instances_by_type<IfcSchema::IfcWallStandardCase>()->generalize(),
-#else
-		file.instances_by_type<IfcSchema::IfcWallStandardCase>()->as<IfcSchema::IfcRoot>(),
-#endif
-		layer_usage);
+	Ifc2x3::IfcRelAssociatesMaterial* associates_material = new Ifc2x3::IfcRelAssociatesMaterial(guid(),
+		file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null,
+		file.EntitiesByType<Ifc2x3::IfcWallStandardCase>()->as<Ifc2x3::IfcRoot>(), layer_usage);
 
-	file.addEntity(material);
-	file.addEntity(layer);
-	file.addEntity(layer_set);	
-	file.addEntity(layer_usage);
-	file.addEntity(associates_material);
+	file.AddEntity(material);
+	file.AddEntity(layer);
+	file.AddEntity(layer_set);	
+	file.AddEntity(layer_usage);
+	file.AddEntity(associates_material);
 
 	// In addition, another common way to represent geometry in IFC files is to use extrusions of
 	// planar areas bounded by a polygon.
@@ -359,44 +226,30 @@ int main() {
 	stair_points.push_back(XY(500, 200));
 	stair_points.push_back(XY(500, 400));
 	stair_points.push_back(XY(  0, 400));
-	IfcSchema::IfcStairFlight* stair = new IfcSchema::IfcStairFlight(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(storey_placement, 5050, 1000, 0, 0, 1, 0, 1, 0, 0),
-		file.addExtrudedPolyline(stair_points, 1200), null, 2, 2, 0.2, 0.25
-#ifdef USE_IFC4
-		, IfcSchema::IfcStairFlightTypeEnum::IfcStairFlightType_STRAIGHT
-#endif
-	);
+	Ifc2x3::IfcStairFlight* stair = new Ifc2x3::IfcStairFlight(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+		null, null, null, file.addLocalPlacement(5050, 1000, 0, 0, 1, 0, 1, 0, 0),
+		file.addExtrudedPolyline(stair_points, 1200), null, 2, 2, 0.2, 0.25);
 
 	file.addBuildingProduct(stair);
 	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
-#ifdef USE_IFC4
-		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
-#endif	
-	);
-	file.addEntity(door_opening);
-	file.addEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, east_wall, door_opening));
+	Ifc2x3::IfcOpeningElement* door_opening = new Ifc2x3::IfcOpeningElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+		null, null, null, file.addLocalPlacement(5000-180, 2500-900, 0), file.addBox(1000, 1000, 2200), null);
+	file.AddEntity(door_opening);
+	file.AddEntity(new Ifc2x3::IfcRelVoidsElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null, east_wall, door_opening));
 
 	// A single shape representation can contain multiple representiation items. This way a product
 	// 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
-#ifdef USE_IFC4
-		, IfcSchema::IfcDoorTypeEnum::IfcDoorType_DOOR
-		, IfcSchema::IfcDoorTypeOperationEnum::IfcDoorTypeOperation_SINGLE_SWING_LEFT
-		, null
-#endif
-	);
+	Ifc2x3::IfcDoor* door = new Ifc2x3::IfcDoor(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null, null,
+		file.addLocalPlacement(4800, 1600, 0, 0, 0, 1, 0, 1, 0), 0, null, 2200, 1000);
 	door->setRepresentation(file.addBox(80, 80, 2120, 0, file.addPlacement3d(460, 0, 0)));
-	IfcSchema::IfcRepresentation::list::ptr door_representations = door->Representation()->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") {
-			door_body = (IfcSchema::IfcShapeRepresentation*) rep;
+	Ifc2x3::IfcRepresentation::list door_representations = door->Representation()->Representations();
+	Ifc2x3::IfcShapeRepresentation* door_body = 0;
+	for (Ifc2x3::IfcRepresentation::it i = door_representations->begin(); i != door_representations->end(); ++i) {
+		Ifc2x3::IfcRepresentation* rep = *i;
+		if (rep->is(Ifc2x3::Type::IfcShapeRepresentation) && rep->RepresentationIdentifier() == "Body") {
+			door_body = (Ifc2x3::IfcShapeRepresentation*) rep;
 		}
 	}
 	file.addBox(door_body,  80, 80, 2120, 0, file.addPlacement3d(-460, 0,   0));
@@ -404,11 +257,7 @@ int main() {
 	file.addBox(door_body, 860, 30, 2120);
 	file.addBuildingProduct(door);
 	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);
+	file.AddEntity(new Ifc2x3::IfcRelFillsElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null, door_opening, 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 
@@ -416,103 +265,82 @@ int main() {
 	// 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
 	// to align with the lowerleft corner of the constituent parts.
-	IfcSchema::IfcShapeRepresentation::list::ptr frame_representations(new IfcSchema::IfcShapeRepresentation::list);
-	
-	IfcSchema::IfcShapeRepresentation* horizontal_bar = file.addEmptyRepresentation();
-	IfcSchema::IfcShapeRepresentation* vertical_bar = file.addEmptyRepresentation();
-	file.addBox(horizontal_bar, 1860, 90, 90);
-	file.addBox(vertical_bar, 90, 90, 1420);
-
-	frame_representations->push(horizontal_bar);
-	frame_representations->push(horizontal_bar); // Add another reference to the horizontal bar created above
-	frame_representations->push(vertical_bar);
-	frame_representations->push(vertical_bar); // Add another reference to the vertical bar created above
+	Ifc2x3::IfcProductDefinitionShape::list frame_representations (new IfcTemplatedEntityList<Ifc2x3::IfcProductDefinitionShape>());
+	frame_representations->push(file.addBox(1860, 90, 90));
+	frame_representations->push(*frame_representations->begin()); // Add a reference to the shape created above
+	frame_representations->push(file.addBox(90, 90, 1420));
+	frame_representations->push(*(frame_representations->end()-1)); // Add a reference to the shape created above
 
 	// The beams all have the same surface style assigned
-	IfcSchema::IfcPresentationStyleAssignment* frame_style = 0;
-	for (IfcSchema::IfcShapeRepresentation::list::it i = frame_representations->begin(); i != frame_representations->end(); i += 2) {
+	Ifc2x3::IfcPresentationStyleAssignment* frame_style = 0;
+	for (Ifc2x3::IfcProductDefinitionShape::it i = frame_representations->begin(); i != frame_representations->end(); ++i) {
 		if (frame_style) {
 			file.setSurfaceColour(*i, frame_style);
 		} else {
 			frame_style = file.setSurfaceColour(*i, 0.5, 0.4, 0.3);
 		}
-		// Because of the duplication the iterator is incremented twice
 	}
 
 	// This window will be placed at five locations within the building. A list of placements is 
 	// created and is iterated over to create all window instances.
-	IfcSchema::IfcLocalPlacement::list::ptr window_placements (new IfcSchema::IfcLocalPlacement::list);
-	window_placements->push(file.addLocalPlacement(storey_placement, 2*-1770-430-930,   -45, 400));
-	window_placements->push(file.addLocalPlacement(storey_placement,   -1770-430-930,   -45, 400));
-	window_placements->push(file.addLocalPlacement(storey_placement,        -430-930,   -45, 400));
-	window_placements->push(file.addLocalPlacement(storey_placement,        3000-930,   -45, 400));
-	window_placements->push(file.addLocalPlacement(storey_placement, -4855+45, 885-930, 400, 0, 0, 1, 0, 1, 0));
+	Ifc2x3::IfcLocalPlacement::list window_placements (new IfcTemplatedEntityList<Ifc2x3::IfcLocalPlacement>());
+	window_placements->push(file.addLocalPlacement(2*-1770-430-930,   -45, 400));
+	window_placements->push(file.addLocalPlacement(  -1770-430-930,   -45, 400));
+	window_placements->push(file.addLocalPlacement(       -430-930,   -45, 400));
+	window_placements->push(file.addLocalPlacement(       3000-930,   -45, 400));
+	window_placements->push(file.addLocalPlacement(      -4855+45, 885-930, 400, 0, 0, 1, 0, 1, 0));
 	
-	for (IfcSchema::IfcLocalPlacement::list::it it = window_placements->begin(); it != window_placements->end(); ++it) {
+	for (Ifc2x3::IfcLocalPlacement::it it = window_placements->begin(); it != window_placements->end(); ++it) {
 		
 		// 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
-#ifdef USE_IFC4
-			, IfcSchema::IfcWindowTypeEnum::IfcWindowType_WINDOW
-			, IfcSchema::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioning_SINGLE_PANEL
-			, null
-#endif
-	);
+		Ifc2x3::IfcLocalPlacement* place = *it;
+		Ifc2x3::IfcWindow* window = new Ifc2x3::IfcWindow(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+			null, null, null, place, 0, null, 1600, 1860);
 		file.addBuildingProduct(window);		
 
-		// Initialize a list of parts for the window to be composed of
-		IfcSchema::IfcObjectDefinition::list::ptr window_parts(new IfcTemplatedEntityList<IfcSchema::IfcObjectDefinition>());
+		// Initalize a list of parts for the window to be composed of
+		Ifc2x3::IfcObjectDefinition::list window_parts(new IfcTemplatedEntityList<Ifc2x3::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));
-		frame_placements->push(file.addLocalPlacement(storey_placement,  930, 45, 1510));
-		frame_placements->push(file.addLocalPlacement(storey_placement, -885+930, 45,  90));
-		frame_placements->push(file.addLocalPlacement(storey_placement,  885+930, 45,  90));
+		Ifc2x3::IfcLocalPlacement::list frame_placements (new IfcTemplatedEntityList<Ifc2x3::IfcLocalPlacement>());
+		frame_placements->push(file.addLocalPlacement( 930,45));
+		frame_placements->push(file.addLocalPlacement( 930, 45, 1510));
+		frame_placements->push(file.addLocalPlacement(-885+930, 45,  90));
+		frame_placements->push(file.addLocalPlacement( 885+930, 45,  90));
 		
 		// Now iterate over the placements and representations of the beam and add them to list of parts
-		IfcSchema::IfcLocalPlacement::list::it frame_placement;
-		IfcSchema::IfcShapeRepresentation::list::it frame_representation;
+		Ifc2x3::IfcLocalPlacement::it frame_placement;
+		Ifc2x3::IfcProductDefinitionShape::it frame_representation;
 		for (frame_placement = frame_placements->begin(), frame_representation = frame_representations->begin();
 			frame_placement != frame_placements->end() && frame_representation != frame_representations->end();
 			++frame_placement, ++frame_representation)
 		{
-			IfcSchema::IfcMember* frame_part = new IfcSchema::IfcMember(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-				null, null, null, *frame_placement, file.addMappedItem(*frame_representation), null
-#ifdef USE_IFC4
-				, IfcSchema::IfcMemberTypeEnum::IfcMemberType_MULLION
-#endif
-			);
-			file.addEntity(frame_part);
+			Ifc2x3::IfcMember* frame_part = new Ifc2x3::IfcMember(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+				null, null, null, *frame_placement, *frame_representation, null);
+			file.AddEntity(frame_part);
 			window_parts->push(frame_part);
 			file.relatePlacements(window, frame_part);
 		}
 
 		// Add the glass plate to the list of parts
-		IfcSchema::IfcPlate* glass_part = new IfcSchema::IfcPlate(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null,
-			null, null, file.addLocalPlacement(storey_placement, 930, 45, 90), file.addBox(1680, 10, 1420), null
-#ifdef USE_IFC4
-			, IfcSchema::IfcPlateTypeEnum::IfcPlateType_SHEET
-#endif
-		);
-		file.addEntity(glass_part);
+		Ifc2x3::IfcPlate* glass_part = new Ifc2x3::IfcPlate(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null,
+			null, null, file.addLocalPlacement(930, 45, 90), file.addBox(1680, 10, 1420), null);
+		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);
 		
 		// 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.
-		IfcSchema::IfcRelDecomposes* decomposition = new IfcSchema::IfcRelAggregates(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
+		Ifc2x3::IfcRelDecomposes* decomposition = new Ifc2x3::IfcRelAggregates(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
 			null, null, window, window_parts);
-		file.addEntity(decomposition);		
+		file.AddEntity(decomposition);		
 	}
 
 	// Finally create a file stream for our output and write the IFC file to it.
@@ -557,6 +385,6 @@ void createGroundShape(TopoDS_Shape& shape) {
 #if OCC_VERSION_HEX < 0x60502
 	shape = BRepBuilderAPI_MakeFace(surf);
 #else
-	shape = BRepBuilderAPI_MakeFace(surf, Precision::Confusion());
+	shape = BRepBuilderAPI_MakeFace(surf, 1);
 #endif
 }

src/examples/IfcParseExamples.cpp

@@ -17,15 +17,9 @@
  *                                                                              *
  ********************************************************************************/
 
-// TODO: Multiple schemas
-#define IfcSchema Ifc2x3
+#include "../ifcparse/IfcParse.h"
 
-#include "../ifcparse/IfcFile.h"
-#include "../ifcparse/Ifc2x3.h"
-
-#if USE_VLD
-#include <vld.h>
-#endif
+using namespace Ifc2x3;
 
 int main(int argc, char** argv) {
 
@@ -38,15 +32,15 @@ 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;
 	}
 
 	// Lets get a list of IfcBuildingElements, this is the parent
 	// type of things like walls, windows and doors.
-	// entitiesByType is a templated function and returns a
+	// EntitiesByType is a templated function and returns a
 	// templated class that behaves like a std::vector.
 	// Note that the return types are all typedef'ed as members of
 	// the generated classes, ::list for the templated vector class,
@@ -60,18 +54,19 @@ 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 elements = file.EntitiesByType<IfcBuildingElement>();
 
-	std::cout << "Found " << elements->size() << " elements in " << argv[1] << ":" << std::endl;
+	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::it it = elements->begin(); it != elements->end(); ++ it ) {
 		
-		const IfcSchema::IfcBuildingElement* element = *it;
-		std::cout << element->data().toString() << std::endl;
+		const IfcBuildingElement::ptr 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()) {
+		if ( element->is(IfcWindow::Class()) ) {
+			const IfcWindow::ptr window = reinterpret_pointer_cast<IfcBuildingElement,IfcWindow>(element);
+			
+			if ( window->hasOverallWidth() && window->hasOverallHeight() ) {
 				const double area = window->OverallWidth()*window->OverallHeight();
 				std::cout << "The area of this window is " << area << std::endl;
 			}

src/examples/arbitrary_open_profile_def.cpp

@@ -1,140 +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 representations from                          *
- * IfcArbitraryOpenProfileDefs and its subclass IfcCenterLineProfileDef         *
- *                                                                              *
- ********************************************************************************/
-
-#include <string>
-#include <iostream>
-#include <fstream>
-
-#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 = boost::none;
-static int i = 0;
-
-void create_product_from_item(IfcHierarchyHelper& file, IfcSchema::IfcRepresentationItem* item, const std::string& s) {
-	IfcSchema::IfcBuildingElementProxy* product = new IfcSchema::IfcBuildingElementProxy(
-		guid(), 0, S("product"), null, null, 0, 0, null, null);
-	file.addBuildingProduct(product);
-	product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
-
-	product->setObjectPlacement(file.addLocalPlacement(0, 120 * i++));
-
-	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list());
-	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list());
-	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->push(set);
-	}
-		
-	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
-		file.getSingle<IfcSchema::IfcRepresentationContext>(), S("Body"), s, items);
-	reps->push(rep);
-
-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
-	file.addEntity(rep);
-	file.addEntity(shape);
-		
-	product->setRepresentation(shape);
-}
-
-void create_surfaces_from_profile(IfcHierarchyHelper& file, IfcSchema::IfcProfileDef* profile) {
-	IfcSchema::IfcSurfaceOfLinearExtrusion* extrusion = new IfcSchema::IfcSurfaceOfLinearExtrusion(profile, file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 100.);
-	file.addEntity(extrusion);
-
-	IfcSchema::IfcAxis1Placement* ax1 = new IfcSchema::IfcAxis1Placement(file.addTriplet<IfcSchema::IfcCartesianPoint>(0,100,0), file.addTriplet<IfcSchema::IfcDirection>(1,0,0));
-	IfcSchema::IfcSurfaceOfRevolution* revolution = new IfcSchema::IfcSurfaceOfRevolution(profile, file.addPlacement3d(), ax1);
-	file.addEntity(ax1);
-	file.addEntity(revolution);
-
-	create_product_from_item(file, extrusion, "GeometricSet");
-	create_product_from_item(file, revolution, "GeometricSet");
-}
-
-void create_solids_from_profile(IfcHierarchyHelper& file, IfcSchema::IfcProfileDef* profile) {
-	IfcSchema::IfcExtrudedAreaSolid* extrusion = new IfcSchema::IfcExtrudedAreaSolid(profile, file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 100.);
-	file.addEntity(extrusion);
-
-	IfcSchema::IfcAxis1Placement* ax1 = new IfcSchema::IfcAxis1Placement(file.addTriplet<IfcSchema::IfcCartesianPoint>(0,100,0), file.addTriplet<IfcSchema::IfcDirection>(1,0,0));
-	IfcSchema::IfcRevolvedAreaSolid* revolution1 = new IfcSchema::IfcRevolvedAreaSolid(profile, file.addPlacement3d(), ax1, 360.);
-	IfcSchema::IfcRevolvedAreaSolid* revolution2 = new IfcSchema::IfcRevolvedAreaSolid(profile, file.addPlacement3d(), ax1, 90.);
-	file.addEntity(ax1);
-	file.addEntity(revolution1);
-	file.addEntity(revolution2);
-
-	create_product_from_item(file, extrusion, "SweptSolid");
-	create_product_from_item(file, revolution1, "SweptSolid");
-	create_product_from_item(file, revolution2, "SweptSolid");
-}
-
-void create_products_from_curve(IfcHierarchyHelper& file, IfcSchema::IfcBoundedCurve* curve) {
-	IfcSchema::IfcArbitraryOpenProfileDef* open = new IfcSchema::IfcArbitraryOpenProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_CURVE, null, curve);
-	IfcSchema::IfcCenterLineProfileDef* center_line = new IfcSchema::IfcCenterLineProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, null, curve, 10.);
-	file.addEntity(open);
-	file.addEntity(center_line);
-
-	create_surfaces_from_profile(file, open);
-	create_solids_from_profile(file, center_line);
-}
-
-int main(int argc, char** argv) {
-	const char filename[] = "IfcArbitraryOpenProfileDef.ifc";
-	IfcHierarchyHelper file;
-	file.header().file_name().name(filename);
-
-	double coords1[] = {-50.0, 0.0};
-	double coords2[] = { 50.0, 0.0};
-	IfcSchema::IfcCartesianPoint::list::ptr points (new IfcSchema::IfcCartesianPoint::list());
-	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());
-	IfcSchema::IfcPolyline* poly = new IfcSchema::IfcPolyline(points);
-	file.addEntity(poly);
-
-	create_products_from_curve(file, poly);
-
-	IfcSchema::IfcEllipse* ellipse = new IfcSchema::IfcEllipse(file.addPlacement2d(), 50., 25.);
-	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.));
-	IfcSchema::IfcTrimmedCurve* trim = new IfcSchema::IfcTrimmedCurve(ellipse, trim1, trim2, true, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	file.addEntity(trim);
-
-	create_products_from_curve(file, trim);
-
-	file.getSingle<Ifc2x3::IfcProject>()->setName("IfcArbitraryOpenProfileDef");
-
-	std::ofstream f(filename);
-	f << file;
-}

src/examples/composite_profile_def.cpp

@@ -1,119 +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 extrusions of parameterized profiles.                 *
- *                                                                              *
- ********************************************************************************/
-
-#include <string>
-#include <iostream>
-#include <fstream>
-
-#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 = boost::none;
-
-int main(int argc, char** argv) {
-	const char filename[] = "IfcCompositeProfileDef.ifc";
-	IfcHierarchyHelper file;
-	file.header().file_name().name(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::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);
-	
-	IfcSchema::IfcProfileDef* p1 = new Ifc2x3::IfcIShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, file.addPlacement2d(),    25.0,    50.0,     5.0,     5.0,     2.0);
-
-	IfcSchema::IfcProfileDef* p2 = new Ifc2x3::IfcLShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, file.addPlacement2d(),    50.0,    25.0,     5.0,      1.0,     2.0,     2.0,    null,    null);
-
-	IfcSchema::IfcProfileDef* p3 = new Ifc2x3::IfcTShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, file.addPlacement2d(),    50.0,    40.0,    10.0,     10.0,     3.0,     2.0,     1.0,     2.0,     2.0,    null);
-
-	IfcSchema::IfcProfileDef* p4 = new Ifc2x3::IfcCShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, file.addPlacement2d(80.),    50.0,    25.0,     5.0,    10.0,     2.0,    null);
-
-	file.addEntity(p2);
-	file.addEntity(p3);
-	
-	file.addEntity(transform1);
-	file.addEntity(transform2);
-	
-	IfcSchema::IfcDerivedProfileDef* p5 = new IfcSchema::IfcDerivedProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, null, p2, transform1, null);
-	IfcSchema::IfcDerivedProfileDef* p6 = new IfcSchema::IfcDerivedProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, null, p3, transform2, null);
-	
-	profiles->push(p1);
-	profiles->push(p5);
-	profiles->push(p6);
-	profiles->push(p4);
-
-	file.addEntities(profiles->generalize());
-
-	IfcSchema::IfcCompositeProfileDef* composite = new IfcSchema::IfcCompositeProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, S("IFC"), profiles, null);
-
-	IfcSchema::IfcBuildingElementProxy* product = new IfcSchema::IfcBuildingElementProxy(
-			guid(), 0, S("profile"), null, null, 0, 0, null, null);
-
-	file.addBuildingProduct(product);
-
-	product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
-
-	product->setObjectPlacement(file.addLocalPlacement());
-
-	IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(composite,
-		file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 20.0);
-
-	file.addEntity(composite);
-	file.addEntity(solid);
-		
-	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("SweptSolid"), items);
-	reps->push(rep);
-
-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
-	file.addEntity(rep);
-	file.addEntity(shape);
-		
-	product->setRepresentation(shape);
-
-	file.getSingle<IfcSchema::IfcProject>()->setName("IfcCompositeProfileDef");
-
-	std::ofstream f(filename);
-	f << file;
-}

src/examples/csg_primitive.cpp

@@ -1,193 +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 a Constructive Solid Geometry example                 *
- *                                                                              *
- ********************************************************************************/
-
-#include <string>
-#include <iostream>
-#include <fstream>
-
-#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 = boost::none;
-
-class Node {
-private:
-	typedef enum {
-		OP_ADD, OP_SUBTRACT, OP_INTERSECT, OP_TERMINAL
-	} Op;
-	typedef enum {
-		PRIM_BOX, PRIM_CONE, PRIM_CYLINDER, PRIM_PYRAMID, PRIM_SPHERE
-	} Prim;
-
-	double x,y,z, zx,zy,zz, xx,xy,xz, a,b,c;
-	const Node *left, *right;
-	
-	Op op;
-	Prim prim;
-
-	Node& operate(Op op, const Node& p) {
-		left = new Node(*this);
-		right = new Node(p);
-		this->op = op;
-		return *this;
-	}
-
-	Node(Prim p, double la, double lb=0., double lc=0.)
-		: prim(p), op(OP_TERMINAL),
-		  x(0.), y(0.), z(0.), 
-		  zx(0.), zy(0.), zz(1.), 
-		  xx(1.), xy(0.), xz(0.), 
-		  a(la), b(lb), c(lc) {}
-public:
-	static Node Sphere(double r) {
-		return Node(PRIM_SPHERE, r);
-	}
-	static Node Box(double dx, double dy, double dz) {
-		return Node(PRIM_BOX, dx, dy, dz);
-	}
-	static Node Pyramid(double dx, double dy, double dz) {
-		return Node(PRIM_PYRAMID, dx, dy, dz);
-	}
-	static Node Cylinder(double r, double h) {
-		return Node(PRIM_CYLINDER, r, h);
-	}
-	static Node Cone(double r, double h) {
-		return Node(PRIM_CONE, r, h);
-	}
-
-	Node& move(
-		double px = 0., double py = 0., double pz = 0., 
-		double zx = 0., double zy = 0., double zz = 1., 
-		double xx = 1., double xy = 0., double xz = 0.) 
-	{
-		this->x = px; this->y = py;	this->z = pz;
-		this->zx = zx; this->zy = zy; this->zz = zz;
-		this->xx = xx; this->xy = xy; this->xz = xz;
-		return *this;
-	}
-
-	Node& add(const Node& p) {
-		return operate(OP_ADD, p);
-	}
-	Node& subtract(const Node& p) {
-		return operate(OP_SUBTRACT, p);
-	}
-	Node& intersect(const Node& p) {
-		return operate(OP_INTERSECT, p);
-	}
-
-	IfcSchema::IfcRepresentationItem* serialize(IfcHierarchyHelper& file) const {
-		IfcSchema::IfcRepresentationItem* my;
-		if (op == OP_TERMINAL) {
-			IfcSchema::IfcAxis2Placement3D* place = file.addPlacement3d(x,y,z,zx,zy,zz,xx,xy,xz);
-			if (prim == PRIM_SPHERE) {
-				my = new IfcSchema::IfcSphere(place, a);
-			} else if (prim == PRIM_BOX) {
-				my = new IfcSchema::IfcBlock(place, a, b, c);
-			} else if (prim == PRIM_PYRAMID) {
-				my = new IfcSchema::IfcRectangularPyramid(place, a, b, c);
-			} else if (prim == PRIM_CYLINDER) {
-				my = new IfcSchema::IfcRightCircularCylinder(place, b, a);
-			} else if (prim == PRIM_CONE) {
-				my = new IfcSchema::IfcRightCircularCone(place, b, a);
-			}
-		} else {
-			IfcSchema::IfcBooleanOperator::IfcBooleanOperator o;
-			if (op == OP_ADD) {
-				o = IfcSchema::IfcBooleanOperator::IfcBooleanOperator_UNION;
-			} else if (op == OP_SUBTRACT) {
-				o = IfcSchema::IfcBooleanOperator::IfcBooleanOperator_DIFFERENCE;
-			} else if (op == OP_INTERSECT) {
-				o = IfcSchema::IfcBooleanOperator::IfcBooleanOperator_INTERSECTION;
-			}
-			my = new IfcSchema::IfcBooleanResult(o, left->serialize(file), right->serialize(file));
-		}
-		file.addEntity(my);
-		return my;
-	}
-};
-
-int main(int argc, char** argv) {
-	const char filename[] = "IfcCsgPrimitive.ifc";
-	IfcHierarchyHelper file;
-	file.header().file_name().name(filename);
-
-	IfcSchema::IfcRepresentationItem* csg1 = Node::Box(8000.,6000.,3000.).subtract(
-		Node::Box(7600.,5600.,2800.).move(200.,200.,200.)
-	).add(
-		Node::Pyramid(8000.,6000.,3000.).move(0,0,3000.).add(
-			Node::Cylinder(1000.,4000.).move(4000.,1000.,4000., 0.,1.,0.)
-		).subtract(
-			Node::Pyramid(7600.,5600.,2800.).move(200.,200.,3000.)
-		).subtract(
-			Node::Cylinder(900.,4000.).move(4000.,1000.,4000., 0.,1.,0.).intersect(
-				Node::Box(2000.,4000.,1000.).move(3000.,1000.,4000.)
-			)
-		)
-	).serialize(file);
-
-	const double x = 1000.; const double y = -4000.;
-
-	IfcSchema::IfcRepresentationItem* csg2 = Node::Sphere(5000.).move(x,y,-4500.).intersect(
-		Node::Box(6000., 6000., 6000.).move(x-3000., y-3000., 0.)
-	).add(
-		Node::Cone(500., 3000.).move(x,y).add(
-			Node::Cone(1500., 1000.).move(x,y, 900.).add(
-				Node::Cone(1100., 1000.).move(x,y, 1800.).add(
-					Node::Cone(750., 600.).move(x,y, 2700.)
-	)))).serialize(file);
-
-	IfcSchema::IfcBuildingElementProxy* product = new IfcSchema::IfcBuildingElementProxy(
-			guid(), 0, S("IfcCsgPrimitive"), 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());
-		
-	items->push(csg1);
-	items->push(csg2);
-	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
-		file.getSingle<IfcSchema::IfcRepresentationContext>(), S("Body"), S("CSG"), items);
-	reps->push(rep);
-
-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(null, null, reps);
-	file.addEntity(rep);
-	file.addEntity(shape);
-		
-	product->setRepresentation(shape);
-
-	file.getSingle<IfcSchema::IfcProject>()->setName("IfcCompositeProfileDef");
-
-	std::ofstream f(filename);
-	f << file;
-}

src/examples/ellipse_pies.cpp

@@ -1,148 +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 profiles of trimmed ellipses.                         *
- *                                                                              *
- ********************************************************************************/
-
-#include <string>
-#include <iostream>
-#include <fstream>
-
-#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 = boost::none;
-
-typedef struct {
-	double r1;
-	double r2;
-	double t1;
-	double t2;
-} EllipsePie;
-
-static int i = 0;
-
-void create_testcase_for(IfcHierarchyHelper& file, const EllipsePie& pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference pref) {
-	const double deg = 1. / 180. * 3.141592653;
-	double flt1[] = {0.                      , 0.                      };
-	double flt2[] = {pie.r1 * cos(pie.t1*deg), pie.r2 * sin(pie.t1*deg)};
-	double flt3[] = {pie.r1 * cos(pie.t2*deg), pie.r2 * sin(pie.t2*deg)};
-
-	std::vector<double> coords1(flt1, flt1 + 2);
-	std::vector<double> coords2(flt2, flt2 + 2);
-	std::vector<double> coords3(flt3, flt3 + 2);
-	
-	Ifc2x3::IfcCartesianPoint* p1 = new Ifc2x3::IfcCartesianPoint(coords1);
-	Ifc2x3::IfcCartesianPoint* p2 = new Ifc2x3::IfcCartesianPoint(coords2);
-	Ifc2x3::IfcCartesianPoint* p3 = new Ifc2x3::IfcCartesianPoint(coords3);
-	
-	Ifc2x3::IfcCartesianPoint::list::ptr points(new Ifc2x3::IfcCartesianPoint::list());
-	points->push(p3);
-	points->push(p1);
-	points->push(p2);
-	file.addEntities(points->generalize());
-
-	
-	Ifc2x3::IfcEllipse* ellipse = new Ifc2x3::IfcEllipse(file.addPlacement2d(), pie.r1, pie.r2);
-	file.addEntity(ellipse);
-	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));
-	} else {
-		trim1->push(p2);
-		trim2->push(p3);
-	}
-	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* s2 = new Ifc2x3::IfcCompositeCurveSegment(Ifc2x3::IfcTransitionCode::IfcTransitionCode_CONTINUOUS, true, trim);
-	
-	Ifc2x3::IfcPolyline* poly = new Ifc2x3::IfcPolyline(points);	
-	file.addEntity(poly);
-	Ifc2x3::IfcCompositeCurveSegment* s1 = new Ifc2x3::IfcCompositeCurveSegment(Ifc2x3::IfcTransitionCode::IfcTransitionCode_CONTINUOUS, true, poly);
-	segments->push(s1);
-	
-	segments->push(s2);
-	file.addEntities(segments->generalize());
-	
-	Ifc2x3::IfcCompositeCurve* ccurve = new Ifc2x3::IfcCompositeCurve(segments, false);
-	Ifc2x3::IfcArbitraryClosedProfileDef* profile = new Ifc2x3::IfcArbitraryClosedProfileDef(Ifc2x3::IfcProfileTypeEnum::IfcProfileType_AREA, null, ccurve);
-	file.addEntity(ccurve);
-	file.addEntity(profile);
-
-	IfcSchema::IfcBuildingElementProxy* product = new IfcSchema::IfcBuildingElementProxy(
-		guid(), 0, S("profile"), null, null, 0, 0, null, null);
-	file.addBuildingProduct(product);
-	product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
-
-	product->setObjectPlacement(file.addLocalPlacement(0, 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());
-		
-	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);
-	file.addEntity(rep);
-	file.addEntity(shape);
-		
-	product->setRepresentation(shape);
-}
-
-int main(int argc, char** argv) {
-	const std::string filename = "ellipse_pies.ifc";
-	IfcHierarchyHelper file;
-	{ EllipsePie pie = {80., 50.,  0., 150.};
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
-	{ EllipsePie pie = {80,  50., 30., 300.};
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
-	{ EllipsePie pie = {80,  50., 300., 30.};
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
-	{ EllipsePie pie = {50., 80.,  0., 150.};
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
-	{ EllipsePie pie = {50,  80., 30., 300.};
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
-	{ EllipsePie pie = {50,  80., 300., 30.};
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
-	std::ofstream f(filename.c_str());
-	f << file;
-}

src/examples/faces.cpp

@@ -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;
-}

src/examples/ifc_curve_rebar.cpp

@@ -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;
-}

src/examples/profiles.cpp

@@ -1,206 +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 extrusions of parameterized profiles.                 *
- *                                                                              *
- ********************************************************************************/
-
-#include <string>
-#include <iostream>
-#include <fstream>
-
-#include "../ifcparse/Ifc2x3.h"
-#include "../ifcparse/IfcUtil.h"
-#include "../ifcparse/IfcHierarchyHelper.h"
-
-typedef std::string S;
-typedef IfcWrite::IfcGuidHelper guid;
-boost::none_t const null = (static_cast<boost::none_t>(0));
-
-void create_testcase_for(IfcSchema::IfcProfileDef::list::ptr profiles) {
-	IfcSchema::IfcProfileDef* profile = *profiles->begin();
-	const std::string profile_type = IfcSchema::Type::ToString(profile->type());
-	const std::string filename = profile_type + ".ifc";
-	
-	IfcHierarchyHelper file;
-	file.filename(filename);
-	
-	int i = 0;
-	for (IfcSchema::IfcProfileDef::list::it it = profiles->begin(); it != profiles->end(); ++it, ++i) {
-		IfcSchema::IfcProfileDef* profile = *it;
-		IfcSchema::IfcBuildingElementProxy* product = new IfcSchema::IfcBuildingElementProxy(
-			guid(), 0, S("profile"), null, null, 0, 0, null, null);
-		file.addBuildingProduct(product);
-		file.getSingle<IfcSchema::IfcProject>()->setName(profile_type);
-		product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
-
-		product->setObjectPlacement(file.addLocalPlacement(0, 100. * i));
-
-		if (profile->is(IfcSchema::Type::IfcParameterizedProfileDef)) {
-			((IfcSchema::IfcParameterizedProfileDef*) profile)->setPosition(file.addPlacement2d());
-		}
-
-		IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(profile,
-			file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 20.0);
-
-		file.addEntity(profile);
-		file.addEntity(solid);
-		
-		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("SweptSolid"), items);
-		reps->push(rep);
-
-		IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
-		file.addEntity(rep);
-		file.addEntity(shape);
-		
-		product->setRepresentation(shape);
-	}
-	
-	std::ofstream f(filename.c_str());
-	f << file;
-}
-
-int main(int argc, char** argv) {
-	{ IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new Ifc2x3::IfcUShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     5.0,    null,    null,    null,    null));
-	profiles->push(new Ifc2x3::IfcUShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     5.0,     2.0,     2.0,    null,    null));
-	profiles->push(new Ifc2x3::IfcUShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     5.0,    null,    null,     4.0,    null));
-	profiles->push(new Ifc2x3::IfcUShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     5.0,     1.0,     3.0,     6.0,    null));
-	create_testcase_for(profiles); }
-	
-    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new Ifc2x3::IfcTShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     5.0,    null,    null,    null,    null,    null,    null));
-	profiles->push(new Ifc2x3::IfcTShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     5.0,     2.0,     2.0,     2.0,    null,    null,    null));
-	profiles->push(new Ifc2x3::IfcTShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     5.0,    null,    null,    null,     2.0,     2.0,    null));
-	profiles->push(new Ifc2x3::IfcTShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     5.0,     3.0,     2.0,     1.0,     2.0,     2.0,    null));
-	create_testcase_for(profiles); }
-	
-    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new Ifc2x3::IfcZShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     5.0,    null,    null));
-	profiles->push(new Ifc2x3::IfcZShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     5.0,     2.0,     2.0));
-	create_testcase_for(profiles); }
-	
-    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new Ifc2x3::IfcEllipseProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    25.0,    15.0));
-	profiles->push(new Ifc2x3::IfcEllipseProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    15.0,    25.0));
-	create_testcase_for(profiles); }
-	
-    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new Ifc2x3::IfcIShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    25.0,    50.0,     5.0,     5.0,    null));
-	profiles->push(new Ifc2x3::IfcIShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    25.0,    50.0,     5.0,     5.0,     2.0));
-	profiles->push(new Ifc2x3::IfcAsymmetricIShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    25.0,    50.0,     5.0,     5.0,     2.0, 20.0, 10.0, 5.0, null));
-	create_testcase_for(profiles); }
-
-    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new Ifc2x3::IfcLShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     null,    null,    null,    null,    null));
-	profiles->push(new Ifc2x3::IfcLShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     2.0,      2.0,    null,    null,    null));
-	profiles->push(new Ifc2x3::IfcLShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     null,    null,     2.0,    null,    null));
-	profiles->push(new Ifc2x3::IfcLShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,      1.0,     2.0,     2.0,    null,    null));
-	create_testcase_for(profiles); }
-	
-    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new Ifc2x3::IfcCShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,    10.0,    null,    null));
-	profiles->push(new Ifc2x3::IfcCShapeProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,    10.0,     2.0,    null));
-	create_testcase_for(profiles); }
-
-    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new Ifc2x3::IfcCircleProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    25.0));
-	profiles->push(new Ifc2x3::IfcCircleHollowProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    25.0,     5.0));
-	create_testcase_for(profiles); }
-	
-    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new Ifc2x3::IfcRectangleProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0));
-	profiles->push(new Ifc2x3::IfcRoundedRectangleProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0));
-	profiles->push(new Ifc2x3::IfcRectangleHollowProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,    null,    null));
-	profiles->push(new Ifc2x3::IfcRectangleHollowProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    25.0,     5.0,     2.0,     4.0));
-	create_testcase_for(profiles); }
-	
-    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new Ifc2x3::IfcTrapeziumProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    30.0,    25.0,     0.0));
-	profiles->push(new Ifc2x3::IfcTrapeziumProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    60.0,    25.0,   -20.0));
-	profiles->push(new Ifc2x3::IfcTrapeziumProfileDef(
-		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
-		null, 0,    50.0,    10.0,    25.0,    30.0));
-	create_testcase_for(profiles); }
-}

src/examples/triangulated_faceset.cpp

@@ -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;
-}

src/ifcblender/io_import_scene_ifc/__init__.py

@@ -27,146 +27,107 @@
 
 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
-    if "ifcopenshell" in locals():
-        importlib.reload(ifcopenshell)
+    import imp
+    if "IfcImport" in locals():
+        imp.reload(IfcImport)
 
 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)}...")
-    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()
+def import_ifc(filename, use_names, process_relations):
+    from . import IfcImport
+    print("Reading %s..."%bpy.path.basename(filename))
+    valid_file = IfcImport.Init(filename)
     if not valid_file:
+        IfcImport.CleanUp()
         return False
     print("Done reading file")
     id_to_object = {}
     id_to_parent = {}
     id_to_matrix = {}
-    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
-        matids = ob.geometry.material_ids
-        m = ob.transformation.matrix.data
+        ob = IfcImport.Get()
+ 
+        f = ob.mesh.faces
+        v = ob.mesh.verts
+        mats = ob.mesh.materials
+        matids = ob.mesh.material_ids
+        m = ob.matrix        
         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.mesh.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')
@@ -174,60 +135,58 @@ def import_ifc(filename, use_names, process_relations, blender_booleans):
         bob.ifc_id, bob.ifc_guid, bob.ifc_name, bob.ifc_type = \
             ob.id, ob.guid, ob.name, ob.type
 
-        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 = ob.type == 'IfcSpace' or ob.type == 'IfcOpeningElement'
+        bob.hide_render = bob.hide
+        
+        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)
-
-        progress = iterator.progress() // 2
+            
+        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 = IfcImport.Progress() // 2
         if progress > old_progress:
             print("\r[" + "#" * progress + " " * (50 - progress) + "]", end="")
             old_progress = progress
-        if not iterator.next():
+        if not IfcImport.Next():
             break
 
     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:
-            parent_ob = iterator.getObject(parent_id)
+            parent_ob = IfcImport.GetObject(parent_id)
             if parent_ob.id == -1:
                 bob = None
             else:
-                m = parent_ob.transformation.matrix.data
+                m = parent_ob.matrix
                 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,27 +209,18 @@ 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")
+    
+    txt = bpy.data.texts.new("%s.log"%bpy.path.basename(filename))
+    txt.from_string(IfcImport.GetLog())
 
-    for opening_id in openings:
-        parent_id = id_to_parent[opening_id]
-        if parent_id in id_to_object:
-            parent_ob = id_to_object[parent_id][0]
-            for opening_ob in id_to_object[opening_id]:
-                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())
-
+    IfcImport.CleanUp()
+    
     return True
 
 
@@ -279,51 +229,38 @@ 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)
 
     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.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__":

src/ifcconvert/ColladaSerializer.cpp

@@ -0,0 +1,285 @@
+/********************************************************************************
+ *                                                                              *
+ * 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<float>& 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<float>::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<float>& positions, const std::vector<float>& normals, const std::vector<int>& indices, const std::vector<int> material_ids, const std::vector<IfcGeomObjects::Material>& materials) {
+	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 = -2;
+	for (std::vector<int>::const_iterator it = indices.begin(); ; it += 3) {
+		const int current_material_id = material_it == material_ids.end()
+			? -3
+			: *(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(collada_id(previous_material_id < 0
+				? default_material_name
+				: 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<float>& 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 IfcGeomObjects::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 IfcGeomObjects::Material& material) {
+	if (!contains(material)) {
+		effects.write(material);
+		materials.push_back(material);
+	}
+}
+
+bool ColladaSerializer::ColladaExporter::ColladaMaterials::contains(const IfcGeomObjects::Material& material) {
+	return std::find(materials.begin(), materials.end(), material) != materials.end();
+}
+
+void ColladaSerializer::ColladaExporter::ColladaMaterials::write() {
+	effects.close();
+	for (std::vector<IfcGeomObjects::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::writeTesselated(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<float>& matrix, const std::vector<float>& vertices, const std::vector<float>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, const std::vector<IfcGeomObjects::Material>& _materials) {
+	const IfcGeomObjects::Material default_for_type = IfcGeomObjects::Material(IfcGeom::get_default_style(type));
+	std::vector<std::string> material_references;
+	const bool needs_default = std::find(material_ids.begin(), material_ids.end(), -1) != material_ids.end();
+	if (needs_default) {
+		if (!materials.contains(default_for_type)) {
+			materials.add(default_for_type);
+		}
+		material_references.push_back(collada_id(default_for_type.name()));
+	}	
+	for (std::vector<IfcGeomObjects::Material>::const_iterator it = _materials.begin(); it != _materials.end(); ++it) {
+		const IfcGeomObjects::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::writeTesselated(const IfcGeomObjects::IfcGeomObject* o) {
+	const IfcGeomObjects::IfcRepresentationTriangulation& mesh = o->mesh();
+	exporter.writeTesselated(o->guid(), o->name(), o->type(), o->id(), o->matrix(), mesh.verts(), mesh.normals(), mesh.faces(), mesh.material_ids(), mesh.materials());
+}
+
+void ColladaSerializer::finalize() {
+	exporter.endDocument();
+}
+
+#endif

src/ifcconvert/ColladaSerializer.h

@@ -0,0 +1,164 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcGeomObjects.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<float>& floats, const char* coords = "XYZ");
+			void write(const std::string mesh_id, const std::string& default_material_name, const std::vector<float>& positions, const std::vector<float>& normals, const std::vector<int>& indices, const std::vector<int> material_ids, const std::vector<IfcGeomObjects::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<float>& 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 IfcGeomObjects::Material& material);
+				void close();
+			};
+			std::vector<IfcGeomObjects::Material> materials;
+			ColladaEffects effects;
+		public:
+			explicit ColladaMaterials(COLLADASW::StreamWriter& stream)
+				: COLLADASW::LibraryMaterials(&stream)
+				, effects(stream)
+			{}
+			void add(const IfcGeomObjects::Material& material);
+			bool contains(const IfcGeomObjects::Material& material);
+			void write();
+		};
+		class DeferredObject {
+		public:
+			std::string guid, name, type;
+			int obj_id;
+			std::vector<float> matrix;
+			std::vector<float> vertices;
+			std::vector<float> normals;
+			std::vector<int> indices;
+			std::vector<int> material_ids;
+			std::vector<IfcGeomObjects::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<float>& matrix, const std::vector<float>& vertices,
+				const std::vector<float>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, 
+				const std::vector<IfcGeomObjects::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 writeTesselated(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<float>& matrix, const std::vector<float>& vertices, const std::vector<float>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, const std::vector<IfcGeomObjects::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 writeTesselated(const IfcGeomObjects::IfcGeomObject* o);
+	void writeShapeModel(const IfcGeomObjects::IfcGeomShapeModelObject* o) {}
+	void finalize();
+	bool isTesselated() const { return true; }
+	void setUnitNameAndMagnitude(const std::string& name, float magnitude) {
+		unit_name = name;
+		unit_magnitude = magnitude;
+	}
+};
+
+#endif
+
+#endif

src/ifcconvert/GeometrySerializer.h

@@ -17,19 +17,21 @@
  *                                                                              *
  ********************************************************************************/
 
-#ifndef SERIALIZER_H
-#define SERIALIZER_H
+#ifndef GEOMETRYSERIALIZER_H
+#define GEOMETRYSERIALIZER_H
 
-#include "../ifcparse/IfcFile.h"
+#include "../ifcgeom/IfcGeomObjects.h"
 
-class Serializer {
+class GeometrySerializer {
 public:
-	virtual ~Serializer() {}
-
 	virtual bool ready() = 0;
 	virtual void writeHeader() = 0;
 	virtual void finalize() = 0;
-	virtual void setFile(IfcParse::IfcFile*) = 0;
+	virtual bool isTesselated() const = 0;
+	virtual ~GeometrySerializer() {} 
+	virtual void writeTesselated(const IfcGeomObjects::IfcGeomObject* o) = 0;
+	virtual void writeShapeModel(const IfcGeomObjects::IfcGeomShapeModelObject* o) = 0;
+	virtual void setUnitNameAndMagnitude(const std::string& name, float magnitude) = 0;
 };
 
 #endif

src/ifcconvert/IgesSerializer.h

@@ -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/IfcGeomObjects.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

src/ifcconvert/OpenCascadeBasedSerializer.cpp

@@ -17,54 +17,72 @@
  *                                                                              *
  ********************************************************************************/
 
-#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;
-
-	if (o->geometry().settings().get(IfcGeom::IteratorSettings::CONVERT_BACK_UNITS)) {
-		gp_Trsf scale;
-		scale.SetScaleFactor(1.0 / o->geometry().settings().unit_magnitude());
+void OpenCascadeBasedSerializer::writeShapeModel(const IfcGeomObjects::IfcGeomShapeModelObject* o) {		
+	for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = o->mesh().begin(); it != o->mesh().end(); ++ it) {
+		gp_GTrsf gtrsf = it->Placement();
 		
-		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(
+			o->matrix()[0], o->matrix()[3], o->matrix()[6], o->matrix()[ 9],
+			o->matrix()[1], o->matrix()[4], o->matrix()[7], o->matrix()[10], 
+			o->matrix()[2], o->matrix()[5], o->matrix()[8], o->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)
-#define APPROXIMATELY_THE_SAME(a,b) (fabs(a-b) < RATHER_SMALL)
+#define ALMOST_THE_SAME(a,b) (fabs(a-b) < RATHER_SMALL)
 
 const char* OpenCascadeBasedSerializer::getSymbolForUnitMagnitude(float mag) {
-	if (APPROXIMATELY_THE_SAME(mag, 0.001f)) {
+	if (ALMOST_THE_SAME(mag, 0.001f)) {
 		return "MM";
-	} else if (APPROXIMATELY_THE_SAME(mag, 0.01f)) {
+	} else if (ALMOST_THE_SAME(mag, 0.01f)) {
 		return "CM";
-	} else if (APPROXIMATELY_THE_SAME(mag, 1.0f)) {
+	} else if (ALMOST_THE_SAME(mag, 1.0f)) {
 		return "M";
-	} else if (APPROXIMATELY_THE_SAME(mag, 0.3048f)) {
+	} else if (ALMOST_THE_SAME(mag, 0.3048f)) {
 		return "FT";
-	} else if (APPROXIMATELY_THE_SAME(mag, 0.0254f)) {
+	} else if (ALMOST_THE_SAME(mag, 0.0254f)) {
 		return "INCH";
 	} else {
 		return 0;

src/ifcconvert/OpenCascadeBasedSerializer.h

@@ -20,29 +20,27 @@
 #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/IfcGeomObjects.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 writeTesselated(const IfcGeomObjects::IfcGeomObject* o) {}
+	void writeShapeModel(const IfcGeomObjects::IfcGeomShapeModelObject* o);
 	bool isTesselated() const { return false; }
-	void setFile(IfcParse::IfcFile*) {}
 };
 
-#endif
+#endif

src/ifcconvert/StepSerializer.h

@@ -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/IfcGeomObjects.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);
 		}
 	}

src/ifcconvert/SurfaceStyle.h

@@ -16,67 +16,63 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
  *                                                                              *
  ********************************************************************************/
- 
-/*********************************************************************************
- *                                                                               *
- * Reads a file and provides functions to access its                             *
- * contents randomly and character by character                                  *
- *                                                                               *
+
+/********************************************************************************
+ *                                                                              *
+ * This file defines default materials for several IFC datatypes                *
+ *                                                                              *
  ********************************************************************************/
- 
-#ifndef IFCSPFSTREAM_H
-#define IFCSPFSTREAM_H
 
-#include <fstream>
+#ifndef SURFACESTYLE_H
+#define SURFACESTYLE_H
+
 #include <string>
+#include <sstream>
 
-#ifdef USE_MMAP
-#include <boost/iostreams/device/mapped_file.hpp>
-#endif
+#include <array>
 
-#include "ifc_parse_api.h"
-
-namespace IfcParse {
-	/// The IfcSpfStream class represents a ISO 10303-21 IFC-SPF file in memory.
-	/// The file is interpreted as a sequence of tokens which are lazily
-	/// interpreted only when requested.
-	class IFC_PARSE_API IfcSpfStream {
+class SurfaceStyle {
+public:
+	class ColorComponent {
 	private:
-#ifdef USE_MMAP
-		boost::iostreams::mapped_file_source mfs;
-#endif
-		FILE* stream;
-		const char* buffer;
-		unsigned int ptr;
-		unsigned int len;
+		std::array<double, 3> data;
 	public:
-		bool valid;
-		bool eof;
-		unsigned int size;
-#ifdef USE_MMAP
-		IfcSpfStream(const std::string& fn, bool mmap=false);
-#else
-		IfcSpfStream(const std::string& fn);
-#endif
-		IfcSpfStream(std::istream& f, int len);
-		IfcSpfStream(void* data, int len);
-		~IfcSpfStream();
-		/// Returns the character at the cursor 
-		char Peek();
-		/// Returns the character at specified offset
-		char Read(unsigned int offset);
-		/// Increment the file cursor and reads new page if necessary
-		void Inc();
-		void Close();
-		/// Moves the file cursor to an arbitrary offset in the file
-		void Seek(unsigned int offset);
-		/// Returns the cursor position
-		unsigned int Tell();
-
-		bool is_eof_at(unsigned int);
-		void increment_at(unsigned int&);
-		char peek_at(unsigned int);
+		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; }
+};
 
-#endif
+SurfaceStyle GetDefaultMaterial(const std::string& s);
+
+#endif

src/ifcconvert/WavefrontObjSerializer.cpp

@@ -0,0 +1,121 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 "../ifcgeom/IfcGeomRenderStyles.h"
+
+#include "WavefrontObjSerializer.h"
+
+#include <iomanip>
+
+bool WaveFrontOBJSerializer::ready() {
+	return obj_stream.is_open() && mtl_stream.is_open();
+}
+
+void WaveFrontOBJSerializer::writeHeader() {
+	obj_stream << "# File generated by IfcOpenShell " << IFCOPENSHELL_VERSION << "\n";
+#ifdef WIN32
+	const char dir_separator = '\\';
+#else
+	const char dir_separator = '/';
+#endif
+	std::string mtl_basename = mtl_filename;
+	std::string::size_type slash = mtl_basename.find_last_of(dir_separator);
+	if (slash != std::string::npos) {
+		mtl_basename = mtl_basename.substr(slash+1);
+	}
+	obj_stream << "mtllib " << mtl_basename << "\n";
+	mtl_stream << "# File generated by IfcOpenShell " << IFCOPENSHELL_VERSION << "\n";	
+}
+
+void WaveFrontOBJSerializer::writeMaterial(const IfcGeomObjects::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";
+	}
+	if (style.hasSpecular()) {
+		const double* specular = style.specular();
+		mtl_stream << "Ks " << specular[0] << " " << specular[1] << " " << specular[2] << "\n";
+	}
+	if (style.hasSpecularity()) {
+		mtl_stream << "Ns " << style.specularity() << "\n";
+	}
+	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::writeTesselated(const IfcGeomObjects::IfcGeomObject* o) {
+
+	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 IfcGeomObjects::IfcRepresentationTriangulation& mesh = o->mesh();
+	
+	const int vcount = mesh.verts().size() / 3;
+	for ( std::vector<float>::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<float>::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";
+	}
+
+	int previous_material_id = -2;
+	std::vector<int>::const_iterator material_it = mesh.material_ids().begin();
+
+	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) {
+			IfcGeomObjects::Material material(0);
+			if (material_id >= 0) {
+				material = mesh.materials()[material_id];
+			} else {
+				material = IfcGeomObjects::Material(IfcGeom::get_default_style(o->type()));
+			}
+			const std::string 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 = *(it++)+vcount_total;
+		const int v2 = *(it++)+vcount_total;
+		const int v3 = *(it++)+vcount_total;
+		obj_stream << "f " << v1 << "//" << v1 << " " << v2 << "//" << v2 << " " << v3 << "//" << v3 << "\n";
+	}
+    vcount_total += vcount;
+}

src/ifcconvert/WavefrontObjSerializer.h

@@ -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,22 @@ 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 writeMaterial(const IfcGeomObjects::Material& style);
+	void writeTesselated(const IfcGeomObjects::IfcGeomObject* o);
+	void writeShapeModel(const IfcGeomObjects::IfcGeomShapeModelObject* o) {}
 	void finalize() {}
 	bool isTesselated() const { return true; }
-	void setUnitNameAndMagnitude(const std::string& /*name*/, float /*magnitude*/) {}
-	void setFile(IfcParse::IfcFile*) {}
+	void setUnitNameAndMagnitude(const std::string& name, float magnitude) {}
 };
 
-#endif
+#endif

src/ifcexpressparser/IfcDocumentation.py

@@ -27,51 +27,45 @@
 #                                                                             #
 ###############################################################################
 
-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','  ']))
+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):
     global name_to_oid, oid_to_desc, oid_to_name, oid_to_pid
     oid = name_to_oid.get(item,0)
-    desc = oid_to_desc.get(oid, None)
+    desc = oid_to_desc.get(oid,None)
     if desc:
         for a,b in entitydefs.items(): desc = desc.replace("&%s;"%a,b)
         desc = desc.replace("\r","")
-        for r,s in regices: desc = r.sub(s,desc)
+        for r,s in regices[:-1]: desc = r.sub(s,desc)
         desc = desc.strip()
-        return desc.split("\n")
-    else: return []
+        r,s = regices[-1]
+        desc = r.sub(s,desc)
+    return desc

src/ifcexpressparser/IfcExpressParser.py

@@ -0,0 +1,659 @@
+header = """
+/********************************************************************************
+ *                                                                              *
+ * 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/>.         *
+ *                                                                              *
+ ********************************************************************************/
+ """.strip()
+
+###############################################################################
+#                                                                             #
+# This file can be used to generate C++ code from Express schema files. The   #
+# generated code works alongside the IfcOpenShell IfcParse library. This      #
+# script has only been tested on IFC2X3_TC1.exp and will most probably not    #
+# work on any other schemas.                                                  #
+#                                                                             #
+# Note this script uses funcparserlib, which is available at:                 #
+# http://code.google.com/p/funcparserlib/                                     #
+# The script only works with revision 30f7ee896bc9 because it uses the some() #
+# parser and is incompatible with other changes as well.                      #
+#                                                                             #
+###############################################################################
+
+import os, sys
+import IfcDocumentation
+
+filename = sys.argv[1]
+
+#
+# A class to split the Express schema files into seperate tokens
+#
+class Tokenizer(object):
+    comment = ['(*','*)']
+    termchars = ',;()=[]:'
+    def __init__(self, fn):
+        if hasattr(fn,'read'): object.__setattr__(self,'f',fn)
+        else: object.__setattr__(self,'f',open(fn,'rb'))
+    def __getattr__(self, name):
+        return getattr(self.f, name)
+    def __setattr__(self, name, value):
+        setattr(self.f, name, value)
+    def __iter__(self): return self
+    def next(self):
+        def get():
+            buffer = ''
+            in_comment = False
+            in_string = False
+            offset = self.tell()
+            while True:
+                c = self.read(2)
+                if len(c) < 2: raise StopIteration
+                if c in Tokenizer.comment:
+                    in_comment = c == Tokenizer.comment[0]
+                    continue
+                if in_string and c == "''":
+                    buffer += "'"
+                    continue
+                self.seek(-1,1)
+                if not in_string and c[0].isspace():
+                    if ( len(buffer) ): return buffer
+                    else:
+                        offset = self.tell()
+                        continue
+                if not in_comment:
+                    if len(buffer) and (c[0] in Tokenizer.termchars or buffer[-1] in Tokenizer.termchars):
+                        self.seek(-1,1)
+                        return buffer
+                    buffer += c[0]
+        return get()
+
+#
+# Some global variables to keep track of variable names
+#
+express_to_cpp = {
+    'BOOLEAN':'bool',
+    'LOGICAL':'bool',
+    'INTEGER':'int',
+    'REAL':'double',
+    'NUMBER':'double',
+    'STRING':'std::string'
+}
+schema_version = ''
+enumerations = set()
+selections = set()
+entity_names = set()
+simple_types = {}
+selectable_simple_types = set()
+argument_count = {}
+parent_relations = {}
+argument_names_and_types = {}
+entity_map = {}
+
+#
+# Since inherited arguments of Express entities are placed in sequence before the 
+# non-inherited ones, we need to keep track of how many inherited arguments exist
+#
+def argument_start(c):
+    if c not in parent_relations: return 0
+    i = 0
+    while True:
+        c = parent_relations[c]
+        i += argument_count[c] if c in argument_count else 0
+        if not (c in parent_relations): break
+    return i
+    
+def parent_arguments(c):
+    if c not in parent_relations: return []
+    l = []
+    while True:
+        c = parent_relations[c]
+        i += argument_count[c] if c in argument_count else 0
+        if not (c in parent_relations): break
+    return []
+
+#
+# Every constructor also initializes their parent class members, hence they
+# need be stored as well.
+#    
+def parent_arguments(c):
+    if c not in parent_relations: return []
+    l = []
+    while True:
+        c = parent_relations[c]
+        i += argument_count[c] if c in argument_count else 0
+        if not (c in parent_relations): break
+    return []
+
+#
+# Several classes to generate code from Express types and entities
+#
+class ArrayType:
+    def __init__(self,l): 
+        self.type = express_to_cpp.get(l[3],l[3])
+        self.upper = l[2]
+        self.lower = l[1]
+    def is_select_list(self): return self.type in selections
+    def __str__(self):
+        if self.type in entity_names:
+            return "SHARED_PTR< IfcTemplatedEntityList< %s > >"%self.type
+        elif self.type in selections:
+            return "SHARED_PTR< IfcTemplatedEntityList< IfcAbstractSelect > >"
+        else:
+            return "std::vector< %(type)s > /*[%(lower)s:%(upper)s]*/"%self.__dict__
+    def is_shared_ptr(self): return self.type in entity_names or self.type in selections
+    def type_enum(self):
+        if self.type in simple_types:
+            t = simple_types[self.type].type_enum()
+        else:
+            t = self.type
+        if t in entity_names or t == "Argument_ENTITY":
+            return "Argument_ENTITY_LIST"
+        elif t in selections:
+            return "Argument_ENTITY_LIST"
+        elif t == "int":
+            return "Argument_VECTOR_INT"
+        elif t == "double" or t == "Argument_DOUBLE":
+            return "Argument_VECTOR_DOUBLE"
+        elif t == "std::string" or t == "Argument_STRING":
+            return "Argument_VECTOR_STRING"
+        elif isinstance(t, BinaryType):
+            return "Argument_UNKNOWN"
+        else:
+            assert False, t
+        
+class ScalarType:
+    def __init__(self,l): self.type = express_to_cpp.get(l,l)
+    def __str__(self): return self.type
+    def is_select_list(self): return False
+    def type_enum(self):
+        if self.type in simple_types:
+            return simple_types[self.type].type_enum()
+        elif self.type in entity_names:
+            return "Argument_ENTITY"
+        else:
+            return { "bool":"Argument_BOOL","int":"Argument_INT","double":"Argument_DOUBLE","std::string":"Argument_STRING"}[self.type]
+class EnumType:
+    def __init__(self,l):
+        self.v = [(x,'%s_%s'%('%(fancy_name)s',x)) for x in l]
+        self.maxlen = max([len(v) for v in self.v])
+    def __str__(self): 
+        if generator_mode == 'HEADER':
+            return "enum {%s}"%", ".join([v2 for v1,v2 in self.v])
+        elif generator_mode == 'SOURCE_TO':
+            return '{ "%s" }'%'","'.join([v1 for v1,v2 in self.v])
+        elif generator_mode == 'SOURCE_FROM':
+            return "".join(['    if(s=="%s"%s) return ::%s::%s::%s;\n'%(v1.upper()," "*(self.maxlen-len(v1)),schema_version,"%(name)s",v2) for v1,v2 in self.v])
+    def is_select_list(self): return False
+    def __len__(self): return len(self.v)
+    def type_enum(self):
+        return "Argument_ENUMERATION"
+class SelectType:
+    def __init__(self,l): 
+        for x in l: 
+            if x in simple_types: selectable_simple_types.add(x)
+    def __str__(self): return "IfcSchemaEntity"
+    def is_select_list(self): return False
+    def type_enum(self): return "Argument_ENTITY"
+class BinaryType:
+    def __init__(self,l): self.l = int(l)
+    def __str__(self): return "char[%s]"%self.l
+    def is_select_list(self): return False
+    def type_enum(self): raise NotImplementedError()
+class InverseType:
+    def __init__(self,l):
+        self.name, self.type, self.reference = l
+    def type_enum(self): return "Argument_ENTITY"
+    def is_select_list(self): return False
+class Typedef:
+    def __init__(self,l):
+        self.name,self.type=l[1:3]
+        self.fancy_name = self.name[:-4] if self.name.endswith("Enum") else self.name
+        if isinstance(self.type,EnumType): 
+            enumerations.add(self.name)
+            self.len = len(self.type)
+        elif isinstance(self.type,SelectType): selections.add(self.name)
+        simple_types[self.name] = self
+        comment = IfcDocumentation.description(self.name)
+        self.comment = comment+"\n" if comment else ''
+    def __str__(self):
+        global generator_mode
+        if generator_mode == 'HEADER' and isinstance(self.type,EnumType):
+            return ("namespace %(name)s {\n%(comment)stypedef %(type)s %(name)s;\nconst char* ToString(%(name)s v);\n%(name)s FromString(const std::string& s);\n}"%self.__dict__)%self.__dict__
+        elif generator_mode == 'HEADER':
+            return "%stypedef %s %s;"%(self.comment,self.type,self.name)
+        elif generator_mode == 'SOURCE' and isinstance(self.type,EnumType):
+            generator_mode = 'SOURCE_TO'
+            s =  "const char* %(name)s::ToString(%(name)s v) {\n    if ( v < 0 || v >= %(len)d ) throw IfcException(\"Unable to find find keyword in schema\");\n    const char* names[] = %(type)s;\n    return names[v];\n}\n"%self.__dict__
+            generator_mode = 'SOURCE_FROM'
+            s += ("%(name)s::%(name)s %(name)s::FromString(const std::string& s) {\n%(type)s    throw IfcException(\"Unable to find find keyword in schema\");\n}"%self.__dict__)%self.__dict__
+            generator_mode = 'SOURCE'
+            return s
+    def type_enum(self):
+        return self.type.type_enum()
+class Argument(object):
+    def __init__(self,l):
+        self.name, self.optional, self.type = l
+    def is_enum(self): return str(self.type) in enumerations
+    def type_str(self):
+        if self.type.is_select_list():
+            # This is extremely hackish indeed
+            return "optional< IfcEntities >" if self.optional else "IfcEntities"
+        elif str(self.type) in entity_names:
+            return "%(type)s*"%self.__dict__
+        else:
+            t = "%(type)s::%(type)s"%self.__dict__ if self.is_enum() else self.type
+            return "optional< %s >"%t if self.optional else t
+class ArgumentList:
+    def __init__(self,l):
+        self.l = [Argument(a) for a in l]
+        self.argstart = 0
+    def __len__(self): return len(self.l)
+    def __str__(self):
+        s = ""
+        argv = self.argstart
+        for a in self.l:
+            class_name = indent = comment = optional_comment = ""
+            is_array = isinstance(a.type,ArrayType) and a.type.is_shared_ptr()
+            return_type = str(a.type)
+            if generator_mode == 'SOURCE':
+                class_name = "%(class_name)s::"
+                if isinstance(a.type,BinaryType) or (isinstance(a.type,ArrayType) and isinstance(a.type.type,BinaryType)):
+                    function_body = " { throw; /* Not implemented argument*/ }"
+                elif isinstance(a.type,ArrayType) and str(a.type.type) in entity_names:
+                    function_body = " { RETURN_AS_LIST(%s,%d) }"%(a.type.type,argv)
+                elif isinstance(a.type,ArrayType) and str(a.type.type) in selections:
+                    function_body = " { RETURN_AS_LIST(IfcAbstractSelect,%d) }"%(argv)
+                elif return_type in entity_names:
+                    function_body = " { return reinterpret_pointer_cast<IfcBaseClass,%s>(*entity->getArgument(%d)); }"%(return_type,argv)
+                elif return_type in enumerations:
+                    function_body = " { return %s::FromString(*entity->getArgument(%d)); }"%(return_type,argv)
+                else:
+                    function_body = " { return *entity->getArgument(%d); }"%argv
+                function_body2 = " { return !entity->getArgument(%d)->isNull(); }"%argv
+                if isinstance(a.type,BinaryType) or (isinstance(a.type,ArrayType) and isinstance(a.type.type,BinaryType)):
+                    function_body3 = " { if ( ! entity->isWritable() ) { throw; } }"
+                elif return_type in enumerations:
+                    function_body3 = " { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%d,v%s,%s::ToString(v)); }"%(argv,"->generalize()" if is_array else "",return_type)
+                else:
+                    function_body3 = " { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%d,v%s); }"%(argv,"->generalize()" if is_array else "")
+            else:
+                indent = "    "
+                function_body = function_body2 = function_body3 = ";"
+                comment = IfcDocumentation.description((self.class_name,a.name))
+                comment = comment+"\n" if comment else ''
+                comment = comment.replace("///","%s///"%indent)
+                optional_comment = "%s/// Whether the optional attribute %s is defined for this %s\n"%(indent,a.name,self.class_name)
+            if a.optional: s += "\n%s%sbool %shas%s()%s"%(optional_comment,indent,class_name,a.name,function_body2)
+            if ( str(a.type) in enumerations ):
+                return_type = "%(type)s::%(type)s"%a.__dict__
+            elif ( str(a.type) in entity_names ):
+                return_type = "%(type)s*"%a.__dict__
+            s += "\n%s%s%s %s%s()%s"%(comment,indent,return_type,class_name,a.name,function_body)
+            s += "\n%svoid %sset%s(%s v)%s"%(indent,class_name,a.name,return_type,function_body3)
+            argv += 1
+
+        if generator_mode == 'HEADER':
+            s += "\n virtual unsigned int getArgumentCount() const { return %(n_arguments)d; }" % dict(class_name=self.class_name, n_arguments=len(self.l) + argument_start(self.class_name))
+
+            s += "\n virtual ArgumentType getArgumentType(unsigned int i) const {"
+            if len(self.l):
+                s += " switch (i) {"
+                for i, a in enumerate(self.l):
+                    s += "case %d: " % (i + argument_start(self.class_name))
+                    s += "return %s; " % a.type.type_enum()
+                s += "}"
+            if self.parent_class is not None:
+                s += " return %s::getArgumentType(i); }" % self.parent_class
+            else:
+                s += " throw IfcException(\"argument out of range\"); }"
+
+            s += "\n virtual const char* getArgumentName(unsigned int i) const {"
+            if len(self.l):
+                s += " switch (i) {"
+                for i, a in enumerate(self.l):
+                    s += "case %d: " % (i + argument_start(self.class_name))
+                    s += "return \"%s\"; " % a.name
+                s += "}"
+            if self.parent_class is not None:
+                s += " return %s::getArgumentName(i); }" % self.parent_class
+            else:
+                s += " throw IfcException(\"argument out of range\"); }"
+
+            s += "\n virtual ArgumentPtr getArgument(unsigned int i) const { return entity->getArgument(i); }"
+        return s
+class InverseList:
+    def __init__(self,l):
+        self.l = l
+    def __str__(self):
+        if self.l is None: return ""
+        s = ""
+        for i in self.l:
+            if generator_mode == 'HEADER':
+                s += "\n    SHARED_PTR< IfcTemplatedEntityList< %s > > %s(); // INVERSE %s::%s"%(i.type.type,i.name,i.type.type,i.reference)
+            elif generator_mode == 'SOURCE':
+                s += "\n%s::list %s::%s() { RETURN_INVERSE(%s) }"%(i.type.type,"%(class_name)s",i.name,i.type.type)
+        return s
+class Classdef:
+    def __init__(self,l):
+        self.class_name, self.parent_class, self.arguments, derive, self.inverse = l
+        self.arguments.class_name = self.class_name
+        self.arguments.parent_class = self.parent_class
+        entity_names.add(self.class_name)
+        parent_relations[self.class_name] = self.parent_class
+        argument_count[self.class_name] = len(self.arguments)
+        entity_map[self.class_name] = self
+        # For derived attributes only a reference is kepts to overridden attributes in parent classes
+        self.derive = [x[0].split('.')[-1] for x in derive[1] if x[0].startswith("SELF\\")] if derive else []
+    def list_constructor_args(self):
+        s = entity_map[self.parent_class].list_constructor_args() if self.parent_class else []
+        i = len(s) + 1
+        s += [(a.type_str(),b+i,a.name) for a,b in zip(self.arguments.l,range(len(self.arguments)))]
+        return s
+    def get_constructor_args(self):
+        return ["%s v%d_%s"%x for x in self.list_constructor_args() if x[2] not in self.get_derived()]        
+    def get_constructor_implementation(self):
+        s = entity_map[self.parent_class].get_constructor_implementation() if self.parent_class else []
+        i = len(s) + 1
+        b = 0
+        for a in self.arguments.l:
+            is_enumeration = str(a.type) in enumerations
+            # boost::optional is not used for pointer types, because they are set to NULL using 0
+            use_boost_optional = a.optional and str(a.type) not in entity_names
+            # boost::optional types need to be dereferenced before passing to the writable entity
+            dereference = "*" if use_boost_optional else ""
+            generalize = "->generalize()" if (isinstance(a.type,ArrayType) and a.type.is_shared_ptr() and not a.type.is_select_list()) else ""
+            if isinstance(a.type,BinaryType) or (isinstance(a.type,ArrayType) and isinstance(a.type.type,BinaryType)):
+                continue
+            if is_enumeration:
+                impl = "e->setArgument(%d,%sv%d_%s,%s::ToString(%sv%d_%s))"%(b+i-1,dereference,b+i,a.name,str(a.type),dereference,b+i,a.name)
+            else:
+                impl = "e->setArgument(%d,(%sv%d_%s)%s)"%(b+i-1,dereference,b+i,a.name,generalize)            
+            if use_boost_optional:
+                s.append(["if (v%d_%s) { %s; } else { e->setArgument(%d); } "%(b+i,a.name,impl,b+i-1),a.name,i-1])
+            else: s.append([impl,a.name,i-1])
+            b += 1
+        return s
+    def get_derived(self):
+        s = entity_map[self.parent_class].get_derived() if self.parent_class else []
+        return s + self.derive
+    def __str__(self):
+        self.constructor_args_list = self.get_constructor_args()
+        self.constructor_args = ", ".join(self.constructor_args_list)
+        if generator_mode == 'HEADER':            
+            comment = IfcDocumentation.description(self.class_name)
+            comment = comment+"\n" if comment else ''
+            return "%sclass %s : public %s {\npublic:%s%s%s\n};" % (comment,self.class_name,
+                "IfcBaseEntity" if self.parent_class is None else self.parent_class,
+                self.arguments,
+                self.inverse,
+                ("\n    bool is(Type::Enum v) const;"+
+                "\n    Type::Enum type() const;"+
+                "\n    static Type::Enum Class();"+
+                "\n    %(class_name)s (IfcAbstractEntityPtr e = IfcAbstractEntityPtr());"+
+               ("\n    %(class_name)s (%(constructor_args)s);" if len(self.constructor_args_list) else "")+
+                "\n    typedef %(class_name)s* ptr;"+
+                "\n    typedef SHARED_PTR< IfcTemplatedEntityList< %(class_name)s > > list;"+
+                "\n    typedef IfcTemplatedEntityList< %(class_name)s >::it it;")%self.__dict__
+            )
+        elif generator_mode == 'SOURCE':
+            self.arguments.argstart = argument_start(self.class_name)
+            self.constructor_implementation = "; ".join([x[0] if x[1] not in self.get_derived() else "e->setArgumentDerived(%d)"%x[2] for x in self.get_constructor_implementation()])
+            return (("\n// Function implementations for %(class_name)s"+str(self.arguments)+str(self.inverse)+
+            ("\nbool %(class_name)s::is(Type::Enum v) const { return v == Type::%(class_name)s; }" if self.parent_class is None else
+            "\nbool %(class_name)s::is(Type::Enum v) const { return v == Type::%(class_name)s || %(parent_class)s::is(v); }")+
+            "\nType::Enum %(class_name)s::type() const { return Type::%(class_name)s; }"+
+            "\nType::Enum %(class_name)s::Class() { return Type::%(class_name)s; }"+
+            "\n%(class_name)s::%(class_name)s(IfcAbstractEntityPtr e) { if (!is(Type::%(class_name)s)) throw IfcException(\"Unable to find find keyword in schema\"); entity = e; }"+
+            ("\n%(class_name)s::%(class_name)s(%(constructor_args)s) { IfcWritableEntity* e = new IfcWritableEntity(Class()); %(constructor_implementation)s; entity = e; EntityBuffer::Add(this); }"  if len(self.constructor_args_list) else "")
+            )%self.__dict__)%self.__dict__
+
+
+from funcparserlib.parser import a, skip, many, maybe, some
+
+#
+# Lambda functions to map combinator output to classes
+# 
+array_type = lambda t: ArrayType(t)
+scalar_type = lambda t: ScalarType(t)
+enum_type = lambda t: EnumType(t)
+select_type = lambda t: SelectType(t)
+binary_type = lambda t: BinaryType(t)
+inverse_type = lambda t: InverseType(t)
+format_type = lambda t: Typedef(t)
+argument_list = lambda t: ArgumentList(t)
+inverse_list = lambda t: InverseList(t)
+format_options = lambda t: [t[0]]+t[1]
+
+#
+# The actual grammar definition
+#
+s = some(lambda t: not t in ['UNIQUE','WHERE','END_ENTITY','END_TYPE','INVERSE','DERIVE'])
+x = lambda s:skip(a(s))
+list_or_array = a('ARRAY') | a('LIST') | a('SET')
+binary = x('BINARY')+x('(') + s + x(')') >> binary_type
+array = list_or_array + x('[') + s + x(':') + s + x(']') + x('OF') + skip(maybe(a('UNIQUE'))) + (binary|s) >> array_type
+options = x('(') + s + many(x(',')+s) + x(')') >> format_options
+enum = x('ENUMERATION') + x('OF') + options >> enum_type
+select = x('SELECT') + options >> select_type
+single = s + skip(maybe(x('(')+s+x(')')) + maybe(a('FIXED'))) >> scalar_type
+type_type = array | enum | select | single
+type_start = a('TYPE') + s + x('=') + type_type + x(';')
+type_end = a('END_TYPE') + x(';')
+
+to_end = many(some(lambda t: t != ';'))
+clause = s + x(':') + to_end + x(';')
+where = a('WHERE') + many(clause)
+
+type = type_start + maybe(where) + type_end >> format_type
+
+subtype = x('SUBTYPE') + x('OF') + x('(') + s + x(')')
+supertype = maybe(x('ABSTRACT')) + x('SUPERTYPE') + x('OF') + x('(') + x('ONEOF') + options + x(')')
+entity_start = x('ENTITY') + s + skip(maybe(supertype)) + maybe(subtype) + x(';')
+entity_end = x('END_ENTITY') + x(';')
+key_value = s + x(':') + maybe(a('OPTIONAL')) + (array|binary|single) + x(';')
+arguments = many(key_value) >> argument_list
+unique_value = s + x(':') + s + many(a(',')+s) + a(';')
+unique = skip(a('UNIQUE') + many(unique_value))
+inverse_def = s + x(':') + (array|single) + x('FOR') + s + x(';') >> inverse_type
+inverse = maybe(x('INVERSE') + many( inverse_def )) >> inverse_list
+derive = a('DERIVE') + many(clause)
+
+entity = entity_start + arguments + skip(maybe(unique)) + maybe(derive) + inverse + skip(maybe(where)) + entity_end >> Classdef
+
+schema = skip(a('SCHEMA')) + s + x(';')
+
+express = schema + many(type) + many(entity)
+schema_version,types,entities = express.parse(list(Tokenizer(filename)))
+schema_version = schema_version.capitalize()
+
+#
+# Writing of the three generated files starts here
+#
+h_file = open("%s.h"%schema_version,'w')
+enumh_file = open("%senum.h"%schema_version,'w')
+cpp_file = open("%s.cpp"%schema_version,'w')
+
+header += """
+
+/********************************************************************************
+ *                                                                              *
+ * This file has been generated from %s. Do not make modifications  *
+ * but instead modify the python script that has been used to generate this.    *
+ *                                                                              *
+ ********************************************************************************/
+ """%filename
+
+generator_mode = 'HEADER'
+ 
+print >>h_file, header
+print >>enumh_file, header
+print >>cpp_file, header
+print >>h_file, """#ifndef %(schema_upper)s_H
+#define %(schema_upper)s_H
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <boost/optional.hpp>
+
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/IfcException.h"
+#include "../ifcparse/%(schema)senum.h"
+
+using namespace IfcUtil;
+using IfcParse::IfcException;
+using boost::optional;
+
+#define RETURN_INVERSE(T) \\
+    IfcEntities e = entity->getInverse(T::Class()); \\
+    SHARED_PTR< IfcTemplatedEntityList<T> > l ( new IfcTemplatedEntityList<T>() ); \\
+    for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) { \\
+        l->push(reinterpret_pointer_cast<IfcBaseClass,T>(*it)); \\
+    } \\
+    return l;
+
+#define RETURN_AS_SINGLE(T,a) \\
+    return reinterpret_pointer_cast<IfcBaseClass,T>(*entity->getArgument(a));
+
+#define RETURN_AS_LIST(T,a)  \\
+    IfcEntities e = *entity->getArgument(a);  \\
+    SHARED_PTR< IfcTemplatedEntityList<T> > l ( new IfcTemplatedEntityList<T>() );  \\
+    for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) {  \\
+        l->push(reinterpret_pointer_cast<IfcBaseClass,T>(*it)); \\
+    }  \\
+    return l;
+
+namespace %(schema)s {
+"""%{'schema_upper':schema_version.upper(),'schema':schema_version}
+
+simple_enumerations = sorted(selectable_simple_types)
+entity_enumerations = sorted(entity_names)
+all_enumerations = simple_enumerations + entity_enumerations
+
+print >>enumh_file, """#ifndef IFC2X3ENUM_H
+#define IFC2X3ENUM_H
+
+namespace Ifc2x3 {
+
+namespace Type {
+    typedef enum {
+        %(enum)s
+    } Enum;
+    Enum Parent(Enum v);
+    Enum FromString(const std::string& s);
+    std::string ToString(Enum v);
+    bool IsSimple(Enum v);
+}
+
+}
+
+#endif
+"""%{'schema_upper':schema_version.upper(),'schema':schema_version,'enum':", ".join(all_enumerations + ["ALL"])}
+
+defined_types = set(express_to_cpp.values())
+deferred_types = []
+
+for t in [T for T in types if not (isinstance(T.type,EnumType) or isinstance(T.type,SelectType))]:
+    if isinstance(t.type,ScalarType) and str(t.type) not in defined_types:
+        deferred_types.append(t)
+    else:
+        print >>h_file, t
+for t in [T for T in types if isinstance(T.type,SelectType)]:
+    print >>h_file, t
+for t in deferred_types:
+    print >>h_file, t
+for t in [T for T in types if isinstance(T.type,EnumType)]:
+    print >>h_file, t
+    
+print >>h_file, "// Forward definitions"
+print >>h_file, "class %s;\n"%"; class ".join([e.class_name for e in entities])
+
+defined_classes = set()
+while True:
+    classes = [c for c in entities if c.class_name not in defined_classes]
+    if not len(classes): break
+    for c in classes:
+        if c.parent_class is None or c.parent_class in defined_classes:
+            defined_classes.add(c.class_name)
+            print >>h_file, c
+
+print >>h_file, "void InitStringMap();"
+print >>h_file, "IfcSchemaEntity SchemaEntity(IfcAbstractEntityPtr e = 0);"
+
+print >>h_file, "}\n\n#endif"
+
+generator_mode = 'SOURCE'
+
+print >>cpp_file, """#include "%(schema)s.h"
+#include "IfcException.h"
+#include "IfcWrite.h"
+#include "IfcWritableEntity.h"
+
+using namespace %(schema)s;
+using namespace IfcParse;
+using namespace IfcWrite;
+
+IfcSchemaEntity %(schema)s::SchemaEntity(IfcAbstractEntityPtr e) {
+    switch(e->type()){"""%{'schema':schema_version}
+
+for e in simple_enumerations:
+    print >>cpp_file, "        case Type::%s: return new IfcEntitySelect(e); break;"%e
+for e in entity_enumerations:
+    print >>cpp_file, "        case Type::%s: return new %s(e); break;"%(e,e)
+print >>cpp_file, "        default: throw IfcException(\"Unable to find find keyword in schema\"); break; "
+print >>cpp_file, "    }\n}"
+print >>cpp_file
+print >>cpp_file, "std::string Type::ToString(Enum v) {"
+print >>cpp_file, "    if (v < 0 || v >= %d) throw IfcException(\"Unable to find find keyword in schema\");"%len(all_enumerations)
+print >>cpp_file, '    const char* names[] = { "%s" };'%'","'.join(all_enumerations)
+print >>cpp_file, '    return names[v];'
+print >>cpp_file, "}"
+print >>cpp_file
+#print >>cpp_file, "Type::Enum Type::FromStringOld(const std::string& s){"
+#elseif = "if"
+#maxlen = max([len(e) for e in all_enumerations])
+#for e in all_enumerations:
+#    print >>cpp_file, '    %s(s=="%s"%s) { return %s; }'%(elseif,e.upper()," "*(maxlen-len(e)),e)
+#print >>cpp_file, "    throw;"
+#print >>cpp_file, "}"
+print >>cpp_file, "std::map<std::string,Type::Enum> string_map;"
+print >>cpp_file, "void Ifc2x3::InitStringMap() {"
+maxlen = max([len(e) for e in all_enumerations])
+for e in all_enumerations:
+    print >>cpp_file, '    string_map["%s"%s] = Type::%s;'%(e.upper()," "*(maxlen-len(e)),e)
+print >>cpp_file, """}
+Type::Enum Type::FromString(const std::string& s) {
+    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;
+}"""
+
+print >>cpp_file, "Type::Enum Type::Parent(Enum v){"
+print >>cpp_file, "    if (v < 0 || v >= %d) return (Enum)-1;"%len(all_enumerations)
+for e in entity_enumerations:
+    if e not in parent_relations or parent_relations[e] is None: continue
+    print >>cpp_file, '    if(v==%s%s) { return %s; }'%(e," "*(maxlen-len(e)),parent_relations[e])
+print >>cpp_file, "    return (Enum)-1;"
+print >>cpp_file, "}"
+
+print >>cpp_file, "bool Type::IsSimple(Enum v){"
+print >>cpp_file, "    return v == Type::%s;"%" || v == Type::".join(simple_enumerations)
+print >>cpp_file, "}"
+
+for t in [T for T in types if isinstance(T.type,EnumType)]:
+    print >>cpp_file, t
+for e in entities: print >>cpp_file, e,

src/ifcexpressparser/README.txt

@@ -1,11 +0,0 @@
-This folder contains Python code to generate C++ type information based on an
-Express schema. In particular is has only been tested using recent version of
-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.
-
-$ python bootstrap.py express.bnf > express_parser.py && python express_parser.py IFC2X3_TC1.exp
-
-[1] http://pyparsing.wikispaces.com/Download+and+Installation

src/ifcexpressparser/bootstrap.py

@@ -1,212 +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 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]
-    def __repr__(self):
-        if self.op is None: return repr(self.contents)
-        c = [isinstance(c,str) and c or str(c) for c in self.contents]
-        if "%s" in self.op: return self.op % (" ".join(c))
-        else: return "(%s)" % (" %s "%self.op).join(c)
-    def __iter__(self):
-        return self.contents.__iter__()
-
-class Union(Expression):
-    op = "|"
-
-class Concat(Expression):
-    op = "+"
-
-class Optional(Expression):
-    op = "Optional(%s)"
-
-class Repeated(Expression):
-    op = "ZeroOrMore(%s)"
-
-class Term(Expression):
-    op = None
-
-class Keyword:
-    def __init__(self, contents):
-        self.contents = contents[0]
-    def __repr__(self):
-        return self.contents
-
-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)
-
-
-LPAREN = Suppress("(")
-RPAREN = Suppress(")")
-LBRACK = Suppress("[")
-RBRACK = Suppress("]")
-LBRACE = Suppress("{")
-RBRACE = Suppress("}")
-EQUALS = Suppress("=")
-VBAR   = Suppress("|")
-PERIOD = Suppress(".")
-HASH   = Suppress("#")
-
-identifier = Word(alphanums+"_")
-keyword    = Word(alphanums+"_").setParseAction(Keyword)
-expression = Forward()
-optional   = Group(LBRACK + expression + RBRACK).setParseAction(Optional)
-repeated   = Group(LBRACE + expression + RBRACE).setParseAction(Repeated)
-terminal   = quotedString.setParseAction(Terminal)
-term       = (keyword | terminal | optional | repeated | (LPAREN + expression + RPAREN)).setParseAction(Term)
-concat     = Group(term + OneOrMore(term)).setParseAction(Concat)
-factor     = concat | term
-union      = Group(factor + OneOrMore(VBAR + factor)).setParseAction(Union)
-rule       = identifier + EQUALS + expression + PERIOD
-
-expression << (union | factor)
-
-grammar = OneOrMore(Group(rule))
-grammar.ignore(HASH + restOfLine)
-
-express = grammar.parseFile(sys.argv[1])
-
-def find_bytype(expr, ty, li = None):
-    if li is None: li = []
-    if isinstance(expr, Term):
-        expr = expr.contents
-    if isinstance(expr, ty):
-        li.append(expr)
-        return set(li)
-    elif isinstance(expr, Expression):
-        for term in expr:
-            find_bytype(term, ty, li)
-    return set(li)
-
-actions = {
-    'type_decl'                 : "lambda t: TypeDeclaration(t)",
-    'entity_decl'               : "lambda t: EntityDeclaration(t)",
-    'underlying_type'           : "lambda t: UnderlyingType(t)",
-    'enumeration_type'          : "lambda t: EnumerationType(t)",
-    'aggregation_types'         : "lambda t: AggregationType(t)",
-    '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)",
-    '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)
-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))
-        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,)))
-            if id in actions:
-                stmt = "%s.setParseAction(%s)" % (stmt, actions[id])
-            statements.append("%s = %s" % (id, stmt))
-    to_emit -= emitted_in_loop
-    if not emitted_in_loop: break
-
-for id in to_emit:
-    action = ".setParseAction(%s)" % actions[id] if id in actions else ""
-    statements.append("%s = Forward()%s" % (id, action))
-
-for id in to_emit:
-    expr = [e for k, e in express if k == id][0]
-    stmt = "(%s)" % expr
-    if id in to_combine:
-        stmt = "Suppress%s" % stmt
-    statements.append("%s << %s" % (id, stmt))
-
-print ("""import os
-import sys
-import pickle
-
-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
-
-    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 header
-import implementation
-import schema_class
-import definitions
-
-header.Header(mapping).emit()
-implementation.Implementation(mapping).emit()
-schema_class.SchemaClass(mapping).emit()
-definitions.Definitions(mapping).emit()
-
-sys.stdout.write(schema.name)
-"""%('\n    '.join(statements)))

src/ifcexpressparser/codegen.py

@@ -1,35 +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/>.        #
-#                                                                             #
-###############################################################################
-
-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.
-    """
-    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.close()

src/ifcexpressparser/definitions.py

@@ -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

src/ifcexpressparser/express.bnf

@@ -1,342 +0,0 @@
-ABS = "abs" .
-ABSTRACT = "abstract" .
-ACOS = "acos" .
-AGGREGATE = "aggregate" .
-ALIAS = "alias" .
-AND = "and" .
-ANDOR = "andor" .
-ARRAY = "array" .
-AS = "as" .
-ASIN = "asin" .
-ATAN = "atan" .
-BAG = "bag" .
-BASED_ON = "based_on" .
-BEGIN = "begin" .
-BINARY = "binary" .
-BLENGTH = "blength" .
-BOOLEAN = "boolean" .
-BY = "by" .
-CASE = "case" .
-CONSTANT = "constant" .
-CONST_E = "const_e" .
-COS = "cos" .
-DERIVE = "derive" .
-DIV = "div" .
-ELSE = "else" .
-END = "end" .
-END_ALIAS = "end_alias" .
-END_CASE = "end_case" .
-END_CONSTANT = "end_constant" .
-END_ENTITY = "end_entity" .
-END_FUNCTION = "end_function" .
-END_IF = "end_if" .
-END_LOCAL = "end_local" .
-END_PROCEDURE = "end_procedure" .
-END_REPEAT = "end_repeat" .
-END_RULE = "end_rule" .
-END_SCHEMA = "end_schema" .
-END_SUBTYPE_CONSTRAINT = "end_subtype_constraint" .
-END_TYPE = "end_type" .
-ENTITY = "entity" .
-ENUMERATION = "enumeration" .
-ESCAPE = "escape" .
-EXISTS = "exists" .
-EXTENSIBLE = "extensible" .
-EXP = "exp" .
-FALSE = "false" .
-FIXED = "fixed" .
-FOR = "for" .
-FORMAT = "format" .
-FROM = "from" .
-FUNCTION = "function" .
-GENERIC = "generic" .
-GENERIC_ENTITY = "generic_entity" .
-HIBOUND = "hibound" .
-HIINDEX = "hiindex" .
-IF = "if" .
-IN = "in" .
-INSERT = "insert" .
-INTEGER = "integer" .
-INVERSE = "inverse" .
-LENGTH = "length" .
-LIKE = "like" .
-LIST = "list" .
-LOBOUND = "lobound" .
-LOCAL = "local" .
-LOG = "log" .
-LOG10 = "log10" .
-LOG2 = "log2" .
-LOGICAL = "logical" .
-LOINDEX = "loindex" .
-MOD = "mod" .
-NOT = "not" .
-NUMBER = "number" .
-NVL = "nvl" .
-ODD = "odd" .
-OF = "of" .
-ONEOF = "oneof" .
-OPTIONAL = "optional" .
-OR = "or" .
-OTHERWISE = "otherwise" .
-PI = "pi" .
-PROCEDURE = "procedure" .
-QUERY = "query" .
-REAL = "real" .
-REFERENCE = "reference" .
-REMOVE = "remove" .
-RENAMED = "renamed" .
-REPEAT = "repeat" .
-RETURN = "return" .
-ROLESOF = "rolesof" .
-RULE = "rule" .
-SCHEMA = "schema" .
-SELECT = "select" .
-SELF = "self" .
-SET = "set" .
-SIN = "sin" .
-SIZEOF = "sizeof" .
-SKIP = "skip" .
-SQRT = "sqrt" .
-STRING = "string" .
-SUBTYPE = "subtype" .
-SUBTYPE_CONSTRAINT = "subtype_constraint" .
-SUPERTYPE = "supertype" .
-TAN = "tan" .
-THEN = "then" .
-TO = "to" .
-TOTAL_OVER = "total_over" .
-TRUE = "true" .
-TYPE = "type" .
-TYPEOF = "typeof" .
-UNIQUE = "unique" .
-UNKNOWN = "unknown" .
-UNTIL = "until" .
-USE = "use" .
-USEDIN = "usedin" .
-VALUE = "value" .
-VALUE_IN = "value_in" .
-VALUE_UNIQUE = "value_unique" .
-VAR = "var" .
-WHERE = "where" .
-WHILE = "while" .
-WITH = "with" .
-XOR = "xor" .
-bit = "0" | "1" .
-digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" .
-digits = digit { digit } .
-encoded_character = octet octet octet octet .
-hex_digit = digit | "a" | "b" | "c" | "d" | "e" | "f" .
-letter = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" .
-lparen_then_not_lparen_star = "(" { "(" } not_lparen_star { not_lparen_star } .
-not_lparen_star = not_paren_star | ")" .
-not_paren_star = letter | digit | not_paren_star_special .
-not_paren_star_quote_special = "!" | "#" | "$" | "%" | "&" | "+" | "," | "-" | "." | "/" | ":" | ";" | "<" | "=" | ">" | "?" | "@" | "[" | "\\" | "]" | "^" | "_" | "{" | "|" | "}" | "~" .
-not_paren_star_special = not_paren_star_quote_special | "\"\"" .
-not_quote = not_paren_star_quote_special | letter | digit | "(" | ")" | "*" .
-not_rparen_star = not_paren_star | "(" .
-octet = hex_digit hex_digit .
-special = not_paren_star_quote_special | "(" | ")" | "*" | "\"\"" .
-not_rparen_star_then_rparen = not_rparen_star { not_rparen_star } ")" { ")" } .
-binary_literal = "%" bit { bit } .
-encoded_string_literal = "\"" encoded_character { encoded_character } "\"" .
-integer_literal = digits .
-real_literal = ( digits "." [ digits ] [ "e" [ sign ] digits ] ) | integer_literal .
-simple_id = letter { letter | digit | "_" } .
-simple_string_literal = "'" { ( "'" "'" ) | not_quote } "'" .
-embedded_remark = "(*" [ remark_tag ] { ( not_paren_star { not_paren_star } ) | lparen_then_not_lparen_star | ( "*" { "*" } ) | not_rparen_star_then_rparen | embedded_remark } "*)" .
-remark = embedded_remark | tail_remark .
-remark_tag = "\"" remark_ref { "." remark_ref } "\"" .
-remark_ref = attribute_ref | constant_ref | entity_ref | enumeration_ref | function_ref | parameter_ref | procedure_ref | rule_label_ref | rule_ref | schema_ref | subtype_constraint_ref | type_label_ref | type_ref | variable_ref .
-tail_remark = "--" [ remark_tag ] .
-attribute_ref = attribute_id .
-constant_ref = constant_id .
-entity_ref = entity_id .
-enumeration_ref = enumeration_id .
-function_ref = function_id .
-parameter_ref = parameter_id .
-procedure_ref = procedure_id .
-rule_label_ref = rule_label_id .
-rule_ref = rule_id .
-schema_ref = schema_id .
-subtype_constraint_ref = subtype_constraint_id .
-type_label_ref = type_label_id .
-type_ref = type_id .
-variable_ref = variable_id .
-abstract_entity_declaration = ABSTRACT .
-abstract_supertype = ABSTRACT SUPERTYPE ";" .
-abstract_supertype_declaration = ABSTRACT SUPERTYPE [ subtype_constraint ] .
-actual_parameter_list = "(" [ parameter ] { "," parameter } ")" .
-add_like_op = "+" | "-" | OR | XOR .
-aggregate_initializer = "[" [ element { "," element } ] "]" .
-aggregate_source = simple_expression .
-aggregate_type = AGGREGATE [ ":" type_label ] OF parameter_type .
-aggregation_types = array_type | bag_type | list_type | set_type .
-algorithm_head = { declaration } [ constant_decl ] [ local_decl ] .
-alias_stmt = ALIAS variable_id FOR general_ref { qualifier } ";" stmt { stmt } END_ALIAS ";" .
-array_type = ARRAY bound_spec OF [ OPTIONAL ] [ UNIQUE ] instantiable_type .
-assignment_stmt = general_ref { qualifier } ":=" expression ";" .
-attribute_decl = redeclared_attribute | attribute_id .
-attribute_id = simple_id .
-attribute_qualifier = "." attribute_ref .
-bag_type = BAG [ bound_spec ] OF instantiable_type .
-binary_type = BINARY [ width_spec ] .
-boolean_type = BOOLEAN .
-bound_1 = numeric_expression .
-bound_2 = numeric_expression .
-bound_spec = "[" bound_1 ":" bound_2 "]" .
-built_in_constant = CONST_E | PI | SELF | "?" .
-built_in_function = ABS | ACOS | ASIN | ATAN | BLENGTH | COS | EXISTS | EXP | FORMAT | HIBOUND | HIINDEX | LENGTH | LOBOUND | LOINDEX | LOG | LOG2 | LOG10 | NVL | ODD | ROLESOF | SIN | SIZEOF | SQRT | TAN | TYPEOF | USEDIN | VALUE | VALUE_IN | VALUE_UNIQUE .
-built_in_procedure = INSERT | REMOVE .
-case_action = case_label { "," case_label } ":" stmt .
-case_label = expression .
-case_stmt = CASE selector OF { case_action } [ OTHERWISE ":" stmt ] END_CASE ";" .
-compound_stmt = BEGIN stmt { stmt } END ";" .
-concrete_types = aggregation_types | simple_types | type_ref .
-constant_body = constant_id ":" instantiable_type ":=" expression ";" .
-constant_decl = CONSTANT constant_body { constant_body } END_CONSTANT ";" .
-constant_factor = built_in_constant | constant_ref .
-constant_id = simple_id .
-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 .
-element = expression [ ":" repetition ] .
-entity_body = { explicit_attr } [ derive_clause ] [ inverse_clause ] [ unique_clause ] [ where_clause ] .
-entity_constructor = entity_ref "(" [ expression { "," expression } ] ")" .
-entity_decl = entity_head entity_body END_ENTITY ";" .
-entity_head = ENTITY entity_id subsuper ";" .
-entity_id = simple_id .
-enumeration_extension = BASED_ON type_ref [ WITH enumeration_items ] .
-enumeration_id = simple_id .
-enumeration_items = "(" enumeration_id { "," enumeration_id } ")" .
-enumeration_reference = [ type_ref "." ] enumeration_ref .
-enumeration_type = [ EXTENSIBLE ] ENUMERATION [ ( OF enumeration_items ) | enumeration_extension ] .
-escape_stmt = ESCAPE ";" .
-explicit_attr = attribute_decl { "," attribute_decl } ":" [ OPTIONAL ] parameter_type ";" .
-expression = simple_expression [ rel_op_extended simple_expression ] .
-factor = simple_factor [ "**" simple_factor ] .
-formal_parameter = parameter_id { "," parameter_id } ":" parameter_type .
-function_call = ( built_in_function | function_ref ) actual_parameter_list .
-function_decl = function_head algorithm_head stmt { stmt } END_FUNCTION ";" .
-function_head = FUNCTION function_id [ "(" formal_parameter { ";" formal_parameter } ")" ] ":" parameter_type ";" .
-function_id = simple_id .
-generalized_types = aggregate_type | general_aggregation_types | generic_entity_type | generic_type .
-general_aggregation_types = general_array_type | general_bag_type | general_list_type | general_set_type .
-general_array_type = ARRAY [ bound_spec ] OF [ OPTIONAL ] [ UNIQUE ] parameter_type .
-general_bag_type = BAG [ bound_spec ] OF parameter_type .
-general_list_type = LIST [ bound_spec ] OF [ UNIQUE ] parameter_type .
-general_ref = parameter_ref | variable_ref .
-general_set_type = SET [ bound_spec ] OF parameter_type .
-generic_entity_type = GENERIC_ENTITY [ ":" type_label ] .
-generic_type = GENERIC [ ":" type_label ] .
-group_qualifier = "\\" entity_ref .
-if_stmt = IF logical_expression THEN stmt { stmt } [ ELSE stmt { stmt } ] END_IF ";" .
-increment = numeric_expression .
-increment_control = variable_id ":=" bound_1 TO bound_2 [ BY increment ] .
-index = numeric_expression .
-index_1 = index .
-index_2 = index .
-index_qualifier = "[" index_1 [ ":" index_2 ] "]" .
-instantiable_type = concrete_types | entity_ref .
-integer_type = INTEGER .
-interface_specification = reference_clause | use_clause .
-interval = "{" interval_low interval_op interval_item interval_op interval_high "}" .
-interval_high = simple_expression .
-interval_item = simple_expression .
-interval_low = simple_expression .
-interval_op = "<=" | "<" .
-inverse_attr = attribute_decl ":" [ ( SET | BAG ) [ bound_spec ] OF ] entity_ref FOR [ entity_ref "." ] attribute_ref ";" .
-inverse_clause = INVERSE inverse_attr { inverse_attr } .
-list_type = LIST [ bound_spec ] OF [ UNIQUE ] instantiable_type .
-literal = binary_literal | logical_literal | real_literal | string_literal .
-local_decl = LOCAL local_variable { local_variable } END_LOCAL ";" .
-local_variable = variable_id { "," variable_id } ":" parameter_type [ ":=" expression ] ";" .
-logical_expression = expression .
-logical_literal = FALSE | TRUE | UNKNOWN .
-logical_type = LOGICAL .
-multiplication_like_op = "*" | "/" | DIV | MOD | AND | "||" .
-named_types = entity_ref | type_ref .
-named_type_or_rename = named_types [ AS ( entity_id | type_id ) ] .
-null_stmt = ";" .
-number_type = NUMBER .
-numeric_expression = simple_expression .
-one_of = ONEOF "(" supertype_expression { "," supertype_expression } ")" .
-parameter = expression .
-parameter_id = simple_id .
-parameter_type = generalized_types | simple_types | named_types .
-population = entity_ref .
-precision_spec = numeric_expression .
-primary = literal | ( qualifiable_factor { qualifier } ) .
-procedure_call_stmt = ( built_in_procedure | procedure_ref ) actual_parameter_list ";" .
-procedure_decl = procedure_head algorithm_head { stmt } END_PROCEDURE ";" .
-procedure_head = PROCEDURE procedure_id [ "(" [ VAR ] formal_parameter { ";" [ VAR ] formal_parameter } ")" ] ";" .
-procedure_id = simple_id .
-qualifiable_factor = function_call | attribute_ref | constant_factor | general_ref | population .
-qualified_attribute = SELF group_qualifier attribute_qualifier .
-qualifier = attribute_qualifier | group_qualifier | index_qualifier .
-query_expression = QUERY "(" variable_id "<*" aggregate_source "|" logical_expression ")" .
-real_type = REAL [ "(" precision_spec ")" ] .
-redeclared_attribute = qualified_attribute [ RENAMED attribute_id ] .
-referenced_attribute = attribute_ref | qualified_attribute .
-reference_clause = REFERENCE FROM schema_ref [ "(" resource_or_rename { "," resource_or_rename } ")" ] ";" .
-rel_op = "<=" | ">=" | "<>" | "=" | ":<>:" | ":=:" | "<" | ">" .
-rel_op_extended = rel_op | IN | LIKE .
-rename_id = constant_id | entity_id | function_id | procedure_id | type_id .
-repeat_control = [ increment_control ] [ while_control ] [ until_control ] .
-repeat_stmt = REPEAT repeat_control ";" stmt { stmt } END_REPEAT ";" .
-repetition = numeric_expression .
-resource_or_rename = resource_ref [ AS rename_id ] .
-resource_ref = constant_ref | entity_ref | function_ref | procedure_ref | type_ref .
-return_stmt = RETURN [ "(" expression ")" ] ";" .
-rule_decl = rule_head algorithm_head { stmt } where_clause END_RULE ";" .
-rule_head = RULE rule_id FOR "(" entity_ref { "," entity_ref } ")" ";" .
-rule_id = simple_id .
-rule_label_id = simple_id .
-schema_body = { interface_specification } [ constant_decl ] { declaration | rule_decl } .
-schema_decl = SCHEMA schema_id [ schema_version_id ] ";" schema_body END_SCHEMA ";" .
-schema_id = simple_id .
-schema_version_id = string_literal .
-selector = expression .
-select_extension = BASED_ON type_ref [ WITH select_list ] .
-select_list = "(" named_types { "," named_types } ")" .
-select_type = [ EXTENSIBLE [ GENERIC_ENTITY ] ] SELECT [ select_list | select_extension ] .
-set_type = SET [ bound_spec ] OF instantiable_type .
-sign = "+" | "-" .
-simple_expression = term { add_like_op term } .
-simple_factor = aggregate_initializer | interval | query_expression | ( [ unary_op ] ( "(" expression ")" | primary ) ) | entity_constructor | enumeration_reference .
-simple_types = binary_type | boolean_type | integer_type | logical_type | number_type | real_type | string_type .
-skip_stmt = SKIP ";" .
-stmt = alias_stmt | assignment_stmt | case_stmt | compound_stmt | escape_stmt | if_stmt | null_stmt | procedure_call_stmt | repeat_stmt | return_stmt | skip_stmt .
-string_literal = simple_string_literal | encoded_string_literal .
-string_type = STRING [ width_spec ] .
-subsuper = [ supertype_constraint ] [ subtype_declaration ] .
-subtype_constraint = OF "(" supertype_expression ")" .
-subtype_constraint_body = [ abstract_supertype ] [ total_over ] [ supertype_expression ";" ] .
-subtype_constraint_decl = subtype_constraint_head subtype_constraint_body END_SUBTYPE_CONSTRAINT ";" .
-subtype_constraint_head = SUBTYPE_CONSTRAINT subtype_constraint_id FOR entity_ref ";" .
-subtype_constraint_id = simple_id .
-subtype_declaration = SUBTYPE OF "(" entity_ref { "," entity_ref } ")" .
-supertype_constraint = abstract_supertype_declaration | abstract_entity_declaration | supertype_rule .
-supertype_expression = supertype_factor { ANDOR supertype_factor } .
-supertype_factor = supertype_term { AND supertype_term } .
-supertype_rule = SUPERTYPE subtype_constraint .
-supertype_term = one_of | "(" supertype_expression ")" | entity_ref .
-syntax = schema_decl { schema_decl } .
-term = factor { multiplication_like_op factor } .
-total_over = TOTAL_OVER "(" entity_ref { "," entity_ref } ")" ";" .
-type_decl = TYPE type_id "=" underlying_type ";" [ where_clause ] END_TYPE ";" .
-type_id = simple_id .
-type_label = type_label_id | type_label_ref .
-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 } .
-until_control = UNTIL logical_expression .
-use_clause = USE FROM schema_ref [ "(" named_type_or_rename { "," named_type_or_rename } ")" ] ";" .
-variable_id = simple_id .
-where_clause = WHERE domain_rule ";" { domain_rule ";" } .
-while_control = WHILE logical_expression .
-width = numeric_expression .
-width_spec = "(" width ")" [ FIXED ] .

src/ifcexpressparser/header.py

@@ -1,147 +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 codegen
-import templates
-import documentation
-
-class Header(codegen.Base):
-    def __init__(self, mapping):
-        declarations = []
-
-        write = lambda str, **kwargs: declarations.append(str%dict({
-            'documentation': templates.multi_line_comment(documentation.description(kwargs['name']))}, **kwargs))
-            
-        forward_names = list(mapping.schema.entities.keys()) + list(mapping.schema.simpletypes.keys())
-        forward_definitions = "".join(["class %s; "%n for n in forward_names])
-        
-        for name, type in mapping.schema.selects.items():
-            write(templates.select, name=name)
-
-        for name, type in mapping.schema.enumerations.items():
-            short_name = name[:-4] if name.endswith("Enum") else name
-            write(templates.enumeration, name=name, values=", ".join(["%s_%s"%(short_name, v) for v in type.values]))
-        
-        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
-                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:
-                    continue
-                else:
-                    # Case normalize
-                    superclass = [k for k in mapping.schema.simpletypes.keys() if k.lower() == superclass.lower()][0]
-                emitted_simpletypes.add(name.lower())
-                write(templates.simpletype, name=name, type=type_str, attr_type=attr_type, superclass=superclass)
-
-        class_definitions = []
-
-        write = lambda str, **kwargs: class_definitions.append(str%dict({
-            'documentation': templates.multi_line_comment(documentation.description(kwargs['name']))}, **kwargs))
-
-        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:
-                    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)
-                        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))
-
-                    [write_method(attr) for attr in type.attributes]
-
-                    inv_lines = []
-                    def write_inverse(attr):
-                        inv_lines.append(templates.inverse_attr%{'name':attr.name, 'entity':attr.entity, 'attribute':attr.attribute})
-
-                    if type.inverse:
-                        [write_inverse(attr) for attr in type.inverse.elements]
-
-                    attributes = "\n".join(["%s%s"%(' '*4, a) for a in attr_lines])
-                    if len(attributes): attributes += '\n'
-
-                    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']
-                    superclass = ": %s "%(", ".join(["public %s"%c for c in supertypes]))
-
-                    argument_count = mapping.argument_count(type)
-
-                    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 = 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 = 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 = argument_entity_function_body_switch_stmt + argument_entity_function_body_tail
-
-                    constructor_arguments = ", ".join("%(full_type)s v%(index)d_%(name)s"%a for a in mapping.get_assignable_arguments(type))
-
-                    write(templates.entity, **locals())
-                    emitted_entities.add(name)
-
-        self.str = templates.header % {
-            'schema_name_upper'   : mapping.schema.name.upper(),
-            'schema_name'         : mapping.schema.name.capitalize(),
-            'declarations'        : ''.join(declarations),
-            'forward_definitions' : forward_definitions,
-            'class_definitions'   : ''.join(class_definitions)
-        }
-
-        self.schema_name = mapping.schema.name.capitalize()
-        
-        self.file_name = '%s.h'%self.schema_name
-        
-        
-    def __repr__(self):
-        return self.str

src/ifcexpressparser/implementation.py

@@ -1,259 +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 codegen
-import templates
-
-from schema import OrderedCaseInsensitiveDict
-
-class Implementation(codegen.Base):
-    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)
-        catc = lambda vs: ", ".join(vs)
-        catnl = lambda vs: "\n".join(vs)
-        cator = lambda vs: " || ".join(vs)
-        nl = lambda s: "%s\n"%s if len(s) else s
-
-        write = lambda str, **kwargs: enumeration_functions.append(str%kwargs)
-
-        for name, enum in mapping.schema.enumerations.items():
-            short_name = name[:-4] if name.endswith("Enum") else name
-            context = locals()
-            write(
-                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)
-            )
-
-        write = lambda str, **kwargs: entity_implementations.append(str%kwargs)
-
-        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 = []
-            constructor_implementations = []
-            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
-
-                    tmpl = find_template(arg)
-                    write_attr(
-                        templates.const_function,
-                        class_name  = name,
-                        name        = arg['name'],
-                        arguments   = '',
-                        schema_name = schema_name,
-                        schema_name_upper = schema_name_upper,
-                        return_type = arg['non_optional_type'],
-                        body        = tmpl % {'index': arg['index']-1,
-                                              'type' : arg['non_optional_type'].replace('::Value', ''),
-                                              'list_instance_type' : arg['list_instance_type']}
-                    )
-                    
-                    def find_template(arg):
-                        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
-
-                    tmpl = find_template(arg)
-                    write_attr(
-                        templates.function,
-                        class_name  = name,
-                        name        = 'set%s'%arg['name'],
-                        arguments   = '%s v'%arg['non_optional_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', '')}
-                    )
-
-                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
-
-                    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:
-                        impl = templates.constructor_stmt_optional%{'name'  : arg_name,
-                                                            'index' : arg['index']-1,
-                                                            'stmt'  : impl}
-                    constructor_implementations.append(impl)
-                    
-            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())
-
-            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}
-            } 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()'
-
-            write(
-                templates.entity_implementation,
-                name                       = name,
-                parent_type_test           = parent_type_test,
-                constructor_arguments      = constructor_arguments_str,
-                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
-            )
-
-        selectable_simple_types = sorted(set(sum([b.values for a,b in mapping.schema.selects.items()], [])) & set(map(str, 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()]
-
-        enumerable_types = sorted(set([name for name, type in mapping.schema.types.items()] + [name for name, type in mapping.schema.entities.items()]))
-        max_len = max(map(len, enumerable_types))
-        type_name_strings = catc(map(stringify, enumerable_types))
-        string_map_statements = [templates.string_map_statement % {
-            'uppercase_name' : name.upper(),
-            '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)))
-
-        max_id = len(enumerable_types)
-
-        simple_type_statements = cator("v == Type::%s"%name for name in selectable_simple_types)
-        
-        simple_type_impl = []
-        for class_name, type in mapping.schema.simpletypes.items():
-            type_str = mapping.make_type_string(mapping.flatten_type_string(type))
-            attr_type = mapping.make_argument_type(type)
-            superclass = mapping.simple_type_parent(class_name)
-            
-            simpletype_impl_is = templates.simpletype_impl_is_with_supertype if superclass \
-                else templates.simpletype_impl_is_without_supertype
-                
-            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):
-                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.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,
-            '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,
-            'entity_implementations'   : catnl(entity_implementations),
-            'simple_type_impl'         : catnl(simple_type_impl),
-            'external_definitions'     : catnl(external_definitions)
-        }
-
-        self.schema_name = mapping.schema.name.capitalize()
-        
-        self.file_name = '%s.cpp'%self.schema_name
-        
-        
-    def __repr__(self):
-        return self.str

src/ifcexpressparser/mapping.py

@@ -1,229 +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/>.        #
-#                                                                             #
-###############################################################################
-
-from __future__ import print_function
-
-import sys
-import nodes
-import templates
-
-class Mapping:
-
-    express_to_cpp_typemapping = {
-        'boolean' : 'bool',
-        'logical' : 'bool',
-        'integer' : 'int',
-        'real'    : 'double',
-        'number'  : 'double',
-        'string'  : 'std::string',
-        'binary'  : 'boost::dynamic_bitset<>'
-    }
-    
-    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
-        
-    def flatten_type_string(self, type):
-        return self.flatten_type_string(self.schema.types[type].type.type) if self.schema.is_simpletype(type) else type
-        
-    def flatten_type(self, type):
-        res = self.flatten_type(self.schema.types[type].type.type) if self.schema.is_simpletype(type) else type
-        return res
-        
-    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
-
-    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))
-        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)),
-                'lower'         : type.bounds.lower,
-                'upper'         : type.bounds.upper,
-            }
-
-    def is_array(self, type):
-        if isinstance(type, nodes.AggregationType):
-            return True
-        elif isinstance(type, str) and self.schema.is_type(type):
-            return self.is_array(self.schema.types[type].type.type)
-        else:
-            return False
-            
-    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"
-        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"
-            elif isinstance(type, nodes.BinaryType):
-                return "BINARY"
-            elif isinstance(type, nodes.StringType):
-                return "STRING"
-            elif isinstance(type, nodes.EnumerationType):
-                return "ENUMERATION"
-            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))
-        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'
-        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)
-        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)
-        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):
-                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 % {
-                    'instance_type' : ty,
-                    'lower'         : bounds[0],
-                    'upper'         : bounds[1]
-                }
-            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 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:
-            type_str = "boost::optional< %s >"%type_str
-        return type_str
-
-    def argument_count(self, t):
-        c = sum([self.argument_count(self.schema.entities[s]) for s in t.supertypes])
-        return c + len(t.attributes)
-
-    def arguments(self, t):
-        c = sum([self.arguments(self.schema.entities[s]) for s in t.supertypes], [])
-        return c + t.attributes
-
-    def derived_in_supertype(self, t):
-        c = sum([self.derived_in_supertype(self.schema.entities[s]) for s in t.supertypes], [])
-        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)
-            else:
-                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)
-        simple = self.schema.is_simpletype(ty)
-        express = self.flatten_type_string(ty) in self.express_to_cpp_typemapping
-        select = ty == 'IfcUtil::IfcBaseClass'
-        return arr and not simple and not express and not select
-
-    def get_assignable_arguments(self, t, include_derived = False):
-        count = self.argument_count(t)
-        num_inherited = count - len(t.attributes)
-        derived = set(self.derived_in_supertype(t))
-        attrs = enumerate(self.arguments(t))
-
-        def include(attr):
-            not_derived = include_derived or (attr.name not in derived)
-            supported = self.make_argument_type(attr) != "IfcUtil::Argument_UNKNOWN"
-            return not_derived and supported
-
-        return [{
-            'index'              : i+1,
-            'name'               : attr.name,
-            'full_type'          : self.get_parameter_type(attr, allow_optional=True, allow_entities=True),
-            'specialized_type'   : self.get_parameter_type(attr, allow_optional=True, allow_entities=False),
-            'non_optional_type'  : self.get_parameter_type(attr, allow_optional=False, allow_entities=False),
-            'list_instance_type' : self.list_instance_type(attr),
-            'is_optional'        : attr.optional,
-            'is_inherited'       : i < num_inherited,
-            'is_enum'            : attr.type in self.schema.enumerations,
-            'is_array'           : self.is_array(attr.type),
-            'is_nested'          : self.is_array(attr.type) and not isinstance(attr.type, str) and self.is_array(attr.type.type),
-            'is_derived'         : attr.name in derived,
-            'is_templated_list'  : self.is_templated_list(attr),
-            'argument_type_enum' : self.make_argument_type(attr),
-            'argument_entity'    : self.make_argument_entity(attr),
-            'argument_type'      : attr.type
-        } for i, attr in attrs if include(attr)]
-

src/ifcexpressparser/nodes.py

@@ -1,202 +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 string
-import collections
-
-class Node:
-    def __init__(self, tokens = None):
-        self.tokens = tokens or []
-        self.init()
-    def tokens_of_type(self, cls):
-        return [t for t in self.tokens if isinstance(t, cls)]
-    def single_token_of_type(self, cls, k = None, v = None):
-        ts = [t for t in self.tokens if isinstance(t, cls) and (k is None or getattr(t, k) == v)]
-        return ts[0] if len(ts) == 1 else None
-
-
-class TypeDeclaration(Node):
-    name = property(lambda self: self.tokens[1])
-    type = property(lambda self: self.tokens[3])
-    def init(self):
-        assert self.tokens[0] == 'type'
-        assert isinstance(self.type, UnderlyingType)
-    def __repr__(self):
-        return "%s = TypeDeclaration(%s)" % (self.name, self.type)
-
-
-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)
-        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)
-        if len(self.supertypes):
-            builder += "\n  Supertypes: %s"%(",".join(self.supertypes))
-        if len(self.attributes):
-            builder += "\n  Attributes: %s"%("".join(["\n    %s"%a for a in self.attributes]))
-        if self.derive:
-            builder += "\n  Derive:"
-            builder += str(self.derive)
-        if self.inverse:
-            builder += "\n  Inverse:"
-            builder += str(self.inverse)
-        builder += "\n"
-        return builder
-
-
-class UnderlyingType(Node):
-    type = property(lambda self: self.tokens[0])
-    def init(self):
-        pass
-    def __repr__(self):
-        return repr(self.type)
-
-
-class EnumerationType(Node):
-    type = property(lambda self: self.tokens[0])
-    values = property(lambda self: self.tokens[3::2])
-    def init(self):
-        assert self.type == 'enumeration'
-    def __repr__(self):
-        return ",".join(self.values)
-
-
-class AggregationType(Node):
-    aggregate_type = property(lambda self: self.tokens[0])
-    bounds = property(lambda self: None if self.tokens[1] == 'of' else self.tokens[1])
-    type = property(lambda self: self.tokens[-1])
-    def init(self):
-        assert self.bounds is None or isinstance(self.bounds, BoundSpecification)
-    def __repr__(self):
-        return "%s%s of %s"%(self.aggregate_type, self.bounds, self.type)
-
-
-class SelectType(Node):
-    type = property(lambda self: self.tokens[0])
-    values = property(lambda self: self.tokens[2::2])
-    def init(self):
-        assert self.type == 'select'
-    def __repr__(self):
-        return ",".join(self.values)
-
-
-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
-
-
-class SubTypeExpression(SubSuperTypeExpression):
-    type_relationship = 'subtype'
-
-
-class SuperTypeExpression(SubSuperTypeExpression):
-    type_relationship = 'supertype'
-
-
-class AttributeList(Node):
-    elements = property(lambda self: self.tokens[1:])
-    def __init__(self, ty, toks):
-        self.type = ty
-        Node.__init__(self, toks)
-    def init(self):
-        assert self.type == self.tokens[0]
-    def __repr__(self):
-        return "".join(["\n    %s"%s for s in self.elements])
-
-
-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])
-    entity = property(lambda self: self.tokens[-4])
-    attribute = property(lambda self: self.tokens[-2])
-    def init(self):
-        assert self.bounds is None or isinstance(self.bounds, BoundSpecification)
-    def __repr__(self):
-        return "%s = %s.%s (%s%s)"%(self.name, self.entity, self.attribute, self.type, self.bounds or "")
-
-
-class DerivedAttribute(Node):
-    def init(self):
-        name_index = list(self.tokens).index(':') - 1
-        self.name = self.tokens[name_index]
-    def __repr__(self):
-        return str(self.name)
-
-
-class BinaryType(Node):
-    def init(self):
-        pass
-    def __repr__(self):
-        return "binary"
-
-
-class BoundSpecification(Node):
-    lower = property(lambda self: self.tokens[1])
-    upper = property(lambda self: self.tokens[3])
-    def init(self):
-        # assert self.lower in string.digits or self.lower == '?'
-        # assert self.upper in string.digits or self.upper == '?'
-        pass
-    def __repr__(self):
-        return "[%s:%s]"%(self.lower, self.upper)
-
-
-class ExplicitAttribute(Node):
-    name = property(lambda self: self.tokens[0])
-    type = property(lambda self: self.tokens[-2])
-    optional = property(lambda self: len(self.tokens) == 5 and self.tokens[-3] == 'optional')
-    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"

src/ifcexpressparser/schema.py

@@ -1,84 +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 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
-    def is_select(self, v):
-        return str(v) in self.selects
-    def is_simpletype(self, v):
-        return str(v) in self.simpletypes
-    def is_type(self, v):
-        return str(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]
-    def __init__(self, parsetree):
-        self.name = parsetree[1]
-
-        sort = lambda d: OrderedCaseInsensitiveDict(sorted(d))
-
-        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()}
-
-        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)

src/ifcexpressparser/schema_class.py

@@ -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

src/ifcexpressparser/templates.py

@@ -1,227 +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/>.        #
-#                                                                             #
-###############################################################################
-
-header = """
-#ifndef %(schema_name_upper)s_H
-#define %(schema_name_upper)s_H
-
-#include <string>
-#include <vector>
-
-#include <boost/optional.hpp>
-
-#include "../ifcparse/ifc_parse_api.h"
-
-#include "../ifcparse/IfcEntityList.h"
-#include "../ifcparse/IfcBaseClass.h"
-#include "../ifcparse/IfcSchema.h"
-#include "../ifcparse/IfcException.h"
-#include "../ifcparse/Argument.h"
-
-struct %(schema_name)s {
-
-static const IfcParse::schema_definition& get_schema();
-
-static const char* const Identifier;
-
-// Forward definitions
-%(forward_definitions)s
-
-%(declarations)s
-
-%(class_definitions)s
-};
-
-#endif
-"""
-
-enum_header = """
-#ifndef %(schema_name_upper)sENUM_H
-#define %(schema_name_upper)sENUM_H
-
-#include "../ifcparse/ifc_parse_api.h"
-
-#include <string>
-#include <boost/optional.hpp>
-
-#endif
-"""
-
-lb_header = """"""
-
-implementation= """
-#include "../ifcparse/%(schema_name)s.h"
-#include "../ifcparse/IfcSchema.h"
-#include "../ifcparse/IfcException.h"
-#include "../ifcparse/IfcWrite.h"
-
-#include <map>
-
-const char* const %(schema_name)s::Identifier = "%(schema_name_upper)s";
-
-using namespace IfcParse;
-using namespace IfcWrite;
-
-// External definitions
-%(external_definitions)s
-
-%(enumeration_functions)s
-
-%(simple_type_impl)s
-
-%(entity_implementations)s
-"""
-
-lb_implementation = """"""
-
-entity_descriptor = """    current = entity_descriptor_map[Type::%(type)s] = new IfcEntityDescriptor(Type::%(type)s,%(parent_statement)s);
-%(entity_descriptor_attributes)s"""
-
-entity_descriptor_parent = "entity_descriptor_map.find(Type::%(type)s)->second"
-entity_descriptor_attribute_without_entity = '    current->add("%(name)s",%(optional)s,%(type)s);'
-entity_descriptor_attribute_with_entity = '    current->add("%(name)s",%(optional)s,%(type)s,Type::%(entity_name)s);'
-
-enumeration_descriptor = """    values.clear(); values.reserve(128);
-%(enumeration_descriptor_values)s
-    enumeration_descriptor_map[Type::%(type)s] = new IfcEnumerationDescriptor(Type::%(type)s, values);"""
-
-enumeration_descriptor_value = '    values.push_back("%(name)s");'
-
-derived_field_statement = '    {std::set<int> idxs; %(statements)sderived_map[Type::%(type)s] = idxs;}';
-derived_field_statement_attrs = 'idxs.insert(%d); '
-
-simpletype = """%(documentation)s
-class IFC_PARSE_API %(name)s : public %(superclass)s {
-public:
-    virtual const IfcParse::type_declaration& declaration() const;
-    static const IfcParse::type_declaration& Class();
-    explicit %(name)s (IfcEntityInstanceData* 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;"
-    
-select = """%(documentation)s
-typedef IfcUtil::IfcBaseClass %(name)s;
-"""
-
-enumeration = """struct %(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);
-};
-"""
-
-entity = """%(documentation)s
-class IFC_PARSE_API %(name)s %(superclass)s{
-public:
-%(attributes)s    %(inverse)s    virtual const IfcParse::entity& declaration() const;
-    static const IfcParse::entity& Class();
-    %(name)s (IfcEntityInstanceData* e);
-    %(name)s (%(constructor_arguments)s);
-    typedef IfcTemplatedEntityList< %(name)s > list;
-};
-"""
-
-enumeration_function="""
-const char* %(schema_name)s::%(name)s::ToString(Value 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) {
-%(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 }
-"""
-
-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 }"
-
-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"
-inverse_attr = "IfcTemplatedEntityList< %(entity)s >::ptr %(name)s() const; // INVERSE %(entity)s::%(attribute)s"
-
-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;'
-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 = "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 >();"
-
-get_inverse = "return data_->getInverse(%(schema_name_upper)s_%(type)s_type, %(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); }"
-
-inverse_implementation = "    inverse_map[Type::%(type)s].insert(std::make_pair(\"%(name)s\", std::make_pair(Type::%(related_type)s, %(index)d)));"
-
-def multi_line_comment(li):
-    return ("/// %s"%("\n/// ".join(li))) if len(li) else ""
-

src/ifcgeom/IfcGeom.h

@@ -0,0 +1,116 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcRepresentationShapeItem.h"
+
+namespace IfcGeom {
+
+	// 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_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 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_Face& result);
+	bool convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
+	bool convert_openings_fast(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
+	Ifc2x3::IfcSurfaceStyleShading* get_surface_style(Ifc2x3::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_Face& 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);
+	Ifc2x3::IfcProductDefinitionShape* tesselate(TopoDS_Shape& shape, double deflection, IfcEntities es);
+	void remove_redundant_points_from_loop(TColgp_SequenceOfPnt& polygon, bool closed, double tol=-1.);
+	
+	
+	namespace Cache {
+		void Purge();
+		void PurgeShapeCache();
+	}
+#include "IfcRegisterGeomHeader.h"
+}
+#endif

src/ifcgeom/IfcGeomCurves.cpp

@@ -23,8 +23,6 @@
  *                                                                              *
  ********************************************************************************/
 
-#include <algorithm>
-
 #include <gp_Pnt.hxx>
 #include <gp_Vec.hxx>
 #include <gp_Dir.hxx>
@@ -77,122 +75,56 @@
 
 #include <TopLoc_Location.hxx>
 
-#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
+#include "../ifcgeom/IfcGeom.h"
 
-#ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
-#include <Geom_BSplineCurve.hxx>
-#endif
-
-#define Kernel MAKE_TYPE_NAME(Kernel)
-
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircle* l, Handle(Geom_Curve)& curve) {
-	const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
+bool IfcGeom::convert(const Ifc2x3::IfcCircle::ptr l, Handle(Geom_Curve)& curve) {
+	const double r = l->Radius() * IfcGeom::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())) {
-		IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
+	Ifc2x3::IfcAxis2Placement placement = l->Position();
+	if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) {
+		IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf2d;
-		IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf2d);
+		IfcGeom::convert((IfcAxis2Placement2D*)placement,trsf2d);
 		trsf = trsf2d;
 	}
 	gp_Ax2 ax = gp_Ax2().Transformed(trsf);
 	curve = new Geom_Circle(ax, r);
 	return true;
 }
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipse* l, Handle(Geom_Curve)& curve) {
-	double x = l->SemiAxis1() * getValue(GV_LENGTH_UNIT);
-	double y = l->SemiAxis2() * getValue(GV_LENGTH_UNIT);
+bool IfcGeom::convert(const Ifc2x3::IfcEllipse::ptr l, Handle(Geom_Curve)& curve) {
+	double x = l->SemiAxis1() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	double y = l->SemiAxis2() * IfcGeom::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
-	// is greater than the major radius. Hence, in this case, the
-	// ellipse is rotated. Note that special care needs to be taken
-	// when creating a trimmed curve off of an ellipse like this.
-	const bool rotated = y > x;
+    if (y > x) {
+        Logger::Message(Logger::LOG_ERROR, "Ellipse with SemiAxis2 larger than SemiAxis1 not supported for:", l->entity);
+        return false;
+    }
 	gp_Trsf trsf;
-	IfcSchema::IfcAxis2Placement* placement = l->Position();
-	if (placement->declaration().is(IfcSchema::IfcAxis2Placement3D::Class())) {
-		convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
+	Ifc2x3::IfcAxis2Placement placement = l->Position();
+	if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) {
+		IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf2d;
-		convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf2d);
+		IfcGeom::convert((Ifc2x3::IfcAxis2Placement2D*)placement,trsf2d);
 		trsf = trsf2d;
 	}
-	gp_Ax2 ax = gp_Ax2();
-	if (rotated) {
-		ax.Rotate(ax.Axis(), M_PI / 2.);
-		std::swap(x, y);
-	}
-	ax.Transform(trsf);
+	gp_Ax2 ax = gp_Ax2().Transformed(trsf);
 	curve = new Geom_Ellipse(ax, x, y);
 	return true;
 }
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcLine* l, Handle(Geom_Curve)& curve) {
+bool IfcGeom::convert(const Ifc2x3::IfcLine::ptr l, Handle(Geom_Curve)& curve) {
 	gp_Pnt pnt;gp_Vec vec;
-	convert(l->Pnt(),pnt);
-	convert(l->Dir(),vec);	
+	IfcGeom::convert(l->Pnt(),pnt);
+	IfcGeom::convert(l->Dir(),vec);	
 	// 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
+}

src/ifcgeom/IfcGeomFaces.cpp

@@ -0,0 +1,344 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <new>
+
+#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 <BRepOffsetAPI_Sewing.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 <BRepBuilderAPI_MakeShell.hxx>
+#include <BRepBuilderAPI_MakeSolid.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <ShapeFix_Solid.hxx>
+
+#include <TopLoc_Location.hxx>
+#include <BRepGProp_Face.hxx>
+
+#include "../ifcgeom/IfcGeom.h"
+
+bool IfcGeom::convert(const Ifc2x3::IfcFace::ptr l, TopoDS_Face& face) {
+	Ifc2x3::IfcFaceBound::list bounds = l->Bounds();
+	Ifc2x3::IfcFaceBound::it it = bounds->begin();
+	Ifc2x3::IfcLoop::ptr loop = (*it)->Bound();
+	TopoDS_Wire outer_wire;
+	if ( ! IfcGeom::convert_wire(loop,outer_wire) ) return false;
+	BRepBuilderAPI_MakeFace mf (outer_wire);
+	BRepBuilderAPI_FaceError er = mf.Error();
+	if ( er == BRepBuilderAPI_NotPlanar ) {
+		ShapeFix_ShapeTolerance FTol;
+		FTol.SetTolerance(outer_wire, 0.01, TopAbs_WIRE);
+		mf.~BRepBuilderAPI_MakeFace();
+		new (&mf) BRepBuilderAPI_MakeFace(outer_wire);
+		er = mf.Error();
+	}
+	if ( er != BRepBuilderAPI_FaceDone ) return false;
+	if ( bounds->Size() == 1 ) {
+		face = mf.Face();
+	} else {
+		for( ++it; it != bounds->end(); ++ it) {
+			Ifc2x3::IfcLoop::ptr loop = (*it)->Bound();
+			TopoDS_Wire wire;
+			if ( ! IfcGeom::convert_wire(loop,wire) ) return false;
+			mf.Add(wire);
+		}
+		if ( mf.IsDone() ) {
+			ShapeFix_Shape sfs(mf.Face());
+			sfs.Perform();
+			TopoDS_Shape sfs_shape = sfs.Shape();
+			bool is_face = sfs_shape.ShapeType() == TopAbs_FACE;
+			if ( is_face ) {
+				face = TopoDS::Face(sfs_shape);
+			} else {
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+
+	if ( IfcGeom::GetValue(GV_FORCE_CCW_FACE_ORIENTATION)>0 ) { 
+	// Check the orientation of the face by comparing the 
+	// normal of the topological surface to the Newell's Method's
+	// normal. Newell's Method is used for the normal calculation
+	// as a simple edge cross product can give opposite results
+	// for a concave face boundary.
+	// Reference: Graphics Gems III p. 231
+	BRepGProp_Face prop(face);
+	gp_Vec normal_direction;
+	gp_Pnt center;
+	double u1,u2,v1,v2;
+	prop.Bounds(u1,u2,v1,v2);
+	prop.Normal((u1+u2)/2.0,(v1+v2)/2.0,center,normal_direction);						
+	gp_Dir face_normal1 = gp_Dir(normal_direction.XYZ());
+
+	double x = 0, y = 0, z = 0;
+	gp_Pnt current, previous, first;
+	int n = 0;
+	// Iterate over the vertices of the outer wire (discarding
+	// any potential holes)
+	for ( TopExp_Explorer exp(outer_wire,TopAbs_VERTEX);; exp.Next()) {
+		unsigned has_more = exp.More();
+		if ( has_more ) {
+			const TopoDS_Vertex& v = TopoDS::Vertex(exp.Current());
+			current = BRep_Tool::Pnt(v);
+		} else {
+			current = first;			
+		}
+		if ( n ) {
+			const double& xn  = previous.X();
+			const double& yn  = previous.Y();
+			const double& zn  = previous.Z();
+			const double& xn1 =  current.X();
+			const double& yn1 =  current.Y();
+			const double& zn1 =  current.Z();
+			x += (yn-yn1)*(zn+zn1);
+			y += (xn+xn1)*(zn-zn1);
+			z += (xn-xn1)*(yn+yn1);
+		} else {
+			first = current;
+		}
+		if ( !has_more ) {
+			break;
+		} 
+		previous = current;
+		++n;
+	}
+
+	// If Newell's normal does not point in the same direction
+	// as the topological face normal the face orientation is
+	// reversed
+	gp_Vec face_normal2(x,y,z);
+
+	if (face_normal2.Magnitude() > ALMOST_ZERO) {
+		if ( face_normal1.Dot(face_normal2) < 0 ) {
+			TopAbs_Orientation o = face.Orientation();
+			face.Orientation(o == TopAbs_FORWARD ? TopAbs_REVERSED : TopAbs_FORWARD);
+		}
+	}
+	}
+	
+	// It might be a good idea to globally discard faces
+	// smaller than a certain treshold value. But for now
+	// only when processing IfcConnectedFacesets the small
+	// faces are skipped.
+	// return face_area(face) > 0.0001;
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcArbitraryClosedProfileDef::ptr l, TopoDS_Face& face) {
+	TopoDS_Wire wire;
+	if ( ! IfcGeom::convert_wire(l->OuterCurve(),wire) ) return false;
+	return IfcGeom::convert_wire_to_face(wire,face);
+}
+bool IfcGeom::convert(const Ifc2x3::IfcArbitraryProfileDefWithVoids::ptr l, TopoDS_Face& face) {
+	TopoDS_Wire profile;
+	if ( ! IfcGeom::convert_wire(l->OuterCurve(),profile) ) return false;
+	BRepBuilderAPI_MakeFace mf(profile);
+	Ifc2x3::IfcCurve::list voids = l->InnerCurves();
+	for( Ifc2x3::IfcCurve::it it = voids->begin(); it != voids->end(); ++ it ) {
+		TopoDS_Wire hole;
+		if ( IfcGeom::convert_wire(*it,hole) ) {
+			mf.Add(hole);
+		}
+	}
+	ShapeFix_Shape sfs(mf.Face());
+	sfs.Perform();
+	face = TopoDS::Face(sfs.Shape());
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcRectangleProfileDef::ptr l, TopoDS_Face& face) {
+	const double x = l->XDim() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	const double y = l->YDim() / 2.0f  * IfcGeom::GetValue(GV_LENGTH_UNIT);
+
+	if ( x == 0.0f || y == 0.0f ) {
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		return false;
+	}
+
+	gp_Trsf2d trsf2d;
+	IfcGeom::convert(l->Position(),trsf2d);
+	double coords[8] = {-x,-y,x,-y,x,y,-x,y};
+	return IfcGeom::profile_helper(4,coords,0,0,0,trsf2d,face);
+}
+bool IfcGeom::convert(const Ifc2x3::IfcIShapeProfileDef::ptr l, TopoDS_Face& face) {
+	const double x = l->OverallWidth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	const double y = l->OverallDepth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	const double d1 = l->WebThickness() / 2.0f  * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	const double d2 = l->FlangeThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	bool doFillet = l->hasFilletRadius();
+	double f;
+	if ( doFillet ) {
+		f = l->FilletRadius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	}
+
+	if ( x == 0.0f || y == 0.0f || d1 == 0.0f || d2 == 0.0f ) {
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		return false;
+	}
+
+	gp_Trsf2d trsf2d;
+	IfcGeom::convert(l->Position(),trsf2d);
+
+	double coords[24] = {-x,-y,x,-y,x,-y+d2,d1,-y+d2,d1,y-d2,x,y-d2,x,y,-x,y,-x,y-d2,-d1,y-d2,-d1,-y+d2,-x,-y+d2};
+	int fillets[4] = {3,4,9,10};
+	double radii[4] = {f,f,f,f};
+	return IfcGeom::profile_helper(12,coords,doFillet ? 4 : 0,fillets,radii,trsf2d,face);
+}
+bool IfcGeom::convert(const Ifc2x3::IfcCShapeProfileDef::ptr l, TopoDS_Face& face) {
+	const double y = l->Depth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	const double x = l->Width() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	const double d1 = l->WallThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	const double d2 = l->Girth() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	bool doFillet = l->hasInternalFilletRadius();
+	double f1,f2;
+	if ( doFillet ) {
+		f1 = l->InternalFilletRadius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+		f2 = f1 + d1;
+	}
+
+	if ( x == 0.0f || y == 0.0f || d1 == 0.0f || d2 == 0.0f ) {
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		return false;
+	}
+
+	gp_Trsf2d trsf2d;
+	IfcGeom::convert(l->Position(),trsf2d);
+
+	double coords[24] = {-x,-y,x,-y,x,-y+d2,x-d1,-y+d2,x-d1,-y+d1,-x+d1,-y+d1,-x+d1,y-d1,x-d1,y-d1,x-d1,y-d2,x,y-d2,x,y,-x,y};
+	int fillets[8] = {0,1,4,5,6,7,10,11};
+	double radii[8] = {f2,f2,f1,f1,f1,f1,f2,f2};
+	return IfcGeom::profile_helper(12,coords,doFillet ? 8 : 0,fillets,radii,trsf2d,face);
+}
+bool IfcGeom::convert(const Ifc2x3::IfcLShapeProfileDef::ptr l, TopoDS_Face& face) {
+	const double y = l->Depth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	const double x = (l->hasWidth() ? l->Width() : l->Depth()) / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	const double d = l->Thickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	bool doEdgeFillet = l->hasEdgeRadius();
+	bool doFillet = l->hasFilletRadius();
+	double f1 = 0.0f;
+	double f2 = 0.0f;
+	if (doFillet) {
+		f1 = l->FilletRadius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	}
+	if ( doEdgeFillet) {
+		f2 = l->EdgeRadius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	}
+	if ( x == 0.0f || y == 0.0f || d == 0.0f ) {
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		return false;
+	}
+
+	gp_Trsf2d trsf2d;
+	IfcGeom::convert(l->Position(),trsf2d);
+
+	double coords[12] = {-x,-y,x,-y,x,-y+d,-x+d,-y+d,-x+d,y,-x,y};
+	int fillets[3] = {2,3,4};
+	double radii[3] = {f2,f1,f2};
+	return IfcGeom::profile_helper(6,coords,doFillet ? 3 : 0,fillets,radii,trsf2d,face);
+}
+bool IfcGeom::convert(const Ifc2x3::IfcCircleProfileDef::ptr l, TopoDS_Face& face) {
+	const double r = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	if ( r == 0.0f ) {
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		return false;
+	}
+	
+	gp_Trsf2d trsf;	
+	IfcGeom::convert(l->Position(),trsf);
+
+	BRepBuilderAPI_MakeWire w;
+	gp_Ax2 ax = gp_Ax2().Transformed(trsf);
+	Handle(Geom_Circle) circle = new Geom_Circle(ax, r);
+	TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(circle);
+	w.Add(edge);
+	return IfcGeom::convert_wire_to_face(w,face);
+}
+bool IfcGeom::convert(const Ifc2x3::IfcCircleHollowProfileDef::ptr l, TopoDS_Face& face) {
+	const double r = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	const double t = l->WallThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	
+	if ( r == 0.0f || t == 0.0f ) {
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		return false;
+	}
+	
+	gp_Trsf2d trsf;	
+	IfcGeom::convert(l->Position(),trsf);
+	gp_Ax2 ax = gp_Ax2().Transformed(trsf);
+
+	BRepBuilderAPI_MakeWire outer;	
+	Handle(Geom_Circle) outerCircle = new Geom_Circle(ax, r);
+	outer.Add(BRepBuilderAPI_MakeEdge(outerCircle));
+	BRepBuilderAPI_MakeFace mf(outer.Wire(), false);
+
+	BRepBuilderAPI_MakeWire inner;	
+	Handle(Geom_Circle) innerCirlce = new Geom_Circle(ax, r-t);
+	inner.Add(BRepBuilderAPI_MakeEdge(innerCirlce));
+	mf.Add(inner);
+
+	ShapeFix_Shape sfs(mf.Face());
+	sfs.Perform();
+	face = TopoDS::Face(sfs.Shape());	
+	return true;		
+}

src/ifcgeom/IfcGeomFunctions.cpp

@@ -0,0 +1,603 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 IfcGeom.h     *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <cassert>
+#include <algorithm>
+
+#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 <BRepOffsetAPI_Sewing.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 <BRepBuilderAPI_MakeShell.hxx>
+#include <BRepBuilderAPI_MakeSolid.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <ShapeFix_Solid.hxx>
+
+#include <BRepFilletAPI_MakeFillet2d.hxx>
+
+#include <TopLoc_Location.hxx>
+
+#include <GProp_GProps.hxx>
+#include <BRepGProp.hxx>
+
+#include <BRepBuilderAPI_GTransform.hxx>
+
+#include <BRepCheck_Analyzer.hxx>
+
+#include <BRepGProp_Face.hxx>
+
+#include <BRepMesh_IncrementalMesh.hxx>
+#include <BRepTools.hxx>
+
+#include <Poly_Triangulation.hxx>
+#include <Poly_Array1OfTriangle.hxx>
+
+#include "../ifcgeom/IfcGeom.h"
+
+bool IfcGeom::create_solid_from_compound(const TopoDS_Shape& compound, TopoDS_Shape& shape) {
+	BRepOffsetAPI_Sewing builder;
+	builder.SetTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
+	builder.SetMaxTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
+	builder.SetMinTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
+	TopExp_Explorer exp(compound,TopAbs_FACE);
+	if ( ! exp.More() ) return false;
+	for ( ; exp.More(); exp.Next() ) {
+		TopoDS_Face face = TopoDS::Face(exp.Current());
+		builder.Add(face);
+	}
+	builder.Perform();
+	shape = builder.SewedShape();
+	try {
+	ShapeFix_Solid sf_solid;
+	sf_solid.LimitTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
+	shape = sf_solid.SolidFromShell(TopoDS::Shell(shape));
+	} catch(...) {}
+	return true;
+}
+
+bool IfcGeom::is_compound(const TopoDS_Shape& shape) {
+	bool has_solids = TopExp_Explorer(shape,TopAbs_SOLID).More() != 0;
+	bool has_shells = TopExp_Explorer(shape,TopAbs_SHELL).More() != 0;
+	bool has_compounds = TopExp_Explorer(shape,TopAbs_COMPOUND).More() != 0;
+	bool has_faces = TopExp_Explorer(shape,TopAbs_FACE).More() != 0;
+	return has_compounds && has_faces && !has_solids && !has_shells;
+}
+
+const TopoDS_Shape& IfcGeom::ensure_fit_for_subtraction(const TopoDS_Shape& shape, TopoDS_Shape& solid) {
+	const bool is_comp = IfcGeom::is_compound(shape);
+	if (!is_comp) {
+		return solid = shape;
+	}
+	IfcGeom::create_solid_from_compound(shape, solid);
+	
+	// If the SEW_SHELLS option had been set this precision had been applied
+	// at the end of the generic IfcGeom::convert_shape() call.
+	const double precision = IfcGeom::GetValue(GV_PRECISION);
+	IfcGeom::apply_tolerance(solid, precision);
+	
+	return solid;
+}
+
+bool IfcGeom::convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, 
+							   const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes) {
+	// Iterate over IfcOpeningElements
+	IfcGeom::IfcRepresentationShapeItems opening_shapes;
+	unsigned int last_size = 0;
+	for ( Ifc2x3::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
+		Ifc2x3::IfcRelVoidsElement::ptr v = *it;
+		Ifc2x3::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
+		if ( fes->is(Ifc2x3::Type::IfcOpeningElement) ) {
+
+			// Convert the IfcRepresentation of the IfcOpeningElement
+			gp_Trsf opening_trsf;
+			IfcGeom::convert(fes->ObjectPlacement(),opening_trsf);
+
+			// Move the opening into the coordinate system of the IfcProduct
+			opening_trsf.PreMultiply(entity_trsf.Inverted());
+
+			Ifc2x3::IfcProductRepresentation::ptr prodrep = fes->Representation();
+			Ifc2x3::IfcRepresentation::list reps = prodrep->Representations();
+						
+			for ( Ifc2x3::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
+				IfcGeom::convert_shapes(*it2,opening_shapes);
+			}
+
+			const unsigned int current_size = (const unsigned int) opening_shapes.size();
+			for ( unsigned int i = last_size; i < current_size; ++ i ) {
+				opening_shapes[i].prepend(opening_trsf);
+			}
+			last_size = current_size;
+		}
+	}
+
+	// Iterate over the shapes of the IfcProduct
+	for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it3 = entity_shapes.begin(); it3 != entity_shapes.end(); ++ it3 ) {
+		TopoDS_Shape entity_shape_solid;
+		const TopoDS_Shape& entity_shape_unlocated = IfcGeom::ensure_fit_for_subtraction(it3->Shape(),entity_shape_solid);
+		const gp_GTrsf& entity_shape_gtrsf = it3->Placement();
+		TopoDS_Shape entity_shape;
+		if ( entity_shape_gtrsf.Form() == gp_Other ) {
+			Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to:",entity->entity);
+			entity_shape = BRepBuilderAPI_GTransform(entity_shape_unlocated,entity_shape_gtrsf,true).Shape();
+		} else {
+			entity_shape = entity_shape_unlocated.Moved(entity_shape_gtrsf.Trsf());
+		}
+
+		// Iterate over the shapes of the IfcOpeningElements
+		for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it4 = opening_shapes.begin(); it4 != opening_shapes.end(); ++ it4 ) {
+			TopoDS_Shape opening_shape_solid;
+			const TopoDS_Shape& opening_shape_unlocated = IfcGeom::ensure_fit_for_subtraction(it4->Shape(),opening_shape_solid);
+			const gp_GTrsf& opening_shape_gtrsf = it4->Placement();
+			if ( opening_shape_gtrsf.Form() == gp_Other ) {
+				Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to opening of:",entity->entity);
+			}
+			const TopoDS_Shape& opening_shape = opening_shape_gtrsf.Form() == gp_Other
+				? BRepBuilderAPI_GTransform(opening_shape_unlocated,opening_shape_gtrsf,true).Shape()
+				: opening_shape_unlocated.Moved(opening_shape_gtrsf.Trsf());
+					
+			double opening_volume, original_shape_volume;
+			if ( Logger::Verbosity() >= Logger::LOG_WARNING ) {
+				opening_volume = shape_volume(opening_shape);
+				if ( opening_volume <= ALMOST_ZERO )
+					Logger::Message(Logger::LOG_WARNING,"Empty opening for:",entity->entity);
+				original_shape_volume = shape_volume(entity_shape);
+			}
+			
+			BRepAlgoAPI_Cut brep_cut(entity_shape,opening_shape);
+
+			if ( brep_cut.IsDone() ) {
+				TopoDS_Shape brep_cut_result = brep_cut;
+				
+				BRepCheck_Analyzer analyser(brep_cut_result);
+				bool is_valid = analyser.IsValid() != 0;
+				if ( is_valid ) {
+					entity_shape = brep_cut;
+					if ( Logger::Verbosity() >= Logger::LOG_WARNING ) {
+						const double volume_after_subtraction = shape_volume(entity_shape);
+					
+						if ( ALMOST_THE_SAME(original_shape_volume,volume_after_subtraction) )
+							Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",entity->entity);
+					}
+				} else {
+					Logger::Message(Logger::LOG_ERROR,"Invalid result from subtraction:",entity->entity);
+				}
+			} else {
+				Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",entity->entity);
+			}
+
+		}
+		cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(entity_shape, &it3->Style()));
+	}
+
+	return true;
+}
+
+bool IfcGeom::convert_openings_fast(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, 
+							   const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes) {
+	
+	// Create a compound of all opening shapes in order to speed up the boolean operations
+	TopoDS_Compound opening_compound;
+	BRep_Builder builder;
+	builder.MakeCompound(opening_compound);
+
+	for ( Ifc2x3::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
+		Ifc2x3::IfcRelVoidsElement::ptr v = *it;
+		Ifc2x3::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
+		if ( fes->is(Ifc2x3::Type::IfcOpeningElement) ) {
+
+			// Convert the IfcRepresentation of the IfcOpeningElement
+			gp_Trsf opening_trsf;
+			IfcGeom::convert(fes->ObjectPlacement(),opening_trsf);
+
+			// Move the opening into the coordinate system of the IfcProduct
+			opening_trsf.PreMultiply(entity_trsf.Inverted());
+
+			Ifc2x3::IfcProductRepresentation::ptr prodrep = fes->Representation();
+			Ifc2x3::IfcRepresentation::list reps = prodrep->Representations();
+
+			IfcGeom::IfcRepresentationShapeItems opening_shapes;
+						
+			for ( Ifc2x3::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
+				IfcGeom::convert_shapes(*it2,opening_shapes);
+			}
+
+			for ( unsigned int i = 0; i < opening_shapes.size(); ++ i ) {
+				gp_GTrsf gtrsf = opening_shapes[i].Placement();
+				gtrsf.PreMultiply(opening_trsf);
+				const TopoDS_Shape& opening_shape = gtrsf.Form() == gp_Other
+					? BRepBuilderAPI_GTransform(opening_shapes[i].Shape(),gtrsf,true).Shape()
+					: (opening_shapes[i].Shape()).Moved(gtrsf.Trsf());
+				builder.Add(opening_compound,opening_shape);
+			}
+
+		}
+	}
+
+	// Iterate over the shapes of the IfcProduct
+	for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it3 = entity_shapes.begin(); it3 != entity_shapes.end(); ++ it3 ) {
+		TopoDS_Shape entity_shape_solid;
+		const TopoDS_Shape& entity_shape_unlocated = IfcGeom::ensure_fit_for_subtraction(it3->Shape(),entity_shape_solid);
+		const gp_GTrsf& entity_shape_gtrsf = it3->Placement();
+		TopoDS_Shape entity_shape;
+		if ( entity_shape_gtrsf.Form() == gp_Other ) {
+			Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to:",entity->entity);
+			entity_shape = BRepBuilderAPI_GTransform(entity_shape_unlocated,entity_shape_gtrsf,true).Shape();
+		} else {
+			entity_shape = entity_shape_unlocated.Moved(entity_shape_gtrsf.Trsf());
+		}
+
+		BRepAlgoAPI_Cut brep_cut(entity_shape,opening_compound);
+		bool is_valid = false;
+		if ( brep_cut.IsDone() ) {
+			TopoDS_Shape brep_cut_result = brep_cut;
+				
+			BRepCheck_Analyzer analyser(brep_cut_result);
+			is_valid = analyser.IsValid() != 0;
+			if ( is_valid ) {
+				cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(brep_cut_result, &it3->Style()));
+			}
+		}
+		if ( !is_valid ) {
+			// Apparently processing the boolean operation failed or resulted in an invalid result
+			// in which case the original shape without the subtractions is returned instead
+			// we try convert the openings in the original way, one by one.
+			Logger::Message(Logger::LOG_WARNING,"Subtracting combined openings compound failed:",entity->entity);
+			return false;
+		}
+		
+	}
+	return true;
+}
+
+bool IfcGeom::convert_wire_to_face(const TopoDS_Wire& wire, TopoDS_Face& face) {
+	BRepBuilderAPI_MakeFace mf(wire, false);
+	BRepBuilderAPI_FaceError er = mf.Error();
+	if ( er == BRepBuilderAPI_NotPlanar ) {
+		ShapeFix_ShapeTolerance FTol;
+		FTol.SetTolerance(wire, 0.01, TopAbs_WIRE);
+		mf.~BRepBuilderAPI_MakeFace();
+		new (&mf) BRepBuilderAPI_MakeFace(wire);
+		er = mf.Error();
+	}
+	if ( er != BRepBuilderAPI_FaceDone ) return false;
+	face = mf.Face();
+	return true;
+}
+bool IfcGeom::profile_helper(int numVerts, double* verts, int numFillets, int* filletIndices, double* filletRadii, gp_Trsf2d trsf, TopoDS_Face& face) {
+	TopoDS_Vertex* vertices = new TopoDS_Vertex[numVerts];
+	
+	for ( int i = 0; i < numVerts; i ++ ) {
+		gp_XY xy (verts[2*i],verts[2*i+1]);
+		trsf.Transforms(xy);
+		vertices[i] = BRepBuilderAPI_MakeVertex(gp_Pnt(xy.X(),xy.Y(),0.0f));
+	}
+
+	BRepBuilderAPI_MakeWire w;
+	for ( int i = 0; i < numVerts; i ++ )
+		w.Add(BRepBuilderAPI_MakeEdge(vertices[i],vertices[(i+1)%numVerts]));
+
+	IfcGeom::convert_wire_to_face(w.Wire(),face);
+
+	if ( numFillets && *std::max_element(filletRadii, filletRadii + numFillets) > 1e-7 ) {
+		BRepFilletAPI_MakeFillet2d fillet (face);
+		for ( int i = 0; i < numFillets; i ++ ) {
+			const double radius = filletRadii[i];
+			if ( radius <= 1e-7 ) continue;
+			fillet.AddFillet(vertices[filletIndices[i]],radius);
+		}
+		fillet.Build();
+		if (fillet.IsDone()) {
+			face = TopoDS::Face(fillet.Shape());
+		} else {
+			Logger::Message(Logger::LOG_WARNING, "Failed to process profile fillets");
+		}
+	}
+
+	delete[] vertices;
+	return true;
+}
+double IfcGeom::shape_volume(const TopoDS_Shape& s) {
+	GProp_GProps prop;
+	BRepGProp::VolumeProperties(s, prop);
+	return prop.Mass();
+}
+double IfcGeom::face_area(const TopoDS_Face& f) {
+	GProp_GProps prop;
+	BRepGProp::SurfaceProperties(f,prop);
+	return prop.Mass();
+}
+bool IfcGeom::is_convex(const TopoDS_Wire& wire) {
+	for ( TopExp_Explorer exp1(wire,TopAbs_VERTEX); exp1.More(); exp1.Next() ) {
+		TopoDS_Vertex V1 = TopoDS::Vertex(exp1.Current());
+		gp_Pnt P1 = BRep_Tool::Pnt(V1);
+		// Store the neighboring points
+		std::vector<gp_Pnt> neighbors;
+		for ( TopExp_Explorer exp3(wire,TopAbs_EDGE); exp3.More(); exp3.Next() ) {
+			TopoDS_Edge edge = TopoDS::Edge(exp3.Current());
+			std::vector<gp_Pnt> edge_points;
+			for ( TopExp_Explorer exp2(edge,TopAbs_VERTEX); exp2.More(); exp2.Next() ) {
+				TopoDS_Vertex V2 = TopoDS::Vertex(exp2.Current());
+				gp_Pnt P2 = BRep_Tool::Pnt(V2);
+				edge_points.push_back(P2);
+			}
+			if ( edge_points.size() != 2 ) continue;
+			if ( edge_points[0].IsEqual(P1,GetValue(GV_POINT_EQUALITY_TOLERANCE))) neighbors.push_back(edge_points[1]);
+			else if ( edge_points[1].IsEqual(P1, GetValue(GV_POINT_EQUALITY_TOLERANCE))) neighbors.push_back(edge_points[0]);
+		}
+		// There should be two of these
+		if ( neighbors.size() != 2 ) return false;
+		// Now find the non neighboring points
+		std::vector<gp_Pnt> non_neighbors;
+		for ( TopExp_Explorer exp2(wire,TopAbs_VERTEX); exp2.More(); exp2.Next() ) {
+			TopoDS_Vertex V2 = TopoDS::Vertex(exp2.Current());
+			gp_Pnt P2 = BRep_Tool::Pnt(V2);
+			if ( P1.IsEqual(P2,GetValue(GV_POINT_EQUALITY_TOLERANCE)) ) continue;
+			bool found = false;
+			for( std::vector<gp_Pnt>::const_iterator it = neighbors.begin(); it != neighbors.end(); ++ it ) {
+				if ( (*it).IsEqual(P2,GetValue(GV_POINT_EQUALITY_TOLERANCE)) ) { found = true; break; }
+			}
+			if ( ! found ) non_neighbors.push_back(P2);
+		}
+		// Calculate the angle between the two edges of the vertex
+		gp_Dir dir1(neighbors[0].XYZ() - P1.XYZ());
+		gp_Dir dir2(neighbors[1].XYZ() - P1.XYZ());
+		const double angle = acos(dir1.Dot(dir2)) + 0.0001;
+		// Now for the non-neighbors see whether a greater angle can be found with one of the edges
+		for ( std::vector<gp_Pnt>::const_iterator it = non_neighbors.begin(); it != non_neighbors.end(); ++ it ) {
+			gp_Dir dir3((*it).XYZ() - P1.XYZ());
+			const double angle2 = acos(dir3.Dot(dir1));
+			const double angle3 = acos(dir3.Dot(dir2));
+			if ( angle2 > angle || angle3 > angle ) return false;
+		}
+	}
+	return true;
+}
+TopoDS_Shape IfcGeom::halfspace_from_plane(const gp_Pln& pln,const gp_Pnt& cent) {
+	TopoDS_Face face = BRepBuilderAPI_MakeFace(pln).Face();
+	return BRepPrimAPI_MakeHalfSpace(face,cent).Solid();
+}
+gp_Pln IfcGeom::plane_from_face(const TopoDS_Face& face) {
+	BRepGProp_Face prop(face);
+	Standard_Real u1,u2,v1,v2;
+	prop.Bounds(u1,u2,v1,v2);
+	Standard_Real u = (u1+u2)/2.0;
+	Standard_Real v = (v1+v2)/2.0;
+	gp_Pnt p;
+	gp_Vec n;
+	prop.Normal(u,v,p,n);
+	return gp_Pln(p,n);
+}
+gp_Pnt IfcGeom::point_above_plane(const gp_Pln& pln, bool agree) {
+	if ( agree ) {
+		return pln.Location().Translated(pln.Axis().Direction());
+	} else {
+		return pln.Location().Translated(-pln.Axis().Direction());
+	}
+}
+
+void IfcGeom::apply_tolerance(TopoDS_Shape& s, double t) {
+	ShapeFix_ShapeTolerance tol;
+	tol.SetTolerance(s, t);
+}
+
+static double deflection_tolerance = 0.001;
+static double wire_creation_tolerance = 0.0001;
+static double minimal_face_area = 0.000001;
+static double point_equality_tolerance = 0.00001;
+static double max_faces_to_sew = -1.0;
+static double ifc_length_unit = 1.0;
+static double ifc_planeangle_unit = -1.0;
+static double force_ccw_face_orientation = -1.0;
+static double modelling_precision = 0.00001;
+
+void IfcGeom::SetValue(GeomValue var, double value) {
+	switch (var) {
+	case GV_DEFLECTION_TOLERANCE:
+		deflection_tolerance = value;
+		break;
+	case GV_WIRE_CREATION_TOLERANCE:
+		wire_creation_tolerance = value;
+		break;
+	case GV_MINIMAL_FACE_AREA:
+		minimal_face_area = value;
+		break;
+	case GV_POINT_EQUALITY_TOLERANCE:
+		point_equality_tolerance = value;
+		break;
+	case GV_MAX_FACES_TO_SEW:
+		max_faces_to_sew = value;
+		break;
+	case GV_LENGTH_UNIT:
+		ifc_length_unit = value;
+		break;
+	case GV_PLANEANGLE_UNIT:
+		ifc_planeangle_unit = value;
+		break;
+	case GV_FORCE_CCW_FACE_ORIENTATION:
+		force_ccw_face_orientation = value;
+		break;
+	case GV_PRECISION:
+		modelling_precision = value;
+		break;
+	default:
+		assert(!"never reach here");
+	}
+}
+
+double IfcGeom::GetValue(GeomValue var) {
+	switch (var) {
+	case GV_DEFLECTION_TOLERANCE:
+		return deflection_tolerance;
+	case GV_WIRE_CREATION_TOLERANCE:
+		return wire_creation_tolerance;
+	case GV_MINIMAL_FACE_AREA:
+		return minimal_face_area;
+	case GV_POINT_EQUALITY_TOLERANCE:
+		return point_equality_tolerance;
+	case GV_MAX_FACES_TO_SEW:
+		return max_faces_to_sew;
+	case GV_LENGTH_UNIT:
+		return ifc_length_unit;
+		break;
+	case GV_PLANEANGLE_UNIT:
+		return ifc_planeangle_unit;
+		break;
+	case GV_FORCE_CCW_FACE_ORIENTATION:
+		return force_ccw_face_orientation;
+		break;
+	case GV_PRECISION:
+		return modelling_precision;
+		break;
+	}
+	assert(!"never reach here");
+	return 0;
+}
+
+Ifc2x3::IfcProductDefinitionShape* IfcGeom::tesselate(TopoDS_Shape& shape, double deflection, IfcEntities es) {
+	BRepMesh_IncrementalMesh(shape, deflection);
+
+	Ifc2x3::IfcFace::list faces (new IfcTemplatedEntityList<Ifc2x3::IfcFace>());
+
+	for (TopExp_Explorer exp(shape, TopAbs_FACE); exp.More(); exp.Next()) {
+		const TopoDS_Face& face = TopoDS::Face(exp.Current());
+		TopLoc_Location loc;
+		Handle(Poly_Triangulation) tri = BRep_Tool::Triangulation(face, loc);
+
+		if (! tri.IsNull()) {
+			const TColgp_Array1OfPnt& nodes = tri->Nodes();
+			std::vector<Ifc2x3::IfcCartesianPoint*> vertices;
+			for (int i = 1; i <= nodes.Length(); ++i) {
+				gp_Pnt pnt = nodes(i).Transformed(loc);
+				std::vector<double> xyz; xyz.push_back(pnt.X()); xyz.push_back(pnt.Y()); xyz.push_back(pnt.Z());
+				Ifc2x3::IfcCartesianPoint* cpnt = new Ifc2x3::IfcCartesianPoint(xyz);
+				vertices.push_back(cpnt);
+				es->push(cpnt);
+			}
+			const Poly_Array1OfTriangle& triangles = tri->Triangles();			
+			for (int i = 1; i <= triangles.Length(); ++ i) {
+				int n1, n2, n3;
+				triangles(i).Get(n1, n2, n3);
+				Ifc2x3::IfcCartesianPoint::list points (new IfcTemplatedEntityList<Ifc2x3::IfcCartesianPoint>());
+				points->push(vertices[n1-1]);
+				points->push(vertices[n2-1]);
+				points->push(vertices[n3-1]);
+				Ifc2x3::IfcPolyLoop* loop = new Ifc2x3::IfcPolyLoop(points);
+				Ifc2x3::IfcFaceOuterBound* bound = new Ifc2x3::IfcFaceOuterBound(loop, face.Orientation() != TopAbs_REVERSED);
+				Ifc2x3::IfcFaceBound::list bounds (new IfcTemplatedEntityList<Ifc2x3::IfcFaceBound>());
+				bounds->push(bound);
+				Ifc2x3::IfcFace* face = new Ifc2x3::IfcFace(bounds);
+				es->push(loop);
+				es->push(bound);
+				es->push(face);
+				faces->push(face);
+			}
+		}
+	}
+	Ifc2x3::IfcOpenShell* shell = new Ifc2x3::IfcOpenShell(faces);
+	Ifc2x3::IfcConnectedFaceSet::list shells (new IfcTemplatedEntityList<Ifc2x3::IfcConnectedFaceSet>());
+	shells->push(shell);
+	Ifc2x3::IfcFaceBasedSurfaceModel* surface_model = new Ifc2x3::IfcFaceBasedSurfaceModel(shells);
+
+	Ifc2x3::IfcRepresentation::list reps (new IfcTemplatedEntityList<Ifc2x3::IfcRepresentation>());
+	Ifc2x3::IfcRepresentationItem::list items (new IfcTemplatedEntityList<Ifc2x3::IfcRepresentationItem>());
+
+	items->push(surface_model);
+
+	Ifc2x3::IfcShapeRepresentation* rep = new Ifc2x3::IfcShapeRepresentation(
+		0, std::string("Facetation"), std::string("SurfaceModel"), items);
+
+	reps->push(rep);
+	Ifc2x3::IfcProductDefinitionShape* shapedef = new Ifc2x3::IfcProductDefinitionShape(0, 0, reps);
+
+	es->push(shell);
+	es->push(surface_model);
+	es->push(rep);
+	es->push(shapedef);
+
+	return shapedef;
+}
+
+void IfcGeom::remove_redundant_points_from_loop(TColgp_SequenceOfPnt& polygon, bool closed, double tol) {
+	if (tol <= 0.) tol = GetValue(GV_POINT_EQUALITY_TOLERANCE);
+	tol *= tol;
+
+	while (true) {
+		bool removed = false;
+		int n = polygon.Length() - (closed ? 0 : 1);
+		for (int i = 1; i <= n; ++i) {
+			// wrap around to the first point in case of a closed loop
+			int j = (i % polygon.Length()) + 1;
+			double dist = polygon.Value(i).SquareDistance(polygon.Value(j));
+			if (dist < tol) {
+				// do not remove the first or last point to
+				// maintain connectivity with other wires
+				if ((closed && j == 1) || (!closed && j == n)) polygon.Remove(i);
+				else polygon.Remove(j);
+				removed = true;
+				break;
+			}
+		}
+		if (!removed) break;
+	}
+}

src/ifcgeom/IfcGeomHelpers.cpp

@@ -0,0 +1,264 @@
+/********************************************************************************
+ *                                                                              *
+ * 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_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 <BRepOffsetAPI_Sewing.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 <BRepBuilderAPI_MakeShell.hxx>
+#include <BRepBuilderAPI_MakeSolid.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <ShapeFix_Solid.hxx>
+
+#include <BRepFilletAPI_MakeFillet2d.hxx>
+
+#include <TopLoc_Location.hxx>
+
+#include "../ifcgeom/IfcGeom.h"
+
+
+namespace IfcGeom {
+	namespace Cache {
+#include "IfcRegisterCreateCache.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;
+
+bool IfcGeom::convert(const Ifc2x3::IfcCartesianPoint::ptr l, gp_Pnt& point) {
+	IN_CACHE(IfcCartesianPoint,l,gp_Pnt,point)
+	std::vector<double> xyz = l->Coordinates();
+	point = gp_Pnt(
+		xyz.size()     ? (xyz[0]*IfcGeom::GetValue(GV_LENGTH_UNIT)) : 0.0f,
+		xyz.size() > 1 ? (xyz[1]*IfcGeom::GetValue(GV_LENGTH_UNIT)) : 0.0f,
+		xyz.size() > 2 ? (xyz[2]*IfcGeom::GetValue(GV_LENGTH_UNIT)) : 0.0f
+	);
+	CACHE(IfcCartesianPoint,l,point)
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcDirection::ptr l, gp_Dir& dir) {
+	IN_CACHE(IfcDirection,l,gp_Dir,dir)
+	std::vector<double> xyz = l->DirectionRatios();
+	dir = gp_Dir(
+		xyz.size()     ? xyz[0] : 0.0f,
+		xyz.size() > 1 ? xyz[1] : 0.0f,
+		xyz.size() > 2 ? xyz[2] : 0.0f
+	);
+	CACHE(IfcDirection,l,dir)
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcVector::ptr l, gp_Vec& v) {
+	IN_CACHE(IfcVector,l,gp_Vec,v)
+	gp_Dir d;
+	IfcGeom::convert(l->Orientation(),d);
+	v = l->Magnitude() * IfcGeom::GetValue(GV_LENGTH_UNIT) * d;
+	CACHE(IfcVector,l,v)
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement3D::ptr l, gp_Trsf& trsf) {
+	IN_CACHE(IfcAxis2Placement3D,l,gp_Trsf,trsf)
+	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
+	IfcGeom::convert(l->Location(),o);
+	bool hasRef = l->hasRefDirection();
+	if ( l->hasAxis() ) IfcGeom::convert(l->Axis(),axis);
+	if ( hasRef ) IfcGeom::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;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3D::ptr l, gp_Trsf& trsf) {
+	IN_CACHE(IfcCartesianTransformationOperator3D,l,gp_Trsf,trsf)
+	gp_Pnt origin;
+	IfcGeom::convert(l->LocalOrigin(),origin);
+	gp_Dir axis1 (1.,0.,0.);
+	gp_Dir axis2 (0.,1.,0.);
+	gp_Dir axis3 (0.,0.,1.);
+	if ( l->hasAxis1() ) IfcGeom::convert(l->Axis1(),axis1);
+	if ( l->hasAxis2() ) IfcGeom::convert(l->Axis2(),axis2);
+	if ( l->hasAxis3() ) IfcGeom::convert(l->Axis3(),axis3);
+	gp_Ax3 ax3 (origin,axis3,axis1);
+	if ( axis2.Dot(ax3.YDirection()) < 0 ) ax3.YReverse();
+	trsf.SetTransformation(ax3);
+	trsf.Invert();
+	if ( l->hasScale() ) trsf.SetScaleFactor(l->Scale());
+	CACHE(IfcCartesianTransformationOperator3D,l,trsf)
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2D::ptr l, gp_Trsf2d& trsf) {
+	IN_CACHE(IfcCartesianTransformationOperator2D,l,gp_Trsf2d,trsf)
+	gp_Pnt origin;
+	IfcGeom::convert(l->LocalOrigin(),origin);
+	gp_Dir axis1 (1.,0.,0.);
+	if ( l->hasAxis1() ) IfcGeom::convert(l->Axis1(),axis1);
+	const gp_Ax2d ax2d (gp_Pnt2d(origin.X(),origin.Y()),gp_Dir2d(axis1.X(),axis1.Y()));
+	trsf.SetTransformation(ax2d);
+	trsf.Invert();
+	if ( l->hasScale() ) trsf.SetScaleFactor(l->Scale());
+	CACHE(IfcCartesianTransformationOperator2D,l,trsf)
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::ptr l, gp_GTrsf& gtrsf) {
+	IN_CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gp_GTrsf,gtrsf)
+	gp_Trsf trsf;
+	gp_Pnt origin;
+	IfcGeom::convert(l->LocalOrigin(),origin);
+	gp_Dir axis1 (1.,0.,0.);
+	gp_Dir axis2 (0.,1.,0.);
+	gp_Dir axis3 (0.,0.,1.);
+	if ( l->hasAxis1() ) IfcGeom::convert(l->Axis1(),axis1);
+	if ( l->hasAxis2() ) IfcGeom::convert(l->Axis2(),axis2);
+	if ( l->hasAxis3() ) IfcGeom::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;
+	gtrsf = gp_GTrsf();
+	gtrsf.SetValue(1,1,scale1);
+	gtrsf.SetValue(2,2,scale2);
+	gtrsf.SetValue(3,3,scale3);
+	gtrsf.PreMultiply(trsf);
+	CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gtrsf)
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2DnonUniform::ptr l, gp_GTrsf2d& gtrsf) {
+	IN_CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gp_GTrsf2d,gtrsf)
+	gp_Trsf2d trsf;
+	gp_Pnt origin;
+	IfcGeom::convert(l->LocalOrigin(),origin);
+	gp_Dir axis1 (1.,0.,0.);
+	if ( l->hasAxis1() ) IfcGeom::convert(l->Axis1(),axis1);
+	const gp_Ax2d ax2d (gp_Pnt2d(origin.X(),origin.Y()),gp_Dir2d(axis1.X(),axis1.Y()));
+	trsf.SetTransformation(ax2d);
+	trsf.Invert();
+	const double scale1 = l->hasScale() ? l->Scale() : 1.0f;
+	const double scale2 = l->hasScale2() ? l->Scale2() : scale1;
+	gtrsf = gp_GTrsf2d();
+	gtrsf.SetValue(1,1,scale1);
+	gtrsf.SetValue(2,2,scale2);
+	gtrsf.Multiply(trsf);
+	CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gtrsf)
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcPlane::ptr pln, gp_Pln& plane) {
+	IN_CACHE(IfcPlane,pln,gp_Pln,plane)
+	Ifc2x3::IfcAxis2Placement3D::ptr l = pln->Position();
+	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
+	IfcGeom::convert(l->Location(),o);
+	bool hasRef = l->hasRefDirection();
+	if ( l->hasAxis() ) IfcGeom::convert(l->Axis(),axis);
+	if ( hasRef ) IfcGeom::convert(l->RefDirection(),refDirection);
+	gp_Ax3 ax3;
+	if ( hasRef ) ax3 = gp_Ax3(o,axis,refDirection);
+	else ax3 = gp_Ax3(o,axis);
+	plane = gp_Pln(ax3);
+	CACHE(IfcPlane,pln,plane)
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement2D::ptr l, gp_Trsf2d& trsf) {
+	IN_CACHE(IfcAxis2Placement2D,l,gp_Trsf2d,trsf)
+	gp_Pnt P; gp_Dir V (1,0,0);
+	IfcGeom::convert(l->Location(),P);
+	if ( l->hasRefDirection() )
+		IfcGeom::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::convert(const Ifc2x3::IfcObjectPlacement::ptr l, gp_Trsf& trsf) {
+	IN_CACHE(IfcObjectPlacement,l,gp_Trsf,trsf)
+	if ( ! l->is(Ifc2x3::Type::IfcLocalPlacement) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l->entity);
+		return false; 		
+	}
+	Ifc2x3::IfcLocalPlacement::ptr current = reinterpret_pointer_cast<Ifc2x3::IfcObjectPlacement,Ifc2x3::IfcLocalPlacement>(l);
+	while (1) {
+		gp_Trsf trsf2;
+		Ifc2x3::IfcAxis2Placement relplacement = current->RelativePlacement();
+		if ( relplacement->is(Ifc2x3::Type::IfcAxis2Placement3D) ) {
+			IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)relplacement,trsf2);
+			trsf.PreMultiply(trsf2);
+		}
+		if ( current->hasPlacementRelTo() ) {
+			Ifc2x3::IfcObjectPlacement::ptr relto = current->PlacementRelTo();
+			if ( relto->is(Ifc2x3::Type::IfcLocalPlacement) )
+				current = reinterpret_pointer_cast<Ifc2x3::IfcObjectPlacement,Ifc2x3::IfcLocalPlacement>(current->PlacementRelTo());
+			else break;			
+		} else break;
+	}
+	CACHE(IfcObjectPlacement,l,trsf)
+	return true;
+}
+void IfcGeom::Cache::Purge() {
+#include "IfcRegisterPurgeCache.h"
+	IfcGeom::Cache::PurgeShapeCache();
+}

src/ifcgeom/IfcGeomObjects.cpp

@@ -0,0 +1,846 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <stdexcept>
+#include <limits>
+
+#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_Compound.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepTools.hxx>
+#include <BRep_Tool.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRepMesh_IncrementalMesh.hxx>
+#include <Poly_Triangulation.hxx>
+#include <Poly_PolygonOnTriangulation.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
+#include <TShort_Array1OfShortReal.hxx>
+#include <Poly_Array1OfTriangle.hxx>
+#include <StdFail_NotDone.hxx>
+#include <BRepGProp_Face.hxx>
+#include <BRepBuilderAPI_GTransform.hxx>
+
+#include "../ifcparse/IfcException.h"
+#include "../ifcgeom/IfcGeomObjects.h"
+#include "../ifcgeom/IfcGeom.h"
+
+// Welds vertices that belong to different faces
+static bool weld_vertices = true;
+
+static bool convert_back_units = false;
+static bool use_faster_booleans = false;
+static bool disable_subtractions = false;
+static bool disable_triangulation = false;
+
+int IfcGeomObjects::IfcRepresentationTriangulation::addvert(int material_index, const gp_XYZ& p) {
+	const float X = convert_back_units ? (float) (p.X() / IfcGeom::GetValue(IfcGeom::GV_LENGTH_UNIT)) : (float)p.X();
+	const float Y = convert_back_units ? (float) (p.Y() / IfcGeom::GetValue(IfcGeom::GV_LENGTH_UNIT)) : (float)p.Y();
+	const float Z = convert_back_units ? (float) (p.Z() / IfcGeom::GetValue(IfcGeom::GV_LENGTH_UNIT)) : (float)p.Z();
+	int i = (int) _verts.size() / 3;
+	if ( weld_vertices ) {
+		const VertKey key = std::make_pair(material_index, std::make_pair(X, std::make_pair(Y, Z)));
+		VertKeyMap::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;
+}
+
+static bool use_world_coords = false;
+static bool use_brep_data = false;
+
+static IfcParse::IfcFile* ifc_file = 0;
+
+IfcGeomObjects::IfcRepresentationBrepData::IfcRepresentationBrepData(const IfcRepresentationShapeModel& shapes)
+	: _id(shapes.getId()) 
+{
+	try {
+		TopoDS_Compound compound;
+		BRep_Builder builder;
+		builder.MakeCompound(compound);
+		for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
+			const TopoDS_Shape& s = it->Shape();
+			gp_GTrsf trsf = it->Placement();
+			if (convert_back_units) {
+				gp_Trsf scale;
+				scale.SetScaleFactor(1.0 / IfcGeom::GetValue(IfcGeom::GV_LENGTH_UNIT));
+				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();
+	} catch(...) {
+		Logger::Message(Logger::LOG_ERROR,"Failed to serialize shape:",ifc_file->EntityById(_id)->entity);
+	}
+}
+
+IfcGeomObjects::IfcRepresentationTriangulation::IfcRepresentationTriangulation(const IfcRepresentationShapeModel& shapes)
+	: _id(shapes.getId()) 
+{
+	for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it = shapes.begin(); it != shapes.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();
+			}
+		}
+
+		const TopoDS_Shape& s = it->Shape();
+		const gp_GTrsf& trsf = it->Placement();
+
+		// Triangulate the shape
+		try {
+			BRepMesh_IncrementalMesh(s, IfcGeom::GetValue(IfcGeom::GV_DEFLECTION_TOLERANCE));
+		} catch(...) {
+			Logger::Message(Logger::LOG_ERROR,"Failed to triangulate shape:",ifc_file->EntityById(_id)->entity);
+			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 = ! weld_vertices;
+
+				for( int i = 1; i <= nodes.Length(); ++ i ) {
+					coords.push_back(nodes(i).Transformed(loc).XYZ());
+					trsf.Transforms(*coords.rbegin());
+					dict[i] = addvert(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);
+				}
+			}
+		}
+	}
+}
+
+IfcGeomObjects::IfcObject::IfcObject(
+	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)
+{
+	// 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 && convert_back_units
+				? trsf_value / IfcGeom::GetValue(IfcGeom::GV_LENGTH_UNIT)
+				: trsf_value;
+			_matrix.push_back(static_cast<float>(matrix_value));
+		}
+	}
+}
+
+IfcGeomObjects::IfcGeomShapeModelObject::IfcGeomShapeModelObject(
+	int id, 
+	int parent_id, 
+	const std::string& name, 
+	const std::string& type, 
+	const std::string& guid,
+	const gp_Trsf& trsf, 
+	IfcRepresentationShapeModel* shapes) 
+		: IfcObject(id,parent_id,name,type,guid,trsf)
+		, _mesh(shapes)
+{}
+
+IfcGeomObjects::IfcGeomBrepDataObject::IfcGeomBrepDataObject(
+	const IfcGeomShapeModelObject& shape_model)
+		: IfcObject(shape_model)
+		, _mesh(new IfcRepresentationBrepData(shape_model.mesh()))
+{}
+
+IfcGeomObjects::IfcGeomObject::IfcGeomObject(
+	const IfcGeomShapeModelObject& shape_model)
+		: IfcObject(shape_model)
+		, _mesh(new IfcRepresentationTriangulation(shape_model.mesh()))
+{}
+
+// A container and iterator for IfcShapeRepresentations
+static Ifc2x3::IfcShapeRepresentation::list shapereps;
+static Ifc2x3::IfcShapeRepresentation::it shaperep_iterator;
+
+// The object is fetched beforehand to be positive an entity actually exists
+static IfcGeomObjects::IfcGeomObject* current_geom_obj = 0;
+static IfcGeomObjects::IfcGeomShapeModelObject* current_shape_model_obj = 0;
+static IfcGeomObjects::IfcGeomBrepDataObject* current_brep_data_obj = 0;
+
+// A container and iterator for IfcBuildingElements for the current IfcShapeRepresentation referenced by *shaperep_iterator
+static Ifc2x3::IfcProduct::list entities;
+static Ifc2x3::IfcProduct::it ifcproduct_iterator;
+
+static int done;
+static int total;
+
+// Move the the next IfcShapeRepresentation
+void _nextShape() {
+	entities.reset();
+	++ shaperep_iterator;
+	++ done;
+}
+
+int _getParentId(const Ifc2x3::IfcProduct::ptr ifc_product) {
+	int parent_id = -1;
+	// In case of an opening element, parent to the RelatingBuildingElement
+	if ( ifc_product->is(Ifc2x3::Type::IfcOpeningElement ) ) {
+		Ifc2x3::IfcOpeningElement::ptr opening = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcOpeningElement>(ifc_product);
+		Ifc2x3::IfcRelVoidsElement::list voids = opening->VoidsElements();
+		if ( voids->Size() ) {
+			Ifc2x3::IfcRelVoidsElement::ptr ifc_void = *voids->begin();
+			parent_id = ifc_void->RelatingBuildingElement()->entity->id();
+		}
+	} else if ( ifc_product->is(Ifc2x3::Type::IfcElement ) ) {
+		Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcElement>(ifc_product);
+		Ifc2x3::IfcRelFillsElement::list fills = element->FillsVoids();
+		// Incase of a RelatedBuildingElement parent to the opening element
+		if ( fills->Size() ) {
+			for ( Ifc2x3::IfcRelFillsElement::it it = fills->begin(); it != fills->end(); ++ it ) {
+				Ifc2x3::IfcRelFillsElement::ptr fill = *it;
+				Ifc2x3::IfcObjectDefinition* ifc_objectdef = fill->RelatingOpeningElement();
+				if ( ifc_product == ifc_objectdef ) continue;
+				parent_id = ifc_objectdef->entity->id();
+			}
+		} 
+		// Else simply parent to the containing structure
+		if ( parent_id == -1 ) {
+			Ifc2x3::IfcRelContainedInSpatialStructure::list parents = element->ContainedInStructure();
+			if ( parents->Size() ) {
+				Ifc2x3::IfcRelContainedInSpatialStructure::ptr parent = *parents->begin();
+				parent_id = parent->RelatingStructure()->entity->id();
+			}
+		}
+	}
+	// Parent decompositions to the RelatingObject
+	if ( parent_id == -1 ) {
+		IfcEntities parents = ifc_product->entity->getInverse(Ifc2x3::Type::IfcRelAggregates);
+		parents->push(ifc_product->entity->getInverse(Ifc2x3::Type::IfcRelNests));
+		for ( IfcEntityList::it it = parents->begin(); it != parents->end(); ++ it ) {
+			Ifc2x3::IfcRelDecomposes::ptr decompose = reinterpret_pointer_cast<IfcBaseClass,Ifc2x3::IfcRelDecomposes>(*it);
+			Ifc2x3::IfcObjectDefinition* ifc_objectdef = decompose->RelatingObject();
+			if ( ifc_product == ifc_objectdef ) continue;
+			parent_id = ifc_objectdef->entity->id();
+		}
+	}
+	return parent_id;
+}
+
+IfcGeomObjects::IfcGeomShapeModelObject* create_shape_model_for_next_entity() {
+	while ( true ) {
+		Ifc2x3::IfcShapeRepresentation::ptr shaperep;
+
+		// Have we reached the end of our list of representations?
+		if ( shaperep_iterator == shapereps->end() ) {
+			shapereps.reset();
+			return 0;
+		}
+		shaperep = *shaperep_iterator;
+
+		// Has the list of IfcProducts for this representation been initialized?
+		if ( ! entities ) {
+			if ( shaperep->hasRepresentationIdentifier() ) {
+				const std::string representation_identifier = shaperep->RepresentationIdentifier();
+				if ( shaperep->hasRepresentationType() && representation_identifier == "IAI" && shaperep->RepresentationType() != "BoundingBox" ) {
+					// Allow for Ifc 2x compatibility
+				} else if ( representation_identifier != "Body" &&
+					representation_identifier != "Facetation" ) {
+						_nextShape();
+						continue;
+				}
+			}
+			Ifc2x3::IfcProductRepresentation::list prodreps = shaperep->OfProductRepresentation();
+			entities = Ifc2x3::IfcProduct::list( new IfcTemplatedEntityList<Ifc2x3::IfcProduct>() );
+			for ( Ifc2x3::IfcProductRepresentation::it it = prodreps->begin(); it != prodreps->end(); ++it ) {
+				if ( (*it)->is(Ifc2x3::Type::IfcProductDefinitionShape) ) {
+					Ifc2x3::IfcProductDefinitionShape::ptr pds = reinterpret_pointer_cast<Ifc2x3::IfcProductRepresentation,Ifc2x3::IfcProductDefinitionShape>(*it);
+					entities->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
+					IfcEntities products = (*it)->entity->getInverse(Ifc2x3::Type::IfcProduct);
+					for ( IfcEntityList::it it = products->begin(); it != products->end(); ++ it ) {
+						entities->push(reinterpret_pointer_cast<IfcBaseClass,Ifc2x3::IfcProduct>(*it));
+					}
+				}
+			}
+			// Does this representation have any IfcProducts?
+			if ( ! entities->Size() ) {
+				_nextShape();
+				continue;
+			}
+			ifcproduct_iterator = entities->begin();
+		}
+		// Have we reached the end of our list of IfcProducts?
+		if ( ifcproduct_iterator == entities->end() ) {
+			_nextShape();
+			continue;
+		}
+		
+		IfcGeomObjects::IfcRepresentationShapeModel* shape;
+		IfcGeom::IfcRepresentationShapeItems shapes;
+
+		if ( !IfcGeom::convert_shapes(shaperep,shapes) ) {
+			_nextShape();
+			continue;
+		}
+
+		Ifc2x3::IfcProduct::ptr ifc_product = *ifcproduct_iterator;
+
+		int parent_id = -1;
+		try {
+			parent_id = _getParentId(ifc_product);
+		} catch (...) {}
+		
+		const std::string name = ifc_product->hasName() ? ifc_product->Name() : "";
+		const std::string guid = ifc_product->GlobalId();
+		
+		gp_Trsf trsf;
+		try {
+			IfcGeom::convert(ifc_product->ObjectPlacement(),trsf);
+		} catch (...) {}
+
+		// Does the IfcElement have any IfcOpenings?
+		// Note that openings for IfcOpeningElements are not processed
+		Ifc2x3::IfcRelVoidsElement::list openings = Ifc2x3::IfcRelVoidsElement::list();
+		if ( ifc_product->is(Ifc2x3::Type::IfcElement) && !ifc_product->is(Ifc2x3::Type::IfcOpeningElement) ) {
+			Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcElement>(ifc_product);
+			openings = element->HasOpenings();
+		}
+		// Is the IfcElement a decomposition of an IfcElement with any IfcOpeningElements?
+		if ( ifc_product->is(Ifc2x3::Type::IfcBuildingElementPart ) ) {
+			Ifc2x3::IfcBuildingElementPart::ptr part = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcBuildingElementPart>(ifc_product);
+			Ifc2x3::IfcRelDecomposes::list decomposes = part->Decomposes();
+			for ( Ifc2x3::IfcRelDecomposes::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
+				Ifc2x3::IfcObjectDefinition::ptr obdef = (*it)->RelatingObject();
+				if ( obdef->is(Ifc2x3::Type::IfcElement) ) {
+					Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcObjectDefinition,Ifc2x3::IfcElement>(obdef);
+					openings->push(element->HasOpenings());
+				}
+			}
+		}
+
+		if ( !disable_subtractions && openings && openings->Size() ) {
+			IfcGeom::IfcRepresentationShapeItems opened_shapes;
+			try {
+				if ( use_faster_booleans ) {
+					bool succes = IfcGeom::convert_openings_fast(ifc_product,openings,shapes,trsf,opened_shapes);
+					if ( ! succes ) {
+						opened_shapes.clear();
+						IfcGeom::convert_openings(ifc_product,openings,shapes,trsf,opened_shapes);
+					}
+				} else {
+					IfcGeom::convert_openings(ifc_product,openings,shapes,trsf,opened_shapes);
+				}
+			} catch(...) { 
+				Logger::Message(Logger::LOG_ERROR,"Error processing openings for:",ifc_product->entity); 
+			}
+			if ( use_world_coords ) {
+				for ( IfcGeom::IfcRepresentationShapeItems::iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
+					it->prepend(trsf);
+				}
+				trsf = gp_Trsf();
+			}
+			shape = new IfcGeomObjects::IfcRepresentationShapeModel(shaperep->entity->id(),opened_shapes);
+		} else if ( use_world_coords ) {
+			for ( IfcGeom::IfcRepresentationShapeItems::iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
+				it->prepend(trsf);
+			}
+			trsf = gp_Trsf();
+			shape = new IfcGeomObjects::IfcRepresentationShapeModel(shaperep->entity->id(),shapes);
+		} else {
+			shape = new IfcGeomObjects::IfcRepresentationShapeModel(shaperep->entity->id(),shapes);
+		}
+
+		return new IfcGeomObjects::IfcGeomShapeModelObject(ifc_product->entity->id(), parent_id, name, 
+			Ifc2x3::Type::ToString(ifc_product->type()), guid, trsf, shape);
+	}	
+}
+
+bool try_and_create_representations_for_current_entity() {
+	current_shape_model_obj = create_shape_model_for_next_entity();
+	if (current_shape_model_obj == 0) {
+		return false;
+	}
+	
+	if (use_brep_data) {
+		current_brep_data_obj = new IfcGeomObjects::IfcGeomBrepDataObject(*current_shape_model_obj);
+		if (current_brep_data_obj == 0) {
+			return false;
+		}
+	}
+
+	if (!disable_triangulation) {
+		current_geom_obj = new IfcGeomObjects::IfcGeomObject(*current_shape_model_obj);
+		if (current_geom_obj == 0) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool IfcGeomObjects::Next() {
+	// Free all possible representations of the current geometrical entity
+	delete current_geom_obj;
+	delete current_brep_data_obj;
+	delete current_shape_model_obj;
+	current_geom_obj = 0;
+	current_brep_data_obj = 0;
+	current_shape_model_obj = 0;
+
+	// Increment the iterator over the list of products using the current
+	// shape representation
+	if (entities) {
+		++ifcproduct_iterator;
+	}
+
+	return try_and_create_representations_for_current_entity();
+}
+
+static std::vector<IfcGeomObjects::IfcObject*> returned_objects;
+bool IfcGeomObjects::CleanUp() {
+	// TODO: Correctly implement destructor for IfcFile
+	delete ifc_file;
+	IfcGeom::Cache::Purge();
+	std::vector<IfcGeomObjects::IfcObject*>::const_iterator it;
+	for (it = returned_objects.begin(); it != returned_objects.end(); ++ it ) {
+		delete *it;
+	}
+	returned_objects.clear();
+	return true;
+}
+const IfcGeomObjects::IfcObject* IfcGeomObjects::GetObject(int id) {
+	IfcObject* ifc_object = 0;
+	try {
+		const IfcParse::IfcEntity& ifc_entity = ifc_file->EntityById(id);
+		if ( ifc_entity->is(Ifc2x3::Type::IfcProduct) ) {
+			Ifc2x3::IfcProduct::ptr ifc_product = reinterpret_pointer_cast<IfcUtil::IfcBaseClass,Ifc2x3::IfcProduct>(ifc_entity);
+			int parent_id = -1;
+			try {
+				parent_id = _getParentId(ifc_product);
+			} catch (...) {}
+			const std::string name = ifc_product->hasName() ? ifc_product->Name() : "";
+			gp_Trsf trsf;
+			try {
+				IfcGeom::convert(ifc_product->ObjectPlacement(),trsf);
+			} catch (...) {}
+			ifc_object = new IfcObject(ifc_product->entity->id(),parent_id,name,
+				Ifc2x3::Type::ToString(ifc_product->type()),ifc_product->GlobalId(),trsf);
+		}
+	} catch(...) {}
+	if ( !ifc_object ) ifc_object = new IfcObject(-1,-1,"","","",gp_Trsf());
+	returned_objects.push_back(ifc_object);
+	return ifc_object;
+}
+const IfcGeomObjects::IfcGeomObject* IfcGeomObjects::Get() {
+	if (disable_triangulation) {
+		throw std::runtime_error("No triangulation available");
+	}
+	return current_geom_obj;
+}
+const IfcGeomObjects::IfcGeomShapeModelObject* IfcGeomObjects::GetShapeModel() {
+	return current_shape_model_obj;
+}
+const IfcGeomObjects::IfcGeomBrepDataObject* IfcGeomObjects::GetBrepData() {
+	if (!use_brep_data) {
+		throw std::runtime_error("No BRep data available");
+	}
+	return current_brep_data_obj;
+}
+double UnitPrefixToValue( Ifc2x3::IfcSIPrefix::IfcSIPrefix v ) {
+	if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_EXA   ) return (double) 1e18;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_PETA  ) return (double) 1e15;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_TERA  ) return (double) 1e12;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_GIGA  ) return (double) 1e9;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_MEGA  ) return (double) 1e6;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_KILO  ) return (double) 1e3;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_HECTO ) return (double) 1e2;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_DECA  ) return (double) 1;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_DECI  ) return (double) 1e-1;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_CENTI ) return (double) 1e-2;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_MILLI ) return (double) 1e-3;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_MICRO ) return (double) 1e-6;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_NANO  ) return (double) 1e-9;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_PICO  ) return (double) 1e-12;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_FEMTO ) return (double) 1e-15;
+	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_ATTO  ) return (double) 1e-18;
+	else return 1.0f;
+}
+
+static std::string unit_name = "METER";
+static float unit_magnitude = 1.0f;
+
+void IfcGeomObjects::InitPrecision() {
+	IfcGeom::SetValue(IfcGeom::GV_PRECISION, 0.00001);
+
+	try {
+		Ifc2x3::IfcGeometricRepresentationContext::list rep_contexts = ifc_file->EntitiesByType<Ifc2x3::IfcGeometricRepresentationContext>();
+		// Currently, IfcGeometricRepresentationContext aren't used as much as they should be
+		// in the evaluation of shape representations, hence, we try to find the one with the
+		// lowest precision. Typically, a value of 1e-5 is encountered. This value is applied
+		// to all TopoDS_Shapes generated by one of the IfcGeom::convert() functions.
+		// TODO: Many of the empirically found tolerances should probably be substituted by
+		// one that is defined in the model file.
+		double lowest_precision_encountered = std::numeric_limits<double>::infinity();
+		bool any_precision_encountered = false;
+		for (Ifc2x3::IfcGeometricRepresentationContext::it it = rep_contexts->begin(); it != rep_contexts->end(); ++it) {
+			Ifc2x3::IfcGeometricRepresentationContext* rep_context = *it;
+			if (rep_context->is(Ifc2x3::Type::IfcGeometricRepresentationSubContext)) continue;
+			if (rep_context->hasPrecision()) {
+				const double precision = rep_context->Precision();
+				if (precision < lowest_precision_encountered) {
+					any_precision_encountered = true;
+					lowest_precision_encountered = precision;
+				}
+			}
+		}
+		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");
+				IfcGeom::SetValue(IfcGeom::GV_PRECISION, 1.e-7);
+			} else {
+				IfcGeom::SetValue(IfcGeom::GV_PRECISION, lowest_precision_encountered);
+			}
+		}
+	} catch (const IfcParse::IfcException& ex) {
+		std::stringstream ss;
+		ss << "Failed to determine precision value '" << ex.what() << "'";
+		Logger::Message(Logger::LOG_ERROR, ss.str());
+	}
+}
+
+void IfcGeomObjects::InitUnits() {
+	// Set default units, set length to meters, angles to undefined
+	IfcGeom::SetValue(IfcGeom::GV_LENGTH_UNIT,1.0);
+	IfcGeom::SetValue(IfcGeom::GV_PLANEANGLE_UNIT,-1.0);
+	
+	Ifc2x3::IfcUnitAssignment::list unit_assignments = ifc_file->EntitiesByType<Ifc2x3::IfcUnitAssignment>();
+	IfcUtil::IfcAbstractSelect::list units = IfcUtil::IfcAbstractSelect::list();
+	try {
+		if ( unit_assignments->Size() ) {
+			Ifc2x3::IfcUnitAssignment::ptr unit_assignment = *unit_assignments->begin();
+			units = unit_assignment->Units();
+		}
+	} catch (const IfcParse::IfcException&) {}
+
+	if (!units) {
+		// No units eh... Since tolerances and deflection are specified internally in meters
+		// we will try to find another indication of the model size.
+		Ifc2x3::IfcExtrudedAreaSolid::list extrusions = ifc_file->EntitiesByType<Ifc2x3::IfcExtrudedAreaSolid>();
+		if ( ! extrusions->Size() ) return;
+		double max_height = -1.0f;
+		for ( Ifc2x3::IfcExtrudedAreaSolid::it it = extrusions->begin(); it != extrusions->end(); ++ it ) {
+			try {
+				const double depth = (*it)->Depth();
+				if ( depth > max_height ) max_height = depth;
+			} catch (const IfcParse::IfcException&) {}
+		}
+		if ( max_height > 100.0f ) {
+			IfcGeom::SetValue(IfcGeom::GV_LENGTH_UNIT,0.001);
+			Logger::Message(Logger::LOG_NOTICE, "Guessed length unit to be in millimeters based on extrusion depth");
+		}
+		return;
+	}
+
+	try {
+		for ( IfcUtil::IfcAbstractSelect::it it = units->begin(); it != units->end(); ++ it ) {
+			std::string current_unit_name = "";
+			const IfcUtil::IfcAbstractSelect::ptr base = *it;
+			Ifc2x3::IfcSIUnit::ptr unit = Ifc2x3::IfcSIUnit::ptr();
+			double value = 1.0f;
+			if ( base->is(Ifc2x3::Type::IfcConversionBasedUnit) ) {
+				const Ifc2x3::IfcConversionBasedUnit::ptr u = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcConversionBasedUnit>(base);
+				current_unit_name = u->Name();
+				const Ifc2x3::IfcMeasureWithUnit::ptr u2 = u->ConversionFactor();
+				Ifc2x3::IfcUnit u3 = u2->UnitComponent();
+				if ( u3->is(Ifc2x3::Type::IfcSIUnit) ) {
+					unit = (Ifc2x3::IfcSIUnit*) u3;
+				}
+				Ifc2x3::IfcValue v = u2->ValueComponent();
+				IfcUtil::IfcArgumentSelect* v2 = (IfcUtil::IfcArgumentSelect*) v;
+				const double f = *v2->wrappedValue();
+				value *= f;
+			} else if ( base->is(Ifc2x3::Type::IfcSIUnit) ) {
+				unit = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcSIUnit>(base);
+			}
+			if ( unit ) {
+				if ( unit->hasPrefix() ) {
+					value *= UnitPrefixToValue(unit->Prefix());
+				}
+				Ifc2x3::IfcUnitEnum::IfcUnitEnum type = unit->UnitType();
+				if ( type == Ifc2x3::IfcUnitEnum::IfcUnit_LENGTHUNIT ) {
+					IfcGeom::SetValue(IfcGeom::GV_LENGTH_UNIT,value);
+					if (current_unit_name.empty()) {
+						if (unit->hasPrefix()) {
+							current_unit_name = Ifc2x3::IfcSIPrefix::ToString(unit->Prefix());
+						}
+						current_unit_name += Ifc2x3::IfcSIUnitName::ToString(unit->Name());
+					}
+					unit_magnitude = value;
+					unit_name = current_unit_name;
+				} else if ( type == Ifc2x3::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT ) {
+					IfcGeom::SetValue(IfcGeom::GV_PLANEANGLE_UNIT,value);
+				}
+			}
+		}
+	} catch (const IfcParse::IfcException& ex) {
+		std::stringstream ss;
+		ss << "Failed to determine unit information '" << ex.what() << "'";
+		Logger::Message(Logger::LOG_ERROR, ss.str());
+	}
+}
+
+bool IfcGeomObjects::Init(const std::string fn) {
+	return IfcGeomObjects::Init(fn, 0, 0);
+}
+bool _Init() {
+	IfcGeomObjects::InitUnits();
+	IfcGeomObjects::InitPrecision();
+
+	shapereps = ifc_file->EntitiesByType<Ifc2x3::IfcShapeRepresentation>();
+	if ( ! shapereps ) return false;
+	
+	shaperep_iterator = shapereps->begin();
+	entities.reset();
+
+	if (!try_and_create_representations_for_current_entity()) {
+		return false;
+	}
+
+	done = 0;
+	total = shapereps->Size();
+	return true;
+}
+bool IfcGeomObjects::Init(const std::string fn, std::ostream* log1, std::ostream* log2) {
+	Logger::SetOutput(log1,log2);
+	ifc_file = new IfcParse::IfcFile();
+	if ( !ifc_file->Init(fn) ) return false;
+	return _Init();	
+}
+bool IfcGeomObjects::Init(std::istream& f, int len, std::ostream* log1, std::ostream* log2) {
+	Logger::SetOutput(log1,log2);
+	ifc_file = new IfcParse::IfcFile();
+	if ( !ifc_file->Init(f, len) ) return false;
+	return _Init();
+}
+bool IfcGeomObjects::Init(void* data, int len) {
+	Logger::SetOutput(0,0);
+	ifc_file = new IfcParse::IfcFile();
+	if ( !ifc_file->Init(data, len) ) return false;
+	return _Init();
+}
+void IfcGeomObjects::Settings(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:
+		use_faster_booleans = value;
+		break;
+	case SEW_SHELLS:
+		IfcGeom::SetValue(IfcGeom::GV_MAX_FACES_TO_SEW,value ? 1000 : -1);
+		break;
+	case FORCE_CCW_FACE_ORIENTATION:
+		IfcGeom::SetValue(IfcGeom::GV_FORCE_CCW_FACE_ORIENTATION,value ? 1 : -1);
+		break;
+    case DISABLE_OPENING_SUBTRACTIONS:
+        disable_subtractions = value;
+        break;
+	case DISABLE_TRIANGULATION:
+        disable_triangulation = value;
+        break;
+	}
+}
+int IfcGeomObjects::Progress() {
+	return 100 * done / total;
+}
+
+const std::string& IfcGeomObjects::GetUnitName() {
+	return unit_name;
+}
+
+const float IfcGeomObjects::GetUnitMagnitude() {
+	return unit_magnitude;
+}
+
+const std::string IfcGeomObjects::GetLog() {
+	return Logger::GetLog();
+}
+
+IfcParse::IfcFile* IfcGeomObjects::GetFile() {
+  return ifc_file;
+}
+
+static double black[3] = {0,0,0};
+
+IfcGeomObjects::Material::Material(const IfcGeom::SurfaceStyle* style) : style(style) {}
+bool IfcGeomObjects::Material::hasDiffuse() const { return style->Diffuse() ? true : false; }
+bool IfcGeomObjects::Material::hasSpecular() const { return style->Specular() ? true : false; }
+bool IfcGeomObjects::Material::hasTransparency() const { return style->Transparency() ? true : false; }
+bool IfcGeomObjects::Material::hasSpecularity() const { return style->Specularity() ? true : false; }
+const double* IfcGeomObjects::Material::diffuse() const { if (hasDiffuse()) return &((*style->Diffuse()).R()); else return black; }
+const double* IfcGeomObjects::Material::specular() const { if (hasSpecular()) return &((*style->Specular()).R()); else return black; }
+double IfcGeomObjects::Material::transparency() const { if (hasTransparency()) return *style->Transparency(); else return 0; }
+double IfcGeomObjects::Material::specularity() const { if (hasSpecularity()) return *style->Specularity(); else return 0; }
+const std::string IfcGeomObjects::Material::name() const { return style->Name(); }
+bool IfcGeomObjects::Material::operator==(const IfcGeomObjects::Material& other) const { return style == other.style; }
+
+int IfcGeomObjects::IfcRepresentationBrepData::id() const { return _id; }
+const std::string& IfcGeomObjects::IfcRepresentationBrepData::brep_data() const { return _brep_data; }
+
+int IfcGeomObjects::IfcRepresentationTriangulation::id() const { return _id; }
+const std::vector<float>& IfcGeomObjects::IfcRepresentationTriangulation::verts() const { return _verts; }
+const std::vector<int>& IfcGeomObjects::IfcRepresentationTriangulation::faces() const { return _faces; }
+const std::vector<int>& IfcGeomObjects::IfcRepresentationTriangulation::edges() const { return _edges; }
+const std::vector<float>& IfcGeomObjects::IfcRepresentationTriangulation::normals() const { return _normals; }
+const std::vector<int>& IfcGeomObjects::IfcRepresentationTriangulation::material_ids() const { return _material_ids; }
+const std::vector<IfcGeomObjects::Material>& IfcGeomObjects::IfcRepresentationTriangulation::materials() const { return _materials; }
+
+int IfcGeomObjects::IfcObject::id() const { return _id; }
+int IfcGeomObjects::IfcObject::parent_id() const { return _parent_id; }
+const std::string& IfcGeomObjects::IfcObject::name() const { return _name; }
+const std::string& IfcGeomObjects::IfcObject::type() const { return _type; }
+const std::string& IfcGeomObjects::IfcObject::guid() const { return _guid; }
+const std::vector<float>& IfcGeomObjects::IfcObject::matrix() const { return _matrix; }
+
+const IfcGeomObjects::IfcRepresentationShapeModel& IfcGeomObjects::IfcGeomShapeModelObject::mesh() const { return *_mesh; }
+const IfcGeomObjects::IfcRepresentationTriangulation& IfcGeomObjects::IfcGeomObject::mesh() const { return *_mesh; }
+const IfcGeomObjects::IfcRepresentationBrepData& IfcGeomObjects::IfcGeomBrepDataObject::mesh() const { return *_mesh; }
+

src/ifcgeom/IfcGeomObjects.h

@@ -0,0 +1,286 @@
+/********************************************************************************
+ *                                                                              *
+ * 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).                *
+ *                                                                              *
+ * IfcMesh is a class that represents a triangulated IfcShapeRepresentation.    *
+ *   IfcMesh.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]                                                  *
+ *   IfcMesh.faces is a 1 dimensional vector of int containing the indices of   *
+ *     the triangles referencing positions in IfcMesh.verts                     *
+ *   IfcMesh.edges is a 1 dimensional vector of int in {0,1} that dictates      *
+ *	   the visibility of the edges that span the faces in IfcMesh.faces         *
+ *                                                                              *
+ * IfcGeomObject 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.matrix is a 4x3 matrix that defines the orientation and      *
+ *     translation of the mesh in relation to the world origin                  *
+ *                                                                              *
+ * Init(char* fn) parses the IFC file in fn, returns true on succes.            *
+ *                                                                              *
+ * Get() returns a pointer to the current IfcGeomObject                         *
+ *                                                                              * 
+ * Next() returns true if there is an entity yet available                      *
+ *                                                                              *
+ * Progress() returns an int in [0..100] that indicates the overall progress    *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCOBJECTS_H
+#define IFCOBJECTS_H
+
+#include <map>
+#include <vector>
+#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/IfcParse.h"
+#include "../ifcgeom/IfcRepresentationShapeItem.h"
+
+namespace IfcGeomObjects {
+
+	// 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.
+	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.
+	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.
+	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.
+	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.
+	const int SEW_SHELLS = 5;
+	// Specifies whether to compose IfcOpeningElements into a single compound
+	// in order to speed up the processing of opening subtractions.
+	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.
+	const int FORCE_CCW_FACE_ORIENTATION = 7;
+    // Disables the subtraction of IfcOpeningElement representations from
+    // the related building element representations.
+    const int DISABLE_OPENING_SUBTRACTIONS = 8;
+	// Disables the triangulation of the topological representations. Useful if
+	// the client application understands Open Cascade's native format.
+    const int DISABLE_TRIANGULATION = 9;
+
+	// End of settings enumeration.
+
+	// 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 std::pair<int, std::pair<float,std::pair<float,float> > > VertKey;
+	typedef std::map<VertKey,int> VertKeyMap;
+	typedef std::pair<int,int> Edge;
+
+	class Material {
+	private:
+		const IfcGeom::SurfaceStyle* style;
+	public:
+		explicit Material(const IfcGeom::SurfaceStyle* style);
+		// Material(const Material& other);
+		// Material& operator=(const Material& other);
+		bool hasDiffuse() const;
+		bool hasSpecular() const;
+		bool hasTransparency() const;
+		bool hasSpecularity() const;
+		const double* diffuse() const;
+		const double* specular() const;
+		double transparency() const;
+		double specularity() const;
+		const std::string name() const;
+		bool operator==(const Material& other) const;
+	};
+
+	class IfcRepresentationShapeModel {
+	private:
+		unsigned int id;
+		const IfcGeom::IfcRepresentationShapeItems shapes;
+		IfcRepresentationShapeModel(const IfcRepresentationShapeModel& other);
+		IfcRepresentationShapeModel& operator=(const IfcRepresentationShapeModel& other);
+	public:
+		IfcRepresentationShapeModel(unsigned int id, const IfcGeom::IfcRepresentationShapeItems& shapes)
+			: id(id)
+			, shapes(shapes)
+		{}
+		virtual ~IfcRepresentationShapeModel() {}
+		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 IfcRepresentationBrepData {
+	private:
+		int _id;
+		std::string _brep_data;
+	public:
+		int id() const;
+		const std::string& brep_data() const;
+		IfcRepresentationBrepData(const IfcRepresentationShapeModel& s);
+		virtual ~IfcRepresentationBrepData() {}
+	private:
+		IfcRepresentationBrepData();
+		IfcRepresentationBrepData(const IfcRepresentationBrepData&);
+		IfcRepresentationBrepData& operator=(const IfcRepresentationBrepData&);
+	};
+
+	class IfcRepresentationTriangulation {
+	private:
+		int _id;
+		std::vector<float> _verts;
+		std::vector<int> _faces;
+		std::vector<int> _edges;
+		std::vector<float> _normals;
+		std::vector<int> _material_ids;
+		std::vector<Material> _materials;
+		VertKeyMap welds;
+	public:
+		int id() const;
+		const std::vector<float>& verts() const;
+		const std::vector<int>& faces() const;
+		const std::vector<int>& edges() const;
+		const std::vector<float>& normals() const;
+		const std::vector<int>& material_ids() const;
+		const std::vector<Material>& materials() const;
+		IfcRepresentationTriangulation(const IfcRepresentationShapeModel& s);
+		virtual ~IfcRepresentationTriangulation() {}
+	private:
+		int addvert(int material_index, const gp_XYZ& p);
+		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);
+		}
+		IfcRepresentationTriangulation();
+		IfcRepresentationTriangulation(const IfcRepresentationTriangulation&);
+		IfcRepresentationTriangulation& operator=(const IfcRepresentationTriangulation&);
+	};
+
+	class IfcObject {
+	private:
+		int _id;
+		int _parent_id;
+		std::string _name;
+		std::string _type;
+		std::string _guid;
+		std::vector<float> _matrix;
+	public:
+		int id() const;
+		int parent_id() const;
+		const std::string& name() const;
+		const std::string& type() const;
+		const std::string& guid() const;
+		const std::vector<float>& matrix() const;
+		IfcObject(int id, int parent_id, const std::string& name, const std::string& type, const std::string& guid, const gp_Trsf& trsf);
+		virtual ~IfcObject() {}
+	};
+
+	class IfcGeomShapeModelObject : public IfcObject {
+	private:
+		IfcRepresentationShapeModel* _mesh;
+	public:
+		const IfcRepresentationShapeModel& mesh() const;
+		IfcGeomShapeModelObject(int id, int parent_id, const std::string& name, const std::string& type, const std::string& guid, const gp_Trsf& trsf, IfcRepresentationShapeModel* mesh);
+		virtual ~IfcGeomShapeModelObject() {
+			delete _mesh;
+		}
+	private:
+		IfcGeomShapeModelObject(const IfcGeomShapeModelObject& other);
+		IfcGeomShapeModelObject& operator=(const IfcGeomShapeModelObject& other);		
+	};
+
+	class IfcGeomObject : public IfcObject {
+	private:
+		IfcRepresentationTriangulation* _mesh;
+	public:
+		const IfcRepresentationTriangulation& mesh() const;
+		IfcGeomObject(const IfcGeomShapeModelObject& shape_model);
+		virtual ~IfcGeomObject() {
+			delete _mesh;
+		}
+	private:
+		IfcGeomObject(const IfcGeomObject& other);
+		IfcGeomObject& operator=(const IfcGeomObject& other);
+	};
+
+	class IfcGeomBrepDataObject : public IfcObject {
+	private:
+		IfcRepresentationBrepData* _mesh;
+	public:
+		const IfcRepresentationBrepData& mesh() const;
+		IfcGeomBrepDataObject(const IfcGeomShapeModelObject& shape_model);
+		virtual ~IfcGeomBrepDataObject() {
+			delete _mesh;
+		}
+	private:
+		IfcGeomBrepDataObject(const IfcGeomBrepDataObject& other);
+		IfcGeomBrepDataObject& operator=(const IfcGeomBrepDataObject& other);
+	};
+
+	bool Init(const std::string fn);
+	bool Init(void* data, int len);
+	bool Init(const std::string fn, std::ostream* log1= 0, std::ostream* log2= 0);
+	bool Init(std::istream& f, int len, std::ostream* log1= 0, std::ostream* log2= 0);
+	
+	void Settings(int setting, bool value);
+	void InitUnits();
+	void InitPrecision();
+	
+	const IfcGeomObject* Get();
+	const IfcObject* GetObject(int id);
+	const IfcGeomBrepDataObject* GetBrepData();
+	const IfcGeomShapeModelObject* GetShapeModel();
+	
+	bool Next();
+	int Progress();
+
+	const std::string& GetUnitName();
+	const float GetUnitMagnitude();
+	
+	const std::string GetLog();
+	IfcParse::IfcFile* GetFile();
+
+	bool CleanUp();
+}
+
+#endif

src/ifcgeom/IfcGeomRenderStyles.cpp

@@ -0,0 +1,169 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 "IfcGeomRenderStyles.h"
+
+namespace IfcGeom {
+	namespace Cache {
+		std::map<int,SurfaceStyle> Style;
+		void PurgeStyleCache() {
+			Style.clear();
+		}
+	}
+}
+
+bool process_colour(Ifc2x3::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(IfcUtil::IfcArgumentSelect* factor, std::tr1::array<double, 3>& rgb) {
+	if (factor != 0) {
+		const double f = *factor->wrappedValue();
+		rgb[0] = rgb[1] = rgb[2] = f;
+	}
+	return factor != 0;
+}
+
+bool process_colour(Ifc2x3::IfcColourOrFactor colour_or_factor, std::tr1::array<double, 3>& rgb) {
+	if (colour_or_factor == 0) {
+		return false;
+	} else if (colour_or_factor->is(Ifc2x3::Type::IfcColourRgb)) {
+		return process_colour(static_cast<Ifc2x3::IfcColourRgb*>(colour_or_factor), rgb);
+	} else if (colour_or_factor->is(Ifc2x3::Type::IfcNormalisedRatioMeasure)) {
+		return process_colour(static_cast<IfcUtil::IfcArgumentSelect*>(colour_or_factor), rgb);
+	} else {
+		return false;
+	}
+}
+
+const IfcGeom::SurfaceStyle* IfcGeom::get_style(Ifc2x3::IfcRepresentationItem* item) {
+	std::pair<Ifc2x3::IfcSurfaceStyle*, Ifc2x3::IfcSurfaceStyleShading*> shading_styles = get_surface_style<Ifc2x3::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->hasName()) {
+		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(Ifc2x3::Type::IfcSurfaceStyleRendering)) {
+		Ifc2x3::IfcSurfaceStyleRendering* rendering_style = static_cast<Ifc2x3::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()) {
+			IfcUtil::IfcArgumentSelect* highlight = static_cast<IfcUtil::IfcArgumentSelect*>(rendering_style->SpecularHighlight());
+			if (highlight->is(Ifc2x3::Type::IfcSpecularRoughness)) {
+				double roughness = *highlight->wrappedValue();
+				if (roughness >= 1e-9) {
+					surface_style.Specularity().reset(1.0 / roughness);
+				}
+			} else if (highlight->is(Ifc2x3::Type::IfcSpecularExponent)) {
+				surface_style.Specularity().reset(*highlight->wrappedValue());
+			}
+		}
+		if (rendering_style->hasTransmissionColour()) {
+			// Not supported
+		}
+		if (rendering_style->hasTransparency()) {
+			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()) return &default_material;
+	else {
+		const IfcGeom::SurfaceStyle& surface_style = it->second;
+		return &surface_style;
+	}
+}

src/ifcgeom/IfcGeomRenderStyles.h

@@ -20,20 +20,20 @@
 #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>
+#include "../ifcparse/Ifc2x3.h"
 
 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,43 +46,46 @@ 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(int id) : id(id) {
-			std::stringstream sstr; 
-			sstr << "surface-style-" << 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)
-        {
-			std::stringstream sstr; 
-			std::string sanitized = name;
-            boost::to_lower(sanitized);
-            boost::replace_all(sanitized, " ", "-");
-			sstr << "surface-style-" << id << "-" << sanitized;
-			this->name = sstr.str(); 
-		}
+		SurfaceStyle() {}
+		SurfaceStyle(int id) : id(id) {}
+		SurfaceStyle(const std::string& name) : name(name) {}
+		SurfaceStyle(int id, const std::string& name) : id(id), name(name) {}
 		
 		// Not used at this point. In fact, equality testing in the current
 		// architecture can just as easily be accomplished by comparing the
 		// 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 { 
+			if (name && id) {
+				std::stringstream sstr; 
+				sstr << (*id) << "_" << (*name);
+				return sstr.str(); 
+			} else if (name) { 
+				return *name; 
+			} else if (id) { 
+				std::stringstream sstr; 
+				sstr << "IfcSurfaceStyleShading_" << (*id); 
+				return sstr.str(); 
+			} else {
+				return "IfcSurfaceStyleShading";
+			}
+		}
 
 		const boost::optional<ColorComponent>& Diffuse() const { return diffuse; }
 		const boost::optional<ColorComponent>& Specular() const { return specular; }
@@ -94,8 +97,42 @@ 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);
+	template <typename T> std::pair<Ifc2x3::IfcSurfaceStyle*, T*> get_surface_style(Ifc2x3::IfcRepresentationItem* representation_item) {
+		Ifc2x3::IfcStyledItem::list styled_items = representation_item->StyledByItem();
+		for (Ifc2x3::IfcStyledItem::it jt = styled_items->begin(); jt != styled_items->end(); ++jt) {
+			Ifc2x3::IfcPresentationStyleAssignment::list style_assignments = (*jt)->Styles();
+			for (Ifc2x3::IfcPresentationStyleAssignment::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
+				IfcAbstractSelect::list styles = (*kt)->Styles();
+				for (IfcAbstractSelect::it lt = styles->begin(); lt != styles->end(); ++lt) {
+					IfcAbstractSelect::ptr style = *lt;
+					if (style->is(Ifc2x3::Type::IfcSurfaceStyle)) {
+						Ifc2x3::IfcSurfaceStyle* surface_style = (Ifc2x3::IfcSurfaceStyle*) style;
+						if (surface_style->Side() != Ifc2x3::IfcSurfaceSide::IfcSurfaceSide_NEGATIVE) {
+							IfcAbstractSelect::list styles_elements = surface_style->Styles();
+							for (IfcAbstractSelect::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<Ifc2x3::IfcSurfaceStyle*, T*>(0,0);
+	}
+
+	const SurfaceStyle* get_style(Ifc2x3::IfcRepresentationItem* representation_item);
+	const SurfaceStyle* get_default_style(const std::string& ifc_type);
+	
+	namespace Cache {
+		void PurgeStyleCache();
+	}
 }
 
-#endif
+#endif

src/ifcgeom/IfcGeomShapes.cpp

@@ -0,0 +1,336 @@
+/********************************************************************************
+ *                                                                              *
+ * 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_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 <BRepOffsetAPI_Sewing.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 <BRepBuilderAPI_MakeShell.hxx>
+#include <BRepBuilderAPI_MakeSolid.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <ShapeFix_Solid.hxx>
+
+#include <TopLoc_Location.hxx>
+
+#include <BRepCheck_Analyzer.hxx>
+#include <BRepAlgoAPI_Common.hxx>
+
+#include <BRepClass3d_SolidClassifier.hxx>
+
+#include "../ifcgeom/IfcGeom.h"
+
+bool IfcGeom::convert(const Ifc2x3::IfcExtrudedAreaSolid::ptr l, TopoDS_Shape& shape) {
+	TopoDS_Face face;
+	if ( ! IfcGeom::convert_face(l->SweptArea(),face) ) return false;
+	const double height = l->Depth() * IfcGeom::GetValue(GV_LENGTH_UNIT);
+	gp_Trsf trsf;
+	IfcGeom::convert(l->Position(),trsf);
+
+	gp_Dir dir;
+	convert(l->ExtrudedDirection(),dir);
+
+	shape = BRepPrimAPI_MakePrism(face,height*dir);
+	shape.Move(trsf);
+	return ! shape.IsNull();
+}
+bool IfcGeom::convert(const Ifc2x3::IfcFacetedBrep::ptr l, IfcRepresentationShapeItems& shape) {
+	TopoDS_Shape s;
+	const SurfaceStyle* collective_style = get_style(l);
+	if (IfcGeom::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::convert(const Ifc2x3::IfcFaceBasedSurfaceModel::ptr l, IfcRepresentationShapeItems& shapes) {
+	Ifc2x3::IfcConnectedFaceSet::list facesets = l->FbsmFaces();
+	const SurfaceStyle* collective_style = get_style(l);
+	for( Ifc2x3::IfcConnectedFaceSet::it it = facesets->begin(); it != facesets->end(); ++ it ) {
+		TopoDS_Shape s;
+		const SurfaceStyle* shell_style = get_style(*it);
+		if (IfcGeom::convert_shape(*it,s)) {
+			shapes.push_back(IfcRepresentationShapeItem(s, shell_style ? shell_style : collective_style));
+		}
+	}
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcHalfSpaceSolid::ptr l, TopoDS_Shape& shape) {
+	Ifc2x3::IfcSurface::ptr surface = l->BaseSurface();
+	if ( ! surface->is(Ifc2x3::Type::IfcPlane) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface->entity);
+		return false;
+	}
+	gp_Pln pln;
+	IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcSurface,Ifc2x3::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::convert(const Ifc2x3::IfcPolygonalBoundedHalfSpace::ptr l, TopoDS_Shape& shape) {
+	TopoDS_Shape halfspace;
+	if ( ! IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcPolygonalBoundedHalfSpace,Ifc2x3::IfcHalfSpaceSolid>(l),halfspace) ) return false;	
+	TopoDS_Wire wire;
+	if ( ! IfcGeom::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::convert(const Ifc2x3::IfcShellBasedSurfaceModel::ptr l, IfcRepresentationShapeItems& shapes) {
+	IfcUtil::IfcAbstractSelect::list shells = l->SbsmBoundary();
+	const SurfaceStyle* collective_style = get_style(l);
+	for( IfcUtil::IfcAbstractSelect::it it = shells->begin(); it != shells->end(); ++ it ) {
+		TopoDS_Shape s;
+		const SurfaceStyle* shell_style = 0;
+		if ((*it)->is(Ifc2x3::Type::IfcRepresentationItem)) {
+			shell_style = get_style((Ifc2x3::IfcRepresentationItem*)*it);
+		}
+		if (IfcGeom::convert_shape(*it,s)) {
+			shapes.push_back(IfcRepresentationShapeItem(s, shell_style ? shell_style : collective_style));
+		}
+	}
+	return true;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcBooleanClippingResult::ptr l, TopoDS_Shape& shape) {
+	TopoDS_Shape s1, s2;
+	TopoDS_Wire boundary_wire;
+	Ifc2x3::IfcBooleanOperand operand1 = l->FirstOperand();
+	Ifc2x3::IfcBooleanOperand operand2 = l->SecondOperand();
+	bool is_halfspace = operand2->is(Ifc2x3::Type::IfcHalfSpaceSolid);
+
+	if ( ! IfcGeom::convert_shape(operand1,s1) )
+		return false;
+
+	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);
+
+	if ( !IfcGeom::convert_shape(l->SecondOperand(),s2) ) {
+		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);
+	}
+
+	bool valid_cut = false;
+	BRepAlgoAPI_Cut brep_cut(s1,s2);
+	if ( brep_cut.IsDone() ) {
+		TopoDS_Shape result = brep_cut;
+
+		ShapeFix_Shape fix(result);
+		fix.Perform();
+		result = fix.Shape();
+		
+		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;
+}
+bool IfcGeom::convert(const Ifc2x3::IfcConnectedFaceSet::ptr l, TopoDS_Shape& shape) {
+	Ifc2x3::IfcFace::list 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( Ifc2x3::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
+			TopoDS_Face face;
+			bool converted_face = false;
+			try {
+				converted_face = IfcGeom::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( Ifc2x3::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
+			TopoDS_Face face;
+			bool converted_face = false;
+			try {
+				converted_face = IfcGeom::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::convert(const Ifc2x3::IfcMappedItem::ptr l, IfcRepresentationShapeItems& shapes) {
+	gp_GTrsf gtrsf;
+	Ifc2x3::IfcCartesianTransformationOperator::ptr transform = l->MappingTarget();
+	if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator3DnonUniform) ) {
+		IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcCartesianTransformationOperator,
+			Ifc2x3::IfcCartesianTransformationOperator3DnonUniform>(transform),gtrsf);
+	} else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator2DnonUniform) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported MappingTarget:", transform->entity);
+		return false;
+	} else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator3D) ) {
+		gp_Trsf trsf;
+		IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcCartesianTransformationOperator,
+			Ifc2x3::IfcCartesianTransformationOperator3D>(transform),trsf);
+		gtrsf = trsf;
+	} else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator2D) ) {
+		gp_Trsf2d trsf_2d;
+		IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcCartesianTransformationOperator,
+			Ifc2x3::IfcCartesianTransformationOperator2D>(transform),trsf_2d);
+		gtrsf = (gp_Trsf) trsf_2d;
+	}
+	Ifc2x3::IfcRepresentationMap::ptr map = l->MappingSource();
+	Ifc2x3::IfcAxis2Placement placement = map->MappingOrigin();
+	gp_Trsf trsf;
+	if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) {
+		IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)placement,trsf);
+	} else {
+		gp_Trsf2d trsf_2d;
+		IfcGeom::convert((Ifc2x3::IfcAxis2Placement2D*)placement,trsf_2d);
+		trsf = trsf_2d;
+	}
+	gtrsf.Multiply(trsf);
+	const unsigned int previous_size = (const unsigned int) shapes.size();
+	bool b = IfcGeom::convert_shapes(map->MappedRepresentation(),shapes);
+	for ( unsigned int i = previous_size; i < shapes.size(); ++ i ) {
+		shapes[i].append(gtrsf);
+	}
+	return b;
+}
+
+bool IfcGeom::convert(const Ifc2x3::IfcShapeRepresentation::ptr l, IfcRepresentationShapeItems& shapes) {
+	Ifc2x3::IfcRepresentationItem::list items = l->Items();
+	bool part_succes = false;
+	if ( items->Size() ) {
+		for ( Ifc2x3::IfcRepresentationItem::it it = items->begin(); it != items->end(); ++ it ) {
+			Ifc2x3::IfcRepresentationItem* representation_item = *it;
+			if ( IfcGeom::is_shape_collection(representation_item) ) {
+				part_succes |= IfcGeom::convert_shapes(*it, shapes);
+			} else {
+				TopoDS_Shape s;
+				if (IfcGeom::convert_shape(representation_item,s)) {
+					shapes.push_back(IfcRepresentationShapeItem(s, get_style(representation_item)));
+					part_succes |= true;
+				}
+			}
+		}
+	}
+	return part_succes;
+}

src/ifcgeom/IfcGeomWires.cpp

@@ -0,0 +1,324 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <BRepOffsetAPI_Sewing.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 <BRepBuilderAPI_MakeShell.hxx>
+#include <BRepBuilderAPI_MakeSolid.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <ShapeFix_Solid.hxx>
+
+#include <BRepFilletAPI_MakeFillet2d.hxx>
+
+#include <TopLoc_Location.hxx>
+
+#include <BRep_Tool.hxx>
+
+#include "../ifcgeom/IfcGeom.h"
+
+bool IfcGeom::convert(const Ifc2x3::IfcCompositeCurve::ptr l, TopoDS_Wire& wire) {
+	if ( IfcGeom::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
+		IfcGeom::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::convert(l,wire_radians);
+        } catch (...) {}
+
+		// Now try degrees
+		IfcGeom::SetValue(GV_PLANEANGLE_UNIT,0.0174532925199433);
+        try {
+		    succes_degrees = IfcGeom::convert(l,wire_degrees);
+        } catch (...) {}
+
+		// Restore to unknown unit state
+		IfcGeom::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;
+	}
+	Ifc2x3::IfcCompositeCurveSegment::list segments = l->Segments();
+	BRepBuilderAPI_MakeWire w;
+	//TopoDS_Vertex last_vertex;
+	for( Ifc2x3::IfcCompositeCurveSegment::it it = segments->begin(); it != segments->end(); ++ it ) {
+		const Ifc2x3::IfcCurve::ptr curve = (*it)->ParentCurve();
+		TopoDS_Wire wire2;
+		if ( ! IfcGeom::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::convert(const Ifc2x3::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
+	Ifc2x3::IfcCurve::ptr basis_curve = l->BasisCurve();
+	bool isConic = basis_curve->is(Ifc2x3::Type::IfcConic);
+	double parameterFactor = isConic ? IfcGeom::GetValue(GV_PLANEANGLE_UNIT) : IfcGeom::GetValue(GV_LENGTH_UNIT);
+	Handle(Geom_Curve) curve;
+	if ( ! IfcGeom::convert_curve(basis_curve,curve) ) return false;
+	bool trim_cartesian = l->MasterRepresentation() == Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN;
+	IfcUtil::IfcAbstractSelect::list trims1 = l->Trim1();
+	IfcUtil::IfcAbstractSelect::list 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 ( IfcUtil::IfcAbstractSelect::it it = trims1->begin(); it != trims1->end(); it ++ ) {
+		const IfcUtil::IfcAbstractSelect::ptr i = *it;
+		if ( i->is(Ifc2x3::Type::IfcCartesianPoint) ) {
+			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcCartesianPoint>(i), pnts[sense_agreement] );
+			has_pnts[sense_agreement] = true;
+		} else if ( i->is(Ifc2x3::Type::IfcParameterValue) ) {
+			const double value = *reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcUtil::IfcArgumentSelect>(i)->wrappedValue();
+			flts[sense_agreement] = value * parameterFactor;
+			has_flts[sense_agreement] = true;
+		}
+	}
+	for ( IfcUtil::IfcAbstractSelect::it it = trims2->begin(); it != trims2->end(); it ++ ) {
+		const IfcUtil::IfcAbstractSelect::ptr i = *it;
+		if ( i->is(Ifc2x3::Type::IfcCartesianPoint) ) {
+			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcCartesianPoint>(i), pnts[1-sense_agreement] );
+			has_pnts[1-sense_agreement] = true;
+		} else if ( i->is(Ifc2x3::Type::IfcParameterValue) ) {
+			const double value = *reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcUtil::IfcArgumentSelect>(i)->wrappedValue();
+			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(Ifc2x3::Type::IfcLine) ) {
+			Ifc2x3::IfcLine* line = static_cast<Ifc2x3::IfcLine*>(basis_curve);
+			const double magnitude = line->Dir()->Magnitude();
+			flts[0] *= magnitude; flts[1] *= magnitude;
+		}
+		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::convert(const Ifc2x3::IfcPolyline::ptr l, TopoDS_Wire& result) {
+	Ifc2x3::IfcCartesianPoint::list points = l->Points();
+
+	// Parse and store the points in a sequence
+	TColgp_SequenceOfPnt polygon;
+	for(Ifc2x3::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it) {
+		gp_Pnt pnt;
+		IfcGeom::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::convert(const Ifc2x3::IfcPolyLoop::ptr l, TopoDS_Wire& result) {
+	Ifc2x3::IfcCartesianPoint::list points = l->Polygon();
+
+	// Parse and store the points in a sequence
+	TColgp_SequenceOfPnt polygon;
+	for(Ifc2x3::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it) {
+		gp_Pnt pnt;
+		IfcGeom::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;
+}

src/ifcgeom/IfcRegister.cpp

@@ -0,0 +1,73 @@
+/********************************************************************************
+*                                                                              *
+* 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 "IfcGeom.h"
+
+namespace IfcGeom {
+	namespace Cache {
+		std::map<int,TopoDS_Shape> Shape;
+		void PurgeShapeCache() {
+			Shape.clear();
+		}
+	}
+}
+
+using namespace Ifc2x3;
+using namespace IfcUtil;
+
+bool IfcGeom::convert_shapes(const IfcBaseClass* l, IfcRepresentationShapeItems& r) {
+#include "IfcRegisterConvertShapes.h"
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	return false;
+}
+bool IfcGeom::is_shape_collection(const IfcBaseClass* l) {
+#include "IfcRegisterIsShapeCollection.h"
+	return false;
+}
+bool IfcGeom::convert_shape(const IfcBaseClass* l, TopoDS_Shape& r) {
+	const unsigned int id = l->entity->id();
+	bool success = false;
+	bool processed = false;
+	std::map<int,TopoDS_Shape>::const_iterator it = Cache::Shape.find(id);
+	if ( it != Cache::Shape.end() ) { r = it->second; return true; }
+#include "IfcRegisterConvertShape.h"
+	if ( processed ) { 
+		const double precision = IfcGeom::GetValue(GV_PRECISION);
+		IfcGeom::apply_tolerance(r, precision);
+		Cache::Shape[id] = r;
+	} else {
+		Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	}
+	return success;
+}
+bool IfcGeom::convert_wire(const IfcBaseClass* l, TopoDS_Wire& r) {
+#include "IfcRegisterConvertWire.h"
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	return false;
+}
+bool IfcGeom::convert_face(const IfcBaseClass* l, TopoDS_Face& r) {
+#include "IfcRegisterConvertFace.h"
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	return false;
+}
+bool IfcGeom::convert_curve(const IfcBaseClass* l, Handle(Geom_Curve)& r) {
+#include "IfcRegisterConvertCurve.h"
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	return false;
+}

src/ifcgeom/IfcRegister.h

@@ -38,107 +38,46 @@
 #include <gp_Trsf.hxx>
 #include <gp_Trsf2d.hxx>
 
-#include "../../../ifcparse/IfcBaseClass.h"
-#include "../../../ifcparse/IfcParse.h"
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/IfcParse.h"
+
+using namespace Ifc2x3;
 
 SHAPES(IfcShellBasedSurfaceModel);
 SHAPES(IfcFaceBasedSurfaceModel);
-SHAPES(IfcRepresentation);
+SHAPES(IfcShapeRepresentation);
 SHAPES(IfcMappedItem);
-// IfcFacetedBrep included
-// IfcAdvancedBrep included
-// IfcFacetedBrepWithVoids included
-// IfcAdvancedBrepWithVoids included
-SHAPES(IfcManifoldSolidBrep);
-SHAPES(IfcGeometricSet);
+SHAPES(IfcFacetedBrep);
 
-#ifdef SCHEMA_HAS_IfcCylindricalSurface
-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(IfcBooleanClippingResult);
 SHAPE(IfcPolygonalBoundedHalfSpace);
 SHAPE(IfcHalfSpaceSolid);
-// FIXME: Surfaces should have a shape type of their own
-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(IfcCShapeProfileDef);
 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);
-#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);
 CLASS(IfcAxis2Placement2D,gp_Trsf2d);
 CLASS(IfcAxis2Placement3D,gp_Trsf);
-CLASS(IfcAxis1Placement,gp_Ax1);
 CLASS(IfcCartesianTransformationOperator2DnonUniform,gp_GTrsf2d);
 CLASS(IfcCartesianTransformationOperator3DnonUniform,gp_GTrsf);
 CLASS(IfcCartesianTransformationOperator2D,gp_Trsf2d);

src/ifcgeom/IfcRegisterConvertCurve.h

@@ -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"

src/ifcgeom/IfcRegisterConvertFace.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"

src/ifcgeom/IfcRegisterConvertShape.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"

src/ifcgeom/IfcRegisterConvertShapes.h

@@ -0,0 +1,12 @@
+#include "IfcRegisterUndef.h"
+#define SHAPES(T) \
+	if ( l->is(T::Class()) ) { \
+		try { \
+			return IfcGeom::convert((T*)l,r); \
+		} catch (...) { } \
+		Logger::Message(Logger::LOG_ERROR,"Failed to convert:",l->entity); \
+		return false; \
+	}
+#include "IfcRegisterDef.h"
+
+#include "IfcRegister.h"

src/ifcgeom/IfcRegisterConvertWire.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"

src/ifcgeom/IfcRegisterGeomHeader.h

@@ -1,9 +1,9 @@
 #include "IfcRegisterUndef.h"
-#define CLASS(T,V) bool convert(const IfcSchema::T* L, V& r);
-#define SHAPES(T) CLASS(T,ConversionResults)
+#define CLASS(T,V) bool convert(const T::ptr L, V& r);
+#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)
+#define FACE(T) CLASS(T,TopoDS_Face)
 #define CURVE(T) CLASS(T,Handle(Geom_Curve))
 #include "IfcRegisterDef.h"
 

src/ifcgeom/IfcRegisterIsShapeCollection.h

@@ -0,0 +1,6 @@
+#include "IfcRegisterUndef.h"
+#define SHAPES(T) \
+	if ( l->is(T::Class()) ) return true;
+#include "IfcRegisterDef.h"
+
+#include "IfcRegister.h"

src/ifcgeom/IfcRepresentationShapeItem.h

@@ -17,19 +17,36 @@
  *                                                                              *
  ********************************************************************************/
 
-#include "IfcGeomMaterial.h"
+#ifndef IFCSHAPELIST_H
+#define IFCSHAPELIST_H
 
-static double black[3] = {0.,0.,0.};
+#include <gp_GTrsf.hxx>
+#include <TopoDS_Shape.hxx>
 
-IfcGeom::Material::Material(const IfcGeom::SurfaceStyle* style) : style(style) {}
-bool IfcGeom::Material::hasDiffuse() const { return style->Diffuse() ? true : false; }
-bool IfcGeom::Material::hasSpecular() const { return style->Specular() ? true : false; }
-bool IfcGeom::Material::hasTransparency() const { return style->Transparency() ? true : false; }
-bool IfcGeom::Material::hasSpecularity() const { return style->Specularity() ? true : false; }
-const double* IfcGeom::Material::diffuse() const { if (hasDiffuse()) return &((*style->Diffuse()).R()); else return black; }
-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(); }
-bool IfcGeom::Material::operator==(const IfcGeom::Material& other) const { return style == other.style; }
+#include "../ifcgeom/IfcGeomRenderStyles.h"
+
+namespace IfcGeom {	
+	class IfcRepresentationShapeItem {
+	private:
+		gp_GTrsf placement;
+		TopoDS_Shape shape;
+		const SurfaceStyle* style;
+	public:
+		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

src/ifcgeom/kernel_agnostic/AbstractKernel.cpp

@@ -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);

src/ifcgeom/kernel_agnostic/AbstractKernel.h

@@ -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

src/ifcgeom/kernel_agnostic/IfcGeomIteratorImplementation.cpp

@@ -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>*);

src/ifcgeom/kernel_agnostic/IfcGeomIteratorImplementation.h

@@ -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

src/ifcgeom/kernels/cgal/CgalConversionFunctions.cpp

@@ -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);
-//}

src/ifcgeom/kernels/cgal/CgalEntityMapping.cpp

@@ -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;
-}

src/ifcgeom/kernels/cgal/CgalEntityMapping.h

@@ -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);

src/ifcgeom/kernels/cgal/CgalEntityMappingCreateCache.h

@@ -1,6 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define CLASS(T,V) \
-	std::map<int,V> T;
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"

src/ifcgeom/kernels/cgal/CgalEntityMappingCurve.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"

src/ifcgeom/kernels/cgal/CgalEntityMappingDeclaration.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"

src/ifcgeom/kernels/cgal/CgalEntityMappingDefine.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

src/ifcgeom/kernels/cgal/CgalEntityMappingFace.h

@@ -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"

src/ifcgeom/kernels/cgal/CgalEntityMappingPurgeCache.h

@@ -1,6 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define CLASS(T,V) \
-	T.clear();
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"

src/ifcgeom/kernels/cgal/CgalEntityMappingShape.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"

src/ifcgeom/kernels/cgal/CgalEntityMappingShapeType.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"

src/ifcgeom/kernels/cgal/CgalEntityMappingShapes.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"

src/ifcgeom/kernels/cgal/CgalEntityMappingUndefine.h

@@ -1,18 +0,0 @@
-#ifdef SHAPES
-#undef SHAPES
-#endif
-#ifdef SHAPE
-#undef SHAPE
-#endif
-#ifdef WIRE
-#undef WIRE
-#endif
-#ifdef FACE
-#undef FACE
-#endif
-#ifdef CURVE
-#undef CURVE
-#endif
-#ifdef CLASS
-#undef CLASS
-#endif

src/ifcgeom/kernels/cgal/CgalEntityMappingWire.h

@@ -1,6 +0,0 @@
-#include "CgalEntityMappingUndefine.h"
-#define WIRE(T) \
-	if (l->declaration().is(IfcSchema::T::Class())) return convert((IfcSchema::T*)l,r);
-#include "CgalEntityMappingDefine.h"
-
-#include "CgalEntityMapping.h"

src/ifcgeom/kernels/cgal/CgalIfcGeomCurves.cpp

@@ -1,78 +0,0 @@
-#include "CgalKernel.h"
-#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
-
-#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCircle* l, cgal_curve_t& 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);
-    return false;
-  }
-  cgal_placement_t trsf;
-  IfcSchema::IfcAxis2Placement* placement = l->Position();
-  if (placement->as<IfcSchema::IfcAxis2Placement3D>()) {
-    IfcGeom::CgalKernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
-  } else {
-    cgal_placement_t trsf2d;
-    IfcGeom::CgalKernel::convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf2d);
-    trsf = trsf2d;
-  }
-  
-  const int segments = 12;
-  
-  curve = cgal_curve_t();
-  for (int current_segment = 0; current_segment < segments; ++current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    curve.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-  }
-  
-  for (auto &vertex: curve) {
-    vertex = vertex.transform(trsf);
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcEllipse* l, cgal_curve_t& 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);
-    return false;
-  }
-  cgal_placement_t trsf;
-  IfcSchema::IfcAxis2Placement* placement = l->Position();
-  if (placement->as<IfcSchema::IfcAxis2Placement3D>()) {
-    convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
-  } else {
-    cgal_placement_t trsf2d;
-    convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf2d);
-    trsf = trsf2d;
-  }
-  
-  const int segments = 12;
-  
-  curve = cgal_curve_t();
-  for (int current_segment = 0; current_segment < segments; ++current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    curve.push_back(Kernel_::Point_3(x*cos(current_angle), y*sin(current_angle), 0));
-  }
-  
-  for (auto &vertex: curve) {
-    vertex = vertex.transform(trsf);
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcLine* l, cgal_curve_t& curve) {
-  cgal_point_t pnt;
-  cgal_direction_t vec;
-  convert(l->Pnt(),pnt);
-  convert(l->Dir(),vec);
-  curve = cgal_curve_t();
-  curve.push_back(pnt);
-  curve.push_back(pnt+vec);
-  return true;
-}

src/ifcgeom/kernels/cgal/CgalIfcGeomFaces.cpp

@@ -1,991 +0,0 @@
-#include "CgalKernel.h"
-#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
-
-#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcArbitraryClosedProfileDef* l, cgal_face_t& face) {
-  cgal_wire_t wire;
-  if ( ! convert_wire(l->OuterCurve(),wire) ) return false;
-  
-  cgal_face_t f;
-  bool success = convert_wire_to_face(wire, f);
-  if (success) face = f;
-  return success;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcArbitraryProfileDefWithVoids* l, cgal_face_t& face) {
-  cgal_wire_t profile;
-  if ( ! convert_wire(l->OuterCurve(),profile) ) return false;
-  cgal_face_t mf;
-  mf.outer = profile;
-  IfcSchema::IfcCurve::list::ptr voids = l->InnerCurves();
-  for( IfcSchema::IfcCurve::list::it it = voids->begin(); it != voids->end(); ++ it ) {
-    cgal_wire_t hole;
-    if ( convert_wire(*it,hole) ) {
-      mf.inner.push_back(hole);
-    }
-  } face = mf;
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRectangleProfileDef* l, cgal_face_t& face) {
-  const double x = l->XDim() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double y = l->YDim() / 2.0f * getValue(GV_LENGTH_UNIT);
-  
-  if ( x < ALMOST_ZERO || y < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  face = cgal_face_t();
-  face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-  face.outer.push_back(Kernel_::Point_3( x, -y, 0.0));
-  face.outer.push_back(Kernel_::Point_3( x,  y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(-x,  y, 0.0));
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRoundedRectangleProfileDef* l, cgal_face_t& face) {
-  const double x = l->XDim() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double y = l->YDim() / 2.0f  * getValue(GV_LENGTH_UNIT);
-  const double r = l->RoundingRadius() * getValue(GV_LENGTH_UNIT);
-  
-  if ( x < ALMOST_ZERO || y < ALMOST_ZERO || r < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 3;
-  
-  if (r == 0.0) {
-    face = cgal_face_t();
-    face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-    face.outer.push_back(Kernel_::Point_3( x, -y, 0.0));
-    face.outer.push_back(Kernel_::Point_3( x,  y, 0.0));
-    face.outer.push_back(Kernel_::Point_3(-x,  y, 0.0));
-  }
-  
-  else {
-    face = cgal_face_t();
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-r+r*cos(current_angle), y-r+r*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+r+r*cos(current_angle), y-r+r*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+r+r*cos(current_angle), -y+r+r*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-r+r*cos(current_angle), -y+r+r*sin(current_angle), 0));
-    }
-  }
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRectangleHollowProfileDef* l, cgal_face_t& face) {
-  const double x = l->XDim() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double y = l->YDim() / 2.0f  * getValue(GV_LENGTH_UNIT);
-  const double d = l->WallThickness() * getValue(GV_LENGTH_UNIT);
-  
-  const bool fr1 = l->hasOuterFilletRadius();
-  const bool fr2 = l->hasInnerFilletRadius();
-  
-  const double r1 = fr1 ? l->OuterFilletRadius() * getValue(GV_LENGTH_UNIT) : 0.;
-  const double r2 = fr2 ? l->InnerFilletRadius() * getValue(GV_LENGTH_UNIT) : 0.;
-  
-  if ( x < ALMOST_ZERO || y < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 3;
-  
-  if (!fr1 || r1 == 0.0) {
-    face = cgal_face_t();
-    face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-    face.outer.push_back(Kernel_::Point_3( x, -y, 0.0));
-    face.outer.push_back(Kernel_::Point_3( x,  y, 0.0));
-    face.outer.push_back(Kernel_::Point_3(-x,  y, 0.0));
-  }
-  
-  else {
-    face = cgal_face_t();
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-r1+r1*cos(current_angle), y-r1+r1*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+r1+r1*cos(current_angle), y-r1+r1*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+r1+r1*cos(current_angle), -y+r1+r1*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-r1+r1*cos(current_angle), -y+r1+r1*sin(current_angle), 0));
-    }
-  }
-  
-  if (!fr2 || r2 == 0.0) {
-    face.inner.push_back(cgal_wire_t());
-    face.inner.back().push_back(Kernel_::Point_3(-x+d, -y+d, 0.0));
-    face.inner.back().push_back(Kernel_::Point_3( x-d, -y+d, 0.0));
-    face.inner.back().push_back(Kernel_::Point_3( x-d,  y-d, 0.0));
-    face.inner.back().push_back(Kernel_::Point_3(-x+d,  y-d, 0.0));
-  }
-  
-  else {
-    face.inner.push_back(cgal_wire_t());
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.inner.back().push_back(Kernel_::Point_3(x-d-r1+r1*cos(current_angle), y-d-r1+r1*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.inner.back().push_back(Kernel_::Point_3(-x+d+r1+r1*cos(current_angle), y-d-r1+r1*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.inner.back().push_back(Kernel_::Point_3(-x+d+r1+r1*cos(current_angle), -y+d+r1+r1*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.inner.back().push_back(Kernel_::Point_3(x-d-r1+r1*cos(current_angle), -y+d+r1+r1*sin(current_angle), 0));
-    }
-  }
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    } for (auto &inner: face.inner) {
-      for (auto &vertex: inner) {
-        vertex = vertex.transform(trsf2d);
-      }
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrapeziumProfileDef* l, cgal_face_t& face) {
-  const double x1 = l->BottomXDim() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double w = l->TopXDim() * getValue(GV_LENGTH_UNIT);
-  const double dx = l->TopXOffset() * getValue(GV_LENGTH_UNIT);
-  const double y = l->YDim() / 2.0f  * getValue(GV_LENGTH_UNIT);
-  
-  if ( x1 < ALMOST_ZERO || w < ALMOST_ZERO || y < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  face = cgal_face_t();
-  face.outer.push_back(Kernel_::Point_3(-x1, -y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(x1, -y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(dx+w-x1, y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(dx-x1, y, 0.0));
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCircleProfileDef* l, cgal_face_t& face) {
-  const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
-  if ( r == 0.0f ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 12;
-  
-  face = cgal_face_t();
-  for (int current_segment = 0; current_segment < segments; ++current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face.outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-  }
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCircleHollowProfileDef* l, cgal_face_t& face) {
-  const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
-  const double t = l->WallThickness() * getValue(GV_LENGTH_UNIT);
-  
-  if ( r == 0.0f || t == 0.0f ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 12;
-  
-  face = cgal_face_t();
-  for (int current_segment = 0; current_segment < segments; ++current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face.outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-  }
-  
-  face.inner.push_back(cgal_wire_t());
-  for (int current_segment = 0; current_segment < segments; ++current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face.inner.back().push_back(Kernel_::Point_3((r-t)*cos(current_angle), (r-t)*sin(current_angle), 0));
-  }
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    } for (auto &inner: face.inner) {
-      for (auto &vertex: inner) {
-        vertex = vertex.transform(trsf2d);
-      }
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcEllipseProfileDef* l, cgal_face_t& face) {
-  double rx = l->SemiAxis1() * getValue(GV_LENGTH_UNIT);
-  double ry = l->SemiAxis2() * getValue(GV_LENGTH_UNIT);
-  
-  if ( rx < ALMOST_ZERO || ry < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 12;
-  
-  face = cgal_face_t();
-  for (int current_segment = 0; current_segment < segments; ++current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face.outer.push_back(Kernel_::Point_3(rx*cos(current_angle), ry*sin(current_angle), 0));
-  }
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcFace* l, cgal_face_t& face) {
-  IfcSchema::IfcFaceBound::list::ptr bounds = l->Bounds();
-  
-  int num_outer_bounds = 0;
-  
-  for (IfcSchema::IfcFaceBound::list::it it = bounds->begin(); it != bounds->end(); ++it) {
-    IfcSchema::IfcFaceBound* bound = *it;
-    if (bound->as<IfcSchema::IfcFaceOuterBound>()) num_outer_bounds ++;
-  }
-  
-  if (num_outer_bounds != 1) {
-    Logger::Message(Logger::LOG_ERROR, "Invalid configuration of boundaries for:", l);
-    return false;
-  }
-  
-  cgal_face_t mf;
-  
-  for (IfcSchema::IfcFaceBound::list::it it = bounds->begin(); it != bounds->end(); ++it) {
-    IfcSchema::IfcFaceBound* bound = *it;
-    IfcSchema::IfcLoop* loop = bound->Bound();
-    
-    const bool is_interior = !bound->as<IfcSchema::IfcFaceOuterBound>();
-    
-    cgal_wire_t wire;
-    if (!convert_wire(loop, wire)) {
-      Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary loop", loop);
-      return false;
-    }
-    
-    if (!is_interior) {
-      mf.outer = wire;
-    } else {
-      mf.inner.push_back(wire);
-    }
-  }
-  
-  face = mf;
-  
-  //  std::cout << "Face: " << std::endl;
-  //  for (auto &point: face.outer) {
-  //    std::cout << "\tPoint(" << point << ")" << std::endl;
-  //  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCShapeProfileDef* l, cgal_face_t& face) {
-  const double y = l->Depth() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double x = l->Width() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double d1 = l->WallThickness() * getValue(GV_LENGTH_UNIT);
-  const double d2 = l->Girth() * getValue(GV_LENGTH_UNIT);
-  bool doFillet = l->hasInternalFilletRadius();
-  double f1 = 0;
-  double f2 = 0;
-  if ( doFillet ) {
-    f1 = l->InternalFilletRadius() * getValue(GV_LENGTH_UNIT);
-    f2 = f1 + d1;
-  }
-  
-  if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 3;
-  
-  if (!doFillet || f1 == 0.0) {
-    face = cgal_face_t();
-    face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-    face.outer.push_back(Kernel_::Point_3(x, -y, 0.0));
-    face.outer.push_back(Kernel_::Point_3(x, -y+d2, 0.0));
-    face.outer.push_back(Kernel_::Point_3(x-d1, -y+d2, 0.0));
-    face.outer.push_back(Kernel_::Point_3(x-d1, -y+d1, 0.0));
-    face.outer.push_back(Kernel_::Point_3(-x+d1, -y+d1, 0.0));
-    face.outer.push_back(Kernel_::Point_3(-x+d1, y-d1, 0.0));
-    face.outer.push_back(Kernel_::Point_3(x-d1, y-d1, 0.0));
-    face.outer.push_back(Kernel_::Point_3(x-d1, y-d2, 0.0));
-    face.outer.push_back(Kernel_::Point_3(x, y-d2, 0.0));
-    face.outer.push_back(Kernel_::Point_3(x, y, 0.0));
-    face.outer.push_back(Kernel_::Point_3(-x, y, 0.0));
-  }
-  
-  else {
-    face = cgal_face_t();
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
-    }
-    face.outer.push_back(Kernel_::Point_3(x, -y+d2, 0.0));
-    face.outer.push_back(Kernel_::Point_3(x-d1, -y+d2, 0.0));
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-f2+f1*cos(current_angle), -y+f2+f1*sin(current_angle), 0));
-    }
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+f2+f1*cos(current_angle), -y+f2+f1*sin(current_angle), 0));
-    }
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+f2+f1*cos(current_angle), y-f2+f1*sin(current_angle), 0));
-    }
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-f2+f1*cos(current_angle), y-f2+f1*sin(current_angle), 0));
-    }
-    face.outer.push_back(Kernel_::Point_3(x-d1, y-d2, 0.0));
-    face.outer.push_back(Kernel_::Point_3(x, y-d2, 0.0));
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), y-f2+f2*sin(current_angle), 0));
-    }
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+f2+f2*cos(current_angle), y-f2+f2*sin(current_angle), 0));
-    }
-  }
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcLShapeProfileDef* l, cgal_face_t& face) {
-  const bool hasSlope = l->hasLegSlope();
-  const bool doEdgeFillet = l->hasEdgeRadius();
-  const bool doFillet = l->hasFilletRadius();
-  
-  const double y = l->Depth() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double x = (l->hasWidth() ? l->Width() : l->Depth()) / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double d = l->Thickness() * getValue(GV_LENGTH_UNIT);
-  const double slope = hasSlope ? (l->LegSlope() * getValue(GV_PLANEANGLE_UNIT)) : 0.;
-  
-  double f1 = 0.0f;
-  double f2 = 0.0f;
-  if (doFillet) {
-    f1 = l->FilletRadius() * getValue(GV_LENGTH_UNIT);
-  }
-  if ( doEdgeFillet) {
-    f2 = l->EdgeRadius() * getValue(GV_LENGTH_UNIT);
-  }
-  
-  if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  double xx = -x+d;
-  double xy = -y+d;
-  double dy1 = 0.;
-  double dy2 = 0.;
-  double dx1 = 0.;
-  double dx2 = 0.;
-  if (hasSlope) {
-    dy1 = tan(slope) * x;
-    dy2 = tan(slope) * (x - d);
-    dx1 = tan(slope) * y;
-    dx2 = tan(slope) * (y - d);
-    
-    const double x1s = x; const double y1s = -y + d - dy1;
-    const double x1e = -x + d; const double y1e = -y + d + dy2;
-    const double x2s = -x + d - dx1; const double y2s = y;
-    const double x2e = -x + d + dx2; const double y2e = -y + d;
-    
-    const double a1 = y1e - y1s;
-    const double b1 = x1s - x1e;
-    const double c1 = a1*x1s + b1*y1s;
-    
-    const double a2 = y2e - y2s;
-    const double b2 = x2s - x2e;
-    const double c2 = a2*x2s + b2*y2s;
-    
-    const double det = a1*b2 - a2*b1;
-    
-    if (ALMOST_THE_SAME(det, 0.)) {
-      Logger::Message(Logger::LOG_NOTICE, "Legs do not intersect for:",l);
-      return false;
-    }
-    
-    xx = (b2*c1 - b1*c2) / det;
-    xy = (a1*c2 - a2*c1) / det;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 3;
-  
-  face = cgal_face_t();
-  face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(x, -y, 0.0));
-  if (f2 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(x, -y+d-dy1, 0.0));
-  } else {
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), -y+d-dy1-f2+f2*sin(current_angle), 0));
-    }
-  } if (f1 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(xx, xy, 0.0));
-  } else {
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(xx+f1+f1*cos(current_angle), xy+f1+f1*sin(current_angle), 0));
-    }
-  } if (f2 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(-x+d-dx1, y, 0.0));
-  } else {
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+d-dx1-f2+f2*cos(current_angle), y-f2+f2*sin(current_angle), 0));
-    }
-  } face.outer.push_back(Kernel_::Point_3(-x, y, 0.0));
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-  
-  return true;
-}
-
-// TODO: Untested
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcIShapeProfileDef* l, cgal_face_t& face) {
-  const double x1 = l->OverallWidth() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double y = l->OverallDepth() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double d1 = l->WebThickness() / 2.0f  * getValue(GV_LENGTH_UNIT);
-  const double dy1 = l->FlangeThickness() * getValue(GV_LENGTH_UNIT);
-  
-  bool doFillet1 = l->hasFilletRadius();
-  double f1 = 0.;
-  if ( doFillet1 ) {
-    f1 = l->FilletRadius() * getValue(GV_LENGTH_UNIT);
-  }
-  
-  bool doFillet2 = doFillet1;
-  double x2 = x1, dy2 = dy1, f2 = f1;
-  
-  if (l->as<IfcSchema::IfcAsymmetricIShapeProfileDef>()) {
-    IfcSchema::IfcAsymmetricIShapeProfileDef* assym = (IfcSchema::IfcAsymmetricIShapeProfileDef*) l;
-    x2 = assym->TopFlangeWidth() / 2. * getValue(GV_LENGTH_UNIT);
-    doFillet2 = assym->hasTopFlangeFilletRadius();
-    if (doFillet2) {
-      f2 = assym->TopFlangeFilletRadius() * getValue(GV_LENGTH_UNIT);
-    }
-    if (assym->hasTopFlangeThickness()) {
-      dy2 = assym->TopFlangeThickness() * getValue(GV_LENGTH_UNIT);
-    }
-  }
-  
-  if ( x1 < ALMOST_ZERO || x2 < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || dy1 < ALMOST_ZERO || dy2 < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 3;
-  
-  face = cgal_face_t();
-  face.outer.push_back(Kernel_::Point_3(-x1, -y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(x1, -y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(x1, -y+dy1, 0.0));
-  if (f1 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(d1, -y+dy1, 0.0));
-    face.outer.push_back(Kernel_::Point_3(d1, y-dy2, 0.0));
-  } else {
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(d1+f1+f1*cos(current_angle), -y+dy1+f1+f1*sin(current_angle), 0));
-    } for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(d1+f1+f1*cos(current_angle), y-dy2-f1+f1*sin(current_angle), 0));
-    }
-  } face.outer.push_back(Kernel_::Point_3(x2, y-dy2, 0.0));
-  face.outer.push_back(Kernel_::Point_3(x2, y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(-x2, y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(-x2, y-dy2, 0.0));
-  if (f2 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(-d1, y-dy2, 0.0));
-    face.outer.push_back(Kernel_::Point_3(-d1, -y+dy1, 0.0));
-  } else {
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-d1-f2+f2*cos(current_angle), y-dy2-f2+f2*sin(current_angle), 0));
-    } for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-d1-f2+f2*cos(current_angle), -y+dy1+f2+f2*sin(current_angle), 0));
-    }
-  } face.outer.push_back(Kernel_::Point_3(-x1, -y+dy1, 0.0));
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTShapeProfileDef* l, cgal_face_t& face) {
-  const bool doFlangeEdgeFillet = l->hasFlangeEdgeRadius();
-  const bool doWebEdgeFillet = l->hasWebEdgeRadius();
-  const bool doFillet = l->hasFilletRadius();
-  const bool hasFlangeSlope = l->hasFlangeSlope();
-  const bool hasWebSlope = l->hasWebSlope();
-  
-  const double y = l->Depth() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double x = l->FlangeWidth() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double d1 = l->WebThickness() * getValue(GV_LENGTH_UNIT);
-  const double d2 = l->FlangeThickness() * getValue(GV_LENGTH_UNIT);
-  const double flangeSlope = hasFlangeSlope ? (l->FlangeSlope() * getValue(GV_PLANEANGLE_UNIT)) : 0.;
-  const double webSlope = hasWebSlope ? (l->WebSlope() * getValue(GV_PLANEANGLE_UNIT)) : 0.;
-  
-  if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  double dy1 = 0.0f;
-  double dy2 = 0.0f;
-  double dx1 = 0.0f;
-  double dx2 = 0.0f;
-  double f1 = 0.0f;
-  double f2 = 0.0f;
-  double f3 = 0.0f;
-  
-  if (doFillet) {
-    f1 = l->FilletRadius() * getValue(GV_LENGTH_UNIT);
-  }
-  if (doWebEdgeFillet) {
-    f2 = l->WebEdgeRadius() * getValue(GV_LENGTH_UNIT);
-  }
-  if (doFlangeEdgeFillet) {
-    f3 = l->FlangeEdgeRadius() * getValue(GV_LENGTH_UNIT);
-  }
-  
-  double xx, xy;
-  if (hasFlangeSlope) {
-    dy1 = (x / 2. - d1) * tan(flangeSlope);
-    dy2 = x / 2. * tan(flangeSlope);
-  }
-  if (hasWebSlope) {
-    dx1 = (y - d2) * tan(webSlope);
-    dx2 = y * tan(webSlope);
-  }
-  if (hasWebSlope || hasFlangeSlope) {
-    const double x1s = d1/2. - dx2; const double y1s = -y;
-    const double x1e = d1/2. + dx1; const double y1e = y - d2;
-    const double x2s = x; const double y2s = y - d2 + dy2;
-    const double x2e = d1/2.; const double y2e = y - d2 - dy1;
-    
-    const double a1 = y1e - y1s;
-    const double b1 = x1s - x1e;
-    const double c1 = a1*x1s + b1*y1s;
-    
-    const double a2 = y2e - y2s;
-    const double b2 = x2s - x2e;
-    const double c2 = a2*x2s + b2*y2s;
-    
-    const double det = a1*b2 - a2*b1;
-    
-    if (ALMOST_THE_SAME(det, 0.)) {
-      Logger::Message(Logger::LOG_NOTICE, "Web and flange do not intersect for:",l);
-      return false;
-    }
-    
-    xx = (b2*c1 - b1*c2) / det;
-    xy = (a1*c2 - a2*c1) / det;
-  } else {
-    xx = d1 / 2;
-    xy = y - d2;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 3;
-  
-  face = cgal_face_t();
-  if (f2 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(d1/2.-dx2, -y, 0.0));
-  } else {
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(d1/2.-dx2-f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
-    }
-  } if (f1 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(xx, xy, 0.0));
-  } else {
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(xx+f1+f1*cos(current_angle), xy-f1+f1*sin(current_angle), 0));
-    }
-  } if (f3 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(x, y-d2+dy2, 0.0));
-  } else {
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-f3+f3*cos(current_angle), y-d2+dy2+f3+f3*sin(current_angle), 0));
-    }
-  } face.outer.push_back(Kernel_::Point_3(x, y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(-x, y, 0.0));
-  if (f3 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(-x, y-d2+dy2, 0.0));
-  } else {
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+f3+f3*cos(current_angle), y-d2+dy2+f3+f3*sin(current_angle), 0));
-    }
-  } if (f1 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(-xx, xy, 0.0));
-  } else {
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-xx-f1+f1*cos(current_angle), xy-f1+f1*sin(current_angle), 0));
-    }
-  } if (f2 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(-d1/2.+dx2, -y, 0.0));
-  } else {
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-d1/2.+dx2+f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
-    }
-  }
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcUShapeProfileDef* l, cgal_face_t& face) {
-  const bool doEdgeFillet = l->hasEdgeRadius();
-  const bool doFillet = l->hasFilletRadius();
-  const bool hasSlope = l->hasFlangeSlope();
-  
-  const double y = l->Depth() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double x = l->FlangeWidth() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double d1 = l->WebThickness() * getValue(GV_LENGTH_UNIT);
-  const double d2 = l->FlangeThickness() * getValue(GV_LENGTH_UNIT);
-  const double slope = hasSlope ? (l->FlangeSlope() * getValue(GV_PLANEANGLE_UNIT)) : 0.;
-  
-  double dy1 = 0.0f;
-  double dy2 = 0.0f;
-  double f1 = 0.0f;
-  double f2 = 0.0f;
-  
-  if (doFillet) {
-    f1 = l->FilletRadius() * getValue(GV_LENGTH_UNIT);
-  }
-  if (doEdgeFillet) {
-    f2 = l->EdgeRadius() * getValue(GV_LENGTH_UNIT);
-  }
-  
-  if (hasSlope) {
-    dy1 = (x - d1) * tan(slope);
-    dy2 = x * tan(slope);
-  }
-  
-  if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 3;
-  
-  face = cgal_face_t();
-  face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(x, -y, 0.0));
-  if (f2 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(x, -y+d2-dy2, 0.0));
-  } else {
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), -y+d2-dy2-f2+f2*sin(current_angle), 0));
-    }
-  } if (f1 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(-x+d1, -y+d2+dy1, 0.0));
-  } else {
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+d1+f1+f1*cos(current_angle), -y+d2+dy1+f1+f1*sin(current_angle), 0));
-    }
-  } if (f1 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(-x+d1, y-d2-dy1, 0.0));
-  } else {
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+d1+f1+f1*cos(current_angle), y-d2-dy1-f1+f1*sin(current_angle), 0));
-    }
-  } if (f2 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(x,y-d2+dy2, 0.0));
-  } else {
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), y-d2+dy2+f2+f2*sin(current_angle), 0));
-    }
-  } face.outer.push_back(Kernel_::Point_3(x,y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(-x,y, 0.0));
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcZShapeProfileDef* l, cgal_face_t& face) {
-  const double x = l->FlangeWidth() * getValue(GV_LENGTH_UNIT);
-  const double y = l->Depth() / 2.0f * getValue(GV_LENGTH_UNIT);
-  const double dx = l->WebThickness() / 2.0f  * getValue(GV_LENGTH_UNIT);
-  const double dy = l->FlangeThickness() * getValue(GV_LENGTH_UNIT);
-  
-  bool doFillet = l->hasFilletRadius();
-  bool doEdgeFillet = l->hasEdgeRadius();
-  
-  double f1 = 0.;
-  double f2 = 0.;
-  
-  if ( doFillet ) {
-    f1 = l->FilletRadius() * getValue(GV_LENGTH_UNIT);
-  }
-  if ( doEdgeFillet ) {
-    f2 = l->EdgeRadius() * getValue(GV_LENGTH_UNIT);
-  }
-  
-  if ( x == 0.0f || y == 0.0f || dx == 0.0f || dy == 0.0f ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
-    return false;
-  }
-  
-  cgal_placement_t trsf2d;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  
-  const int segments = 3;
-  
-  face = cgal_face_t();
-  face.outer.push_back(Kernel_::Point_3(-dx, -y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(x, -y, 0.0));
-  if (f2 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(x, -y+dy, 0.0));
-  } else {
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), -y+dy-f2+f2*sin(current_angle), 0));
-    }
-  } if (f1 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(dx, -y+dy, 0.0));
-  } else {
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(dx+f1+f1*cos(current_angle), -y+dy+f1+f1*sin(current_angle), 0));
-    }
-  } face.outer.push_back(Kernel_::Point_3(dx, y, 0.0));
-  face.outer.push_back(Kernel_::Point_3(-x, y, 0.0));
-  if (f2 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(-x, y-dy, 0.0));
-  } else {
-    for (int current_segment = 0; current_segment <= segments; ++current_segment) {
-      double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-x+f2+f2*cos(current_angle), y-dy+f2+f2*sin(current_angle), 0));
-    }
-  } if (f1 == 0.0) {
-    face.outer.push_back(Kernel_::Point_3(-dx, y-dy, 0.0));
-  } else {
-    for (int current_segment = segments; current_segment >= 0; --current_segment) {
-      double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel_::Point_3(-dx-f1+f1*cos(current_angle), y-dy-f1+f1*sin(current_angle), 0));
-    }
-  }
-  
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
-    for (auto &vertex: face.outer) {
-      vertex = vertex.transform(trsf2d);
-    }
-  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcDerivedProfileDef* l, cgal_face_t& face) {
-  cgal_face_t f;
-  cgal_placement_t trsf2d;
-  if (convert_face(l->ParentProfile(), f) && IfcGeom::CgalKernel::convert(l->Operator(), trsf2d)) {
-    cgal_placement_t trsf = trsf2d;
-    for (auto &vertex: f.outer) vertex = vertex.transform(trsf);
-    for (auto &ring: f.inner) {
-      for (auto &vertex: ring) vertex = vertex.transform(trsf);
-    } face = f;
-    return true;
-  } else {
-    return false;
-  }
-}

src/ifcgeom/kernels/cgal/CgalIfcGeomPrimitives.cpp

@@ -1,323 +0,0 @@
-#include "CgalKernel.h"
-#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
-
-#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianPoint* l, cgal_point_t& point) {
-  std::vector<double> xyz = l->Coordinates();
-  point = Kernel_::Point_3(xyz.size()     ? (xyz[0]*getValue(GV_LENGTH_UNIT)) : 0.0f,
-                          xyz.size() > 1 ? (xyz[1]*getValue(GV_LENGTH_UNIT)) : 0.0f,
-                          xyz.size() > 2 ? (xyz[2]*getValue(GV_LENGTH_UNIT)) : 0.0f);
-  //  std::cout << "Converted Point(" << point << ")" << std::endl;
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcDirection* l, cgal_direction_t& dir) {
-  //  IN_CACHE(IfcDirection,l,cgal_direction_t,dir)
-  std::vector<double> xyz = l->DirectionRatios();
-  dir = Kernel_::Vector_3(xyz.size()     ? xyz[0] : 0.0f,
-                         xyz.size() > 1 ? xyz[1] : 0.0f,
-                         xyz.size() > 2 ? xyz[2] : 0.0f);
-  //  CACHE(IfcDirection,l,dir)
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcVector* l, cgal_vector_t& v) {
-  //  IN_CACHE(IfcVector,l,cgal_vector_t,v)
-  cgal_direction_t d;
-  IfcGeom::CgalKernel::convert(l->Orientation(),d);
-  v = l->Magnitude() * getValue(GV_LENGTH_UNIT) * d;
-  //  CACHE(IfcVector,l,v)
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcPlane* pln, cgal_plane_t& plane) {
-  //  IN_CACHE(IfcPlane,pln,gp_Pln,plane)
-  IfcSchema::IfcAxis2Placement3D* l = pln->Position();
-  cgal_point_t o;
-  cgal_direction_t axis = Kernel_::Vector_3(0,0,1);
-  cgal_direction_t refDirection = Kernel_::Vector_3(1,0,0);
-  IfcGeom::CgalKernel::convert(l->Location(),o);
-  bool hasRef = l->hasRefDirection();
-  if ( l->hasAxis() ) IfcGeom::CgalKernel::convert(l->Axis(),axis);
-  if ( hasRef ) IfcGeom::CgalKernel::convert(l->RefDirection(),refDirection);
-  Kernel_::Vector_3 y = CGAL::cross_product(axis, refDirection);
-  Kernel_::Vector_3 x = CGAL::cross_product(y, axis);
-  
-  cgal_plane_t ax3;
-  if ( hasRef ) ax3 = Kernel_::Plane_3(o,o+x,o+y);
-  else ax3 = Kernel_::Plane_3(o,axis);
-  plane = ax3;
-  
-  //  std::cout << "IfcPlane C = " << o << std::endl;
-  //  std::cout << "IfcPlane z (axis, exact) = " << axis << std::endl;
-  //  std::cout << "IfcPlane x (refDirection, approximate) = " << refDirection << std::endl;
-  //  std::cout << "IfcPlane y (computed, exact) = " << y << std::endl;
-  //  std::cout << "IfcPlane x (computed, exact) = " << x << std::endl;
-  //
-  //  std::cout << "Plane_3 o = " << o << std::endl;
-  //  std::cout << "Plane_3 o+x = " << o+x << std::endl;
-  //  std::cout << "Plane_3 o+y = " << o+y << std::endl;
-  
-  // ax + by + cz + d = 0
-  //  std::cout << "Plane: a = " << plane.a() << ", b = " << plane.b() << ", c = " << plane.c() << ", d = " << plane.d() << std::endl;
-  
-  //  std::ofstream fresult;
-  //  fresult.open("/Users/ken/Desktop/plane.obj");
-  //  // x = -5, y = -5, z = (5a +5b -d)/c
-  //  fresult << "v -5 -5 " << (5.0*CGAL::to_double(plane.a())+5.0*CGAL::to_double(plane.b())-CGAL::to_double(plane.d()))/CGAL::to_double(plane.c()) << std::endl;
-  //  // x = -5, y = +5, z = (5a -5b -d)/c
-  //  fresult << "v -5 5 " << (5.0*CGAL::to_double(plane.a())-5.0*CGAL::to_double(plane.b())-CGAL::to_double(plane.d()))/CGAL::to_double(plane.c()) << std::endl;
-  //  // x = 5, y = -5, z = (-5a +5b -d)/c
-  //  fresult << "v 5 -5 " << (-5.0*CGAL::to_double(plane.a())+5.0*CGAL::to_double(plane.b())-CGAL::to_double(plane.d()))/CGAL::to_double(plane.c()) << std::endl;
-  //  // x = 5, y = +5, z = (-5a -5b -d)/c
-  //  fresult << "v 5 5 " << (-5.0*CGAL::to_double(plane.a())-5.0*CGAL::to_double(plane.b())-CGAL::to_double(plane.d()))/CGAL::to_double(plane.c()) << std::endl;
-  //  fresult << "f 1 2 3" << std::endl;
-  //  fresult << "f 4 3 2" << std::endl;
-  //  fresult.close();
-  
-  //  CACHE(IfcPlane,pln,plane)
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis2Placement2D* l, cgal_placement_t& trsf) {
-  //  IN_CACHE(IfcAxis2Placement3D,l,gp_Trsf,trsf)
-  cgal_point_t o;
-  cgal_direction_t refDirection = Kernel_::Vector_3(1,0,0);
-  IfcGeom::CgalKernel::convert(l->Location(),o);
-  bool hasRef = l->hasRefDirection();
-  if ( hasRef ) IfcGeom::CgalKernel::convert(l->RefDirection(),refDirection);
-  cgal_direction_t y = Kernel_::Vector_3(-refDirection.y(), refDirection.x(), 0.0);
-  
-  const double tolerance = 0.01;
-  if (refDirection.squared_length() < 1.0-tolerance || refDirection.squared_length() > 1.0+tolerance ||
-      y.squared_length() < 1.0-tolerance || y.squared_length() > 1.0+tolerance) {
-    std::cout << "Ref direction (x): " << refDirection << " squared length: " << refDirection.squared_length() << std::endl;
-    std::cout << "y: " << y << " squared length: " << y.squared_length() << std::endl;
-    std::cout << "Origin: " << o << std::endl;
-  }
-  
-  // TODO: Should be checked.
-  trsf = Kernel_::Aff_transformation_3(refDirection.cartesian(0), y.cartesian(0), 0.0, o.cartesian(0),
-                                      refDirection.cartesian(1), y.cartesian(1), 0.0, o.cartesian(1),
-                                      0.0, 0.0, 1.0, 0.0);
-  
-  //  CACHE(IfcAxis2Placement3D,l,trsf)
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis2Placement3D* l, cgal_placement_t& trsf) {
-  //  IN_CACHE(IfcAxis2Placement3D,l,gp_Trsf,trsf)
-  cgal_point_t o;
-  cgal_direction_t axis = Kernel_::Vector_3(0,0,1);
-  cgal_direction_t refDirection = Kernel_::Vector_3(1,0,0);
-  IfcGeom::CgalKernel::convert(l->Location(),o);
-  bool hasRef = l->hasRefDirection();
-  if ( l->hasAxis() ) IfcGeom::CgalKernel::convert(l->Axis(),axis);
-  if ( hasRef ) IfcGeom::CgalKernel::convert(l->RefDirection(),refDirection);
-  Kernel_::Vector_3 y = CGAL::cross_product(axis, refDirection);
-  Kernel_::Vector_3 x = CGAL::cross_product(y, axis);
-  
-  const double tolerance = 0.01;
-  if (x.squared_length() < 1.0-tolerance || x.squared_length() > 1.0+tolerance ||
-      y.squared_length() < 1.0-tolerance || y.squared_length() > 1.0+tolerance ||
-      axis.squared_length() < 1.0-tolerance || axis.squared_length() > 1.0+tolerance) {
-    std::cout << "Ref direction: " << refDirection << " squared length: " << refDirection.squared_length() << std::endl;
-    std::cout << "Axis (z): " << axis << " squared length: " << axis.squared_length() << std::endl;
-    std::cout << "y: " << y << " squared length: " << y.squared_length() << std::endl;
-    std::cout << "x: " << x << " squared length: " << x.squared_length() << std::endl;
-    std::cout << "Origin: " << o << std::endl;
-  }
-  
-  // TODO: Should be checked.
-  trsf = Kernel_::Aff_transformation_3(x.cartesian(0), y.cartesian(0), axis.cartesian(0), o.cartesian(0),
-                                      x.cartesian(1), y.cartesian(1), axis.cartesian(1), o.cartesian(1),
-                                      x.cartesian(2), y.cartesian(2), axis.cartesian(2), o.cartesian(2));
-  
-  //  for (int i = 0; i < 3; ++i) {
-  //    for (int j = 0; j < 4; ++j) {
-  //      std::cout << trsf.cartesian(i, j) << " ";
-  //    } std::cout << std::endl;
-  //  }
-  
-  //  CACHE(IfcAxis2Placement3D,l,trsf)
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis1Placement* l, cgal_placement_t& ax) {
-//  IN_CACHE(IfcAxis1Placement,l,gp_Ax1,ax)
-  cgal_point_t o;
-  cgal_direction_t axis = Kernel_::Vector_3(0,0,1);
-  IfcGeom::CgalKernel::convert(l->Location(),o);
-  if ( l->hasAxis() ) IfcGeom::CgalKernel::convert(l->Axis(), axis);
-  
-  const double tolerance = 0.01;
-  if (axis.squared_length() < 1.0-tolerance || axis.squared_length() > 1.0+tolerance) {
-    std::cout << "Axis (z): " << axis << " squared length: " << axis.squared_length() << std::endl;
-    std::cout << "Origin: " << o << std::endl;
-  }
-  
-  // TODO: Should be checked.
-  ax = Kernel_::Aff_transformation_3(1.0, 0.0, axis.cartesian(0), o.cartesian(0),
-                                    0.0, 1.0, axis.cartesian(1), o.cartesian(1),
-                                    0.0, 0.0, axis.cartesian(2), o.cartesian(2));
-  
-//  CACHE(IfcAxis1Placement,l,ax)
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcObjectPlacement* l, cgal_placement_t& trsf) {
-  //  IN_CACHE(IfcObjectPlacement,l,cgal_placement_t,trsf)
-  if ( ! l->as<IfcSchema::IfcLocalPlacement>() ) {
-    Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l);
-    return false;
-  }
-  
-  //  std::cout << "initial trsf (identity?)" << std::endl;
-  //  for (int i = 0; i < 3; ++i) {
-  //    for (int j = 0; j < 4; ++j) {
-  //      std::cout << trsf.cartesian(i, j) << " ";
-  //    } std::cout << std::endl;
-  //  }
-  
-  IfcSchema::IfcLocalPlacement* current = (IfcSchema::IfcLocalPlacement*)l;
-  for (;;) {
-    cgal_placement_t trsf2;
-    
-    IfcSchema::IfcAxis2Placement* relplacement = current->RelativePlacement();
-    if ( relplacement->as<IfcSchema::IfcAxis2Placement3D>() ) {
-      IfcGeom::CgalKernel::convert((IfcSchema::IfcAxis2Placement3D*)relplacement,trsf2);
-      
-      //      std::cout << "trsf2" << std::endl;
-      //      for (int i = 0; i < 3; ++i) {
-      //        for (int j = 0; j < 4; ++j) {
-      //          std::cout << trsf2.cartesian(i, j) << " ";
-      //        } std::cout << std::endl;
-      //      }
-      
-      trsf = trsf2 * trsf;
-      
-      //      std::cout << "trsf (after multiplication)" << std::endl;
-      //      for (int i = 0; i < 3; ++i) {
-      //        for (int j = 0; j < 4; ++j) {
-      //          std::cout << trsf.cartesian(i, j) << " ";
-      //        } std::cout << std::endl;
-      //      }
-    }
-    if ( current->hasPlacementRelTo() ) {
-      IfcSchema::IfcObjectPlacement* relto = current->PlacementRelTo();
-      if ( relto->as<IfcSchema::IfcLocalPlacement>() )
-        current = (IfcSchema::IfcLocalPlacement*)current->PlacementRelTo();
-      else break;
-    } else break;
-  }
-  //  CACHE(IfcObjectPlacement,l,trsf)
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianTransformationOperator2D* l, cgal_placement_t& trsf) {
-  //  IN_CACHE(IfcCartesianTransformationOperator2D,l,cgal_placement_t,trsf)
-  
-  cgal_point_t origin;
-  cgal_direction_t axis1 (1.,0.,0.);
-  cgal_direction_t axis2 (0.,1.,0.);
-  
-  IfcGeom::CgalKernel::convert(l->LocalOrigin(),origin);
-  if ( l->hasAxis1() ) IfcGeom::CgalKernel::convert(l->Axis1(),axis1);
-  if ( l->hasAxis2() ) IfcGeom::CgalKernel::convert(l->Axis2(),axis2);
-  double scale = 1.0;
-  if (l->hasScale()) {
-    scale = l->Scale();
-  }
-  
-  // TODO: Untested
-  trsf = Kernel_::Aff_transformation_3(scale*axis1.cartesian(0), axis2.cartesian(0), 0.0, origin.cartesian(0),
-                                      axis1.cartesian(1), scale*axis2.cartesian(1), 0.0, origin.cartesian(1),
-                                      0.0, 0.0, 1.0, 0.0);
-  
-  //  CACHE(IfcCartesianTransformationOperator2D,l,trsf)
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianTransformationOperator2DnonUniform* l, cgal_placement_t& trsf) {
-  //  IN_CACHE(IfcCartesianTransformationOperator2DnonUniform,l,cgal_placement_t,gtrsf)
-  
-  cgal_point_t origin;
-  cgal_direction_t axis1 (1.,0.,0.);
-  cgal_direction_t axis2 (0.,1.,0.);
-  
-  IfcGeom::CgalKernel::convert(l->LocalOrigin(),origin);
-  if ( l->hasAxis1() ) IfcGeom::CgalKernel::convert(l->Axis1(),axis1);
-  if ( l->hasAxis2() ) IfcGeom::CgalKernel::convert(l->Axis2(),axis2);
-  
-  const double scale1 = l->hasScale() ? l->Scale() : 1.0f;
-  const double scale2 = l->hasScale2() ? l->Scale2() : scale1;
-  
-  // TODO: Untested
-  trsf = Kernel_::Aff_transformation_3(scale1*axis1.cartesian(0), axis2.cartesian(0), 0.0, origin.cartesian(0),
-                                      axis1.cartesian(1), scale2*axis2.cartesian(1), 0.0, origin.cartesian(1),
-                                      0.0, 0.0, 1.0, 0.0);
-  
-  //  CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gtrsf)
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianTransformationOperator3D* l, cgal_placement_t& trsf) {
-  //  IN_CACHE(IfcCartesianTransformationOperator3D,l,gp_Trsf,trsf)
-  cgal_point_t origin;
-  IfcGeom::CgalKernel::convert(l->LocalOrigin(),origin);
-  cgal_direction_t axis1 (1.,0.,0.);
-  cgal_direction_t axis2 (0.,1.,0.);
-  cgal_direction_t axis3 (0.,0.,1.);
-  if ( l->hasAxis1() ) IfcGeom::CgalKernel::convert(l->Axis1(),axis1);
-  if ( l->hasAxis2() ) IfcGeom::CgalKernel::convert(l->Axis2(),axis2);
-  if ( l->hasAxis3() ) IfcGeom::CgalKernel::convert(l->Axis3(),axis3);
-  double scale = 1.0;
-  if (l->hasScale()) {
-    scale = l->Scale();
-  }
-  
-  // TODO: Untested
-  trsf = Kernel_::Aff_transformation_3(scale*axis1.cartesian(0), axis2.cartesian(0), axis3.cartesian(0), origin.cartesian(0),
-                                      axis1.cartesian(1), scale*axis2.cartesian(1), axis3.cartesian(1), origin.cartesian(1),
-                                      axis1.cartesian(2), axis2.cartesian(2), scale*axis3.cartesian(2), origin.cartesian(2));
-  
-  //  std::cout << std::endl;
-  //  for (int i = 0; i < 3; ++i) {
-  //    for (int j = 0; j < 4; ++j) {
-  //      std::cout << trsf.cartesian(i, j) << " ";
-  //    } std::cout << std::endl;
-  //  }
-  
-  //  CACHE(IfcCartesianTransformationOperator3D,l,trsf)
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianTransformationOperator3DnonUniform* l, cgal_placement_t& gtrsf) {
-  //  IN_CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gp_GTrsf,gtrsf)
-  cgal_point_t origin;
-  IfcGeom::CgalKernel::convert(l->LocalOrigin(),origin);
-  cgal_direction_t axis1 (1.,0.,0.);
-  cgal_direction_t axis2 (0.,1.,0.);
-  cgal_direction_t axis3 (0.,0.,1.);
-  if ( l->hasAxis1() ) IfcGeom::CgalKernel::convert(l->Axis1(),axis1);
-  if ( l->hasAxis2() ) IfcGeom::CgalKernel::convert(l->Axis2(),axis2);
-  if ( l->hasAxis3() ) IfcGeom::CgalKernel::convert(l->Axis3(),axis3);
-  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;
-  
-  // TODO: Untested
-  gtrsf = Kernel_::Aff_transformation_3(scale1*axis1.cartesian(0), axis2.cartesian(0), axis3.cartesian(0), origin.cartesian(0),
-                                       axis1.cartesian(1), scale2*axis2.cartesian(1), axis3.cartesian(1), origin.cartesian(1),
-                                       axis1.cartesian(2), axis2.cartesian(2), scale3*axis3.cartesian(2), origin.cartesian(2));
-  
-  //  for (int i = 0; i < 3; ++i) {
-  //    for (int j = 0; j < 4; ++j) {
-  //      std::cout << gtrsf.cartesian(i, j) << " ";
-  //    } std::cout << std::endl;
-  //  }
-  
-  //  CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gtrsf)
-  return true;
-}

src/ifcgeom/kernels/cgal/CgalIfcGeomShapes.cpp

@@ -1,919 +0,0 @@
-#include "CgalKernel.h"
-#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
-
-#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolid *l, cgal_shape_t &shape) {
-  const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
-  if (height < getValue(GV_PRECISION)) {
-    Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l);
-    return false;
-  }
-  
-  // Outer
-  cgal_face_t bottom_face;
-  if ( !convert_face(l->SweptArea(),bottom_face) ) return false;
-//  std::cout << "Face vertices: " << face.outer.size() << std::endl;
-  
-  cgal_placement_t trsf;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf);
-  }
-  
-  cgal_direction_t dir;
-  convert(l->ExtrudedDirection(),dir);
-  //  std::cout << "Direction: " << dir << std::endl;
-  
-  std::list<cgal_face_t> face_list;
-  face_list.push_back(bottom_face);
-  
-  for (std::vector<Kernel_::Point_3>::const_iterator current_vertex = bottom_face.outer.begin();
-       current_vertex != bottom_face.outer.end();
-       ++current_vertex) {
-    std::vector<Kernel_::Point_3>::const_iterator next_vertex = current_vertex;
-    ++next_vertex;
-    if (next_vertex == bottom_face.outer.end()) {
-      next_vertex = bottom_face.outer.begin();
-    } cgal_face_t side_face;
-    side_face.outer.push_back(*next_vertex);
-    side_face.outer.push_back(*current_vertex);
-    side_face.outer.push_back(*current_vertex+height*dir);
-    side_face.outer.push_back(*next_vertex+height*dir);
-    face_list.push_back(side_face);
-  }
-  
-  cgal_face_t top_face;
-  for (std::vector<Kernel_::Point_3>::const_reverse_iterator vertex = bottom_face.outer.rbegin();
-       vertex != bottom_face.outer.rend();
-       ++vertex) {
-    top_face.outer.push_back(*vertex+height*dir);
-  } face_list.push_back(top_face);
-  
-  if (bottom_face.inner.empty()) {
-    shape = create_polyhedron(face_list);
-    if (has_position) for (auto &vertex: vertices(shape)) vertex->point() = vertex->point().transform(trsf);
-    return true;
-  }
-  
-  CGAL::Nef_polyhedron_3<Kernel_> nef_shape = create_nef_polyhedron(face_list);
-  
-  // Inner
-  // TODO: Would be faster to triangulate top/bottom face template rather than use Nef polyhedra for subtraction
-  for (auto &inner: bottom_face.inner) {
-//    std::cout << "Inner wire" << std::endl;
-    face_list.clear();
-    
-    cgal_face_t hole_bottom_face;
-    hole_bottom_face.outer = inner;
-    remove_duplicate_points_from_loop(hole_bottom_face.outer);
-    face_list.push_back(hole_bottom_face);
-    
-    for (std::vector<Kernel_::Point_3>::const_iterator current_vertex = inner.begin();
-         current_vertex != inner.end();
-         ++current_vertex) {
-      std::vector<Kernel_::Point_3>::const_iterator next_vertex = current_vertex;
-      ++next_vertex;
-      if (next_vertex == inner.end()) {
-        next_vertex = inner.begin();
-      } cgal_face_t hole_side_face;
-      hole_side_face.outer.push_back(*next_vertex);
-      hole_side_face.outer.push_back(*current_vertex);
-      hole_side_face.outer.push_back(*current_vertex+height*dir);
-      hole_side_face.outer.push_back(*next_vertex+height*dir);
-      face_list.push_back(hole_side_face);
-    }
-    
-    cgal_face_t hole_top_face;
-    for (std::vector<Kernel_::Point_3>::const_reverse_iterator vertex = inner.rbegin();
-         vertex != inner.rend();
-         ++vertex) {
-      hole_top_face.outer.push_back(*vertex+height*dir);
-    } face_list.push_back(hole_top_face);
-    
-    try {
-      nef_shape -= create_nef_polyhedron(face_list);
-    } catch (...) {
-      Logger::Message(Logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot subtract opening for:", l);
-      return false;
-    }
-  }
-  
-  if (has_position) {
-    // IfcSweptAreaSolid.Position (trsf) is an IfcAxis2Placement3D
-    // and therefore has a unit scale factor
-    nef_shape.transform(trsf);
-  }
-  
-  try {
-    nef_shape.convert_to_polyhedron(shape);
-    return true;
-  } catch (...) {
-    Logger::Message(Logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot convert Nef to polyhedron for:", l);
-    return false;
-  }
-  
-}
-
-#ifdef USE_IFC4
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered* l, cgal_shape_t& shape) {
-  const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
-  if (height < getValue(GV_PRECISION)) {
-    Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l);
-    return false;
-  }
-  
-  cgal_face_t face1, face2;
-  if (!convert_face(l->SweptArea(), face1)) return false;
-  if (!convert_face(l->EndSweptArea(), face2)) return false;
-  
-  cgal_placement_t trsf;
-  bool has_position = true;
-#ifdef USE_IFC4
-  has_position = l->hasPosition();
-#endif
-  if (has_position) {
-    IfcGeom::CgalKernel::convert(l->Position(), trsf);
-  }
-  
-  cgal_direction_t dir;
-  convert(l->ExtrudedDirection(), dir);
-  
-  for (auto &vertex: face2.outer) vertex = vertex + height*dir;
-  for (auto &ring: face2.inner) {
-    for (auto &vertex: ring) vertex = vertex + height*dir;
-  }
-  
-  // Outer
-  std::list<cgal_face_t> face_list;
-  face_list.push_back(face1);
-  
-  std::vector<Kernel_::Point_3>::const_iterator current_face1_vertex = face1.outer.begin();
-  std::vector<Kernel_::Point_3>::const_iterator current_face2_vertex = face2.outer.begin();
-  while (current_face1_vertex != face1.outer.end() &&
-         current_face2_vertex != face2.outer.end()) {
-    std::vector<Kernel_::Point_3>::const_iterator next_face1_vertex = current_face1_vertex;
-    std::vector<Kernel_::Point_3>::const_iterator next_face2_vertex = current_face2_vertex;
-    ++next_face1_vertex;
-    ++next_face2_vertex;
-    if (next_face1_vertex == face1.outer.end()) next_face1_vertex = face1.outer.begin();
-    if (next_face2_vertex == face2.outer.end()) next_face2_vertex = face2.outer.begin();
-    cgal_face_t side_face;
-    side_face.outer.push_back(*next_face1_vertex);
-    side_face.outer.push_back(*current_face1_vertex);
-    side_face.outer.push_back(*current_face2_vertex);
-    side_face.outer.push_back(*next_face2_vertex);
-    face_list.push_back(side_face);
-    ++current_face1_vertex;
-    ++current_face2_vertex;
-  }
-  
-  cgal_face_t top_face;
-  for (std::vector<Kernel_::Point_3>::const_reverse_iterator vertex = face2.outer.rbegin();
-       vertex != face2.outer.rend();
-       ++vertex) {
-    top_face.outer.push_back(*vertex);
-  } face_list.push_back(top_face);
-  
-  if (face1.inner.empty() || face2.inner.empty()) {
-    shape = create_polyhedron(face_list);
-    if (has_position) for (auto &vertex: vertices(shape)) vertex->point() = vertex->point().transform(trsf);
-    return true;
-  }
-  
-//  std::ofstream f1;
-//  CGAL::Polyhedron_3<Kernel_> outer_polyhedron;
-//  PolyhedronBuilder builder(&face_list);
-//  outer_polyhedron.delegate(builder);
-//  f1.open("/Users/ken/Desktop/outer.off");
-//  f1 << outer_polyhedron << std::endl;
-//  f1.close();
-  
-  CGAL::Nef_polyhedron_3<Kernel_> nef_shape = create_nef_polyhedron(face_list);
-  
-  // Inner
-  // TODO: Would be faster to triangulate top/bottom face template rather than use Nef polyhedra for subtraction
-  std::vector<cgal_wire_t>::iterator inner_face1 = face1.inner.begin();
-  std::vector<cgal_wire_t>::iterator inner_face2 = face2.inner.begin();
-  while (inner_face1 != face1.inner.end() &&
-         inner_face2 != face2.inner.end()) {
-    face_list.clear();
-    
-    cgal_face_t hole_face1;
-    hole_face1.outer = *inner_face1;
-    remove_duplicate_points_from_loop(hole_face1.outer);
-    face_list.push_back(hole_face1);
-    
-    cgal_face_t hole_face2;
-    hole_face2.outer = *inner_face2;
-    remove_duplicate_points_from_loop(hole_face2.outer);
-    
-    current_face1_vertex = hole_face1.outer.begin();
-    current_face2_vertex = hole_face2.outer.begin();
-    while (current_face1_vertex != hole_face1.outer.end() &&
-           current_face2_vertex != hole_face2.outer.end()) {
-      std::vector<Kernel_::Point_3>::const_iterator next_face1_vertex = current_face1_vertex;
-      std::vector<Kernel_::Point_3>::const_iterator next_face2_vertex = current_face2_vertex;
-      ++next_face1_vertex;
-      ++next_face2_vertex;
-      if (next_face1_vertex == hole_face1.outer.end()) next_face1_vertex = hole_face1.outer.begin();
-      if (next_face2_vertex == hole_face2.outer.end()) next_face2_vertex = hole_face2.outer.begin();
-      cgal_face_t side_face;
-      side_face.outer.push_back(*next_face1_vertex);
-      side_face.outer.push_back(*current_face1_vertex);
-      side_face.outer.push_back(*current_face2_vertex);
-      side_face.outer.push_back(*next_face2_vertex);
-      face_list.push_back(side_face);
-      ++current_face1_vertex;
-      ++current_face2_vertex;
-    }
-    
-    cgal_face_t top_hole_face;
-    for (std::vector<Kernel_::Point_3>::const_reverse_iterator vertex = hole_face2.outer.rbegin();
-         vertex != hole_face2.outer.rend();
-         ++vertex) {
-      top_hole_face.outer.push_back(*vertex);
-    } face_list.push_back(top_hole_face);
-    
-//    std::ofstream f2;
-//    CGAL::Polyhedron_3<Kernel_> inner_polyhedron;
-//    PolyhedronBuilder builder(&face_list);
-//    inner_polyhedron.delegate(builder);
-//    f2.open("/Users/ken/Desktop/inner.off");
-//    f2 << inner_polyhedron << std::endl;
-//    f2.close();
-    
-    try {
-      nef_shape -= create_nef_polyhedron(face_list);
-    } catch (...) {
-      std::cout << "IfcExtrudedAreaSolidTapered: cannot subtract opening for:" << std::endl;
-      return false;
-    }
-    
-    ++inner_face1;
-    ++inner_face2;
-  }
-  
-  if (has_position) {
-    // IfcSweptAreaSolid.Position (trsf) is an IfcAxis2Placement3D
-    // and therefore has a unit scale factor
-    nef_shape.transform(trsf);
-  }
-  
-  try {
-    nef_shape.convert_to_polyhedron(shape);
-    return true;
-  } catch (...) {
-    std::cout << "IfcExtrudedAreaSolidTapered: cannot convert Nef to polyhedron!" << std::endl;
-    return false;
-  }
-}
-#endif
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcConnectedFaceSet* l, cgal_shape_t& shape) {
-  IfcSchema::IfcFace::list::ptr faces = l->CfsFaces();
-  
-  std::list<cgal_face_t> face_list;
-  for (IfcSchema::IfcFace::list::it it = faces->begin(); it != faces->end(); ++it) {
-    bool success = false;
-    cgal_face_t face;
-    
-    try {
-      success = convert_face(*it, face);
-    } catch (...) {}
-    
-    if (!success) {
-      Logger::Message(Logger::LOG_WARNING, "Failed to convert face:", (*it));
-      continue;
-    }
-    
-    //    std::cout << "Face in ConnectedFaceSet: " << std::endl;
-    //    for (auto &point: face.outer) {
-    //      std::cout << "\tPoint(" << point << ")" << std::endl;
-    //    }
-    
-    face_list.push_back(face);
-  }
-  
-  shape = create_polyhedron(face_list);
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCsgSolid* l, cgal_shape_t& shape) {
-  return convert_shape(l->TreeRootExpression(), shape);
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcBlock* l, cgal_shape_t& 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);
-  
-  std::list<cgal_face_t> face_list;
-  
-  // x = 0
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, dz));
-  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, dz));
-  
-  // x = dx
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, dz));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, dz));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  
-  // y = 0
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, dz));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, dz));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  
-  // y = dy
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, dz));
-  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, dz));
-  
-  // z = 0
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
-  
-  // z = dz
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, dz));
-  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, dz));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, dz));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, dz));
-  
-  cgal_placement_t trsf;
-  IfcGeom::CgalKernel::convert(l->Position(),trsf);
-
-  shape = create_polyhedron(face_list);
-  for (auto &vertex: vertices(shape)) vertex->point() = vertex->point().transform(trsf);
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcBooleanResult* l, cgal_shape_t& shape) {
-  
-  cgal_shape_t s1, s2;
-  ConversionResults items1, items2;
-  cgal_wire_t boundary_wire;
-  IfcSchema::IfcBooleanOperand* operand1 = l->FirstOperand();
-  IfcSchema::IfcBooleanOperand* operand2 = l->SecondOperand();
-  bool is_halfspace = operand2->as<IfcSchema::IfcHalfSpaceSolid>();
-  
-  if ( shape_type(operand1) == ST_SHAPELIST ) {
-    Logger::Message(Logger::LOG_ERROR, "s1: ST_SHAPELIST Unsupported", operand1);
-//    if (!(convert_shapes(operand1, items1) && flatten_shape_list(items1, s1, true))) {
-      return false;
-//    }
-  } else if ( shape_type(operand1) == ST_SHAPE ) {
-    if (!convert_shape(operand1, s1) ) {
-      return false;
-    }
-  } else {
-    Logger::Message(Logger::LOG_ERROR, "s1: Invalid representation item for boolean operation", operand1);
-    return false;
-  }
-
-//  const double first_operand_volume = shape_volume(s1);
-//  if ( first_operand_volume <= ALMOST_ZERO )
-//    Logger::Message(Logger::LOG_WARNING,"Empty solid for:",l->FirstOperand());
-  
-  bool shape2_processed = false;
-  if ( shape_type(operand2) == ST_SHAPELIST ) {
-    Logger::Message(Logger::LOG_ERROR, "s2: ST_SHAPELIST Unsupported", operand1);
-//    shape2_processed = convert_shapes(operand2, items2) && flatten_shape_list(items2, s2, true);
-  } else if ( shape_type(operand2) == ST_SHAPE ) {
-    shape2_processed = convert_shape(operand2,s2);
-  } else {
-    Logger::Message(Logger::LOG_ERROR, "s2: Invalid representation item for boolean operation", operand2);
-  }
-
-  if (!shape2_processed) {
-    shape = s1;
-    Logger::Message(Logger::LOG_ERROR,"Failed to convert SecondOperand of:",l);
-    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);
-//  }
-  
-  const IfcSchema::IfcBooleanOperator::Value op = l->Operator();
-  
-  if (!s1.is_valid()) {
-    Logger::Message(Logger::LOG_ERROR, "s1: Not valid?", operand1);
-    return false;
-  } else {
-//    std::ofstream f1;
-//    CGAL::Polyhedron_3<Kernel_> p1;
-//    s1.convert_to_Polyhedron(p1);
-//    f1.open("/Users/ken/Desktop/s1.off");
-//    f1 << p1 << std::endl;
-//    f1.close();
-  }
-  
-  bool is_plane = false;
-  cgal_plane_t plane;
-  if (!s2.is_valid()) {
-    Logger::Message(Logger::LOG_ERROR, "s2: Not valid?", operand2);
-    return false;
-  } else if (is_halfspace) {
-    //    std::cout << "s2: halfspace" << std::endl;
-    IfcSchema::IfcHalfSpaceSolid *hss = static_cast<IfcSchema::IfcHalfSpaceSolid *>(operand2);
-    IfcSchema::IfcSurface* surface = hss->BaseSurface();
-    if (surface->as<IfcSchema::IfcPlane>() ) {
-      is_plane = true;
-      IfcGeom::CgalKernel::convert((IfcSchema::IfcPlane *)surface, plane);
-      if (hss->AgreementFlag()) plane = plane.opposite();
-//      std::ofstream fresult;
-//      fresult.open("/Users/ken/Desktop/s2.off");
-//      fresult << "OFF" << std::endl << "4 2 4" << std::endl;
-//      // x = -5, y = -5, z = (5a +5b -d)/c
-//      fresult << "-5 -5 " << (5.0*CGAL::to_double(plane.a())+5.0*CGAL::to_double(plane.b())-CGAL::to_double(plane.d()))/CGAL::to_double(plane.c()) << std::endl;
-//      // x = -5, y = +5, z = (5a -5b -d)/c
-//      fresult << "-5 5 " << (5.0*CGAL::to_double(plane.a())-5.0*CGAL::to_double(plane.b())-CGAL::to_double(plane.d()))/CGAL::to_double(plane.c()) << std::endl;
-//      // x = 5, y = -5, z = (-5a +5b -d)/c
-//      fresult << "5 -5 " << (-5.0*CGAL::to_double(plane.a())+5.0*CGAL::to_double(plane.b())-CGAL::to_double(plane.d()))/CGAL::to_double(plane.c()) << std::endl;
-//      // x = 5, y = +5, z = (-5a -5b -d)/c
-//      fresult << "5 5 " << (-5.0*CGAL::to_double(plane.a())-5.0*CGAL::to_double(plane.b())-CGAL::to_double(plane.d()))/CGAL::to_double(plane.c()) << std::endl;
-//      fresult << "3 0 1 2" << std::endl;
-//      fresult << "3 3 2 1" << std::endl;
-//      fresult.close();
-    }
-  } else {
-//    std::ofstream f2;
-//    CGAL::Polyhedron_3<Kernel_> p2;
-//    s2.convert_to_Polyhedron(p2);
-//    f2.open("/Users/ken/Desktop/s2.off");
-//    f2 << p2 << std::endl;
-//    f2.close();
-  }
-  
-  if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_DIFFERENCE) {
-    
-//    std::cout << "Difference" << std::endl;
-    CGAL::Nef_polyhedron_3<Kernel_> nef_result;
-    try {
-      nef_result = CGAL::Nef_polyhedron_3<Kernel_>(s1);
-    } catch (...) {
-      Logger::Message(Logger::LOG_ERROR, "s1: cannot convert to Nef?", operand1);
-      return false;
-    } if (is_halfspace) {
-      if (is_plane) nef_result = nef_result.intersection(plane, CGAL::Nef_polyhedron_3<Kernel_>::Intersection_mode::CLOSED_HALFSPACE);
-    } else {
-      CGAL::Nef_polyhedron_3<Kernel_> nef_s2;
-      try {
-        nef_s2 = CGAL::Nef_polyhedron_3<Kernel_>(s2);
-      } catch (...) {
-        Logger::Message(Logger::LOG_ERROR, "s2: cannot convert to Nef?", operand2);
-      } nef_result -= nef_s2;
-    }
-    if (!nef_result.is_simple()) {
-      Logger::Message(Logger::LOG_ERROR, "s2: not simple?", operand2);
-      return false;
-    } else {
-//      CGAL::Polyhedron_3<Kernel_> result;
-//      nef_result.convert_to_polyhedron(result);
-//      std::ofstream fresult;
-//      fresult.open("/Users/ken/Desktop/result.off");
-//      fresult << result << std::endl;
-//      fresult.close();
-    } try {
-      nef_result.convert_to_polyhedron(shape);
-      return true;
-    } catch (...) {
-      std::cout << "IfcBooleanResult: cannot convert Nef to polyhedron!" << std::endl;
-      return false;
-    }
-    
-  } else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_UNION) {
-
-//    std::cout << "Union" << std::endl;
-    CGAL::Nef_polyhedron_3<Kernel_> nef_result = CGAL::Nef_polyhedron_3<Kernel_>(s1)+CGAL::Nef_polyhedron_3<Kernel_>(s2);
-    if (!nef_result.is_simple()) {
-      std::cout << "Not simple: " << nef_result.number_of_volumes() << " volumes" << std::endl;
-      return false;
-    } else {
-//      CGAL::Polyhedron_3<Kernel_> result;
-//      nef_result.convert_to_polyhedron(result);
-//      std::ofstream fresult;
-//      fresult.open("/Users/ken/Desktop/result.off");
-//      fresult << result << std::endl;
-//      fresult.close();
-    } try {
-      nef_result.convert_to_polyhedron(shape);
-      return true;
-    } catch (...) {
-      std::cout << "IfcBooleanResult: cannot convert Nef to polyhedron!" << std::endl;
-      return false;
-    }
-    
-  } else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_INTERSECTION) {
-
-//    std::cout << "Intersection" << std::endl;
-    CGAL::Nef_polyhedron_3<Kernel_> nef_result = CGAL::Nef_polyhedron_3<Kernel_>(s1)*CGAL::Nef_polyhedron_3<Kernel_>(s2);
-    if (!nef_result.is_simple()) {
-      std::cout << "Not simple: " << nef_result.number_of_volumes() << " volumes" << std::endl;
-      return false;
-    } else {
-//      CGAL::Polyhedron_3<Kernel_> result;
-//      nef_result.convert_to_polyhedron(result);
-//      std::ofstream fresult;
-//      fresult.open("/Users/ken/Desktop/result.off");
-//      fresult << result << std::endl;
-//      fresult.close();
-    } try {
-      nef_result.convert_to_polyhedron(shape);
-      return true;
-    } catch (...) {
-      std::cout << "IfcBooleanResult: cannot convert Nef to polyhedron!" << std::endl;
-      return false;
-    }
-  } return false;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcSphere* l, cgal_shape_t& shape) {
-  const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
-  
-  // Make icosahedron
-  float golden_ratio = (1.0+sqrtf(5.0))/2.0;
-  float normalising_factor = sqrtf(golden_ratio*golden_ratio+1.0);
-  std::vector<Kernel_::Point_3> icosahedron_vertices;
-  icosahedron_vertices.push_back(Kernel_::Point_3(-1.0/normalising_factor,  golden_ratio/normalising_factor, 0.0));
-  icosahedron_vertices.push_back(Kernel_::Point_3( 1.0/normalising_factor,  golden_ratio/normalising_factor, 0.0));
-  icosahedron_vertices.push_back(Kernel_::Point_3(-1.0/normalising_factor, -golden_ratio/normalising_factor, 0.0));
-  icosahedron_vertices.push_back(Kernel_::Point_3( 1.0/normalising_factor, -golden_ratio/normalising_factor, 0.0));
-  icosahedron_vertices.push_back(Kernel_::Point_3(0.0, -1.0/normalising_factor,  golden_ratio/normalising_factor));
-  icosahedron_vertices.push_back(Kernel_::Point_3(0.0,  1.0/normalising_factor,  golden_ratio/normalising_factor));
-  icosahedron_vertices.push_back(Kernel_::Point_3(0.0, -1.0/normalising_factor, -golden_ratio/normalising_factor));
-  icosahedron_vertices.push_back(Kernel_::Point_3(0.0,  1.0/normalising_factor, -golden_ratio/normalising_factor));
-  icosahedron_vertices.push_back(Kernel_::Point_3( golden_ratio/normalising_factor, 0.0, -1.0/normalising_factor));
-  icosahedron_vertices.push_back(Kernel_::Point_3( golden_ratio/normalising_factor, 0.0,  1.0/normalising_factor));
-  icosahedron_vertices.push_back(Kernel_::Point_3(-golden_ratio/normalising_factor, 0.0, -1.0/normalising_factor));
-  icosahedron_vertices.push_back(Kernel_::Point_3(-golden_ratio/normalising_factor, 0.0,  1.0/normalising_factor));
-  
-  std::list<cgal_face_t> face_list;
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[0]);
-  face_list.back().outer.push_back(icosahedron_vertices[11]);
-  face_list.back().outer.push_back(icosahedron_vertices[5]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[0]);
-  face_list.back().outer.push_back(icosahedron_vertices[5]);
-  face_list.back().outer.push_back(icosahedron_vertices[1]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[0]);
-  face_list.back().outer.push_back(icosahedron_vertices[1]);
-  face_list.back().outer.push_back(icosahedron_vertices[7]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[0]);
-  face_list.back().outer.push_back(icosahedron_vertices[7]);
-  face_list.back().outer.push_back(icosahedron_vertices[10]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[0]);
-  face_list.back().outer.push_back(icosahedron_vertices[10]);
-  face_list.back().outer.push_back(icosahedron_vertices[11]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[1]);
-  face_list.back().outer.push_back(icosahedron_vertices[5]);
-  face_list.back().outer.push_back(icosahedron_vertices[9]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[5]);
-  face_list.back().outer.push_back(icosahedron_vertices[11]);
-  face_list.back().outer.push_back(icosahedron_vertices[4]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[11]);
-  face_list.back().outer.push_back(icosahedron_vertices[10]);
-  face_list.back().outer.push_back(icosahedron_vertices[2]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[10]);
-  face_list.back().outer.push_back(icosahedron_vertices[7]);
-  face_list.back().outer.push_back(icosahedron_vertices[6]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[7]);
-  face_list.back().outer.push_back(icosahedron_vertices[1]);
-  face_list.back().outer.push_back(icosahedron_vertices[8]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[3]);
-  face_list.back().outer.push_back(icosahedron_vertices[9]);
-  face_list.back().outer.push_back(icosahedron_vertices[4]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[3]);
-  face_list.back().outer.push_back(icosahedron_vertices[4]);
-  face_list.back().outer.push_back(icosahedron_vertices[2]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[3]);
-  face_list.back().outer.push_back(icosahedron_vertices[2]);
-  face_list.back().outer.push_back(icosahedron_vertices[6]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[3]);
-  face_list.back().outer.push_back(icosahedron_vertices[6]);
-  face_list.back().outer.push_back(icosahedron_vertices[8]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[3]);
-  face_list.back().outer.push_back(icosahedron_vertices[8]);
-  face_list.back().outer.push_back(icosahedron_vertices[9]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[4]);
-  face_list.back().outer.push_back(icosahedron_vertices[9]);
-  face_list.back().outer.push_back(icosahedron_vertices[5]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[2]);
-  face_list.back().outer.push_back(icosahedron_vertices[4]);
-  face_list.back().outer.push_back(icosahedron_vertices[11]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[6]);
-  face_list.back().outer.push_back(icosahedron_vertices[2]);
-  face_list.back().outer.push_back(icosahedron_vertices[10]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[8]);
-  face_list.back().outer.push_back(icosahedron_vertices[6]);
-  face_list.back().outer.push_back(icosahedron_vertices[7]);
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(icosahedron_vertices[9]);
-  face_list.back().outer.push_back(icosahedron_vertices[8]);
-  face_list.back().outer.push_back(icosahedron_vertices[1]);
-  
-  const unsigned int refinements = 2;
-  for (unsigned int current_refinement = 0; current_refinement < refinements; ++current_refinement) {
-    std::list<cgal_face_t> refined_face_list;
-    for (auto &face: face_list) {
-      Kernel_::Point_3 vertex0 = face.outer[0];
-      Kernel_::Point_3 vertex1 = face.outer[1];
-      Kernel_::Point_3 vertex2 = face.outer[2];
-      
-      Kernel_::Point_3 midpoint01 = CGAL::midpoint(vertex0, vertex1);
-      Kernel_::Point_3 midpoint12 = CGAL::midpoint(vertex1, vertex2);
-      Kernel_::Point_3 midpoint20 = CGAL::midpoint(vertex2, vertex0);
-      
-      double midpoint01_distance_to_origin = sqrt(CGAL::to_double(CGAL::squared_distance(midpoint01, Kernel_::Point_3(0, 0, 0))));
-      midpoint01 = Kernel_::Point_3(midpoint01.x()/midpoint01_distance_to_origin,
-                                   midpoint01.y()/midpoint01_distance_to_origin,
-                                   midpoint01.z()/midpoint01_distance_to_origin);
-      double midpoint12_distance_to_origin = sqrt(CGAL::to_double(CGAL::squared_distance(midpoint12, Kernel_::Point_3(0, 0, 0))));
-      midpoint12 = Kernel_::Point_3(midpoint12.x()/midpoint12_distance_to_origin,
-                                   midpoint12.y()/midpoint12_distance_to_origin,
-                                   midpoint12.z()/midpoint12_distance_to_origin);
-      double midpoint20_distance_to_origin = sqrt(CGAL::to_double(CGAL::squared_distance(midpoint20, Kernel_::Point_3(0, 0, 0))));
-      midpoint20 = Kernel_::Point_3(midpoint20.x()/midpoint20_distance_to_origin,
-                                   midpoint20.y()/midpoint20_distance_to_origin,
-                                   midpoint20.z()/midpoint20_distance_to_origin);
-      
-      refined_face_list.push_back(cgal_face_t());
-      refined_face_list.back().outer.push_back(vertex0);
-      refined_face_list.back().outer.push_back(midpoint01);
-      refined_face_list.back().outer.push_back(midpoint20);
-      
-      refined_face_list.push_back(cgal_face_t());
-      refined_face_list.back().outer.push_back(vertex1);
-      refined_face_list.back().outer.push_back(midpoint12);
-      refined_face_list.back().outer.push_back(midpoint01);
-      
-      refined_face_list.push_back(cgal_face_t());
-      refined_face_list.back().outer.push_back(vertex2);
-      refined_face_list.back().outer.push_back(midpoint20);
-      refined_face_list.back().outer.push_back(midpoint12);
-      
-      refined_face_list.push_back(cgal_face_t());
-      refined_face_list.back().outer.push_back(midpoint01);
-      refined_face_list.back().outer.push_back(midpoint12);
-      refined_face_list.back().outer.push_back(midpoint20);
-    } face_list = refined_face_list;
-  }
-  
-  cgal_placement_t trsf;
-  IfcGeom::CgalKernel::convert(l->Position(),trsf);
-  
-  shape = create_polyhedron(face_list);
-  for (auto &vertex: vertices(shape)) {
-    vertex->point() = Kernel_::Point_3(r*vertex->point().x(),
-                                      r*vertex->point().y(),
-                                      r*vertex->point().z());
-    vertex->point() = vertex->point().transform(trsf);
-  }
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRectangularPyramid* l, cgal_shape_t& 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);
-  
-  std::list<cgal_face_t> face_list;
-  
-  // Base
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
-  
-  // Lateral faces
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0.5*dx, 0.5*dy, dz));
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0.5*dx, 0.5*dy, dz));
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0.5*dx, 0.5*dy, dz));
-  
-  face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel_::Point_3(0.5*dx, 0.5*dy, dz));
-  
-  cgal_placement_t trsf;
-  IfcGeom::CgalKernel::convert(l->Position(),trsf);
-  
-  shape = create_polyhedron(face_list);
-  for (auto &vertex: vertices(shape)) vertex->point() = vertex->point().transform(trsf);
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRightCircularCylinder* l, cgal_shape_t& shape) {
-  const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
-  const double h = l->Height() * getValue(GV_LENGTH_UNIT);
-  
-  std::list<cgal_face_t> face_list;
-  
-  const int segments = 12;
-  
-  // Base
-  face_list.push_back(cgal_face_t());
-  for (int current_segment = 0; current_segment < segments; ++current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-  }
-  
-  // Side faces
-  for (int current_segment = 0; current_segment < segments; ++current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    int next_segment = (current_segment+1)%segments;
-    double next_angle = next_segment*2.0*3.141592653589793/((double)segments);
-    face_list.push_back(cgal_face_t());
-    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(next_angle), r*sin(next_angle), 0));
-    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), h));
-    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(next_angle), r*sin(next_angle), h));
-  }
-  
-  // Top
-  face_list.push_back(cgal_face_t());
-  for (int current_segment = segments-1; current_segment >= 0; --current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), h));
-  }
-  
-  cgal_placement_t trsf;
-  IfcGeom::CgalKernel::convert(l->Position(),trsf);
-  
-  shape = create_polyhedron(face_list);
-  for (auto &vertex: vertices(shape)) vertex->point() = vertex->point().transform(trsf);
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRightCircularCone* l, cgal_shape_t& shape) {
-  const double r = l->BottomRadius() * getValue(GV_LENGTH_UNIT);
-  const double h = l->Height() * getValue(GV_LENGTH_UNIT);
-  
-  std::list<cgal_face_t> face_list;
-  
-  const int segments = 12;
-  
-  // Base
-  face_list.push_back(cgal_face_t());
-  for (int current_segment = 0; current_segment < segments; ++current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-  }
-  
-  // Side faces
-  for (int current_segment = 0; current_segment < segments; ++current_segment) {
-    double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    int next_segment = (current_segment+1)%segments;
-    double next_angle = next_segment*2.0*3.141592653589793/((double)segments);
-    face_list.push_back(cgal_face_t());
-    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(next_angle), r*sin(next_angle), 0));
-    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-    face_list.back().outer.push_back(Kernel_::Point_3(0, 0, h));
-  }
-  
-  cgal_placement_t trsf;
-  IfcGeom::CgalKernel::convert(l->Position(),trsf);
-  
-  shape = create_polyhedron(face_list);
-  for (auto &vertex: vertices(shape)) vertex->point() = vertex->point().transform(trsf);
-  return true;
-}
-
-#ifdef USE_IFC4
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, cgal_shape_t& shape) {
-  IfcSchema::IfcCartesianPointList3D* point_list = l->Coordinates();
-  const std::vector< std::vector<double> > coordinates = point_list->CoordList();
-  std::vector<cgal_point_t> points;
-  points.reserve(coordinates.size());
-  for (std::vector< std::vector<double> >::const_iterator it = coordinates.begin(); it != coordinates.end(); ++it) {
-    const std::vector<double>& coords = *it;
-    if (coords.size() != 3) {
-      Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on Coordinates", l);
-      return false;
-    }
-    points.push_back(Kernel_::Point_3(coords[0] * getValue(GV_LENGTH_UNIT),
-                                     coords[1] * getValue(GV_LENGTH_UNIT),
-                                     coords[2] * getValue(GV_LENGTH_UNIT)));
-  }
-  
-  std::vector< std::vector<int> > indices = l->CoordIndex();
-  
-  std::list<cgal_face_t> face_list;
-  
-  for(std::vector< std::vector<int> >::const_iterator it = indices.begin(); it != indices.end(); ++ it) {
-    const std::vector<int>& tri = *it;
-    if (tri.size() != 3) {
-      Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on CoordIndex", l);
-      return false;
-    }
-    
-    const int min_index = *std::min_element(tri.begin(), tri.end());
-    const int max_index = *std::max_element(tri.begin(), tri.end());
-    
-    if (min_index < 1 || max_index > (int) points.size()) {
-      Logger::Message(Logger::LOG_ERROR, "Contents of CoordIndex out of bounds", l);
-      return false;
-    }
-    
-    const Kernel_::Point_3& a = points[tri[0] - 1]; // account for zero- vs
-    const Kernel_::Point_3& b = points[tri[1] - 1]; // one-based indices in
-    const Kernel_::Point_3& c = points[tri[2] - 1]; // c++ and express
-    
-    face_list.push_back(cgal_face_t());
-    face_list.back().outer.push_back(a);
-    face_list.back().outer.push_back(b);
-    face_list.back().outer.push_back(c);
-  }
-  
-  shape = create_polyhedron(face_list);
-  return true;
-}
-#endif
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcHalfSpaceSolid* l, cgal_shape_t& shape) {
-  IfcSchema::IfcSurface* surface = l->BaseSurface();
-  if ( ! surface->as<IfcSchema::IfcPlane>() ) {
-    Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface);
-    return false;
-  }
-  cgal_plane_t pln;
-  IfcGeom::CgalKernel::convert((IfcSchema::IfcPlane*)surface,pln);
-  
-  // TODO: Don't fully understand the logic here. Might be incorrect.
-  if (l->AgreementFlag()) pln = pln.opposite();
-//  const gp_Pnt pnt = pln.Location().Translated( l->AgreementFlag() ? -pln.Axis().Direction() : pln.Axis().Direction());
-//  shape = BRepPrimAPI_MakeHalfSpace(BRepBuilderAPI_MakeFace(pln),pnt).Solid();
-  
-  // TODO: For now we do nothing and process halfspaces in IfcBooleanResult, which likely doesn't capture all cases.
-  // Find a better solution later (with an abstract shape class?)
-  shape = CGAL::Polyhedron_3<Kernel_>();
-  return true;
-}

src/ifcgeom/kernels/cgal/CgalIfcGeomShapesWithStyles.cpp

@@ -1,166 +0,0 @@
-#include "CgalKernel.h"
-#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
-
-#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRepresentation* l, ConversionResults& 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 (shape_type(representation_item) == ST_SHAPELIST) {
-        part_succes |= convert_shapes(*it, shapes);
-      } else {
-        cgal_shape_t s;
-        if (convert_shape(representation_item, s)) {
-          shapes.push_back(ConversionResult(representation_item->data().id(), new CgalShape(s), get_style(representation_item)));
-          part_succes |= true;
-        }
-      }
-    }
-  }
-  return part_succes;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcGeometricSet* l, ConversionResults& 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;
-    cgal_shape_t s;
-    if (convert_shape(element, s)) {
-      part_succes = true;
-      const IfcGeom::SurfaceStyle* style = 0;
-      if (element->as<IfcSchema::IfcPoint>()) {
-        style = get_style((IfcSchema::IfcPoint*) element);
-      } else if (element->as<IfcSchema::IfcCurve>()) {
-        style = get_style((IfcSchema::IfcCurve*) element);
-      } else if (element->as<IfcSchema::IfcSurface>()) {
-        style = get_style((IfcSchema::IfcSurface*) element);
-      }
-      shapes.push_back(ConversionResult(element->data().id(), new CgalShape(s), style ? style : parent_style));
-    }
-  }
-  return part_succes;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, ConversionResults& shapes) {
-  IfcEntityList::ptr shells = l->SbsmBoundary();
-  const SurfaceStyle* collective_style = get_style(l);
-  for( IfcEntityList::it it = shells->begin(); it != shells->end(); ++ it ) {
-    cgal_shape_t s;
-    const SurfaceStyle* shell_style = 0;
-    if ((*it)->as<IfcSchema::IfcRepresentationItem>()) {
-      shell_style = get_style((IfcSchema::IfcRepresentationItem*)*it);
-    }
-    if (convert_shape(*it,s)) {
-      shapes.push_back(ConversionResult((*it)->data().id(), new CgalShape(s), shell_style ? shell_style : collective_style));
-    }
-  }
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, ConversionResults& shape) {
-  cgal_shape_t s;
-  const SurfaceStyle* collective_style = get_style(l);
-  const SurfaceStyle* indiv_style = get_style(l->Outer());
-  
-  if (convert_shape(l->Outer(),s) ) {
-    IfcSchema::IfcClosedShell::list::ptr voids(new IfcSchema::IfcClosedShell::list);
-    if (l->as<IfcSchema::IfcFacetedBrepWithVoids>()) {
-      voids = l->as<IfcSchema::IfcFacetedBrepWithVoids>()->Voids();
-    }
-#ifdef USE_IFC4
-    if (l->as<IfcSchema::IfcAdvancedBrepWithVoids>()) {
-      voids = l->as<IfcSchema::IfcAdvancedBrepWithVoids>()->Voids();
-    }
-#endif
-
-    if (voids->size()) {
-      CGAL::Nef_polyhedron_3<Kernel_> nef_s = create_nef_polyhedron(s);
-      
-      for (IfcSchema::IfcClosedShell::list::it it = voids->begin(); it != voids->end(); ++it) {
-        cgal_shape_t s2;
-        if (convert_shape(*it, s2)) {
-          nef_s -= CGAL::Nef_polyhedron_3<Kernel_>(s2);
-        }
-      }
-      
-      s = create_polyhedron(nef_s);
-    }
-    
-    shape.push_back(ConversionResult(l->data().id(), new CgalShape(s), indiv_style ? indiv_style : collective_style));
-    return true;
-  }
-  return false;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcMappedItem* l, ConversionResults& shapes) {
-  cgal_placement_t gtrsf;
-  IfcSchema::IfcCartesianTransformationOperator* transform = l->MappingTarget();
-  if ( transform->as<IfcSchema::IfcCartesianTransformationOperator3DnonUniform>() ) {
-    IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator3DnonUniform*)transform,gtrsf);
-  } else if ( transform->as<IfcSchema::IfcCartesianTransformationOperator2DnonUniform>() ) {
-    IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator2DnonUniform*)transform,gtrsf);
-  } else if ( transform->as<IfcSchema::IfcCartesianTransformationOperator3D>() ) {
-    IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator3D*)transform,gtrsf);
-  } else if ( transform->as<IfcSchema::IfcCartesianTransformationOperator2D>() ) {
-    IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator2D*)transform,gtrsf);
-  }
-  IfcSchema::IfcRepresentationMap* map = l->MappingSource();
-  IfcSchema::IfcAxis2Placement* placement = map->MappingOrigin();
-  cgal_placement_t trsf;
-  if (placement->as<IfcSchema::IfcAxis2Placement3D>()) {
-    IfcGeom::CgalKernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
-  } else {
-    cgal_placement_t trsf_2d;
-    IfcGeom::CgalKernel::convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf_2d);
-    trsf = trsf_2d;
-  }
-  
-  // TODO: Check
-  gtrsf = trsf * gtrsf;
-  
-  //  std::cout << std::endl;
-  //  for (int i = 0; i < 3; ++i) {
-  //    for (int j = 0; j < 4; ++j) {
-  //      std::cout << gtrsf.cartesian(i, j) << " ";
-  //    } std::cout << std::endl;
-  //  }
-  
-  const IfcGeom::SurfaceStyle* mapped_item_style = get_style(l);
-  
-  const size_t previous_size = shapes.size();
-  bool b = convert_shapes(map->MappedRepresentation(), shapes);
-  
-  for (size_t i = previous_size; i < shapes.size(); ++ i ) {
-    IfcGeom::CgalPlacement place(gtrsf);
-    shapes[i].prepend(&place);
-    
-    // Apply styles assigned to the mapped item only if on
-    // a more granular level no styles have been applied
-    if (!shapes[i].hasStyle()) {
-      shapes[i].setStyle(mapped_item_style);
-    }
-  }
-  
-  return b;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcFaceBasedSurfaceModel* l, ConversionResults& shapes) {
-  bool part_success = false;
-  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 ) {
-    cgal_shape_t s;
-    const SurfaceStyle* shell_style = get_style(*it);
-    if (convert_shape(*it,s)) {
-      shapes.push_back(ConversionResult((*it)->data().id(), new CgalShape(s), shell_style ? shell_style : collective_style));
-      part_success |= true;
-    }
-  }
-  return part_success;
-}

src/ifcgeom/kernels/cgal/CgalIfcGeomWires.cpp

@@ -1,336 +0,0 @@
-// For MSVC to have M_PI
-#define _USE_MATH_DEFINES
-#include <cmath>
-
-#include "CgalKernel.h"
-#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
-
-#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcPolyLoop* l, cgal_wire_t& result) {
-  IfcSchema::IfcCartesianPoint::list::ptr points = l->Polygon();
-  
-  // Parse and store the points in a sequence
-  cgal_wire_t polygon = std::vector<Kernel_::Point_3>();
-  for(IfcSchema::IfcCartesianPoint::list::it it = points->begin(); it != points->end(); ++ it) {
-    cgal_point_t pnt;
-    IfcGeom::CgalKernel::convert(*it, pnt);
-    polygon.push_back(pnt);
-  }
-  
-  // A loop should consist of at least three vertices
-  std::size_t original_count = polygon.size();
-  if (original_count < 3) {
-    Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l);
-    return false;
-  }
-  
-  // Remove points that are too close to one another
-  remove_duplicate_points_from_loop(polygon);
-  
-  std::size_t count = polygon.size();
-  if (original_count - count != 0) {
-    std::stringstream ss; ss << (original_count - count) << " edges removed for:";
-    Logger::Message(Logger::LOG_WARNING, ss.str(), l);
-  }
-  
-  if (count < 3) {
-    Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l);
-    return false;
-  }
-  
-  result = polygon;
-  
-  //  std::cout << "PolyLoop: " << std::endl;
-  //  for (auto &point: polygon) {
-  //    std::cout << "\tPoint(" << point << ")" << std::endl;
-  //  }
-  
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcPolyline* l, cgal_wire_t& result) {
-  IfcSchema::IfcCartesianPoint::list::ptr points = l->Points();
-  
-  // Parse and store the points in a sequence
-  cgal_wire_t polygon = std::vector<Kernel_::Point_3>();
-  for(IfcSchema::IfcCartesianPoint::list::it it = points->begin(); it != points->end(); ++ it) {
-    cgal_point_t pnt;
-    IfcGeom::CgalKernel::convert(*it, pnt);
-    polygon.push_back(pnt);
-  }
-  
-  // Remove points that are too close to one another
-  remove_duplicate_points_from_loop(polygon);
-  
-  result = polygon;
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcEdgeLoop* l, cgal_wire_t& result) {
-  IfcSchema::IfcOrientedEdge::list::ptr li = l->EdgeList();
-  cgal_wire_t mw;
-  for (IfcSchema::IfcOrientedEdge::list::it it = li->begin(); it != li->end(); ++it) {
-    cgal_wire_t w;
-    if (convert_wire(*it, w)) {
-      // TODO: What to do here? Add some points only?
-//      mw.Add(TopoDS::Edge(TopoDS_Iterator(w).Value()));
-      return false;
-    }
-  }
-  result = mw;
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcOrientedEdge* l, cgal_wire_t& result) {
-  if (convert_wire(l->EdgeElement(), result)) {
-    if (!l->Orientation()) {
-      std::reverse(result.begin(),result.end());
-    }
-    return true;
-  } else {
-    return false;
-  }
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcEdge* l, cgal_wire_t& result) {
-  if (!l->EdgeStart()->as<IfcSchema::IfcVertexPoint>() || !l->EdgeEnd()->as<IfcSchema::IfcVertexPoint>()) {
-    Logger::Message(Logger::LOG_ERROR, "Only IfcVertexPoints are supported for EdgeStart and -End", l);
-    return false;
-  }
-  
-  IfcSchema::IfcPoint* pnt1 = ((IfcSchema::IfcVertexPoint*) l->EdgeStart())->VertexGeometry();
-  IfcSchema::IfcPoint* pnt2 = ((IfcSchema::IfcVertexPoint*) l->EdgeEnd())->VertexGeometry();
-  if (!pnt1->as<IfcSchema::IfcCartesianPoint>() || !pnt2->as<IfcSchema::IfcCartesianPoint>()) {
-    Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l);
-    return false;
-  }
-  
-  cgal_point_t p1, p2;
-  if (!convert(((IfcSchema::IfcCartesianPoint*)pnt1), p1) ||
-      !convert(((IfcSchema::IfcCartesianPoint*)pnt2), p2))
-  {
-    return false;
-  }
-  
-  cgal_wire_t mw;
-  mw.push_back(p1);
-  mw.push_back(p2);
-  
-  result = mw;
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCompositeCurve* l, cgal_wire_t& wire) {
-  if ( getValue(GV_PLANEANGLE_UNIT)<0 ) {
-    Logger::Message(Logger::LOG_WARNING,"Creating a composite curve without unit information:",l);
-    
-    // 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
-    cgal_wire_t wire_radians, wire_degrees;
-    try {
-		    succes_radians = IfcGeom::CgalKernel::convert(l,wire_radians);
-    } catch (...) {}
-    
-    // Now try degrees
-    setValue(GV_PLANEANGLE_UNIT,0.0174532925199433);
-    try {
-		    succes_degrees = IfcGeom::CgalKernel::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.back() == wire_degrees.front() && wire_radians.back() != wire_radians.front() ) {
-        use_degrees = true;
-      } else if ( wire_radians.back() == wire_radians.front() && wire_degrees.back() != wire_degrees.front() ) {
-        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();
-  cgal_wire_t w;
-  //TopoDS_Vertex last_vertex;
-  for( IfcSchema::IfcCompositeCurveSegment::list::it it = segments->begin(); it != segments->end(); ++ it ) {
-    IfcSchema::IfcCurve* curve = (*it)->ParentCurve();
-    cgal_wire_t wire2;
-    if ( !convert_wire(curve,wire2) ) {
-      Logger::Message(Logger::LOG_ERROR,"Failed to convert curve:",curve);
-      continue;
-    }
-    if ( ! (*it)->SameSense() ) std::reverse(wire2.begin(),wire2.end());
-    
-    if (wire2.empty()) {
-      continue;
-    } else if (w.empty()) {
-      w = wire2;
-    } else if (w.back() == w.front()) {
-      std::vector<Kernel_::Point_3>::const_iterator vertex = wire2.begin();
-      ++vertex;
-      while (vertex != wire2.end()) {
-        w.push_back(*vertex);
-        ++vertex;
-      }
-    } else {
-      for (auto &vertex: wire2) w.push_back(vertex);
-    }
-  }
-  
-  remove_duplicate_points_from_loop(w);
-  
-  wire = w;
-  return true;
-}
-
-bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrimmedCurve* l, cgal_wire_t& wire) {
-  IfcSchema::IfcCurve* basis_curve = l->BasisCurve();
-  bool isConic = basis_curve->as<IfcSchema::IfcConic>();
-  double parameterFactor = isConic ? getValue(GV_PLANEANGLE_UNIT) : getValue(GV_LENGTH_UNIT);
-  cgal_curve_t 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();
-  unsigned sense_agreement = l->SenseAgreement() ? 0 : 1;
-  double flts[2];
-  cgal_point_t pnts[2];
-  bool has_flts[2] = {false,false};
-  bool has_pnts[2] = {false,false};
-  cgal_wire_t w;
-  for ( IfcEntityList::it it = trims1->begin(); it != trims1->end(); it ++ ) {
-    IfcUtil::IfcBaseClass* i = *it;
-    if ( i->as<IfcSchema::IfcCartesianPoint>() ) {
-      IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[sense_agreement] );
-      has_pnts[sense_agreement] = true;
-    } else if ( i->as<IfcSchema::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->as<IfcSchema::IfcCartesianPoint>() ) {
-      IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[1-sense_agreement] );
-      has_pnts[1-sense_agreement] = true;
-    } else if ( i->as<IfcSchema::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 ) {
-    // TODO: Project points to closest point in curve?
-    if ( CGAL::squared_distance(pnts[0], pnts[1]) < getValue(GV_WIRE_CREATION_TOLERANCE)*getValue(GV_WIRE_CREATION_TOLERANCE) ) {
-      Logger::Message(Logger::LOG_WARNING,"Skipping segment with length below tolerance level:",l);
-      return false;
-    }
-    if (l->SenseAgreement()) {
-      bool found = false;
-      int loops_to_go = 2;
-      std::vector<Kernel_::Point_3>::const_iterator point = curve.begin();
-      do {
-        if (!found) {
-          if (CGAL::squared_distance(*point, pnts[0]) < getValue(GV_WIRE_CREATION_TOLERANCE)*getValue(GV_WIRE_CREATION_TOLERANCE)) {
-            found = true;
-            w.push_back(*point);
-          }
-        } else {
-          w.push_back(*point);
-          if (CGAL::squared_distance(*point, pnts[1]) < getValue(GV_WIRE_CREATION_TOLERANCE)*getValue(GV_WIRE_CREATION_TOLERANCE)) {
-            break;
-          }
-        } ++point;
-        if (point == curve.end()) {
-          point = curve.begin();
-          --loops_to_go;
-        }
-      } while (point != curve.begin() && loops_to_go > 0);
-    } else {
-      bool found = false;
-      int loops_to_go = 2;
-      std::vector<Kernel_::Point_3>::const_reverse_iterator point = curve.rbegin();
-      do {
-        if (!found) {
-          if (CGAL::squared_distance(*point, pnts[0]) < getValue(GV_WIRE_CREATION_TOLERANCE)*getValue(GV_WIRE_CREATION_TOLERANCE)) {
-            found = true;
-            w.push_back(*point);
-          }
-        } else {
-          w.push_back(*point);
-          if (CGAL::squared_distance(*point, pnts[1]) < getValue(GV_WIRE_CREATION_TOLERANCE)*getValue(GV_WIRE_CREATION_TOLERANCE)) {
-            break;
-          }
-        } ++point;
-        if (point == curve.rend() && loops_to_go > 0) point = curve.rbegin();
-      } while (point != curve.rbegin());
-    }
-  }
-  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->as<IfcSchema::IfcLine>() ) {
-      IfcSchema::IfcLine* line = static_cast<IfcSchema::IfcLine*>(basis_curve);
-      const double magnitude = line->Dir()->Magnitude();
-      flts[0] *= magnitude; flts[1] *= magnitude;
-    }
-    if ( isConic && ALMOST_THE_SAME(fmod(flts[1]-flts[0],M_PI*2.),0.) ) {
-      for (auto &point: curve) w.push_back(point);
-    } else {
-      const int segments_of_full_curve = 12;
-      double segment_angle = 2.0*3.141592653589793/segments_of_full_curve;
-      if ( basis_curve->as<IfcSchema::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);
-        for (double current_angle = flts[0]; current_angle < flts[1]; current_angle += segment_angle) {
-          w.push_back(Kernel_::Point_3(x*cos(current_angle), y*sin(current_angle), 0));
-        } w.push_back(Kernel_::Point_3(x*cos(flts[1]), y*sin(flts[1]), 0));
-      } if ( basis_curve->as<IfcSchema::IfcCircle>() ) {
-        IfcSchema::IfcCircle* circle = static_cast<IfcSchema::IfcCircle*>(basis_curve);
-        double r = circle->Radius() * getValue(GV_LENGTH_UNIT);
-        for (double current_angle = flts[0]; current_angle < flts[1]; current_angle += segment_angle) {
-          w.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-        } w.push_back(Kernel_::Point_3(r*cos(flts[1]), r*sin(flts[1]), 0));
-      }
-    }
-  } else if ( trim_cartesian_failed && (has_pnts[0] && has_pnts[1]) ) {
-    w.push_back(pnts[0]);
-    w.push_back(pnts[1]);
-  }
-  wire = w;
-  return true;
-}