Refactoring

Multithreaded

.gitignore

@@ -0,0 +1,16 @@
+# 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

@@ -0,0 +1,7 @@
+[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

@@ -0,0 +1,66 @@
+language: cpp
+compiler: gcc
+os: linux
+dist: xenial
+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.55;/usr/lib/x86_64-linux-gnu/libicudata.so.55" \
+    -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

COPYING.LESSER

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

README.md

@@ -1,26 +1,183 @@
+About this branch 
+=================
+
+This version splits the geometry interpretation process into two steps (a) map IFC to a smaller set of schema-agnostic definitions (`ifcopenshell::geometry::taxonomy`) (b) convert these into explicit breps or polyhedra with Open CASCADE or CGAL.
+
+Three validation options are added to IfcConvert for (a) storey containment (b) wall connectivity (c) space boundaries.
+
 IfcOpenShell 
 ============
-open source (LGPL) software library for working with the IFC file format
+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)
 
-http://IfcOpenShell.org
+[![Build Status](https://api.travis-ci.org/IfcOpenShell/IfcOpenShell.png)](https://api.travis-ci.org/IfcOpenShell/IfcOpenShell)
 
-About this repository
-=====================
+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)
 
-This is an initiative to expose the functionality of IfcOpenShell for parsing and writing IFC files to a Python interface. The creation of a topological representation for building elements using Open Cascade is also wrapped by returning a string serialization of the Open Cascade TopoDS_Shape. Using SWIG, a wrapper is obtained for a C++ Class which evaluates its Express attribute names at runtime. The functions created by the SWIG wrapper closely resemble the C++ structure. An additional Python wrapper around these functions is created that is more idiomatic to Python.
+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.
 
-The following interactive session illustrates its use:
+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]
-    >>> brep_data = ifcopenshell.create_shape(wall, ifcopenshell.SEW_SHELLS)
     >>> len(wall) # number of EXPRESS attributes
     8
-    >>> wall.GlobalId
+    >>>
+    >>> # Accessing EXPRESS attributes by name:
+    >>> wall.GlobalId 
     '2O2Fr$t4X7Zf8NOew3FL9r'
     >>> wall.Name = "My wall"
     >>> wall.NonExistingAttr
@@ -42,8 +199,11 @@ The following interactive session illustrates its use:
       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'
@@ -52,81 +212,22 @@ The following interactive session illustrates its use:
     >>> 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")
 
-
-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
-
-
-Ubuntu Notes
-============
-
-The following sequence of commands has been tested successfully on Ubuntu 14.04.
-
-OCE installation. This step worked OK with cmake 2.8.12.2, gcc 4.8.2, g++ 4.8.2. Also, it might take up to an hour to complete.
-
-    apt-get install git cmake gcc g++ libftgl-dev libtbb2 libtbb-dev libboost-all-dev
-    cd /
-    mkdir git && cd git
-    git clone https://github.com/tpaviot/oce.git
-    mkdir oceBuild && cd oceBuild
-    cmake ../oce
-    make -j4
-    sudo make install
-    
-IfcOpenShell installation. This step worked OK with cmake 2.8.12.2, gcc 4.8.2, g++ 4.8.2.
-
-    apt-get install swig
-    cd /git/
-    git clone https://github.com/aothms/IfcOpenShell.git
-    cd IfcOpenShell/cmake
-    mkdir build && cd build
-    cmake ../
-    make -j4
-    
-Once done, IfcConvert is to be found in the build folder.
-    
+[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,230 +1,815 @@
-cmake_minimum_required (VERSION 2.6)
+################################################################################
+#                                                                              #
+# 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 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)  # not necessary, but encouraged
+
 project (IfcOpenShell)
 
-FIND_PACKAGE(Boost REQUIRED COMPONENTS program_options)
+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." OFF)
+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)
+UNIFY_ENVVARS_AND_CACHE(EIGEN_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})
 MESSAGE(STATUS "Boost include files found in ${Boost_INCLUDE_DIRS}")
 MESSAGE(STATUS "Boost libraries found in ${Boost_LIBRARY_DIRS}")
 
-# 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}")
+# 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}")
 	MESSAGE(STATUS "Use OCC_INCLUDE_DIR to specify another directory")
 ELSE()
-	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}")
+	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}")
 ENDIF()
 
-FIND_FILE(gp_Pnt_hxx "gp_Pnt.hxx" ${OCC_INCLUDE_DIR} /usr/inc /usr/local/inc /usr/local/include/oce)
+FIND_FILE(gp_Pnt_hxx "gp_Pnt.hxx" ${OCC_INCLUDE_DIR})
 IF(gp_Pnt_hxx)
 	MESSAGE(STATUS "Header files found")
 ELSE()
 	MESSAGE(FATAL_ERROR "Unable to find header files, aborting")
 ENDIF()
 
-# Find Open CASCADE library files
-IF("$ENV{OCC_LIBRARY_DIR}" STREQUAL "") 
+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 "")
 	SET(OCC_LIBRARY_DIR "/usr/lib/" CACHE FILEPATH "Open CASCADE library files")
-	MESSAGE(STATUS "Looking for opencascade library files in: ${OCC_LIBRARY_DIR}")
+	MESSAGE(STATUS "Looking for Open CASCADE library files in: ${OCC_LIBRARY_DIR}")
 	MESSAGE(STATUS "Use OCC_LIBRARY_DIR to specify another directory")
 ELSE()
-	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}")
+	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}")
 ENDIF()
 
-FIND_LIBRARY(libTKernel "TKernel" ${OCC_LIBRARY_DIR} /usr/lib /usr/lib64 /usr/local/lib /usr/local/lib64)
+FIND_LIBRARY(libTKernel NAMES TKernel TKerneld PATHS ${OCC_LIBRARY_DIR} NO_DEFAULT_PATH)
 IF(libTKernel)
 	MESSAGE(STATUS "Library files found")
 ELSE()
 	MESSAGE(FATAL_ERROR "Unable to find library files, aborting")
 ENDIF()
 
-IF("$ENV{ICU_INCLUDE_DIR}" STREQUAL "")
-    MESSAGE(STATUS "No ICU include directory specified")
-ElSE()
-    SET(ICU_INCLUDE_DIR CACHE FILEPATH "ICU header files")
-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_LIBRARY_DIR}" STREQUAL "")
-    MESSAGE(STATUS "No ICU library directory specified")
-ElSE()
-    SET(ICU_LIBRARY_DIR CACHE FILEPATH "ICU library files")
-ENDIF()
+list(APPEND GEOMETRY_KERNELS opencascade)
 
-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)
+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")
 ELSE()
-    MESSAGE(STATUS "Unable to find ICU library files, continuing")	
+	SET(CGAL_INCLUDE_DIR ${CGAL_INCLUDE_DIR} CACHE FILEPATH "CGAL header files")
+	MESSAGE(STATUS "Looking for CGAL include files in: ${CGAL_INCLUDE_DIR}")
 ENDIF()
-
-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
-    )
+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")
 ELSE()
-    MESSAGE(STATUS "OpenCOLLADA header files not found, continuing without COLLADA support")
+	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")
 ENDIF()
 
-INCLUDE(CheckIncludeFileCXX)
+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()
 
-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)
+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()
 
-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)
+# 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?
+    if(NOT APPLE)
+        set(OPENCASCADE_LIBRARIES -Wl,--start-group ${OPENCASCADE_LIBRARIES} -Wl,--end-group ${CMAKE_THREAD_LIBS_INIT})
+    endif()
+    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()
 
 IF(NOT CMAKE_BUILD_TYPE)
- 	SET(CMAKE_BUILD_TYPE "Release")
-ENDIF(NOT CMAKE_BUILD_TYPE)
-
-IF(MSVC)
-    ADD_DEFINITIONS(-D_UNICODE)
-ElSE(MSVC)
-    ADD_DEFINITIONS(-fPIC -Wno-non-virtual-dtor)
-ENDIF(MSVC)
-
-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})
-
-ADD_LIBRARY(IfcParse STATIC 
-  ../src/ifcparse/Ifc2x3.cpp
-  ../src/ifcparse/Ifc4.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
-  
-  ../src/ifcparse/Ifc2x3-rt.cpp
-  ../src/ifcparse/Ifc4-rt.cpp
-  ../src/ifcparse/IfcUntypedEntity.cpp
-)
-
-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
-)
-
-IF(icu)
-    TARGET_LINK_LIBRARIES(IfcParse icuuc)
+	SET(CMAKE_BUILD_TYPE "Release")
 ENDIF()
 
-TARGET_LINK_LIBRARIES(IfcGeom IfcParse)
+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()
 
-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(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_EXECUTABLE(IfcConvert 
-    ../src/ifcconvert/ColladaSerializer.cpp
-    ../src/ifcconvert/IfcConvert.cpp
-    ../src/ifcconvert/OpenCascadeBasedSerializer.cpp
-    ../src/ifcconvert/WavefrontObjSerializer.cpp   
+	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()
+
+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} ${EIGEN_DIR}
 )
 
-TARGET_LINK_LIBRARIES (IfcConvert IfcParse IfcGeom TKernel TKMath TKBRep TKGeomBase TKGeomAlgo TKG3d TKG2d TKShHealing TKTopAlgo TKMesh TKPrim TKBool TKBO TKFillet TKSTEP TKSTEPBase TKSTEPAttr TKXSBase TKSTEP209 TKIGES TKOffset ${Boost_LIBRARIES} ${OPENCOLLADA_LIBRARIES})
+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()
 
-ADD_EXECUTABLE(IfcGeomServer
-    ../src/ifcgeomserver/IfcGeomServer.cpp
+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} geometry_mapping_ifc${s})
+	endforeach()
+	set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} IfcGeom geometry_mappings ${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/kernels/${kernel}/*.h)
+file(GLOB IFCGEOM_CPP_FILES ../src/ifcgeom/kernels/${kernel}/*.cpp)
+set(IFCGEOM_FILES ${IFCGEOM_CPP_FILES} ${IFCGEOM_H_FILES})
+
+add_library(geometry_kernel_${kernel} STATIC ${IFCGEOM_FILES})
+set_target_properties(geometry_kernel_${kernel} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS")
+target_link_libraries(geometry_kernel_${kernel} ${${KERNEL_UPPER}_LIBRARIES})
+list(APPEND kernel_libraries geometry_kernel_${kernel})
+
+endforeach()
+
+file(GLOB SCHEMA_AGNOSTIC_H_FILES ../src/ifcgeom/kernel_agnostic/*.h)
+file(GLOB SCHEMA_AGNOSTIC_CPP_FILES ../src/ifcgeom/kernel_agnostic/*.cpp)
+set(SCHEMA_AGNOSTIC_FILES ${SCHEMA_AGNOSTIC_H_FILES} ${SCHEMA_AGNOSTIC_CPP_FILES})
+
+add_library(geometry_kernels ${SCHEMA_AGNOSTIC_FILES})
+set_target_properties(geometry_kernels PROPERTIES COMPILE_FLAGS -DIFC_GEOM_EXPORTS)
+target_link_libraries(geometry_kernels ${kernel_libraries})
+
+foreach(schema ${SCHEMA_VERSIONS})
+
+file(GLOB IFCGEOM_I_FILES ../src/ifcgeom/schema/*.i)
+file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/schema/*.h)
+file(GLOB IFCGEOM_CPP_FILES ../src/ifcgeom/schema/*.cpp)
+set(IFCGEOM_FILES ${IFCGEOM_CPP_FILES} ${IFCGEOM_H_FILES} ${IFCGEOM_I_FILES})
+
+add_library(geometry_mapping_ifc${schema} STATIC ${IFCGEOM_FILES})
+set_target_properties(geometry_mapping_ifc${schema} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIfcSchema=Ifc${schema}")
+target_link_libraries(geometry_mapping_ifc${schema} IfcParse)
+list(APPEND mapping_libraries geometry_mapping_ifc${schema})
+
+endforeach()
+
+file(GLOB SCHEMA_AGNOSTIC_H_FILES ../src/ifcgeom/*.h)
+file(GLOB SCHEMA_AGNOSTIC_CPP_FILES ../src/ifcgeom/*.cpp)
+set(SCHEMA_AGNOSTIC_FILES ${SCHEMA_AGNOSTIC_H_FILES} ${SCHEMA_AGNOSTIC_CPP_FILES})
+
+add_library(geometry_mappings ${SCHEMA_AGNOSTIC_FILES})
+set_target_properties(geometry_mappings PROPERTIES COMPILE_FLAGS -DIFC_GEOM_EXPORTS)
+target_link_libraries(geometry_mappings ${mapping_libraries})
+
+if (UNIX)
+find_package(Threads)
+endif()
+
+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)
+target_link_libraries(IfcGeom geometry_mappings geometry_kernels ${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/IfcConvert.cpp)
+file(GLOB IFCCONVERT_H_FILES ../src/ifcconvert/skip-for-now.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} ${OPENCASCADE_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}
 )
 
-TARGET_LINK_LIBRARIES (IfcGeomServer IfcParse IfcGeom TKernel TKMath TKBRep TKGeomBase TKGeomAlgo TKG3d TKG2d TKShHealing TKTopAlgo TKMesh TKPrim TKBool TKBO TKFillet TKSTEP TKSTEPBase TKSTEPAttr TKXSBase TKSTEP209 TKIGES TKOffset)
+endif(BUILD_CONVERT)
 
-# Build python wrapper using separate CMakeLists.txt
-ADD_SUBDIRECTORY(../src/ifcwrap ifcwrap)
+# IfcGeomServer
+if(BUILD_GEOMSERVER)
 
-# Build IfcParseExamples using separate CMakeLists.txt
-ADD_SUBDIRECTORY(../src/examples examples)
+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} ${OPENCASCADE_LIBRARIES} ${Boost_LIBRARIES} ${VOXEL_LIBRARIES})
 
-# ADD_SUBDIRECTORY(../src/qtviewer qtviewer)
+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}
+)
+
+endif()
+
+IF(BUILD_IFCPYTHON)
+	ADD_SUBDIRECTORY(../src/ifcwrap ifcwrap)
+ENDIF()
+
+IF(BUILD_EXAMPLES)
+	ADD_SUBDIRECTORY(../src/examples examples)
+ENDIF()
+
+IF(BUILD_IFCMAX)
+	ADD_SUBDIRECTORY(../src/ifcmax ifcmax)
+ENDIF()
 
 # CMake installation targets
-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/IfcGeomRenderStyles.h
-    ../src/ifcgeom/IfcRepresentationShapeItem.h
+INSTALL(FILES ${IFCPARSE_H_FILES} 
+	DESTINATION ${INCLUDEDIR}/ifcparse
 )
-SET(include_files_parse
-    ../src/ifcparse/Ifc2x3.h
-    ../src/ifcparse/Ifc2x3enum.h
-    ../src/ifcparse/Ifc4.h
-    ../src/ifcparse/Ifc4enum.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
 
-    ../src/ifcparse/Ifc2x3-rt.h
-    ../src/ifcparse/Ifc4-rt.h
-    ../src/ifcparse/IfcUntypedEntity.h
-    ../src/ifcparse/IfcEntityDescriptor.h
+INSTALL(TARGETS IfcParse
+	ARCHIVE DESTINATION ${LIBDIR}
+	LIBRARY DESTINATION ${LIBDIR}
+	RUNTIME DESTINATION ${BINDIR}
 )
-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)
+
+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}
+		geometry_mappings ${mapping_libraries}
+		geometry_kernels ${kernel_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()

conda/bld.bat

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,34 @@
+# 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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,825 @@
+#!/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="5.2"
+
+# 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', 'eigen'),
+    'IfcConvert': ('IfcGeom',  'OpenCOLLADA', 'json'),
+    'OpenCOLLADA': ('libxml2',  'pcre'),
+    'IfcGeomServer': ('IfcGeom', ),
+    'IfcOpenShell-Python': ('python',  'swig',  'IfcGeom'),
+    'voxel': ('occ',),
+    'swig': ('pcre',),
+    'occ': (),
+}
+
+def v(dep):
+   yield dep
+   for d in dependency_tree.get(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(tuple(dependency_tree.keys()) + sum(dependency_tree.values(), ()))
+    
+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", "cmake"]:
+    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
+    # @todo this is already in v0.6
+    cmake_path = "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"] + (['--with-toolset=clang'] if "clang" in os.environ.get('CXX', '') else []), 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
+
+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 "eigen" in targets:
+    git_clone_or_pull_repository("https://gitlab.com/libeigen/eigen.git", "{DEPS_DIR}/install/eigen-3.3.7".format(**locals()), revision="3.3.7")
+
+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(' '))) + \
+            (["toolset=clang"] if "clang" in os.environ.get('CXX', '') else []) +\
+            ["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",
+        # applied upstream
+        # patch="./patches/cgal/cgal_4768.patch",
+        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),
+            # for now as the IfOpSh CMakeL expects libraries, we can probably safely turn this off though
+            "-DCGAL_HEADER_ONLY=OFF",            
+            "-DBUILD_SHARED_LIBS=Off"],
+        download_url="https://github.com/CGAL/cgal.git",
+        download_name="cgal",
+        download_tool=download_tool_git,
+        revision="v{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()),
+    "-DEIGEN_DIR="                     "{DEPS_DIR}/install/eigen-3.3.7".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()),
+        "-DUSE_CGAL=ON"
+    ])
+
+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,
+                "-DUSE_CGAL=ON",
+                "-DEIGEN_DIR="               "{DEPS_DIR}/install/eigen-3.3.7".format(**locals()),
+                "-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/cgal/cgal_4768.patch

@@ -0,0 +1,38 @@
+From a86712d1aae9a1a6d2004db3fc8fcdac6ef6b782 Mon Sep 17 00:00:00 2001
+From: Thomas Krijnen <t.krijnen@gmail.com>
+Date: Sun, 7 Jun 2020 15:25:18 +0200
+Subject: [PATCH] Don't segfault on empty Nef_nary_x
+
+---
+ Nef_3/include/CGAL/Nef_nary_intersection_3.h | 3 ++-
+ Nef_3/include/CGAL/Nef_nary_union_3.h        | 3 ++-
+ 2 files changed, 4 insertions(+), 2 deletions(-)
+
+diff --git a/Nef_3/include/CGAL/Nef_nary_intersection_3.h b/Nef_3/include/CGAL/Nef_nary_intersection_3.h
+index 70fc5791fae..5178705dc2f 100644
+--- a/Nef_3/include/CGAL/Nef_nary_intersection_3.h
++++ b/Nef_3/include/CGAL/Nef_nary_intersection_3.h
+@@ -52,7 +52,8 @@ class Nef_nary_intersection_3 {
+   }
+ 
+   Polyhedron get_intersection() {
+-
++    if (queue.empty())
++      return empty;
+     while(queue.size() > 1)
+       intersect();
+     inserted = 0;
+diff --git a/Nef_3/include/CGAL/Nef_nary_union_3.h b/Nef_3/include/CGAL/Nef_nary_union_3.h
+index ecbbae2db59..c8663bb911b 100644
+--- a/Nef_3/include/CGAL/Nef_nary_union_3.h
++++ b/Nef_3/include/CGAL/Nef_nary_union_3.h
+@@ -52,7 +52,8 @@ class Nef_nary_union_3 {
+   }
+ 
+   Polyhedron get_union() {
+-
++    if (queue.empty())
++      return empty;
+     while(queue.size() > 1)
+       unite();
+     inserted = 0;

nix/patches/occt/88af392.patch

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,17 @@
+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,5 +1,30 @@
+################################################################################
+#                                                                              #
+# 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)
+TARGET_LINK_LIBRARIES(IfcParseExamples IfcParse)
+set_target_properties(IfcParseExamples PROPERTIES FOLDER Examples)
 
 ADD_EXECUTABLE(IfcOpenHouse IfcOpenHouse.cpp)
-TARGET_LINK_LIBRARIES (IfcOpenHouse IfcParse IfcGeom TKernel TKMath TKBRep TKGeomBase TKGeomAlgo TKG3d TKG2d TKShHealing TKTopAlgo TKMesh TKPrim TKBool TKBO TKFillet TKOffset)
+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)

src/examples/IfcAdvancedHouse.cpp

@@ -0,0 +1,177 @@
+/********************************************************************************
+ *                                                                              *
+ * 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,34 +28,40 @@
 
 #include <Geom_BSplineSurface.hxx>
 #include <BRepBuilderAPI_MakeFace.hxx>
-
 #include <Standard_Version.hxx>
 
-#ifdef USE_IFC4
-#include "../ifcparse/Ifc4.h"
-#else
-#include "../ifcparse/Ifc2x3.h"
-#endif
+#include <BRepGProp.hxx>
+#include <GProp_GProps.hxx>
 
-#include "../ifcparse/IfcUtil.h"
+#include <Precision.hxx>
+
+#define IfcSchema Ifc2x3
+#include "../ifcparse/macros.h"
+#include "../ifcparse/Ifc2x3.h"
+#include "../ifcparse/IfcBaseClass.h"
 #include "../ifcparse/IfcHierarchyHelper.h"
-#include "../ifcgeom/IfcGeom.h"
+
+#include "../ifcgeom/schema_agnostic/Serialization.h"
+
+#if USE_VLD
+#include <vld.h>
+#endif
 
 // Some convenience typedefs and definitions. 
 typedef std::string S;
-typedef IfcWrite::IfcGuidHelper guid;
+typedef IfcParse::IfcGlobalId guid;
 typedef std::pair<double, double> XY;
-boost::none_t const null = (static_cast<boost::none_t>(0));
+boost::none_t const null = boost::none;
 
 // The creation of Nurbs-surface for the IfcSite mesh, to be implemented lateron
 void createGroundShape(TopoDS_Shape& shape);
 
-int main(int argc, char** argv) {
+int main() {
 
 	// The IfcHierarchyHelper is a subclass of the regular IfcFile that provides several
 	// convenience functions for working with geometry in IFC files.
-	IfcHierarchyHelper file;
-	file.filename("IfcOpenHouse.ifc");
+	IfcHierarchyHelper<IfcSchema> file;
+	file.header().file_name().name("IfcOpenHouse.ifc");
 
 	// Start by adding a wall to the file, initially leaving most attributes blank.
 	IfcSchema::IfcWallStandardCase* south_wall = new IfcSchema::IfcWallStandardCase(
@@ -83,17 +89,23 @@ int main(int argc, char** argv) {
 	// An IfcOwnerHistory has been initialized as well, which should be assigned to the wall.
 	south_wall->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
 
-	// The wall will be shaped as a box, with the dimensions specified in millimeters.
-	IfcSchema::IfcProductDefinitionShape* south_wall_shape = file.addBox(10000, 360, 3000);
+	// 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 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());
+	south_wall->setObjectPlacement(file.addLocalPlacement(storey_placement));
 
 	// A pale white colour is assigned to the wall.
 	IfcSchema::IfcPresentationStyleAssignment* wall_colour = file.setSurfaceColour(
-		south_wall->Representation(), 0.75, 0.73, 0.68);
+		south_wall_shape, 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>(),
@@ -104,90 +116,125 @@ int main(int argc, char** argv) {
 	// 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, 0, 0, 0, file.getSingle<IfcSchema::IfcRepresentationContext>()));
-	footing->setObjectPlacement(file.addLocalPlacement(0, 2500, -2000));
+	footing->setRepresentation(file.addBox(10100, 5460, 2000));
+	footing->setObjectPlacement(file.addLocalPlacement(storey_placement, 0, 2500, -2000));
 	// The footing will have a dark gray colour
 	IfcSchema::IfcPresentationStyleAssignment* footing_colour = file.setSurfaceColour(footing->Representation(), 0.26, 0.22, 0.18);
 
 	// 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
+
+	// 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(-2500, 0, 400),
-		file.addBox(6000, 3630, 1600, 0, 0, 0, file.getSingle<IfcSchema::IfcRepresentationContext>()), null
+		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);
+	file.addEntity(west_opening);
 
 	// Relate the opening element to the wall.
 	IfcSchema::IfcRelVoidsElement* void_element = new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::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(3000, 0, 400),
-		file.addBox(1860, 3000, 1600, 0, 0, 0, file.getSingle<IfcSchema::IfcRepresentationContext>()), null
+		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));
+	file.addEntity(south_opening);
+	file.addEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, south_wall, south_opening));
 	
-	// Create a roof element
-	IfcSchema::IfcRoof* south_roof = new IfcSchema::IfcRoof(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("South roof"), null, null, 
-		0, 0, null, IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
-	
-	// The roof geometry is slanted 45 degrees by specifying a direction for the box extrusion
-	south_roof->setRepresentation(file.addBox(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)), file.getSingle<IfcSchema::IfcRepresentationContext>()));
-	south_roof->setObjectPlacement(file.addLocalPlacement(0, -400, 2700));
-	file.addBuildingProduct(south_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)));
+
+	// 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::IfcRoof* north_roof = new IfcSchema::IfcRoof(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("North roof"),
-		null, null, 0, 0, null, IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
-	north_roof->setOwnerHistory(file.getSingle<IfcSchema::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);
+	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);
 
-	// 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);
+	file.addBuildingProduct(south_roof_part);
+	file.addBuildingProduct(north_roof_part);
+	file.addBuildingProduct(roof);
+
+	file.setSurfaceColour(roof_rep, 0.24, 0.08, 0.04);
 
 	// Copy the south wall to the north
-	file.addBuildingProduct(new IfcSchema::IfcWallStandardCase(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("North wall"),
-		null, null, file.addLocalPlacement(0, 5000, 0), south_wall->Representation(), null
+	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);
+	}
 
 	// 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(4820, 2500, 0, 0, 0, 1, 0, 1, 0), file.addBox(5000, 360, 6000), null
+		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	
 	);
 	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(-4820, 2500, 0, 0, 0, 1, 0, -1, 0), east_wall->Representation(), null
+		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	
@@ -195,32 +242,52 @@ int main(int argc, char** argv) {
 	file.addBuildingProduct(west_wall);
 
 	// The west wall is assigned an opening element we created for the south wall, opening elements are
-	// not shared accross building elements, even if they share the same representation. Hence, the east
+	// not shared across 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, west_opening->ObjectPlacement(), west_opening->Representation(), null
+		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));
+	file.addEntity(west_opening_copy);
+	file.addEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::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);
-	IfcEntities geometrical_entities(new IfcEntityList());
-	IfcSchema::IfcProductDefinitionShape* ground_representation = IfcGeom::tesselate(shape, 100., geometrical_entities);
+	IfcSchema::IfcProductDefinitionShape* ground_representation = IfcGeom::tesselate(STRINGIFY(IfcSchema), shape, 100.)->as<IfcSchema::IfcProductDefinitionShape>();
 	file.getSingle<IfcSchema::IfcSite>()->setRepresentation(ground_representation);
-	file.AddEntities(geometrical_entities);
-	IfcSchema::IfcShapeRepresentation::list ground_reps = geometrical_entities->as<IfcSchema::IfcShapeRepresentation>();
-	for (IfcSchema::IfcShapeRepresentation::it it = ground_reps->begin(); it != ground_reps->end(); ++it) {
-		(*it)->setContextOfItems(file.getSingle<IfcSchema::IfcRepresentationContext>());
+
+	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"));
 	}
+	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
@@ -246,7 +313,7 @@ int main(int argc, char** argv) {
 		, null
 #endif
 	);
-	IfcSchema::IfcMaterialLayer::list layers (new IfcTemplatedEntityList<IfcSchema::IfcMaterialLayer>());
+	IfcSchema::IfcMaterialLayer::list::ptr layers (new IfcTemplatedEntityList<IfcSchema::IfcMaterialLayer>());
 	layers->push(layer);
 	IfcSchema::IfcMaterialLayerSet* layer_set = new IfcSchema::IfcMaterialLayerSet(
 		layers, 
@@ -271,17 +338,17 @@ int main(int argc, char** argv) {
 		null, 
 		null,
 #ifdef USE_IFC4
-		file.EntitiesByType<IfcSchema::IfcWallStandardCase>()->generalize(),
+		file.instances_by_type<IfcSchema::IfcWallStandardCase>()->generalize(),
 #else
-		file.EntitiesByType<IfcSchema::IfcWallStandardCase>()->as<IfcSchema::IfcRoot>(),
+		file.instances_by_type<IfcSchema::IfcWallStandardCase>()->as<IfcSchema::IfcRoot>(),
 #endif
 		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.
@@ -293,7 +360,7 @@ int main(int argc, char** argv) {
 	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(5050, 1000, 0, 0, 1, 0, 1, 0, 0),
+		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
@@ -304,19 +371,19 @@ int main(int argc, char** argv) {
 	file.setSurfaceColour(stair->Representation(), footing_colour);
 
 	IfcSchema::IfcOpeningElement* door_opening = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(5000-180, 2500-900, 0), file.addBox(1000, 1000, 2200), null
+		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));
+	file.addEntity(door_opening);
+	file.addEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::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(4800, 1600, 0, 0, 0, 1, 0, 1, 0), 0, null, 2200, 1000
+		file.addLocalPlacement(storey_placement, 4800, 1600, 0, 0, 0, 1, 0, 1, 0), 0, null, 2200, 1000
 #ifdef USE_IFC4
 		, IfcSchema::IfcDoorTypeEnum::IfcDoorType_DOOR
 		, IfcSchema::IfcDoorTypeOperationEnum::IfcDoorTypeOperation_SINGLE_SWING_LEFT
@@ -324,11 +391,11 @@ int main(int argc, char** argv) {
 #endif
 	);
 	door->setRepresentation(file.addBox(80, 80, 2120, 0, file.addPlacement3d(460, 0, 0)));
-	IfcSchema::IfcRepresentation::list door_representations = door->Representation()->Representations();
+	IfcSchema::IfcRepresentation::list::ptr door_representations = door->Representation()->Representations();
 	IfcSchema::IfcShapeRepresentation* door_body = 0;
-	for (IfcSchema::IfcRepresentation::it i = door_representations->begin(); i != door_representations->end(); ++i) {
+	for (IfcSchema::IfcRepresentation::list::it i = door_representations->begin(); i != door_representations->end(); ++i) {
 		IfcSchema::IfcRepresentation* rep = *i;
-		if (rep->is(IfcSchema::Type::IfcShapeRepresentation) && rep->RepresentationIdentifier() == "Body") {
+		if (rep->declaration().is(IfcSchema::IfcShapeRepresentation::Class()) && rep->RepresentationIdentifier() == "Body") {
 			door_body = (IfcSchema::IfcShapeRepresentation*) rep;
 		}
 	}
@@ -337,7 +404,11 @@ int main(int argc, char** argv) {
 	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));
+	file.addEntity(new IfcSchema::IfcRelFillsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, door_opening, door));
+
+	IfcSchema::IfcDoorStyle* door_style = new IfcSchema::IfcDoorStyle(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("Door type"), null, null, null, null, null,
+		IfcSchema::IfcDoorStyleOperationEnum::IfcDoorStyleOperation_SINGLE_SWING_LEFT, IfcSchema::IfcDoorStyleConstructionEnum::IfcDoorStyleConstruction_WOOD, false, false);
+	file.addRelatedObject<IfcSchema::IfcRelDefinesByType>(door_style, door);
 
 	// Surface styles are assigned to representation items, hence there is no real limitation to
 	// assign different colours within the same representation. However, some viewers have 
@@ -345,37 +416,44 @@ int main(int argc, char** argv) {
 	// 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 seperate beams.
+	// The window frame will consists of four separate 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::IfcProductDefinitionShape::list frame_representations (new IfcTemplatedEntityList<IfcSchema::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
+	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
 
 	// The beams all have the same surface style assigned
 	IfcSchema::IfcPresentationStyleAssignment* frame_style = 0;
-	for (IfcSchema::IfcProductDefinitionShape::it i = frame_representations->begin(); i != frame_representations->end(); ++i) {
+	for (IfcSchema::IfcShapeRepresentation::list::it i = frame_representations->begin(); i != frame_representations->end(); i += 2) {
 		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 window_placements (new IfcTemplatedEntityList<IfcSchema::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));
+	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));
 	
-	for (IfcSchema::IfcLocalPlacement::it it = window_placements->begin(); it != window_placements->end(); ++it) {
+	for (IfcSchema::IfcLocalPlacement::list::it it = window_placements->begin(); it != window_placements->end(); ++it) {
 		
 		// Create the window at the current location
 		IfcSchema::IfcLocalPlacement* place = *it;
@@ -389,43 +467,43 @@ int main(int argc, char** argv) {
 	);
 		file.addBuildingProduct(window);		
 
-		// Initalize a list of parts for the window to be composed of
-		IfcSchema::IfcObjectDefinition::list window_parts(new IfcTemplatedEntityList<IfcSchema::IfcObjectDefinition>());
+		// Initialize a list of parts for the window to be composed of
+		IfcSchema::IfcObjectDefinition::list::ptr window_parts(new IfcTemplatedEntityList<IfcSchema::IfcObjectDefinition>());
 
-		// The placements for the beams are not shared accross the different windows because every
+		// The placements for the beams are not shared across the different windows because every
 		// beam is placed relative to its parent window entity.
-		IfcSchema::IfcLocalPlacement::list frame_placements (new IfcTemplatedEntityList<IfcSchema::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));
+		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));
 		
 		// Now iterate over the placements and representations of the beam and add them to list of parts
-		IfcSchema::IfcLocalPlacement::it frame_placement;
-		IfcSchema::IfcProductDefinitionShape::it frame_representation;
+		IfcSchema::IfcLocalPlacement::list::it frame_placement;
+		IfcSchema::IfcShapeRepresentation::list::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, *frame_representation, null
+				null, null, null, *frame_placement, file.addMappedItem(*frame_representation), null
 #ifdef USE_IFC4
 				, IfcSchema::IfcMemberTypeEnum::IfcMemberType_MULLION
 #endif
 			);
-			file.AddEntity(frame_part);
+			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(930, 45, 90), file.addBox(1680, 10, 1420), 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);
+		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);
@@ -434,7 +512,7 @@ int main(int argc, char** argv) {
 		// 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>(),
 			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.
@@ -479,6 +557,6 @@ void createGroundShape(TopoDS_Shape& shape) {
 #if OCC_VERSION_HEX < 0x60502
 	shape = BRepBuilderAPI_MakeFace(surf);
 #else
-	shape = BRepBuilderAPI_MakeFace(surf, 1);
+	shape = BRepBuilderAPI_MakeFace(surf, Precision::Confusion());
 #endif
 }

src/examples/IfcParseExamples.cpp

@@ -17,10 +17,15 @@
  *                                                                              *
  ********************************************************************************/
 
-#include "../ifcparse/IfcParse.h"
-#include "../ifcparse/IfcFile.h"
+// TODO: Multiple schemas
+#define IfcSchema Ifc2x3
 
-using namespace IfcSchema;
+#include "../ifcparse/IfcFile.h"
+#include "../ifcparse/Ifc2x3.h"
+
+#if USE_VLD
+#include <vld.h>
+#endif
 
 int main(int argc, char** argv) {
 
@@ -33,15 +38,15 @@ int main(int argc, char** argv) {
 	Logger::SetOutput(&std::cout,&std::cout);
 
 	// Parse the IFC file provided in argv[1]
-	IfcParse::IfcFile file;
-	if ( ! file.Init(argv[1]) ) {
+	IfcParse::IfcFile file(argv[1]);
+	if (!file.good()) {
 		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,
@@ -55,19 +60,18 @@ 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.
-	IfcBuildingElement::list elements = file.EntitiesByType<IfcBuildingElement>();
+	IfcSchema::IfcBuildingElement::list::ptr elements = file.instances_by_type<IfcSchema::IfcBuildingElement>();
 
-	std::cout << "Found " << elements->Size() << " elements in " << argv[1] << ":" << std::endl;
+	std::cout << "Found " << elements->size() << " elements in " << argv[1] << ":" << std::endl;
 	
-	for ( IfcBuildingElement::it it = elements->begin(); it != elements->end(); ++ it ) {
+	for (IfcSchema::IfcBuildingElement::list::it it = elements->begin(); it != elements->end(); ++it) {
 		
-		const IfcBuildingElement::ptr element = *it;
-		std::cout << element->entity->toString() << std::endl;
+		const IfcSchema::IfcBuildingElement* element = *it;
+		std::cout << element->data().toString() << std::endl;
 		
-		if ( element->is(IfcWindow::Class()) ) {
-			const IfcWindow::ptr window = reinterpret_pointer_cast<IfcBuildingElement,IfcWindow>(element);
-			
-			if ( window->hasOverallWidth() && window->hasOverallHeight() ) {
+		const IfcSchema::IfcWindow* window;
+		if ((window = element->as<IfcSchema::IfcWindow>()) != 0) {
+			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

@@ -33,8 +33,8 @@
 #include "../ifcparse/IfcHierarchyHelper.h"
 
 typedef std::string S;
-typedef IfcWrite::IfcGuidHelper guid;
-boost::none_t const null = (static_cast<boost::none_t>(0));
+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) {
@@ -43,16 +43,16 @@ void create_product_from_item(IfcHierarchyHelper& file, IfcSchema::IfcRepresenta
 	file.addBuildingProduct(product);
 	product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
 
-	product->setObjectPlacement(file.addLocalPlacement(120 * i++));
+	product->setObjectPlacement(file.addLocalPlacement(0, 120 * i++));
 
-	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
-	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
+	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(new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
+		file.addEntity(set);
+		items = IfcSchema::IfcRepresentationItem::list::ptr(new IfcSchema::IfcRepresentationItem::list());
 		items->push(set);
 	}
 		
@@ -60,21 +60,21 @@ void create_product_from_item(IfcHierarchyHelper& file, IfcSchema::IfcRepresenta
 		file.getSingle<IfcSchema::IfcRepresentationContext>(), S("Body"), s, items);
 	reps->push(rep);
 
-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
-	file.AddEntity(rep);
-	file.AddEntity(shape);
+	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);
+	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);
+	file.addEntity(ax1);
+	file.addEntity(revolution);
 
 	create_product_from_item(file, extrusion, "GeometricSet");
 	create_product_from_item(file, revolution, "GeometricSet");
@@ -82,14 +82,14 @@ void create_surfaces_from_profile(IfcHierarchyHelper& file, IfcSchema::IfcProfil
 
 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);
+	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);
+	file.addEntity(ax1);
+	file.addEntity(revolution1);
+	file.addEntity(revolution2);
 
 	create_product_from_item(file, extrusion, "SweptSolid");
 	create_product_from_item(file, revolution1, "SweptSolid");
@@ -99,8 +99,8 @@ void create_solids_from_profile(IfcHierarchyHelper& file, IfcSchema::IfcProfileD
 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);
+	file.addEntity(open);
+	file.addEntity(center_line);
 
 	create_surfaces_from_profile(file, open);
 	create_solids_from_profile(file, center_line);
@@ -109,27 +109,27 @@ void create_products_from_curve(IfcHierarchyHelper& file, IfcSchema::IfcBoundedC
 int main(int argc, char** argv) {
 	const char filename[] = "IfcArbitraryOpenProfileDef.ifc";
 	IfcHierarchyHelper file;
-	file.filename(filename);
+	file.header().file_name().name(filename);
 
 	double coords1[] = {-50.0, 0.0};
 	double coords2[] = { 50.0, 0.0};
-	IfcSchema::IfcCartesianPoint::list points (new IfcTemplatedEntityList<IfcSchema::IfcCartesianPoint>());
+	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());
+	file.addEntities(points->generalize());
 	IfcSchema::IfcPolyline* poly = new IfcSchema::IfcPolyline(points);
-	file.AddEntity(poly);
+	file.addEntity(poly);
 
 	create_products_from_curve(file, poly);
 
 	IfcSchema::IfcEllipse* ellipse = new IfcSchema::IfcEllipse(file.addPlacement2d(), 50., 25.);
-	file.AddEntity(ellipse);
-	IfcEntities trim1(new IfcEntityList());
-	IfcEntities trim2(new IfcEntityList());
-	trim1->push(new IfcWrite::IfcSelectHelper(  0., Ifc2x3::Type::IfcParameterValue));
-	trim2->push(new IfcWrite::IfcSelectHelper(180., Ifc2x3::Type::IfcParameterValue));
+	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);
+	file.addEntity(trim);
 
 	create_products_from_curve(file, trim);
 

src/examples/composite_profile_def.cpp

@@ -32,19 +32,19 @@
 #include "../ifcparse/IfcHierarchyHelper.h"
 
 typedef std::string S;
-typedef IfcWrite::IfcGuidHelper guid;
-boost::none_t const null = (static_cast<boost::none_t>(0));
+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.filename(filename);
+	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 profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+	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);
@@ -65,11 +65,11 @@ int main(int argc, char** argv) {
 		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(p2);
+	file.addEntity(p3);
 	
-	file.AddEntity(transform1);
-	file.AddEntity(transform2);
+	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);
@@ -79,7 +79,7 @@ int main(int argc, char** argv) {
 	profiles->push(p6);
 	profiles->push(p4);
 
-	file.AddEntities(profiles->generalize());
+	file.addEntities(profiles->generalize());
 
 	IfcSchema::IfcCompositeProfileDef* composite = new IfcSchema::IfcCompositeProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, S("IFC"), profiles, null);
 
@@ -95,20 +95,20 @@ int main(int argc, char** argv) {
 	IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(composite,
 		file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 20.0);
 
-	file.AddEntity(composite);
-	file.AddEntity(solid);
+	file.addEntity(composite);
+	file.addEntity(solid);
 		
-	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
-	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
+	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);
+	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
+	file.addEntity(rep);
+	file.addEntity(shape);
 		
 	product->setRepresentation(shape);
 

src/examples/csg_primitive.cpp

@@ -32,8 +32,8 @@
 #include "../ifcparse/IfcHierarchyHelper.h"
 
 typedef std::string S;
-typedef IfcWrite::IfcGuidHelper guid;
-boost::none_t const null = (static_cast<boost::none_t>(0));
+typedef IfcParse::IfcGlobalId guid;
+boost::none_t const null = boost::none;
 
 class Node {
 private:
@@ -127,7 +127,7 @@ public:
 			}
 			my = new IfcSchema::IfcBooleanResult(o, left->serialize(file), right->serialize(file));
 		}
-		file.AddEntity(my);
+		file.addEntity(my);
 		return my;
 	}
 };
@@ -135,7 +135,7 @@ public:
 int main(int argc, char** argv) {
 	const char filename[] = "IfcCsgPrimitive.ifc";
 	IfcHierarchyHelper file;
-	file.filename(filename);
+	file.header().file_name().name(filename);
 
 	IfcSchema::IfcRepresentationItem* csg1 = Node::Box(8000.,6000.,3000.).subtract(
 		Node::Box(7600.,5600.,2800.).move(200.,200.,200.)
@@ -171,8 +171,8 @@ int main(int argc, char** argv) {
 
 	product->setObjectPlacement(file.addLocalPlacement());
 		
-	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
-	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
+	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list());
+	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list());
 		
 	items->push(csg1);
 	items->push(csg2);
@@ -180,9 +180,9 @@ int main(int argc, char** argv) {
 		file.getSingle<IfcSchema::IfcRepresentationContext>(), S("Body"), S("CSG"), items);
 	reps->push(rep);
 
-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
-	file.AddEntity(rep);
-	file.AddEntity(shape);
+	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(null, null, reps);
+	file.addEntity(rep);
+	file.addEntity(shape);
 		
 	product->setRepresentation(shape);
 

src/examples/ellipse_pies.cpp

@@ -32,8 +32,8 @@
 #include "../ifcparse/IfcHierarchyHelper.h"
 
 typedef std::string S;
-typedef IfcWrite::IfcGuidHelper guid;
-boost::none_t const null = (static_cast<boost::none_t>(0));
+typedef IfcParse::IfcGlobalId guid;
+boost::none_t const null = boost::none;
 
 typedef struct {
 	double r1;
@@ -58,66 +58,66 @@ void create_testcase_for(IfcHierarchyHelper& file, const EllipsePie& pie, Ifc2x3
 	Ifc2x3::IfcCartesianPoint* p2 = new Ifc2x3::IfcCartesianPoint(coords2);
 	Ifc2x3::IfcCartesianPoint* p3 = new Ifc2x3::IfcCartesianPoint(coords3);
 	
-	Ifc2x3::IfcCartesianPoint::list points(new IfcTemplatedEntityList<Ifc2x3::IfcCartesianPoint>());
+	Ifc2x3::IfcCartesianPoint::list::ptr points(new Ifc2x3::IfcCartesianPoint::list());
 	points->push(p3);
 	points->push(p1);
 	points->push(p2);
-	file.AddEntities(points->generalize());
+	file.addEntities(points->generalize());
 
 	
 	Ifc2x3::IfcEllipse* ellipse = new Ifc2x3::IfcEllipse(file.addPlacement2d(), pie.r1, pie.r2);
-	file.AddEntity(ellipse);
-	IfcEntities trim1(new IfcEntityList());
-	IfcEntities trim2(new IfcEntityList());
+	file.addEntity(ellipse);
+	IfcEntityList::ptr trim1(new IfcEntityList);
+	IfcEntityList::ptr trim2(new IfcEntityList);
 	if (pref == Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER) {
-		trim1->push(new IfcWrite::IfcSelectHelper(pie.t1, Ifc2x3::Type::IfcParameterValue));
-		trim2->push(new IfcWrite::IfcSelectHelper(pie.t2, Ifc2x3::Type::IfcParameterValue));
+		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);
+	file.addEntity(trim);
 	
-	Ifc2x3::IfcCompositeCurveSegment::list segments(new IfcTemplatedEntityList<Ifc2x3::IfcCompositeCurveSegment>());
+	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);
+	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());
+	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);
+	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(200 * i++));
+	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);
+	file.addEntity(solid);
 		
-	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
-	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
+	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);
+	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
+	file.addEntity(rep);
+	file.addEntity(shape);
 		
 	product->setRepresentation(shape);
 }

src/examples/faces.cpp

@@ -0,0 +1,207 @@
+/********************************************************************************
+ *                                                                              *
+ * 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

@@ -0,0 +1,143 @@
+/********************************************************************************
+*                                                                              *
+* 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

@@ -35,7 +35,7 @@ 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 profiles) {
+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";
@@ -44,7 +44,7 @@ void create_testcase_for(IfcSchema::IfcProfileDef::list profiles) {
 	file.filename(filename);
 	
 	int i = 0;
-	for (IfcSchema::IfcProfileDef::it it = profiles->begin(); it != profiles->end(); ++it, ++i) {
+	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);
@@ -52,7 +52,7 @@ void create_testcase_for(IfcSchema::IfcProfileDef::list profiles) {
 		file.getSingle<IfcSchema::IfcProject>()->setName(profile_type);
 		product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
 
-		product->setObjectPlacement(file.addLocalPlacement(100 * i));
+		product->setObjectPlacement(file.addLocalPlacement(0, 100. * i));
 
 		if (profile->is(IfcSchema::Type::IfcParameterizedProfileDef)) {
 			((IfcSchema::IfcParameterizedProfileDef*) profile)->setPosition(file.addPlacement2d());
@@ -61,11 +61,11 @@ void create_testcase_for(IfcSchema::IfcProfileDef::list profiles) {
 		IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(profile,
 			file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 20.0);
 
-		file.AddEntity(profile);
-		file.AddEntity(solid);
+		file.addEntity(profile);
+		file.addEntity(solid);
 		
-		IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
-		IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
+		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(
@@ -73,8 +73,8 @@ void create_testcase_for(IfcSchema::IfcProfileDef::list profiles) {
 		reps->push(rep);
 
 		IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
-		file.AddEntity(rep);
-		file.AddEntity(shape);
+		file.addEntity(rep);
+		file.addEntity(shape);
 		
 		product->setRepresentation(shape);
 	}
@@ -84,7 +84,7 @@ void create_testcase_for(IfcSchema::IfcProfileDef::list profiles) {
 }
 
 int main(int argc, char** argv) {
-	{ IfcSchema::IfcProfileDef::list profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+	{ 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));
@@ -99,7 +99,7 @@ int main(int argc, char** argv) {
 		null, 0,    50.0,    25.0,     5.0,     5.0,     1.0,     3.0,     6.0,    null));
 	create_testcase_for(profiles); }
 	
-    { IfcSchema::IfcProfileDef::list profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+    { 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));
@@ -114,7 +114,7 @@ int main(int argc, char** argv) {
 		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 profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+    { 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));
@@ -123,7 +123,7 @@ int main(int argc, char** argv) {
 		null, 0,    50.0,    25.0,     5.0,     5.0,     2.0,     2.0));
 	create_testcase_for(profiles); }
 	
-    { IfcSchema::IfcProfileDef::list profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
 	profiles->push(new Ifc2x3::IfcEllipseProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    25.0,    15.0));
@@ -132,16 +132,19 @@ int main(int argc, char** argv) {
 		null, 0,    15.0,    25.0));
 	create_testcase_for(profiles); }
 	
-    { IfcSchema::IfcProfileDef::list profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+    { 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 profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+    { 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));
@@ -156,7 +159,7 @@ int main(int argc, char** argv) {
 		null, 0,    50.0,    25.0,     5.0,      1.0,     2.0,     2.0,    null,    null));
 	create_testcase_for(profiles); }
 	
-    { IfcSchema::IfcProfileDef::list profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+    { 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));
@@ -165,7 +168,7 @@ int main(int argc, char** argv) {
 		null, 0,    50.0,    25.0,     5.0,    10.0,     2.0,    null));
 	create_testcase_for(profiles); }
 
-    { IfcSchema::IfcProfileDef::list profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
 	profiles->push(new Ifc2x3::IfcCircleProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    25.0));
@@ -174,7 +177,7 @@ int main(int argc, char** argv) {
 		null, 0,    25.0,     5.0));
 	create_testcase_for(profiles); }
 	
-    { IfcSchema::IfcProfileDef::list profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+    { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
 	profiles->push(new Ifc2x3::IfcRectangleProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0));
@@ -189,7 +192,7 @@ int main(int argc, char** argv) {
 		null, 0,    50.0,    25.0,     5.0,     2.0,     4.0));
 	create_testcase_for(profiles); }
 	
-    { IfcSchema::IfcProfileDef::list profiles (new IfcTemplatedEntityList<IfcSchema::IfcProfileDef>());
+    { 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));

src/examples/triangulated_faceset.cpp

@@ -0,0 +1,85 @@
+/********************************************************************************
+ *                                                                              *
+ * 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,181 +27,211 @@
 
 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, 5, 8),
-    "api": 37702,
+    "blender": (2, 80, 0),
     "location": "File > Import",
-    "warning": "",
-    "wiki_url": "http://sourceforge.net/apps/"\
-        "mediawiki/ifcopenshell/index.php",
-    "tracker_url": "http://sourceforge.net/tracker/?group_id=543113",
+    "tracker_url": "https://sourceforge.net/p/ifcopenshell/"
+        "_list/tickets?source=navbar",
     "category": "Import-Export"}
 
-import sys   
-max_unicode = 0x110000-1 if sys.platform[0:5] == 'linux' else 0x10000-1
-wrong_unicode = max_unicode != sys.maxunicode
-if wrong_unicode:
-    print("\nWarning: wrong unicode representation detected, switching to "\
-        "compatibility layer for text transferral, may result in undefined "\
-        "behaviour, please use offical release from http://blender.org\n")
-    
 if "bpy" in locals():
-    import imp
-    if "IfcImport" in locals():
-        imp.reload(IfcImport)
+    import importlib
+    if "ifcopenshell" in locals():
+        importlib.reload(ifcopenshell)
 
 import bpy
 import mathutils
 from bpy.props import StringProperty, IntProperty, BoolProperty
 from bpy_extras.io_utils import ImportHelper
 
-major,minor = bpy.app.version[0:2]
+major, minor = bpy.app.version[0:2]
 transpose_matrices = minor >= 62
 
-bpy.types.Object.ifc_id = IntProperty(name="IFC Entity ID",
+bpy.types.Object.ifc_id = IntProperty(
+    name="IFC Entity ID",
     description="The STEP entity instance name")
-bpy.types.Object.ifc_guid = StringProperty(name="IFC Entity GUID",
+bpy.types.Object.ifc_guid = StringProperty(
+    name="IFC Entity GUID",
     description="The IFC Globally Unique Identifier")
-bpy.types.Object.ifc_name = StringProperty(name="IFC Entity Name",
+bpy.types.Object.ifc_name = StringProperty(
+    name="IFC Entity Name",
     description="The optional name attribute")
-bpy.types.Object.ifc_type = StringProperty(name="IFC Entity Type",
+bpy.types.Object.ifc_type = StringProperty(
+    name="IFC Entity Type",
     description="The STEP Datatype keyword")
 
 
-def import_ifc(filename, use_names, process_relations):
-    global wrong_unicode
-    from . import IfcImport
-    print("Reading %s..."%bpy.path.basename(filename))
-    if wrong_unicode:
-        valid_file = IfcImport.InitUCS2( 
-            ''.join(['\0']+['\0%s'%s for s in filename]+['\0\0'])
-        )
-    else:
-        valid_file = IfcImport.Init(filename)
+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()
     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 = IfcImport.Get()
-        
-        if wrong_unicode:
-            ob_name = ''.join([chr(c) for c in ob.name_as_intvector()])
-            ob_type = ''.join([chr(c) for c in ob.type_as_intvector()])
-            ob_guid = ''.join([chr(c) for c in ob.guid_as_intvector()])
+        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
+        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:
-            ob_name, ob_type, ob_guid = ob.name, ob.type, ob.guid
-        
-        f = ob.mesh.faces
-        v = ob.mesh.verts
-        m = ob.matrix
-        t = ob_type[0:21]
-        nm = ob_name if len(ob_name) and use_names else ob_guid
+            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)]
 
-        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)
 
-        me = bpy.data.meshes.new('mesh%d' % ob.mesh.id)
-        me.from_pydata(verts, [], faces)
-        if t in bpy.data.materials:
-            mat = bpy.data.materials[t]
-            mat.use_fake_user = True
-        else:
-            mat = bpy.data.materials.new(t)
-        me.materials.append(mat)
+            needs_default = -1 in matids
+            if needs_default:
+                add_material(t, {})
 
+            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
-        bpy.context.scene.objects.link(bob)
+        collection.objects.link(bob)
 
-        bpy.context.scene.objects.active = bob
+        bpy.context.view_layer.objects.active = bob
         bpy.ops.object.mode_set(mode='EDIT')
         bpy.ops.mesh.normals_make_consistent()
         bpy.ops.object.mode_set(mode='OBJECT')
 
         bob.ifc_id, bob.ifc_guid, bob.ifc_name, bob.ifc_type = \
-            ob.id, ob_guid, ob_name, ob_type
+            ob.id, ob.guid, ob.name, ob.type
 
-        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] = []
+        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] = []
         id_to_object[ob.id].append(bob)
 
         if ob.parent_id > 0:
             id_to_parent[ob.id] = ob.parent_id
-            
-        progress = IfcImport.Progress() // 2
+
+        if blender_booleans and ob.type == 'IfcOpeningElement':
+            openings.append(ob.id)
+
+        progress = iterator.progress() // 2
         if progress > old_progress:
             print("\r[" + "#" * progress + " " * (50 - progress) + "]", end="")
             old_progress = progress
-        if not IfcImport.Next():
+        if not iterator.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 = IfcImport.GetObject(parent_id)
+            parent_ob = iterator.getObject(parent_id)
             if parent_ob.id == -1:
                 bob = None
             else:
-                if wrong_unicode:
-                    parent_ob_name = ''.join(
-                        [chr(c) for c in parent_ob.name_as_intvector()])
-                    parent_ob_type = ''.join(
-                        [chr(c) for c in parent_ob.type_as_intvector()])
-                    parent_ob_guid = ''.join(
-                        [chr(c) for c in parent_ob.guid_as_intvector()])
-                else:
-                    parent_ob_name, parent_ob_type, parent_ob_guid = \
-                        parent_ob.name, parent_ob.type, parent_ob.guid
-                    
-                m = parent_ob.matrix
-                nm = parent_ob_name if len(parent_ob_name) and use_names \
-                    else parent_ob_guid
+                m = parent_ob.transformation.matrix.data
+                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
-                
-                bpy.context.scene.objects.link(bob)
+
+                rel_collection.objects.link(bob)
 
                 bob.ifc_id = parent_ob.id
                 bob.ifc_name, bob.ifc_type, bob.ifc_guid = \
-                    parent_ob_name, parent_ob_type, parent_ob_guid
+                    parent_ob.name, parent_ob.type, parent_ob.guid
 
                 if parent_ob.parent_id > 0:
                     id_to_parent[parent_id] = parent_ob.parent_id
@@ -220,19 +250,27 @@ def import_ifc(filename, use_names, process_relations):
         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")
-    
-    if not wrong_unicode:
-        txt = bpy.data.texts.new("%s.log"%bpy.path.basename(filename))
-        txt.from_string(IfcImport.GetLog())
 
-    IfcImport.CleanUp()
-    
+    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())
+
     return True
 
 
@@ -241,44 +279,51 @@ 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)
+    use_names: BoolProperty(name="Use entity names",
+                            description="Use entity names rather than "
+                            "GlobalIds for objects",
+                            default=True)
+    process_relations: BoolProperty(name="Process relations",
+                                    description="Convert containment and "
+                                    "aggregation relations to parenting"
+                                    " (warning: may be slow on large files)",
+                                    default=False)
+    blender_booleans: BoolProperty(name="Use Blender booleans",
+                                   description="Use Blender boolean modifiers "
+                                   "for opening elements",
+                                   default=False)
 
     def execute(self, context):
-        global wrong_unicode
-        if wrong_unicode and sys.platform[0:5] != 'linux':
+        if not import_ifc(self.filepath, self.use_names,
+                          self.process_relations, self.blender_booleans):
             self.report({'ERROR'},
-                'Your version of Blender is incompatible with IfcBlender\n' \
-                'Please use the offical release from http://blender.org instead'
-            )
-        elif 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)")
+                         text="Industry Foundation Classes (.ifc)")
+
+
+classes = (
+    ImportIFC,
+)
 
 
 def register():
-    bpy.utils.register_module(__name__)
-    bpy.types.INFO_MT_file_import.append(menu_func_import)
+    for cls in classes:
+        bpy.utils.register_class(cls)
+    bpy.types.TOPBAR_MT_file_import.append(menu_func_import)
 
 
 def unregister():
-    bpy.utils.unregister_module(__name__)
-    bpy.types.INFO_MT_file_import.remove(menu_func_import)
+    for cls in reversed(classes):
+        bpy.utils.unregister_class(cls)
+    bpy.types.TOPBAR_MT_file_import.remove(menu_func_import)
 
 
 if __name__ == "__main__":

src/ifcconvert/ColladaSerializer.cpp

@@ -1,285 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-#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

@@ -1,164 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-#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/SurfaceStyle.h

@@ -1,78 +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 defines default materials for several IFC datatypes                *
- *                                                                              *
- ********************************************************************************/
-
-#ifndef SURFACESTYLE_H
-#define SURFACESTYLE_H
-
-#include <string>
-#include <sstream>
-
-#include <array>
-
-class SurfaceStyle {
-public:
-	class ColorComponent {
-	private:
-		std::array<double, 3> data;
-	public:
-		ColorComponent(double r, double g, double b) {
-			data[0] = r; data[1] = g; data[2] = b;
-		}
-		const double& R() const { return data[0]; }
-		const double& G() const { return data[1]; }
-		const double& B() const { return data[2]; }
-		double& R() { return data[0]; }
-		double& G() { return data[1]; }
-		double& B() { return data[2]; }
-	};
-private:
-	std::string name;
-	ColorComponent diffuse, specular, ambient;
-	double transparency;
-	double specularity;
-public:
-	SurfaceStyle(const std::string& name,
-				 double dr = 0.7,  double dg = 0.7, double db = 0.7,
-			 	 double sr = 0.2,  double sg = 0.2, double sb = 0.2, 
-			 	 double ar = 0.1,  double ag = 0.1, double ab = 0.1,
-				 double Ns = 10.0, double Tr = 1.0)
-		: name(name) 
-		, diffuse(dr, dg, db)
-		, specular(sr, sg, sb)
-		, ambient(ar, ag, ab)
-		, transparency(Tr)
-		, specularity(Ns)
-	{}
-	const std::string& Name() const { return name; }
-	const ColorComponent& Diffuse() const { return diffuse; }
-	const ColorComponent& Specular() const { return specular; }
-	const ColorComponent& Ambient() const { return ambient; }
-	double Transparency() const { return transparency; }
-	double Specularity() const { return specularity; }
-};
-
-SurfaceStyle GetDefaultMaterial(const std::string& s);
-
-#endif

src/ifcconvert/WavefrontObjSerializer.cpp

@@ -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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-#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/validate_space_boundaries.cpp

@@ -0,0 +1,185 @@
+#include "validation_utils.h"
+
+using namespace ifcopenshell::geometry;
+
+#include <CGAL/AABB_tree.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/Polyhedron_3.h>
+#include <CGAL/AABB_face_graph_triangle_primitive.h>
+
+typedef Kernel_::FT FT;
+typedef Kernel_::Point_3 Point;
+typedef Kernel_::Segment_3 Segment;
+typedef CGAL::Polyhedron_3<Kernel_> Polyhedron;
+typedef CGAL::AABB_face_graph_triangle_primitive<Polyhedron> Primitive;
+typedef CGAL::AABB_traits<Kernel_, Primitive> Traits;
+typedef CGAL::AABB_tree<Traits> Tree;
+typedef Tree::Point_and_primitive_id Point_and_primitive_id;
+
+void fix_spaceboundaries(IfcParse::IfcFile& f, bool no_progress, bool quiet, bool stderr_progress) {
+	intersection_validator v(f, { "IfcWall", "IfcSpace", "IfcSlab", "IfcCovering" }, 1.e-5, no_progress, quiet, stderr_progress);
+
+	auto rels = f.instances_by_type("IfcRelSpaceBoundary");
+
+	std::map<std::pair<const IfcUtil::IfcBaseClass*, const IfcUtil::IfcBaseClass*>, const IfcUtil::IfcBaseClass*> rel_by_space_elem;
+
+
+	if (rels) {
+		std::for_each(rels->begin(), rels->end(), [&rel_by_space_elem](const IfcUtil::IfcBaseClass* rel) {
+			auto x = ((IfcUtil::IfcBaseEntity*)rel)->get_value<IfcUtil::IfcBaseClass*>("RelatingSpace");
+			try {
+				auto y = ((IfcUtil::IfcBaseEntity*)rel)->get_value<IfcUtil::IfcBaseClass*>("RelatedBuildingElement");
+				rel_by_space_elem.insert({ { x,y }, rel });
+			} catch (IfcParse::IfcException&) {
+				// RelatedBuildingElement can be NULL
+			}
+		});
+	}
+
+	std::set<const IfcUtil::IfcBaseClass*> rels_encounted;
+
+	IfcParse::IfcFile f2("boundaries-triangulated.ifc");
+	if (!f2.good()) {
+		return;
+	}
+
+	ifcopenshell::geometry::settings settings;
+
+	settings.set(ifcopenshell::geometry::settings::USE_WORLD_COORDS, false);
+	settings.set(ifcopenshell::geometry::settings::WELD_VERTICES, false);
+	settings.set(ifcopenshell::geometry::settings::SEW_SHELLS, true);
+	settings.set(ifcopenshell::geometry::settings::CONVERT_BACK_UNITS, true);
+	settings.set(ifcopenshell::geometry::settings::DISABLE_TRIANGULATION, true);
+	settings.set(ifcopenshell::geometry::settings::DISABLE_OPENING_SUBTRACTIONS, true);
+
+	ifcopenshell::geometry::Converter c("cgal", &f2, settings);
+
+	std::map<std::set<std::string>, std::vector<Kernel_::Point_3>> elem_to_space_boundary_coords;
+
+	for (auto& i : *f2.instances_by_type("IfcProduct")) {
+		auto n = ((IfcUtil::IfcBaseEntity*)i)->get_value<std::string>("Name");
+		auto g1 = n.substr(0, 22);
+		auto g2 = n.substr(23);
+		auto item = c.mapping()->map(i);
+		if (((ifcopenshell::geometry::taxonomy::collection*) item)->children[0] == nullptr) {
+			continue;
+		}
+		auto shell = (taxonomy::shell*) ((taxonomy::collection*)((taxonomy::collection*) item)->children[0])->children[0];
+		for (auto& f : shell->children) {
+			auto face = (taxonomy::face*) f;
+			for (auto& w : face->children) {
+				auto wire = (taxonomy::loop*) w;
+				for (auto& e : wire->children) {
+					auto edge = (taxonomy::edge*) e;
+					auto p3 = boost::get<taxonomy::point3>(edge->start);
+					auto p4 = ((taxonomy::geom_item*)item)->matrix.ccomponents() * p3.ccomponents().homogeneous();
+					Kernel_::Point_3 P(p4(0), p4(1), p4(2));
+					elem_to_space_boundary_coords[{g1, g2}].emplace_back(P);
+				}
+			}
+		}
+	}
+
+	std::set< std::set<std::string> > guid_pairs_visited;
+
+	v([&rel_by_space_elem, &elem_to_space_boundary_coords, &guid_pairs_visited](const intersection_validator::Box& a, const intersection_validator::Box& b) {
+		std::ostringstream ss;
+		// ss << id_map[a.id()]->first->data().toString() << "x" << id_map[b.id()]->first->data().toString() << std::endl;
+		// auto x = id_map[a.id()]->second * id_map[b.id()]->second;
+
+		auto A = a.handle()->first;
+		auto B = b.handle()->first;
+
+		auto Aguid = A->get_value<std::string>("GlobalId");
+		auto Bguid = B->get_value<std::string>("GlobalId");
+
+		int space_count = 0;
+		if (A->declaration().name() == "IfcSpace") {
+			space_count += 1;
+		}
+		if (B->declaration().name() == "IfcSpace") {
+			space_count += 1;
+		}
+		if (space_count != 1) {
+			return;
+		}
+
+		ss << a.handle()->first->data().toString() << "x" << a.handle()->first->data().toString() << std::endl;
+		auto x = a.handle()->second * b.handle()->second;
+
+		if (x.is_empty()) {
+			return;
+		}
+
+		guid_pairs_visited.insert({ Aguid, Bguid });
+
+		cgal_shape_t x_poly;
+		x.convert_to_polyhedron(x_poly);
+
+		{
+			std::string fn = "computed_boundaries_" + Aguid + "_" + Bguid + ".off";
+			std::ofstream computed_boundaries(fn.c_str());
+			computed_boundaries.precision(17);
+			computed_boundaries << x_poly;
+		}
+
+		Tree tree(faces(x_poly).first, faces(x_poly).second, x_poly);
+		tree.accelerate_distance_queries();
+
+		auto itelem = elem_to_space_boundary_coords.find({ Aguid, Bguid });
+
+		if (itelem == elem_to_space_boundary_coords.end()) {
+			Logger::Error("Missing space boundary relationship " + Aguid + " " + Bguid);
+			return;
+		}
+
+		const auto& coords = itelem->second;
+		std::vector<double> distances;
+		std::transform(coords.begin(), coords.end(), std::back_inserter(distances), [&tree](const Kernel_::Point_3& p) {
+			return std::sqrt(CGAL::to_double(tree.squared_distance(p)));
+		});
+
+		bool valid = *std::max_element(distances.begin(), distances.end()) < 0.4;
+
+		if (!valid) {
+			Logger::Error("Wrong connection geometry " + Aguid + " " + Bguid);
+		}
+
+		/*{
+			remove_thickness r(x_poly);
+			std::string fn = "thin_computed_boundaries_" + Aguid + "_" + Bguid + ".off";
+			std::ofstream computed_boundaries(fn.c_str());
+			computed_boundaries.precision(17);
+			computed_boundaries << r.flattened;
+		}*/
+
+		/*
+		{
+			auto FN = s0 + "-" + s1 + "-" + std::to_string(i0) + "-" + std::to_string(i1) + "-sides-sb.off";
+			std::ofstream os(FN.c_str());
+			os.precision(17);
+			os << r.polyhedron2;
+		}
+		{
+			auto FN = s0 + "-" + s1 + "-" + std::to_string(i0) + "-" + std::to_string(i1) + "-flat-sb.off";
+			std::ofstream os(FN.c_str());
+			os.precision(17);
+			os << r.flattened;
+		}
+		*/
+	});
+
+	auto is_wall_space_or_slab = [&f](const std::string& g) {
+		auto decl = f.instance_by_guid(g)->declaration();
+		return decl.is("IfcWall") || decl.is("IfcSpace") || decl.is("IfcSlab");
+	};
+
+	for (auto& i : *f2.instances_by_type("IfcProduct")) {
+		auto n = ((IfcUtil::IfcBaseEntity*)i)->get_value<std::string>("Name");
+		auto g1 = n.substr(0, 22);
+		auto g2 = n.substr(23);
+		if (is_wall_space_or_slab(g1) && is_wall_space_or_slab(g2) && guid_pairs_visited.find({ g1, g2 }) == guid_pairs_visited.end()) {
+			Logger::Error("Space boundary for non-bounding geometry " + g1 + " " + g2);
+		}
+	}
+}

src/ifcconvert/validate_storey_containment.cpp

@@ -0,0 +1,233 @@
+#include "../ifcgeom/kernels/cgal/CgalKernel.h"
+#include "../ifcgeom/schema_agnostic/IfcGeomFilter.h"
+#include "../ifcgeom/schema_agnostic/IfcGeomIterator.h"
+
+#include <CGAL/Polygon_mesh_processing/measure.h>
+#include <CGAL/Polygon_mesh_processing/bbox.h>
+
+#include <algorithm>
+
+void fix_storeycontainment(IfcParse::IfcFile& f, bool no_progress, bool quiet, bool stderr_progress) {
+	ifcopenshell::geometry::settings settings;
+	settings.set(ifcopenshell::geometry::settings::USE_WORLD_COORDS, false);
+	settings.set(ifcopenshell::geometry::settings::WELD_VERTICES, false);
+	settings.set(ifcopenshell::geometry::settings::SEW_SHELLS, true);
+	settings.set(ifcopenshell::geometry::settings::CONVERT_BACK_UNITS, true);
+	settings.set(ifcopenshell::geometry::settings::DISABLE_TRIANGULATION, true);
+	settings.set(ifcopenshell::geometry::settings::DISABLE_OPENING_SUBTRACTIONS, true);
+
+	std::vector<ifcopenshell::geometry::filter_t> no_openings_and_spaces = {
+		IfcGeom::entity_filter(false, false, {"IfcOpeningElement", "IfcSpace"})
+	};
+
+	ifcopenshell::geometry::Iterator context_iterator("cgal", settings, &f, no_openings_and_spaces);
+
+	auto get_elevation = [](IfcUtil::IfcBaseClass* a) {
+		return ((IfcUtil::IfcBaseEntity*)a)->get_value_or<double>("Elevation", 0.);
+	};
+
+	// latebound inverse attribute lookup not working
+	auto rels = f.instances_by_type("IfcRelContainedInSpatialStructure");
+	std::map<IfcUtil::IfcBaseClass*, IfcUtil::IfcBaseClass*> elem_to_storey;
+	std::for_each(rels->begin(), rels->end(), [&elem_to_storey](IfcUtil::IfcBaseClass* r) {
+		auto elems = ((IfcUtil::IfcBaseEntity*)r)->get_value<IfcEntityList::ptr>("RelatedElements");
+		auto storey = ((IfcUtil::IfcBaseEntity*)r)->get_value<IfcUtil::IfcBaseClass*>("RelatingStructure");
+
+		if (storey->declaration().name() == "IfcBuildingStorey") {
+			for (auto it = elems->begin(); it != elems->end(); ++it) {
+				elem_to_storey[*it] = storey;
+			}
+		}
+	});	
+
+	auto storeys = f.instances_by_type("IfcBuildingStorey");
+	std::vector<IfcUtil::IfcBaseClass*> storeys_sorted(storeys->begin(), storeys->end());
+	std::sort(storeys_sorted.begin(), storeys_sorted.end(), [&get_elevation](IfcUtil::IfcBaseClass* a, IfcUtil::IfcBaseClass* b) {
+		return get_elevation(a) < get_elevation(b);
+	});
+
+	/*
+	std::wcout << "Storeys ";
+	for (auto& s : storeys_sorted) {
+		auto n = ((IfcUtil::IfcBaseEntity*)s)->get_value<std::string>("Name");
+		std::wcout << n.c_str() << " ";
+	}
+	std::wcout << std::endl;
+	*/
+
+	std::vector<double> elevations;
+	std::transform(storeys_sorted.begin(), storeys_sorted.end(), std::back_inserter(elevations), get_elevation);
+
+	double LARGE = 1e4;
+
+	std::vector<std::pair<double, double>> elevation_slices;
+	for (size_t i = 0; i < elevations.size(); ++i) {
+		elevation_slices.push_back({
+			i == 0 ? -LARGE : elevations[i],
+			i + 1 == elevations.size() ? LARGE : elevations[i + 1]
+		});
+	}
+
+	std::for_each(elevation_slices.begin(), elevation_slices.end(), [](std::pair<double, double>& p) {
+		p.first -= 0.3;
+		p.second += 0.3;
+	});
+
+	std::vector<CGAL::Nef_polyhedron_3<Kernel_>> nefs;
+	std::transform(elevation_slices.begin(), elevation_slices.end(), std::back_inserter(nefs), [&LARGE](const std::pair<double, double>& p) {
+		// std::wcout << p.first << " - " << p.second << std::endl;
+		Kernel_::Point_3 p1(-LARGE, -LARGE, p.first);
+		Kernel_::Point_3 p2(+LARGE, +LARGE, p.second);
+		auto poly = ifcopenshell::geometry::utils::create_cube(p1, p2);
+		return ifcopenshell::geometry::utils::create_nef_polyhedron(poly);
+	});
+
+	/*
+	for (auto& n : nefs) {
+		auto poly = ifcopenshell::geometry::utils::create_polyhedron(n);
+		auto bounds = CGAL::Polygon_mesh_processing::bbox_3(poly);
+		for (int i = 0; i < 3; ++i) {
+			std::wcout << bounds.min(i) << std::endl;
+		}
+		for (int i = 0; i < 3; ++i) {
+			std::wcout << bounds.max(i) << std::endl;
+		}
+		std::wcout << "---" << std::endl;
+	}
+	*/
+	
+	if (!context_iterator.initialize()) {
+		return;
+	}
+
+	size_t num_created = 0;
+	int old_progress = quiet ? 0 : -1;
+
+	for (;; ++num_created) {
+		bool has_more = true;
+		if (num_created) {
+			has_more = context_iterator.next();
+		}
+		ifcopenshell::geometry::NativeElement* geom_object = nullptr;
+		if (has_more) {
+			geom_object = context_iterator.get_native();
+		}
+		if (!geom_object) {
+			break;
+		}
+
+		/*
+		std::stringstream ss;
+		ss << geom_object->product()->data().toString();
+		auto sss = ss.str();
+		std::wcout << sss.c_str() << std::endl;
+		*/
+
+		if (elem_to_storey.find(geom_object->product()) == elem_to_storey.end()) {
+			// std::wcout << "not associated to storey" << std::endl;
+			continue;
+		}
+
+		std::vector<double> intersection_volumes(nefs.size());
+
+		for (auto& g : geom_object->geometry()) {
+			auto s = ((ifcopenshell::geometry::CgalShape*) g.Shape())->shape();
+			const auto& m = g.Placement().ccomponents();
+			const auto& n = geom_object->transformation().data().ccomponents();
+
+			const cgal_placement_t trsf(
+				m(0, 0), m(0, 1), m(0, 2), m(0, 3),
+				m(1, 0), m(1, 1), m(1, 2), m(1, 3),
+				m(2, 0), m(2, 1), m(2, 2), m(2, 3));
+
+			const cgal_placement_t trsf2(
+				n(0, 0), n(0, 1), n(0, 2), n(0, 3),
+				n(1, 0), n(1, 1), n(1, 2), n(1, 3),
+				n(2, 0), n(2, 1), n(2, 2), n(2, 3));
+
+			// Apply transformation
+			for (auto &vertex : vertices(s)) {
+				vertex->point() = vertex->point().transform(trsf).transform(trsf2);
+			}
+
+			/*
+			{
+				auto bounds = CGAL::Polygon_mesh_processing::bbox_3(s);
+				for (int i = 0; i < 3; ++i) {
+					std::wcout << bounds.min(i) << std::endl;
+				}
+				for (int i = 0; i < 3; ++i) {
+					std::wcout << bounds.max(i) << std::endl;
+				}
+				std::wcout << "---" << std::endl;
+			}
+			*/
+
+			CGAL::Nef_polyhedron_3<Kernel_> part_nef = ifcopenshell::geometry::utils::create_nef_polyhedron(s);
+
+			if (!part_nef.is_simple()) {
+				// std::wcout << "not simple" << std::endl;
+				continue;
+			}
+
+			std::vector<double>::iterator accumulator = intersection_volumes.begin();
+			std::for_each(nefs.begin(), nefs.end(), [&accumulator, &part_nef](const CGAL::Nef_polyhedron_3<Kernel_>& storey_nef) {
+				auto poly = ifcopenshell::geometry::utils::create_polyhedron(part_nef * storey_nef);
+				CGAL::Polygon_mesh_processing::triangulate_faces(poly);
+				*accumulator += CGAL::to_double(CGAL::Polygon_mesh_processing::volume(poly));
+				accumulator++;
+			});
+		}
+
+		/*
+		std::wcout << "volumes: ";
+		for (auto& v : intersection_volumes) {
+			std::wcout << v << " ";
+		}
+		std::wcout << std::endl;
+		*/
+
+		auto calc_idx = std::max_element(intersection_volumes.begin(), intersection_volumes.end()) - intersection_volumes.begin();
+		auto calc_overlap = intersection_volumes[calc_idx];
+		auto assigned_idx = std::distance(storeys_sorted.begin(), std::find(storeys_sorted.begin(), storeys_sorted.end(), elem_to_storey[geom_object->product()]));
+		auto assigned_overlap = intersection_volumes[assigned_idx];
+		if (calc_overlap > 0 && assigned_overlap < calc_overlap * 0.9) {
+			auto s = geom_object->product()->get_value<std::string>("GlobalId");
+			auto s1 = ((IfcUtil::IfcBaseEntity*)storeys_sorted[calc_idx])->get_value<std::string>("GlobalId");
+			auto s2 = ((IfcUtil::IfcBaseEntity*)elem_to_storey[geom_object->product()])->get_value<std::string>("GlobalId");
+			Logger::Error("Element " + s + " contained in " + s2 + " located on " + s1);
+		}
+
+		if (!no_progress) {
+			if (quiet) {
+				const int progress = context_iterator.progress();
+				for (; old_progress < progress; ++old_progress) {
+					std::cout << ".";
+					if (stderr_progress)
+						std::cerr << ".";
+				}
+				std::cout << std::flush;
+				if (stderr_progress)
+					std::cerr << std::flush;
+			} else {
+				const int progress = context_iterator.progress() / 2;
+				if (old_progress != progress) Logger::ProgressBar(progress);
+				old_progress = progress;
+			}
+		}
+	}
+
+	if (!no_progress && quiet) {
+		for (; old_progress < 100; ++old_progress) {
+			std::cout << ".";
+			if (stderr_progress)
+				std::cerr << ".";
+		}
+		std::cout << std::flush;
+		if (stderr_progress)
+			std::cerr << std::flush;
+	} else {
+		Logger::Status("\rDone fixing space boundaries for " + boost::lexical_cast<std::string>(num_created) +
+			" objects                                ");
+	}
+}

src/ifcconvert/validate_wall_connectivity.cpp

@@ -0,0 +1,198 @@
+#include "validation_utils.h"
+
+#include <CGAL/Polygon_mesh_processing/bbox.h>
+#include <CGAL/Polygon_mesh_processing/measure.h>
+
+#include <algorithm>
+
+using namespace ifcopenshell::geometry;
+
+void fix_wallconnectivity(IfcParse::IfcFile& f, bool no_progress, bool quiet, bool stderr_progress) {
+	intersection_validator v(f, { "IfcWall" }, 1.e-3, no_progress, quiet, stderr_progress);
+
+
+	ifcopenshell::geometry::settings settings;
+	settings.set(ifcopenshell::geometry::settings::USE_WORLD_COORDS, false);
+	settings.set(ifcopenshell::geometry::settings::WELD_VERTICES, false);
+	settings.set(ifcopenshell::geometry::settings::SEW_SHELLS, true);
+	settings.set(ifcopenshell::geometry::settings::CONVERT_BACK_UNITS, true);
+	settings.set(ifcopenshell::geometry::settings::DISABLE_TRIANGULATION, true);
+	settings.set(ifcopenshell::geometry::settings::DISABLE_OPENING_SUBTRACTIONS, true);
+
+	settings.set(ifcopenshell::geometry::settings::INCLUDE_CURVES, true);
+	settings.set(ifcopenshell::geometry::settings::EXCLUDE_SOLIDS_AND_SURFACES, true);
+	
+	ifcopenshell::geometry::Converter c("cgal", &f, settings);
+
+	auto rels = f.instances_by_type("IfcRelConnectsPathElements");
+	std::map<std::set<const IfcUtil::IfcBaseClass*>, const IfcUtil::IfcBaseClass*> rel_by_elem;
+	std::for_each(rels->begin(), rels->end(), [&rel_by_elem](const IfcUtil::IfcBaseClass* rel) {
+		auto x = ((IfcUtil::IfcBaseEntity*)rel)->get_value<IfcUtil::IfcBaseClass*>("RelatingElement");
+		auto y = ((IfcUtil::IfcBaseEntity*)rel)->get_value<IfcUtil::IfcBaseClass*>("RelatedElement");
+		rel_by_elem.insert({{ x,y }, rel});
+	});
+
+	std::set<const IfcUtil::IfcBaseClass*> rels_encounted;
+
+	double total_nef_intersection_time = 0.;
+	double conversion_to_poly = 0.;
+
+	v([&c, &rel_by_elem, &rels_encounted, &total_nef_intersection_time, &conversion_to_poly](const intersection_validator::Box& a, const intersection_validator::Box& b) {
+		auto A = a.handle()->first;
+		auto B = b.handle()->first;
+
+		const IfcUtil::IfcBaseClass* rel = nullptr;
+		std::string a_type, b_type;
+
+		auto rit = rel_by_elem.find({ A, B });
+		if (rit != rel_by_elem.end()) {
+			rel = rit->second;
+			const bool a_is_relating = A == ((IfcUtil::IfcBaseEntity*)rel)->get_value<IfcUtil::IfcBaseClass*>("RelatingElement");
+			a_type = ((IfcUtil::IfcBaseEntity*)rel)->get_value<std::string>("RelatingConnectionType");
+			b_type = ((IfcUtil::IfcBaseEntity*)rel)->get_value<std::string>("RelatedConnectionType");
+			if (!a_is_relating) {
+				std::swap(a_type, b_type);
+			}
+		}		
+
+#if 0
+		auto a_poly = ifcopenshell::geometry::utils::create_polyhedron(a.handle()->second);
+		auto b_poly = ifcopenshell::geometry::utils::create_polyhedron(b.handle()->second);
+
+		std::wcout << "a" << std::endl;
+		for (auto& v : vertices(a_poly)) {
+			for (int i = 0; i < 3; ++i) {
+				std::wcout << CGAL::to_double(v->point().cartesian(i)) << " ";
+			}
+			std::wcout << std::endl;
+		}
+
+		std::wcout << "b" << std::endl;
+		for (auto& v : vertices(b_poly)) {
+			for (int i = 0; i < 3; ++i) {
+				std::wcout << CGAL::to_double(v->point().cartesian(i)) << " ";
+			}
+			std::wcout << std::endl;
+		}
+#endif
+
+		std::ostringstream ss;
+		ss << A->data().toString() << "x" << B->data().toString() << std::endl;
+		std::clock_t intersection_begin = std::clock();
+		auto x = a.handle()->second * b.handle()->second;
+		std::clock_t intersection_end = std::clock();
+
+		total_nef_intersection_time += (intersection_end - intersection_begin) / (double) CLOCKS_PER_SEC;
+
+		if (x.is_empty()) {
+			return;
+		}
+
+		std::clock_t poly_begin = std::clock();
+		cgal_shape_t x_poly;
+		x.convert_to_polyhedron(x_poly);
+		std::clock_t poly_end = std::clock();
+		conversion_to_poly += (poly_end - poly_begin) / (double)CLOCKS_PER_SEC;
+
+		auto dza = a.bbox().zmax() - a.bbox().zmin();
+		auto dzb = b.bbox().zmax() - b.bbox().zmin();
+		auto bb = CGAL::Polygon_mesh_processing::bbox_3(x_poly);
+		if (bb.zmax() - bb.zmin() < std::min(dza, dzb) / 3.) {
+			return;
+		}
+
+		CGAL::Polygon_mesh_processing::triangulate_faces(x_poly);
+		if (CGAL::Polygon_mesh_processing::area(x_poly) > 4.0) {
+			return;
+		}
+
+		auto get_axis_parameter_min_max = [&c, &x_poly](IfcUtil::IfcBaseEntity* inst) {
+			auto item = c.mapping()->map(inst);
+			auto shaperep = ((taxonomy::collection*) item)->children[0];
+			auto loop = ((taxonomy::collection*) shaperep)->children[0];
+
+			if (loop->kind() != taxonomy::LOOP) {
+				// std::wcout << "no suitable axis" << std::endl;
+			} else {
+				auto first_vertex = ((taxonomy::edge*) ((taxonomy::loop*) loop)->children.front())->start;
+				auto last_vertex = ((taxonomy::edge*) ((taxonomy::loop*) loop)->children.back())->end;
+
+				if (first_vertex.which() != 0 || last_vertex.which() != 0) {
+					// std::wcout << "trims not supported" << std::endl;
+				} else {
+					auto p0 = boost::get<taxonomy::point3>(first_vertex);
+					auto p1 = boost::get<taxonomy::point3>(last_vertex);
+					
+					auto v0 = ((taxonomy::geom_item*)item)->matrix.ccomponents() * p0.ccomponents().homogeneous();
+					auto v1 = ((taxonomy::geom_item*)item)->matrix.ccomponents() * p1.ccomponents().homogeneous();
+
+					auto P0 = Kernel_::Point_3(v0(0), v0(1), v0(2));
+					auto P1 = Kernel_::Point_3(v1(0), v1(1), v1(2));
+
+					auto D = P1 - P0;
+					auto len = std::sqrt(CGAL::to_double(D.squared_length()));
+					D /= len;
+
+					std::vector<Kernel_::FT> parameters;
+
+					std::transform(vertices(x_poly).begin(), vertices(x_poly).end(), std::back_inserter(parameters), [&P0, D](cgal_vertex_descriptor_t& v) {
+						return (v->point() - P0) * D;
+					});
+
+					auto pit = std::minmax_element(parameters.begin(), parameters.end());
+					return std::make_pair(len, std::make_pair(CGAL::to_double(*pit.first), CGAL::to_double(*pit.second)));
+				}				
+			}
+			const auto& nan = std::numeric_limits<double>::quiet_NaN();
+			return std::make_pair(nan, std::make_pair(nan, nan));
+		};
+
+		auto qualify_connection_type = [](double l, const std::pair<double, double>& p) {
+			if (p.first < 1.e-3) {
+				return "ATSTART";
+			} else if (p.second > l - 1.e-3) {
+				return "ATEND";
+			} else {
+				return "ATPATH";
+			}
+		};
+
+		auto alu0u1 = get_axis_parameter_min_max(A);
+		auto blu0u1 = get_axis_parameter_min_max(B);
+
+		auto atype_computed = qualify_connection_type(alu0u1.first, alu0u1.second);
+		auto btype_computed = qualify_connection_type(blu0u1.first, blu0u1.second);
+
+		rels_encounted.insert(rel);
+
+		if (a_type != atype_computed || b_type != btype_computed) {
+			if (rel) {
+				Logger::Error(std::string("Connection type ") + atype_computed + " " + btype_computed + " for:", rel);
+			} else {
+				auto A_str = A->get_value<std::string>("GlobalId");
+				auto B_str = B->get_value<std::string>("GlobalId");
+				Logger::Error("No connection for adjacent " + A_str + " " + B_str);
+			}
+		}
+	});
+
+	std::for_each(rels->begin(), rels->end(), [&rels_encounted, &v](const IfcUtil::IfcBaseClass* rel) {
+		if (rels_encounted.find(rel) == rels_encounted.end()) {
+			auto x = (IfcUtil::IfcBaseEntity*)((IfcUtil::IfcBaseEntity*)rel)->get_value<IfcUtil::IfcBaseClass*>("RelatingElement");
+			auto y = (IfcUtil::IfcBaseEntity*)((IfcUtil::IfcBaseEntity*)rel)->get_value<IfcUtil::IfcBaseClass*>("RelatedElement");
+			if (v.succesfully_processed.find(x) != v.succesfully_processed.end() && v.succesfully_processed.find(y) != v.succesfully_processed.end()) {
+				Logger::Error("Connection for non-adjacent walls", rel);
+			}
+		}
+	});
+
+	std::wcout << std::setprecision(14);
+	std::wcout << "total_map_time " << v.total_map_time << std::endl;
+	std::wcout << "total_geom_time " << v.total_geom_time << std::endl;
+	std::wcout << "total_nef_time " << v.total_nef_time << std::endl;
+	std::wcout << "total_minkowsky_time " << v.total_minkowsky_time << std::endl;
+	std::wcout << "total_box_time " << v.total_box_time << std::endl;
+	std::wcout << "total_nef_intersection_time " << total_nef_intersection_time << std::endl;
+	std::wcout << "total_conversion_to_poly_time " << conversion_to_poly << std::endl;
+}
+

src/ifcconvert/validation_utils.cpp

@@ -0,0 +1,28 @@
+#include "validation_utils.h"
+
+double facet_area(const cgal_shape_t::Facet_handle& f) {
+	auto p0 = f->facet_begin()->vertex()->point();
+	auto p1 = f->facet_begin()->next()->vertex()->point();
+	auto p2 = f->facet_begin()->next()->next()->vertex()->point();
+	return std::sqrt(CGAL::to_double(CGAL::cross_product(p0 - p1, p2 - p1).squared_length()));
+}
+
+void dump_facet(const cgal_shape_t::Facet_handle& f) {
+	auto p0 = f->facet_begin()->vertex()->point();
+	auto p1 = f->facet_begin()->next()->vertex()->point();
+	auto p2 = f->facet_begin()->next()->next()->vertex()->point();
+	auto V = CGAL::cross_product(p0 - p1, p2 - p1);
+	auto d = std::sqrt(CGAL::to_double(V.squared_length()));
+	if (d > 1.e-20) {
+		V /= d;
+	}
+
+	std::ostringstream oss;
+	oss.precision(8);
+	oss << "Facet with area " << facet_area(f) << " and normal ("
+		<< CGAL::to_double(V.cartesian(0)) << " " << CGAL::to_double(V.cartesian(1)) << " "
+		<< CGAL::to_double(V.cartesian(2)) << ")";
+
+	auto osss = oss.str();
+	std::wcout << osss.c_str() << std::endl;
+}

src/ifcconvert/validation_utils.h

@@ -0,0 +1,581 @@
+#include "../ifcgeom/kernels/cgal/CgalKernel.h"
+#include "../ifcgeom/schema_agnostic/IfcGeomFilter.h"
+#include "../ifcgeom/schema_agnostic/IfcGeomIterator.h"
+
+#include <CGAL/box_intersection_d.h>
+#include <CGAL/minkowski_sum_3.h>
+
+#include <CGAL/AABB_tree.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/Polyhedron_3.h>
+#include <CGAL/AABB_face_graph_triangle_primitive.h>
+
+#include <fstream>
+#include <iostream>
+
+template <typename T>
+T enlarge(const T& t, double d = 1.e-5) {
+	typename T::NT min[3];
+	typename T::NT max[3];
+	for (int i = 0; i < t.dimension(); ++i) {
+		min[i] = t.min_coord(i) - d;
+		max[i] = t.max_coord(i) + d;
+	}
+	return T(min, max, t.handle());
+}
+
+template <class HDS>
+struct Build_Offset : public CGAL::Modifier_base<HDS> {
+	std::list<cgal_shape_t::Facet_handle> input;
+
+	void operator()(HDS& hds) {
+		// Postcondition: hds is a valid polyhedral surface.
+		CGAL::Polyhedron_incremental_builder_3<HDS> B(hds);
+
+		int Nv = 0, Nf = 0;
+		for (auto& f : input) {
+			Nv += 3;
+			Nf += 1;
+		}
+
+		B.begin_surface(Nv, Nf);
+
+		for (auto& f : input) {
+			auto p0 = f->facet_begin()->vertex()->point();
+			auto p1 = f->facet_begin()->next()->vertex()->point();
+			auto p2 = f->facet_begin()->next()->next()->vertex()->point();
+
+			auto O = CGAL::centroid(p0, p1, p2);
+
+			Kernel_::Point_3* p012[3] = { &p0, &p1, &p2 };
+			for (int i = 0; i < 3; ++i) {
+				*p012[i] = CGAL::ORIGIN + (((*(p012[i])) - CGAL::ORIGIN) + ((*(p012[i])) - O));
+				B.add_vertex(*p012[i]);
+			}
+		}
+
+		Nv = 0;
+		for (int i = 0; i < Nf; ++i) {
+			B.begin_facet();
+			B.add_vertex_to_facet(Nv++);
+			B.add_vertex_to_facet(Nv++);
+			B.add_vertex_to_facet(Nv++);
+			B.end_facet();
+		}
+
+		B.end_surface();
+	}
+};
+
+template <typename Ts>
+std::list<cgal_shape_t::Facet_handle> connected_faces(cgal_shape_t::Facet_handle f, const Ts& excluded) {
+	std::set<cgal_shape_t::Facet_handle> fs = { f };
+
+	std::function<void(cgal_shape_t::Facet_handle& f)> process;
+	process = [&fs, &process, &excluded](cgal_shape_t::Facet_handle& f) {
+		cgal_shape_t::Halfedge_around_facet_circulator circ = f->facet_begin(), end(circ);
+		do {
+			auto ff = circ->opposite()->facet();
+			if (excluded.find(ff) == excluded.end()) {
+				auto p = fs.insert(ff);
+				if (p.second) {
+					process(ff);
+				}
+			}
+		} while (++circ != end);
+	};
+
+	process(f);
+	return std::list<cgal_shape_t::Facet_handle>(fs.begin(), fs.end());
+}
+
+template <class HDS>
+struct Builder_With_Map : public CGAL::Modifier_base<HDS> {
+	std::list<cgal_shape_t::Facet_handle> input;
+	std::map<Kernel_::Point_3, Kernel_::Point_3> mapping;
+
+	void operator()(HDS& hds) {
+		// Postcondition: hds is a valid polyhedral surface.
+		CGAL::Polyhedron_incremental_builder_3<HDS> B(hds);
+
+		std::set<Kernel_::Point_3> used_points;
+
+		for (auto& f : input) {
+			cgal_shape_t::Halfedge_around_facet_circulator circ = f->facet_begin(), end(circ);
+			do {
+				auto P = circ->vertex()->point();
+				auto it = mapping.find(P);
+				if (it == mapping.end()) {
+					std::wcout << "WARNING unprojected point :(" << std::endl;
+				} else {
+					P = it->second;
+				}
+				used_points.insert(P);
+			} while (++circ != end);
+		}
+
+		B.begin_surface(used_points.size(), input.size());
+
+		for (auto& p : used_points) {
+			B.add_vertex(p);
+		}
+
+		for (auto& f : input) {
+			B.begin_facet();
+			cgal_shape_t::Halfedge_around_facet_circulator circ = f->facet_begin(), end(circ);
+			do {
+				auto P = circ->vertex()->point();
+				auto it = mapping.find(P);
+				if (it == mapping.end()) {
+					std::wcout << "WARNING unprojected point :(" << std::endl;
+				} else {
+					P = it->second;
+				}
+
+				auto jt = used_points.find(P);
+				if (jt == used_points.end()) {
+					throw std::runtime_error("Unable to map point");
+				}
+				size_t idx = std::distance(used_points.begin(), jt);
+				std::wcout << "idx " << idx << std::endl;
+				B.add_vertex_to_facet(idx);
+			} while (++circ != end);
+
+			B.end_facet();
+		}
+
+		B.end_surface();
+	}
+};
+
+double facet_area(const cgal_shape_t::Facet_handle& f);
+
+void dump_facet(const cgal_shape_t::Facet_handle& f);
+
+struct remove_thickness {
+	typedef Kernel_::Point_3 Point;
+	typedef Kernel_::Plane_3 Plane;
+	typedef Kernel_::Vector_3 Vector;
+	typedef Kernel_::Segment_3 Segment;
+	typedef Kernel_::Ray_3 Ray;
+
+	typedef CGAL::Polyhedron_3<Kernel_> Polyhedron;
+	typedef CGAL::AABB_face_graph_triangle_primitive<Polyhedron> Primitive;
+	typedef CGAL::AABB_traits<Kernel_, Primitive> Traits;
+	typedef CGAL::AABB_tree<Traits> Tree;
+	typedef boost::optional<Tree::Intersection_and_primitive_id<Ray>::Type> Ray_intersection;
+
+	cgal_shape_t polyhedron, polyhedron2, flattened;
+
+	remove_thickness(const cgal_shape_t& p)
+		// edge_collapse(p) still does not work :(
+		: polyhedron(p)
+		, polyhedron2(p) {
+		CGAL::Polygon_mesh_processing::triangulate_faces(polyhedron);
+		CGAL::Polygon_mesh_processing::triangulate_faces(polyhedron2);
+
+		std::list<cgal_shape_t::Facet_handle> non_degenerate, degenerate, longitudonal;
+		std::set<cgal_shape_t::Facet_iterator> thin_sides;
+
+		std::wcout << "ALL FACES:" << std::endl;
+
+		for (auto& f : faces(polyhedron)) {
+			dump_facet(f);
+			if (facet_area(f) > 1.e-20) {
+				non_degenerate.push_back(f);
+			} else {
+				degenerate.push_front(f);
+				std::wcout << "Degenerate, area: " << facet_area(f) << std::endl;
+			}
+		}
+
+		std::wcout << "NON DEGENERATE:" << std::endl;
+		for (auto& f : non_degenerate) {
+			dump_facet(f);
+		}
+
+		cgal_shape_t enlarged_non_degenerate_triangles;
+		Build_Offset<cgal_shape_t::HDS> bo;
+		bo.input = non_degenerate;
+		enlarged_non_degenerate_triangles.delegate(bo);
+
+		// @todo, first on non-enlarged faces, then on enlarged; to fix projection on concave surfaces where the enlarging operation shortens projection distances.
+
+		Tree tree(faces(enlarged_non_degenerate_triangles).first, faces(enlarged_non_degenerate_triangles).second, enlarged_non_degenerate_triangles);
+
+		std::map<cgal_face_descriptor_t, Kernel_::Vector_3> face_normals;
+		boost::associative_property_map<std::map<cgal_face_descriptor_t, Kernel_::Vector_3>> face_normals_map(face_normals);
+		CGAL::Polygon_mesh_processing::compute_face_normals(polyhedron, face_normals_map);
+
+		for (auto& f : non_degenerate) {
+			auto O = CGAL::centroid(
+				f->facet_begin()->vertex()->point(),
+				f->facet_begin()->next()->vertex()->point(),
+				f->facet_begin()->next()->next()->vertex()->point()
+			);
+
+			Ray ray(O, -face_normals_map[f]);
+
+			std::list<Ray_intersection> intersections;
+			tree.all_intersections(ray, std::back_inserter(intersections));
+			double N = std::numeric_limits<double>::infinity();
+			Point P;
+			for (auto& intersection : intersections) {
+				if (boost::get<Point>(&(intersection->first))) {
+					const Point* p = boost::get<Point>(&(intersection->first));
+					const double d = std::sqrt(CGAL::to_double((*p - O).squared_length()));
+					if (d > 1.e-20 && d < N) {
+						N = d;
+					}
+				}
+			}
+			if (N != std::numeric_limits<double>::infinity() && N > 1.e-4) {
+				thin_sides.insert(f);
+			}
+		}
+
+		std::wcout << "THIN SIDES:" << std::endl;
+		for (auto& f : thin_sides) {
+			dump_facet(f);
+		}
+
+		for (auto& f : non_degenerate) {
+			if (thin_sides.find(f) == thin_sides.end()) {
+				longitudonal.push_back(f);
+			}
+		}
+
+		std::wcout << "LONGITUDONAL:" << std::endl;
+		for (auto& f : longitudonal) {
+			dump_facet(f);
+		}
+
+		std::wcout << "faces " << faces(polyhedron).size() << "long " << longitudonal.size() << "thin " << thin_sides.size() << "non-degen " << non_degenerate.size() << std::endl;
+
+		cgal_shape_t enlarged_indiv_triangles;
+		Build_Offset<cgal_shape_t::HDS> bo2;
+		bo2.input = longitudonal;
+		enlarged_indiv_triangles.delegate(bo2);
+
+		{
+			std::ofstream ofs("enlarged.off");
+			ofs.precision(17);
+			ofs << enlarged_indiv_triangles;
+		}
+
+		Tree tree2(faces(enlarged_indiv_triangles).begin(), faces(enlarged_indiv_triangles).end(), enlarged_indiv_triangles);
+
+		std::map<Kernel_::Point_3, Kernel_::Point_3> new_points;
+
+		for (Polyhedron::Facet_iterator fit = polyhedron.facets_begin();
+			fit != polyhedron.facets_end();
+			++fit) {
+			if (CGAL::collinear(
+				fit->halfedge()->vertex()->point(),
+				fit->halfedge()->next()->vertex()->point(),
+				fit->halfedge()->opposite()->vertex()->point())) {
+				std::wcout << "degenerate triangle" << std::endl;
+			}
+		}
+
+		for (auto& v : vertices(polyhedron)) {
+			auto O = v->point();
+
+			Kernel_::Vector_3 norm;
+			Kernel_::Vector_3 accum;
+			int count = 0;
+			CGAL::Face_around_target_circulator<cgal_shape_t> it(v->halfedge(), polyhedron), end(it);
+			do {
+				cgal_shape_t::Facet_handle fh = (*it)->halfedge()->facet();
+
+				auto jt = std::find(non_degenerate.begin(), non_degenerate.end(), fh);
+				std::wcout << "non degen: " << (jt != non_degenerate.end()) << std::endl;
+				auto kt = std::find(thin_sides.begin(), thin_sides.end(), fh);
+				std::wcout << "thin side: " << (kt != thin_sides.end()) << std::endl;
+				if (jt != non_degenerate.end() && kt == thin_sides.end()) {
+					// else degenerate, prevent div by zero, do not incorporate in vnorm.
+					// or else part of thin side
+
+					auto p0 = (*it)->facet_begin()->vertex()->point();
+					auto p1 = (*it)->facet_begin()->next()->vertex()->point();
+					auto p2 = (*it)->facet_begin()->next()->next()->vertex()->point();
+
+					{
+						std::ostringstream oss;
+						oss.precision(8);
+						oss << "p0 " << p0.cartesian(0) << " " << p0.cartesian(1) << " " << p0.cartesian(2) << "\n";
+						oss << "p1 " << p1.cartesian(0) << " " << p1.cartesian(1) << " " << p1.cartesian(2) << "\n";
+						oss << "p2 " << p2.cartesian(0) << " " << p2.cartesian(1) << " " << p2.cartesian(2) << "\n";
+						auto osss = oss.str();
+						std::wcout << osss.c_str() << std::endl;
+					}
+
+					auto fnorm = CGAL::cross_product(p0 - p1, p2 - p1);
+					fnorm /= std::sqrt(CGAL::to_double(fnorm.squared_length()));
+
+					// const auto& fnorm = face_normals_map_2[*it];
+					std::ostringstream oss;
+					oss.precision(8);
+					oss << fnorm.cartesian(0) << " " << fnorm.cartesian(1) << " " << fnorm.cartesian(2);
+					auto osss = oss.str();
+					std::wcout << osss.c_str() << std::endl;
+					accum += fnorm;
+
+					++count;
+				}
+
+				++it;
+			} while (it != end);
+
+			norm = accum / count;
+			std::wcout << "count " << count << std::endl;
+
+			if (count == 0) {
+				// part of only degenerate or only thin sides
+				continue;
+			}
+
+			// v->vertex_begin();
+			Ray ray(O, norm);
+			std::ostringstream oss;
+			oss.precision(8);
+			oss << O << " -> " << norm;
+			auto osss = oss.str();
+			std::wcout << osss.c_str() << std::endl;
+
+			std::list<Ray_intersection> intersections;
+			tree2.all_intersections(ray, std::back_inserter(intersections));
+			double N = std::numeric_limits<double>::infinity();
+			Point P;
+
+			bool used_intersection = false;
+
+			if (intersections.size()) {
+				for (auto& intersection : intersections) {
+					if (boost::get<Point>(&(intersection->first))) {
+						const Point* p = boost::get<Point>(&(intersection->first));
+						const double d = std::sqrt(CGAL::to_double((*p - O).squared_length()));
+						if (d < N && d > 1.e-20) {
+							N = d;
+							P = *p;
+							std::wcout << "intersection @ " << d << std::endl;
+						}
+					}
+				}
+				std::wcout << "-----------" << std::endl;
+
+				// average the new point
+				new_points[O] = CGAL::ORIGIN + (((O - CGAL::ORIGIN) + (P - CGAL::ORIGIN))) / 2;
+				used_intersection = true;
+			}
+
+			if (!used_intersection) {
+				std::wcout << "no intersection :(" << std::endl;
+			}
+		}
+
+		auto thin_sides_degenerate = thin_sides;
+		thin_sides_degenerate.insert(degenerate.begin(), degenerate.end());
+
+		// @todo choose connected / connected_opposing based on largest combined area of facets?
+
+		if (longitudonal.size() == 0) {
+			std::wcout << "no longitudonal faces detected :(" << std::endl;
+			return;
+		}
+
+		auto connected = connected_faces(*longitudonal.begin(), thin_sides_degenerate);
+		decltype(connected) connected_opposing;
+
+		for (auto& f : longitudonal) {
+			if (std::find(connected.begin(), connected.end(), f) == connected.end()) {
+				connected_opposing = connected_faces(f, thin_sides_degenerate);
+
+				std::set<cgal_shape_t::Facet_handle> longi(longitudonal.begin(), longitudonal.end());
+				std::set<cgal_shape_t::Facet_handle> both_sides(connected.begin(), connected.end());
+				both_sides.insert(connected_opposing.begin(), connected_opposing.end());
+
+				if (longi == both_sides) {
+					std::wcout << "Facet connection functioning properly" << std::endl;
+				} else {
+					std::wcout << "Facet connection functioning incorrectly" << std::endl;
+				}
+
+				break;
+			}
+		}
+
+		Builder_With_Map<cgal_shape_t::HDS> b2;
+		b2.input = connected;
+		b2.mapping = new_points;
+
+		flattened.delegate(b2);
+	}
+};
+
+
+struct intersection_validator {
+	typedef std::list<std::pair<IfcUtil::IfcBaseEntity*, CGAL::Nef_polyhedron_3<Kernel_>> > nefs_t;
+	typedef CGAL::Box_intersection_d::Box_with_handle_d<double, 3, nefs_t::value_type*> Box;
+
+	std::vector<Box> boxes;
+	nefs_t nefs;
+
+	double total_map_time = 0.;
+	double total_geom_time = 0.;
+	double total_nef_time = 0.;
+	double total_minkowsky_time = 0.;
+	double total_box_time = 0.;
+
+	std::set<IfcUtil::IfcBaseEntity*> succesfully_processed;
+
+	intersection_validator(IfcParse::IfcFile& f, std::initializer_list<std::string> entities, double eps, bool no_progress, bool quiet, bool stderr_progress) {
+
+		ifcopenshell::geometry::settings settings;
+		settings.set(ifcopenshell::geometry::settings::USE_WORLD_COORDS, false);
+		settings.set(ifcopenshell::geometry::settings::WELD_VERTICES, false);
+		settings.set(ifcopenshell::geometry::settings::SEW_SHELLS, true);
+		settings.set(ifcopenshell::geometry::settings::CONVERT_BACK_UNITS, true);
+		settings.set(ifcopenshell::geometry::settings::DISABLE_TRIANGULATION, true);
+		settings.set(ifcopenshell::geometry::settings::DISABLE_OPENING_SUBTRACTIONS, true);
+
+		std::vector<ifcopenshell::geometry::filter_t> spaces_and_walls = {
+			IfcGeom::entity_filter(true, false, entities)
+		};
+
+		ifcopenshell::geometry::Iterator context_iterator("cgal", settings, &f, spaces_and_walls);
+
+		if (!context_iterator.initialize()) {
+			return;
+		}
+
+		auto polycube = ifcopenshell::geometry::utils::create_cube(eps);
+		auto cube = ifcopenshell::geometry::utils::create_nef_polyhedron(polycube);
+
+		size_t num_created = 0;
+		int old_progress = quiet ? 0 : -1;
+
+		for (;; ++num_created) {
+			bool has_more = true;
+			if (num_created) {
+				has_more = context_iterator.next();
+			}
+			ifcopenshell::geometry::NativeElement* geom_object = nullptr;
+			if (has_more) {
+				geom_object = context_iterator.get_native();
+			}
+			if (!geom_object) {
+				break;
+			}
+
+			std::stringstream ss;
+			ss << geom_object->product()->data().toString();
+			auto sss = ss.str();
+			std::wcout << sss.c_str() << std::endl;
+
+			for (auto& g : geom_object->geometry()) {
+				auto s = ((ifcopenshell::geometry::CgalShape*) g.Shape())->shape();
+				const auto& m = g.Placement().ccomponents();
+				const auto& n = geom_object->transformation().data().ccomponents();
+
+				const cgal_placement_t trsf(
+					m(0, 0), m(0, 1), m(0, 2), m(0, 3),
+					m(1, 0), m(1, 1), m(1, 2), m(1, 3),
+					m(2, 0), m(2, 1), m(2, 2), m(2, 3));
+
+				const cgal_placement_t trsf2(
+					n(0, 0), n(0, 1), n(0, 2), n(0, 3),
+					n(1, 0), n(1, 1), n(1, 2), n(1, 3),
+					n(2, 0), n(2, 1), n(2, 2), n(2, 3));
+
+				// Apply transformation
+				for (auto &vertex : vertices(s)) {
+					vertex->point() = vertex->point().transform(trsf).transform(trsf2);
+				}
+
+				std::clock_t nef_begin = std::clock();
+				CGAL::Nef_polyhedron_3<Kernel_> nef = ifcopenshell::geometry::utils::create_nef_polyhedron(s);
+				std::clock_t nef_end = std::clock();
+				total_nef_time += (nef_end - nef_begin) / (double) CLOCKS_PER_SEC;
+				if (nef.is_empty()) {
+					std::wcout << "Failed to create nef" << std::endl;
+					continue;
+				}
+
+				succesfully_processed.insert(geom_object->product());
+
+				nef = CGAL::minkowski_sum_3(nef, cube);
+				std::clock_t minkowski_end = std::clock();
+				total_minkowsky_time += (minkowski_end - nef_end) / (double) CLOCKS_PER_SEC;
+
+				std::wcout << "product: " << geom_object->product() << std::endl;
+				nefs.push_back({ geom_object->product(), nef });
+
+				Box b(&*(nefs.rbegin()));
+				// id_map[b.id()] = ;
+
+				for (auto &vertex : vertices(s)) {
+					double p[3] = {
+						CGAL::to_double(vertex->point().cartesian(0)),
+						CGAL::to_double(vertex->point().cartesian(1)),
+						CGAL::to_double(vertex->point().cartesian(2))
+					};
+					b.extend(p);
+				}
+
+				boxes.push_back(enlarge(b));
+
+				/*
+				std::ostringstream ss;
+				ss << geom_object->product()->data().toString() << std::endl << b.min_coord(0) << " - " << b.max_coord(0) << std::endl;
+				auto sss = ss.str();
+				std::wcout << sss.c_str();
+				*/
+			}
+
+			if (!no_progress) {
+				if (quiet) {
+					const int progress = context_iterator.progress();
+					for (; old_progress < progress; ++old_progress) {
+						std::cout << ".";
+						if (stderr_progress)
+							std::cerr << ".";
+					}
+					std::cout << std::flush;
+					if (stderr_progress)
+						std::cerr << std::flush;
+				} else {
+					const int progress = context_iterator.progress() / 2;
+					if (old_progress != progress) Logger::ProgressBar(progress);
+					old_progress = progress;
+				}
+			}
+		}
+
+		if (!no_progress && quiet) {
+			for (; old_progress < 100; ++old_progress) {
+				std::cout << ".";
+				if (stderr_progress)
+					std::cerr << ".";
+			}
+			std::cout << std::flush;
+			if (stderr_progress)
+				std::cerr << std::flush;
+		} else {
+			Logger::Status("\rDone fixing space boundaries for " + boost::lexical_cast<std::string>(num_created) +
+				" objects                                ");
+		}
+
+		total_geom_time = context_iterator.converter().total_geom_time;
+		total_map_time = context_iterator.converter().total_map_time;
+	}
+
+	template <typename Fn>
+	void operator()(Fn fn) {
+		std::clock_t box_overlap_begin = std::clock();
+		CGAL::box_self_intersection_d(boxes.begin(), boxes.end(), [](Box& x, Box& y) {});
+		std::clock_t box_overlap_end = std::clock();
+		total_box_time += (box_overlap_end - box_overlap_begin) / (double) CLOCKS_PER_SEC;
+		CGAL::box_self_intersection_d(boxes.begin(), boxes.end(), fn);
+	}
+};

src/ifcexpressparser/IfcDocumentation.py

@@ -1,71 +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 files uses the documentation files from buildingSMART to generate      #
-# descriptions from EXPRESS names that are suitable for comments in the C++   #
-# code. The .csv files used by this file are generated from the MS Office     #
-# Access database, which in turn has been generated from the IFC baseline     #
-# documentation by the IFCDOC utility provided by buildingSMART.              #
-#                                                                             #
-###############################################################################
-
-import re,csv
-import csv
-try: from html.entities import entitydefs
-except: from htmlentitydefs import entitydefs
-
-name_to_oid = {}
-oid_to_desc = {}
-oid_to_name = {}
-oid_to_pid = {}
-regices = list(zip([re.compile(s,re.M) for s in [r'<[\w\n=" \-/\.;_\t:%#,\?\(\)]+>',r'(\n[\t ]*){2,}',r'^[\t ]+','^']],['','\n\n','  ','/// ']))
-
-definition_files = ['DocEntity.csv', 'DocEnumeration.csv', 'DocDefined.csv', 'DocSelect.csv']
-for fn in definition_files:
-    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('DocEntityAttributes.csv') as f:
-    for pid, x, oid in csv.reader(f, delimiter=';', quotechar='"'):
-        oid_to_pid[oid] = pid
-        
-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[(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)
-    if desc:
-        for a,b in entitydefs.items(): desc = desc.replace("&%s;"%a,b)
-        desc = desc.replace("\r","")
-        for r,s in regices[:-1]: desc = r.sub(s,desc)
-        desc = desc.strip()
-        r,s = regices[-1]
-        desc = r.sub(s,desc)
-    return desc

src/ifcexpressparser/IfcExpressParser.py

@@ -1,779 +0,0 @@
-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, 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
-    def get_attributes(self, get_parent=True):
-        s = entity_map[self.parent_class].get_attributes() if get_parent and self.parent_class else []
-        s += [(a.name,not not a.optional,a.type.type_enum(),a.type.type if a.is_enum() else None) for a in self.arguments.l]
-        return s
-    def get_constructor_args(self):
-        s = entity_map[self.parent_class].get_constructor_args() if self.parent_class else []
-        i = len(s) + 1
-        s += ["%s v%d_%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_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))
-            else: s.append(impl)
-            b += 1
-        return s#"; ".join(s)
-    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(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 = skip(a('DERIVE') + many(clause))
-
-entity = entity_start + arguments + skip(maybe(unique)) + skip(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')
-h2_file = open("%s-rt.h"%schema_version,'w')
-enumh_file = open("%senum.h"%schema_version,'w')
-cpp_file = open("%s.cpp"%schema_version,'w')
-cpp2_file = open("%s-rt.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 >>h2_file, header
-print >>enumh_file, header
-print >>cpp_file, header
-print >>cpp2_file, header
-print >>h_file, """#ifndef %(schema_upper)s_H
-#define %(schema_upper)s_H
-
-#include <string>
-#include <vector>
-#include <map>
-#include <set>
-
-#include <boost/optional.hpp>
-
-#include "../ifcparse/IfcUtil.h"
-#include "../ifcparse/IfcException.h"
-#include "../ifcparse/ArgumentType.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(simple_types)
-entity_enumerations = sorted(entity_names)
-all_enumerations = simple_enumerations + entity_enumerations
-
-print >>enumh_file, """#ifndef IFC2X3ENUM_H
-#define IFC2X3ENUM_H
-
-#include "../ifcparse/ArgumentType.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"])}
-print >>h2_file, """#ifndef IFC2X3RT_H
-#define IFC2X3RT_H
-
-#include "../ifcparse/ArgumentType.h"
-
-namespace Ifc2x3 {
-namespace Type {
-    int GetAttributeCount(Enum t);
-    int GetAttributeIndex(Enum t, const std::string& a);
-    IfcUtil::ArgumentType GetAttributeType(Enum t, unsigned char a);
-    const std::string& GetAttributeName(Enum t, unsigned char a);
-    bool GetAttributeOptional(Enum t, unsigned char a);
-    std::pair<const char*, int> GetEnumerationIndex(Enum t, const std::string& a);
-    Enum GetAttributeEnumerationClass(Enum t, unsigned char a);
-}}
-
-#endif
-"""
-
-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 >>cpp2_file, """#include "../ifcparse/%(schema)s.h"
-#include "../ifcparse/%(schema)s-rt.h"
-#include "../ifcparse/IfcException.h"
-#include "../ifcparse/IfcWrite.h"
-#include "../ifcparse/IfcWritableEntity.h"
-#include "../ifcparse/ArgumentType.h"
-
-using namespace %(schema)s;
-using namespace IfcParse;
-using namespace IfcWrite;"""%{'schema':schema_version}
-print >>cpp_file, """#include "../ifcparse/%(schema)s.h"
-#include "../ifcparse/IfcException.h"
-#include "../ifcparse/IfcWrite.h"
-#include "../ifcparse/IfcWritableEntity.h"
-#include "../ifcparse/ArgumentType.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, "std::map<std::string,Type::Enum> string_map;"
-print >>cpp2_file, "std::map<Type::Enum,IfcEntityDescriptor*> entity_descriptor_map;"
-print >>cpp2_file, "std::map<Type::Enum,IfcEnumerationDescriptor*> enumeration_descriptor_map;"
-maxlen = max([len(e) for e in all_enumerations])
-string_map,attribute_count_map,attribute_index_map,attribute_name_map,attribute_optional_map,attribute_type_map = [""]*6
-print >>cpp2_file, "void InitDescriptorMap() {"
-print >>cpp2_file, "    IfcEntityDescriptor* current;"
-for k,v in simple_types.items():
-    if k in enumerations or k in selections: continue
-    print >>cpp2_file, "    current = entity_descriptor_map[Type::%s] = new IfcEntityDescriptor(Type::%s,0);"%(k,k)
-    print >>cpp2_file, "    current->add(\"wrappedValue\",false,%s);"%(v.type_enum())
-rt_entities = set()
-while True:
-    todo = [e for e in entities if e.class_name not in rt_entities]
-    if len(todo) == 0: break
-    for e in todo:
-        if e.parent_class and e.parent_class not in rt_entities: continue
-        rt_entities.add(e.class_name)
-        args = e.get_attributes(False)
-        parent_descriptor = ("entity_descriptor_map.find(Type::%s)->second"%e.parent_class) if e.parent_class else "0" 
-        print >>cpp2_file, "    current = entity_descriptor_map[Type::%s] = new IfcEntityDescriptor(Type::%s,%s);"%(e.class_name,e.class_name,parent_descriptor)
-        for a,i in zip(args,range(len(args))):
-            name,optional,type,enum_class = a
-            if enum_class:
-                print >>cpp2_file, "    current->add(\"%s\",%s,%s,Type::%s);"%(name,"true" if optional else "false",type,enum_class)
-            else:
-                print >>cpp2_file, "    current->add(\"%s\",%s,%s);"%(name,"true" if optional else "false",type)
-print >>cpp2_file, "    // Enumerations"
-print >>cpp2_file, "    IfcEnumerationDescriptor* current_enum;"
-print >>cpp2_file, "    std::vector<std::string> values;"
-for e, name in [(e, name) for name, e in simple_types.items() if name in enumerations]:
-    print >>cpp2_file, "    values.clear(); values.reserve(128);"
-    for value in e.type.v:
-        print >>cpp2_file, "    values.push_back(\"%s\");"%value[0]
-    print >>cpp2_file, "    current_enum = enumeration_descriptor_map[Type::%s] = new IfcEnumerationDescriptor(Type::%s, values);"%(name,name)
-print >>cpp2_file, "}"
-        
-for e in all_enumerations:
-    string_map += '    string_map["%s"%s] = Type::%s;\n'%(e.upper()," "*(maxlen-len(e)),e)
-print >>cpp_file, """void Ifc2x3::InitStringMap() {
-    %(string_map)s
-}"""%locals()
-
-print >>cpp_file, """Type::Enum Type::FromString(const std::string& s) {
-    if (string_map.empty()) ::Ifc2x3::InitStringMap();
-    std::map<std::string,Type::Enum>::const_iterator it = string_map.find(s);
-    if ( it == string_map.end() ) throw IfcException("Unable to find find keyword in schema");
-    else return it->second;
-}"""
-
-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,
-print >>cpp_file, ""
-
-print >>cpp2_file, """int Type::GetAttributeIndex(Enum t, const std::string& a) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else return i->second->getArgumentIndex(a);
-}
-
-int Type::GetAttributeCount(Enum t) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else return i->second->getArgumentCount();
-}
-
-ArgumentType Type::GetAttributeType(Enum t, unsigned char a) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else return i->second->getArgumentType(a);
-}
-
-const std::string& Type::GetAttributeName(Enum t, unsigned char a) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else return i->second->getArgumentName(a);
-}
-
-bool Type::GetAttributeOptional(Enum t, unsigned char a) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else return i->second->getArgumentOptional(a);
-}
-
-std::pair<const char*, int> Type::GetEnumerationIndex(Enum t, const std::string& a) {
-    if (enumeration_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEnumerationDescriptor*>::const_iterator i = enumeration_descriptor_map.find(t);
-    if ( i == enumeration_descriptor_map.end() ) throw IfcException("Value not found");
-    else return i->second->getIndex(a);
-}
-
-Type::Enum Type::GetAttributeEnumerationClass(Enum t, unsigned char a) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else {
-        Type::Enum t = i->second->getArgumentEnumerationClass(a);
-        if ( t == Type::ALL ) throw IfcException("Not an enumeration");
-        else return t;
-    }
-}
-"""

src/ifcexpressparser/README.txt

@@ -4,6 +4,8 @@ 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 library is required.
+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

@@ -19,8 +19,14 @@
 
 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]
@@ -56,12 +62,12 @@ class Keyword:
 class Terminal:
     def __init__(self, contents):
         self.contents = contents[0]
-    def __repr__(self):
         s = self.contents
-        is_keyword = len(s) >= 4 and s[0::len(s)-1] == '""' and \
+        self.is_keyword = len(s) >= 4 and s[0::len(s)-1] == '""' and \
             all(c in alphanums+"_" for c in s[1:-1])
-        ty = "CaselessKeyword" if is_keyword else "CaselessLiteral"
-        return "%s(%s)" % (ty, s)
+    def __repr__(self):
+        ty = "CaselessKeyword" if self.is_keyword else "CaselessLiteral"
+        return "%s(%s)" % (ty, self.contents)
 
 
 LPAREN = Suppress("(")
@@ -94,16 +100,16 @@ grammar.ignore(HASH + restOfLine)
 
 express = grammar.parseFile(sys.argv[1])
 
-def find_keywords(expr, li = None):
+def find_bytype(expr, ty, li = None):
     if li is None: li = []
     if isinstance(expr, Term):
         expr = expr.contents
-    if isinstance(expr, Keyword):
-        li.append(repr(expr))
-        return li
+    if isinstance(expr, ty):
+        li.append(expr)
+        return set(li)
     elif isinstance(expr, Expression):
         for term in expr:
-            find_keywords(term, li)
+            find_bytype(term, ty, li)
     return set(li)
 
 actions = {
@@ -115,13 +121,16 @@ actions = {
     'general_aggregation_types' : "lambda t: AggregationType(t)",
     'select_type'               : "lambda t: SelectType(t)",
     'binary_type'               : "lambda t: BinaryType(t)",
-    'subtype_declaration'       : "lambda t: SubtypeExpression(t)",
+    '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)
@@ -129,18 +138,22 @@ 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 = find_keywords(expr)
+        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 = "originalTextFor(Combine%s)" % stmt
+                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))
@@ -158,36 +171,42 @@ for id in to_emit:
         stmt = "Suppress%s" % stmt
     statements.append("%s << %s" % (id, stmt))
 
-print ("""import sys
-from pyparsing import *
-from nodes import *
+print ("""import os
+import sys
+import pickle
 
-%s
+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
 
-import schema
-import mapping
+    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 enum_header
 import implementation
-import rt_header
-import rt_implementation
-
-syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))"))
-ast = syntax.parseFile(sys.argv[1])
-schema = schema.Schema(ast)
-mapping = mapping.Mapping(schema)
+import schema_class
+import definitions
 
 header.Header(mapping).emit()
-enum_header.EnumHeader(mapping).emit()
 implementation.Implementation(mapping).emit()
-rt_header.RuntimeTypingHeader(mapping).emit()
-rt_implementation.RuntimeTypingImplementation(mapping).emit()
+schema_class.SchemaClass(mapping).emit()
+definitions.Definitions(mapping).emit()
 
-def retry():
-    import imp
-    imp.reload(rt_header)
-    imp.reload(rt_implementation)
-    rt_header.RuntimeTypingHeader(mapping).emit()
-    rt_implementation.RuntimeTypingImplementation(mapping).emit()
-"""%('\n'.join(statements)))
+sys.stdout.write(schema.name)
+"""%('\n    '.join(statements)))

src/ifcexpressparser/codegen.py

@@ -17,22 +17,19 @@
 #                                                                             #
 ###############################################################################
 
-import templates
-
-class EnumHeader:
-    def __init__(self, mapping):
-        enumerable_types = sorted(set([name for name, type in mapping.schema.types.items()] + [name for name, type in mapping.schema.entities.items()]))
-        
-        self.str = templates.enum_header % {
-            'schema_name_upper' : mapping.schema.name.upper(),
-            'schema_name'       : mapping.schema.name.capitalize(),
-            'types'             : ', '.join(enumerable_types)
-        }
-        
-        self.schema_name = mapping.schema.name.capitalize()
-    def __repr__(self):
-        return self.str
+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):
-        f = open('%senum.h'%self.schema_name, 'w', encoding='utf-8')
-        f.write(str(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

@@ -0,0 +1,62 @@
+###############################################################################
+#                                                                             #
+# 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/documentation.py

@@ -27,34 +27,41 @@
 #                                                                             #
 ###############################################################################
 
-import re,csv
+import re
+import os
 import csv
+
+from schema import OrderedCaseInsensitiveDict 
+
 try: from html.entities import entitydefs
 except: from htmlentitydefs import entitydefs
 
-name_to_oid = {}
+make_absolute = lambda fn: os.path.join(os.path.dirname(os.path.realpath(__file__)), fn)
+
+name_to_oid = OrderedCaseInsensitiveDict()
 oid_to_desc = {}
 oid_to_name = {}
 oid_to_pid = {}
 regices = list(zip([re.compile(s,re.M) for s in [r'<[\w\n=" \-/\.;_\t:%#,\?\(\)]+>',r'(\n[\t ]*){2,}',r'^[\t ]+']],['','\n\n','  ']))
 
 definition_files = ['DocEntity.csv', 'DocEnumeration.csv', 'DocDefined.csv', 'DocSelect.csv']
+definition_files = map(make_absolute, definition_files)
 for fn in definition_files:
-    with open(fn) as f:
+    with open(fn, encoding="utf8", errors='ignore') 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('DocEntityAttributes.csv') as f:
+with open(make_absolute('DocEntityAttributes.csv')) as f:
     for pid, x, oid in csv.reader(f, delimiter=';', quotechar='"'):
         oid_to_pid[oid] = pid
 
-with open('DocAttribute.csv') as f:
+with open(make_absolute('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[(pname, name)] = oid
+        name_to_oid[".".join((pname, name))] = oid
         oid_to_desc[oid] = desc
 
 def description(item):
@@ -67,4 +74,4 @@ def description(item):
         for r,s in regices: desc = r.sub(s,desc)
         desc = desc.strip()
         return desc.split("\n")
-    else: return []
+    else: return []

src/ifcexpressparser/express.bnf

@@ -1,5 +1,3 @@
-# Taken from http://sourceforge.net/p/exp-engine/expresso/ci/master/tree/docs/iso-10303-11--2004.bnf
-
 ABS = "abs" .
 ABSTRACT = "abstract" .
 ACOS = "acos" .
@@ -202,7 +200,7 @@ constructed_types = enumeration_type | select_type .
 declaration = entity_decl | function_decl | procedure_decl | subtype_constraint_decl | type_decl .
 derived_attr = attribute_decl ":" parameter_type ":=" expression ";" .
 derive_clause = DERIVE derived_attr { derived_attr } .
-domain_rule = rule_label_id ":" expression .
+domain_rule = [ rule_label_id ":" ] expression .
 element = expression [ ":" repetition ] .
 entity_body = { explicit_attr } [ derive_clause ] [ inverse_clause ] [ unique_clause ] [ where_clause ] .
 entity_constructor = entity_ref "(" [ expression { "," expression } ] ")" .
@@ -334,7 +332,7 @@ type_label_id = simple_id .
 unary_op = "+" | "-" | NOT .
 underlying_type = constructed_types | concrete_types .
 unique_clause = UNIQUE unique_rule ";" { unique_rule ";" } .
-unique_rule = rule_label_id ":" referenced_attribute { "," referenced_attribute } .
+unique_rule = [ rule_label_id ":" ] referenced_attribute { "," referenced_attribute } .
 until_control = UNTIL logical_expression .
 use_clause = USE FROM schema_ref [ "(" named_type_or_rename { "," named_type_or_rename } ")" ] ";" .
 variable_id = simple_id .

src/ifcexpressparser/header.py

@@ -17,39 +17,45 @@
 #                                                                             #
 ###############################################################################
 
+import operator
+
+import codegen
 import templates
 import documentation
 
-class Header:
+class Header(codegen.Base):
     def __init__(self, mapping):
-        emitted_types = set(mapping.express_to_cpp_typemapping.values())
         declarations = []
 
         write = lambda str, **kwargs: declarations.append(str%dict({
             'documentation': templates.multi_line_comment(documentation.description(kwargs['name']))}, **kwargs))
-
-        for name, type in mapping.schema.simpletypes.items():
-            type_str = mapping.make_type_string(type)
-            type_dep = mapping.get_type_dep(type)
-            if type_dep in emitted_types:
-                write(templates.simpletype, name=name, type=type_str)
-                emitted_types.add(name)
-
+            
+        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)
-            emitted_types.add(name)
-
-        for name, type in mapping.schema.simpletypes.items():
-            if name not in emitted_types:
-                type_str = mapping.make_type_string(type)
-                write(templates.simpletype, name=name, type=type_str)
-                emitted_types.add(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]))
-
-        forward_definitions = "".join(["class %s; "%n for n in mapping.schema.entities.keys()])
+        
+        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 = []
 
@@ -59,17 +65,17 @@ class Header:
         emitted_entities = set()
         while len(emitted_entities) < len(mapping.schema.entities):
             for name, type in mapping.schema.entities.items():
-                if name in emitted_entities: continue
-                if len(type.supertypes) == 0 or set(type.supertypes) < emitted_entities:
+                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();"%(attr.name))
-                        attr_lines.extend(["/// %s"%d for d in documentation.description((name, attr.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();"%(type_str, attr.name))
+                            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]
@@ -87,7 +93,11 @@ class Header:
                     inverse = "\n".join(["%s%s"%(' '*4, a) for a in inv_lines])
                     if len(inverse): inverse += '\n'
 
-                    supertypes = type.supertypes if len(type.supertypes) else ['IfcUtil::IfcBaseEntity']
+                    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)
@@ -95,14 +105,25 @@ class Header:
                     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 ' throw IfcParse::IfcException("argument out of range"); '
+                    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
-
-                    argument_type_function_body_switch_stmt = " switch (i) {%s}"%("".join(['case %d: return %s; '%(i+argument_start, mapping.make_argument_type(attr)) for i, attr in enumerate(type.attributes)])) if len(type.attributes) else ""
-                    argument_type_function_body_tail = (" return %s::getArgumentType(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcException("argument out of range"); '
+                    
+                    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))
 
@@ -118,10 +139,9 @@ class Header:
         }
 
         self.schema_name = mapping.schema.name.capitalize()
+        
+        self.file_name = '%s.h'%self.schema_name
+        
+        
     def __repr__(self):
         return self.str
-    def emit(self):
-        f = open('%s.h'%self.schema_name, 'w', encoding='utf-8')
-        f.write(str(self))
-        f.close()
-

src/ifcexpressparser/implementation.py

@@ -17,15 +17,19 @@
 #                                                                             #
 ###############################################################################
 
+import codegen
 import templates
 
-class Implementation:
+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)
@@ -43,6 +47,8 @@ class Implementation:
                 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)
             )
@@ -52,6 +58,7 @@ class Implementation:
         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 = []
@@ -61,35 +68,59 @@ class Implementation:
                 if not arg['is_inherited'] and not arg['is_derived']:
                     if arg['is_optional']:
                         write_attr(
-                            templates.function,
+                            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 = templates.get_attr_stmt_enum if arg['is_enum'] else templates.get_attr_stmt_array if arg['is_array'] and not mapping.schema.is_simpletype(arg['list_instance_type']) and arg['list_instance_type'] not in mapping.express_to_cpp_typemapping else templates.get_attr_stmt_entity if arg['non_optional_type'].endswith('*') else templates.get_attr_stmt
+                    tmpl = find_template(arg)
                     write_attr(
-                        templates.function,
+                        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'].split('::')[0],
+                                              '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 = templates.set_attr_stmt_enum if arg['is_enum'] else templates.set_attr_stmt_array if arg['is_array'] and not mapping.schema.is_simpletype(arg['list_instance_type']) and arg['list_instance_type'] not in mapping.express_to_cpp_typemapping else 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'].split('::')[0]}
+                                              'type' : arg['non_optional_type'].replace('::Value', '')}
                     )
 
                 if arg['is_derived']:
@@ -104,22 +135,28 @@ class Implementation:
                         else templates.constructor_stmt
                     impl = tmpl % {'name'  : deref_name,
                                    'index' : arg['index']-1,
-                                   'type'  : arg['non_optional_type'].split('::')[0]}
+                                   '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.function % {
+            inverse = [templates.const_function % {
                 'class_name'  : name,
+                'schema_name' : schema_name,
+                'schema_name_upper' : schema_name_upper,
                 'name'        : i.name,
                 'arguments'   : '',
-                'return_type' : '%s::list' % i.entity,
-                'body'        : templates.get_inverse % {'type': i.entity}
+                '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((IfcAbstractEntityPtr)0)" % type.supertypes[0] if len(type.supertypes) == 1 else 'IfcUtil::IfcBaseEntity()'
+            superclass = "%s((IfcEntityInstanceData*)0)" % type.supertypes[0] if len(type.supertypes) == 1 else 'IfcUtil::IfcBaseEntity()'
 
             write(
                 templates.entity_implementation,
@@ -129,11 +166,13 @@ class Implementation:
                 constructor_implementation = cat(constructor_implementations),
                 attributes                 = nl(catnl(attributes)),
                 inverse                    = nl(catnl(inverse)),
-                superclass                 = superclass
+                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(mapping.schema.types.keys()))
-        schema_entity_statements += [templates.schema_simple_stmt%locals() for name in selectable_simple_types]
+        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()]))
@@ -144,35 +183,77 @@ class Implementation:
             '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 = [templates.parent_type_stmt % {
-            'name'    : name,
-            'parent'  : type.supertypes[0],
-            'padding' : ' ' * (max_len - len(name))
-        } for name, type in mapping.schema.entities.items() if type.supertypes and len(type.supertypes) == 1]
+        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'        : mapping.schema.name.upper(),
-            'schema_name'              : mapping.schema.name.capitalize(),
+            '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'   : catnl(parent_type_statements),
-            'entity_implementations'   : catnl(entity_implementations)
+            '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
-    def emit(self):
-        f = open('%s.cpp'%self.schema_name, 'w', encoding='utf-8')
-        f.write(str(self))
-        f.close()
-

src/ifcexpressparser/mapping.py

@@ -17,6 +17,9 @@
 #                                                                             #
 ###############################################################################
 
+from __future__ import print_function
+
+import sys
 import nodes
 import templates
 
@@ -28,20 +31,40 @@ class Mapping:
         'integer' : 'int',
         'real'    : 'double',
         'number'  : 'double',
-        'string'  : 'std::string'
+        '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):
-            return self.express_to_cpp_typemapping.get(type, 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)
-            tmpl = templates.list_type if is_list else templates.array_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(type.type),
+                'instance_type' : self.make_type_string(self.flatten_type_string(type.type)),
                 'lower'         : type.bounds.lower,
                 'upper'         : type.bounds.upper,
             }
@@ -53,61 +76,78 @@ class Mapping:
             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 type in self.express_to_cpp_typemapping:
-                return self.express_to_cpp_typemapping.get(type, type).split('::')[-1].upper()
-            elif self.schema.is_entity(type):
-                return "ENTITY"
-            elif self.schema.is_type(type):
-                return _make_argument_type(self.schema.types[type].type.type)
+            if self.schema.is_entity(type) or isinstance(type, nodes.SelectType):
+                return "ENTITY_INSTANCE"
             elif isinstance(type, nodes.BinaryType):
-                return "UNKNOWN"
+                return "BINARY"
+            elif isinstance(type, nodes.StringType):
+                return "STRING"
             elif isinstance(type, nodes.EnumerationType):
                 return "ENUMERATION"
-            elif isinstance(type, nodes.SelectType):
-                return "ENTITY"
             elif isinstance(type, nodes.AggregationType):
                 ty = _make_argument_type(type.type)
                 if ty == "UNKNOWN": return "UNKNOWN"
-                return "ENTITY_LIST" if ty == "ENTITY" else ("VECTOR_%s"%ty)
-            else: raise ValueError
-        supported = {'INT', 'BOOL', 'DOUBLE', 'STRING', 'VECTOR_INT', 'VECTOR_DOUBLE', 'VECTOR_STRING', 'ENTITY', 'ENTITY_LIST', 'ENUMERATION'}
-        ty = _make_argument_type(attr.type)
-        if ty not in supported: ty = '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(type, type)
+            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):
-        type_str = self.express_to_cpp_typemapping.get(str(attr.type), attr.type)
+        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'%(attr.type, attr.type)
+        
+        if self.schema.is_enumeration(attr_type):
+            type_str = '::%s::%s::Value' % (self.schema.name.capitalize(), attr_type)
         elif isinstance(type_str, nodes.AggregationType):
-            ty = self.get_parameter_type(attr.type, False, allow_entities, allow_pointer=False)
-            if allow_entities and self.schema.is_select(attr.type.type):
+            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 ty in self.express_to_cpp_typemapping.values():
-                type_str = templates.array_type % {
+            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'         : attr.type.bounds.lower,
-                    'upper'         : attr.type.bounds.upper
+                    'lower'         : bounds[0],
+                    'upper'         : bounds[1]
                 }
             else:
-                type_str = templates.list_type % {
+                tmpl = templates.list_list_type if is_nested_list else templates.list_type
+                type_str = tmpl % {
                     'instance_type': ty
                 }
-        elif allow_pointer and self.schema.is_entity(type_str):
-            type_str += '*'
+        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::IfcAbstractSelect"
+            type_str = "IfcUtil::IfcBaseClass*"
             is_ptr = True
         if allow_optional and attr.optional and not is_ptr:
             type_str = "boost::optional< %s >"%type_str
@@ -126,19 +166,35 @@ class Mapping:
         return c + ([str(s) for s in t.derive.elements] if t.derive else [])
 
     def list_instance_type(self, attr):
-        f = lambda v : 'IfcUtil::IfcAbstractSelect' if self.schema.is_select(v) else v
-        if self.is_array(attr.type) and not isinstance(attr.type, str):
-            return f(attr.type.type)
-        elif self.is_array(attr.type) and isinstance(attr.type, str):
-            return f(attr.type)
-        else: return None
+        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)
-        arr = self.is_array(attr.type)
+        if ty is None: return False
+        arr = self.is_array(attr_type)
         simple = self.schema.is_simpletype(ty)
-        express = ty in self.express_to_cpp_typemapping
-        select = ty == 'IfcUtil::IfcAbstractSelect'
+        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):
@@ -163,9 +219,11 @@ class Mapping:
             '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

@@ -21,8 +21,8 @@ import string
 import collections
 
 class Node:
-    def __init__(self, tokens):
-        self.tokens = tokens
+    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)]
@@ -44,15 +44,17 @@ class TypeDeclaration(Node):
 class EntityDeclaration(Node):
     name = property(lambda self: self.tokens[1])
     attributes = property(lambda self: self.tokens_of_type(ExplicitAttribute))
+    abstract = property(lambda self: self.single_token_of_type(SuperTypeExpression) is not None and \
+        self.single_token_of_type(SuperTypeExpression).abstract)
     def init(self):
         assert self.tokens[0] == 'entity'
-        s = self.single_token_of_type(SubtypeExpression)
+        s = self.single_token_of_type(SubTypeExpression)
         self.inverse = self.single_token_of_type(AttributeList, 'type', 'inverse')
         self.derive = self.single_token_of_type(AttributeList, 'type', 'derive')
         self.supertypes = s.types if s else []
     def __repr__(self):
         builder = ""
-        builder += "Entity(%s)" % (self.name)
+        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):
@@ -106,12 +108,20 @@ class SelectType(Node):
 class SubSuperTypeExpression(Node):
     type = property(lambda self: self.tokens[0])
     types = property(lambda self: self.tokens[3::2])
+    abstract = False
     def init(self):
-        assert self.type == self.class_type
+        if self.tokens[0] == 'abstract':
+            self.tokens = self.tokens[1:]
+            self.abstract = True
+        assert self.type == self.type_relationship
 
 
-class SubtypeExpression(SubSuperTypeExpression):
-    class_type = 'subtype'
+class SubTypeExpression(SubSuperTypeExpression):
+    type_relationship = 'subtype'
+
+
+class SuperTypeExpression(SubSuperTypeExpression):
+    type_relationship = 'supertype'
 
 
 class AttributeList(Node):
@@ -127,8 +137,8 @@ class AttributeList(Node):
 
 class InverseAttribute(Node):
     name = property(lambda self: self.tokens[0])
-    type = property(lambda self: self.tokens[2])
-    bounds = property(lambda self: None if len(self.tokens) == 6 else self.tokens[3])
+    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):
@@ -149,7 +159,7 @@ class BinaryType(Node):
     def init(self):
         pass
     def __repr__(self):
-        return "BINARY"
+        return "binary"
 
 
 class BoundSpecification(Node):
@@ -170,6 +180,23 @@ class ExplicitAttribute(Node):
     def init(self):
         # NB: This assumes a single name per attribute
         # definition, which is not necessarily the case.
+        if self.tokens[0] == "self":
+            i = list(self.tokens).index(":")
+            self.tokens = self.tokens[i-1:]
         assert self.tokens[1] == ':'
     def __repr__(self):
         return "%s : %s%s" % (self.name, self.type, " ?" if self.optional else "")
+
+        
+class WidthSpec(Node):
+    def init(self):
+        if self.tokens[-1] == "fixed":
+            self.tokens[-1:] = []
+        assert (self.tokens[0], self.tokens[-1]) == ("(", ")")
+        self.width = int("".join(self.tokens[1:-1]))
+        
+class StringType(Node):
+    def init(self):
+        pass
+    def __repr__(self):
+        return "string"

src/ifcexpressparser/rt_implementation.py

@@ -1,117 +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 templates
-
-class RuntimeTypingImplementation:
-    def __init__(self, mapping):
-        schema_name = mapping.schema.name.capitalize()
-        
-        entity_descriptors = []
-        enumeration_descriptors = []
-        derived_field_statements = []
-        inverse_implementations = []
-        
-        for name, type in mapping.schema.simpletypes.items():
-            entity_descriptors.append(templates.entity_descriptor % {
-                'type'                         : name,
-                'parent_statement'             : '0',
-                'entity_descriptor_attributes' : templates.entity_descriptor_attribute % {
-                    'name'     : 'wrappedValue',
-                    'optional' : 'false',
-                    'type'     : mapping.make_argument_type(mapping.schema.types[name].type)
-                }
-            })
-            
-        emitted_entities = set()
-        entities_to_emit = mapping.schema.entities.keys()
-        while len(emitted_entities) < len(mapping.schema.entities):
-            for name, type in mapping.schema.entities.items():
-                if name in emitted_entities: continue
-                if len(type.supertypes) == 0 or set(type.supertypes) < emitted_entities:
-                    constructor_arguments = mapping.get_assignable_arguments(type, include_derived = True)
-                    entity_descriptor_attributes = []
-                    for arg in constructor_arguments:
-                        if not arg['is_inherited']:
-                            tmpl = templates.entity_descriptor_attribute_enum if arg['argument_type_enum'] == 'IfcUtil::Argument_ENUMERATION' else templates.entity_descriptor_attribute
-                            entity_descriptor_attributes.append(tmpl % {
-                                'name'      : arg['name'],
-                                'optional'  : 'true' if arg['is_optional'] else 'false',
-                                'type'      : arg['argument_type_enum'],
-                                'enum_type' : arg['argument_type']
-                            })
-                        
-                    emitted_entities.add(name)
-                    parent_statement = '0' if len(type.supertypes) != 1 else templates.entity_descriptor_parent % {
-                        'type' : type.supertypes[0]
-                    }
-                    entity_descriptors.append(templates.entity_descriptor % {
-                        'type'                         : name,
-                        'parent_statement'             : parent_statement,
-                        'entity_descriptor_attributes' : '\n'.join(entity_descriptor_attributes)
-                    })
-                    
-        for name, enum in mapping.schema.enumerations.items():
-            enumeration_descriptor_values = '\n'.join([templates.enumeration_descriptor_value % {
-                'name' : v
-            } for v in enum.values])
-            enumeration_descriptors.append(templates.enumeration_descriptor % {
-                'type'                          : name,
-                'enumeration_descriptor_values' : enumeration_descriptor_values
-            })
-            
-        for name, type in mapping.schema.entities.items():
-            constructor_arguments = mapping.get_assignable_arguments(type, include_derived = True)
-            statements = ''.join(templates.derived_field_statement_attrs % (a['index']-1) for a in constructor_arguments if a['is_derived'])
-            if len(statements):
-                derived_field_statements.append(templates.derived_field_statement % {
-                    'type'       : name,
-                    'statements' : statements
-                })
-                
-        for name, type in mapping.schema.entities.items():
-            if type.inverse:
-                for attr in type.inverse.elements:
-                    related_entity = mapping.schema.entities[attr.entity]
-                    related_attrs = [a['name'] for a in mapping.get_assignable_arguments(related_entity, include_derived=True)]
-
-                    inverse_implementations.append(templates.inverse_implementation % {
-                        'type'         : name,
-                        'name'         : attr.name,
-                        'related_type' : attr.entity,
-                        'index'        : related_attrs.index(attr.attribute)
-                    })
-
-        self.str = templates.rt_implementation % {
-            'schema_name_upper'        : mapping.schema.name.upper(),
-            'schema_name'              : mapping.schema.name.capitalize(),
-            'entity_descriptors'       : '\n'.join(entity_descriptors),
-            'enumeration_descriptors'  : '\n'.join(enumeration_descriptors),
-            'derived_field_statements' : '\n'.join(derived_field_statements),
-            'inverse_implementations'  : '\n'.join(inverse_implementations)
-        }
-
-        self.schema_name = mapping.schema.name.capitalize()
-    def __repr__(self):
-        return self.str
-    def emit(self):
-        f = open('%s-rt.cpp'%self.schema_name, 'w', encoding='utf-8')
-        f.write(str(self))
-        f.close()
-

src/ifcexpressparser/schema.py

@@ -18,29 +18,67 @@
 ###############################################################################
 
 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 v in self.enumerations
+        return str(v) in self.enumerations
     def is_select(self, v):
-        return v in self.selects
+        return str(v) in self.selects
     def is_simpletype(self, v):
-        return v in self.simpletypes
+        return str(v) in self.simpletypes
     def is_type(self, v):
-        return v in self.types
+        return str(v) in self.types
     def is_entity(self, v):
-        return v in self.entities
+        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: collections.OrderedDict(sorted(d.items()))
+        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.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)})
+        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)
+        self.simpletypes = of_type(str, nodes.AggregationType, nodes.BinaryType, nodes.StringType)

src/ifcexpressparser/schema_class.py

@@ -0,0 +1,268 @@
+###############################################################################
+#                                                                             #
+# 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

@@ -23,17 +23,22 @@ header = """
 
 #include <string>
 #include <vector>
-#include <map>
 
 #include <boost/optional.hpp>
 
-#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/ifc_parse_api.h"
+
+#include "../ifcparse/IfcEntityList.h"
+#include "../ifcparse/IfcBaseClass.h"
+#include "../ifcparse/IfcSchema.h"
 #include "../ifcparse/IfcException.h"
-#include "../ifcparse/%(schema_name)senum.h"
+#include "../ifcparse/Argument.h"
 
-#define IfcSchema %(schema_name)s
+struct %(schema_name)s {
 
-namespace %(schema_name)s {
+static const IfcParse::schema_definition& get_schema();
+
+static const char* const Identifier;
 
 // Forward definitions
 %(forward_definitions)s
@@ -41,9 +46,7 @@ namespace %(schema_name)s {
 %(declarations)s
 
 %(class_definitions)s
-void InitStringMap();
-IfcUtil::IfcSchemaEntity SchemaEntity(IfcAbstractEntityPtr e = 0);
-}
+};
 
 #endif
 """
@@ -52,250 +55,51 @@ enum_header = """
 #ifndef %(schema_name_upper)sENUM_H
 #define %(schema_name_upper)sENUM_H
 
-#define IfcSchema %(schema_name)s
+#include "../ifcparse/ifc_parse_api.h"
 
-namespace %(schema_name)s {
-
-namespace Type {
-    typedef enum {
-        %(types)s, ALL
-    } Enum;
-    Enum Parent(Enum v);
-    Enum FromString(const std::string& s);
-    std::string ToString(Enum v);
-    bool IsSimple(Enum v);
-}
-
-}
+#include <string>
+#include <boost/optional.hpp>
 
 #endif
 """
 
-rt_header = """
-#ifndef %(schema_name_upper)sRT_H
-#define %(schema_name_upper)sRT_H
-
-#define IfcSchema %(schema_name)s
-
-#include "../ifcparse/IfcUtil.h"
-#include "../ifcparse/IfcEntityDescriptor.h"
-#include "../ifcparse/IfcWritableEntity.h"
-
-namespace %(schema_name)s {
-namespace Type {
-    int GetAttributeCount(Enum t);
-    int GetAttributeIndex(Enum t, const std::string& a);
-    IfcUtil::ArgumentType GetAttributeType(Enum t, unsigned char a);
-    const std::string& GetAttributeName(Enum t, unsigned char a);
-    bool GetAttributeOptional(Enum t, unsigned char a);
-    bool GetAttributeDerived(Enum t, unsigned char a);
-    std::pair<const char*, int> GetEnumerationIndex(Enum t, const std::string& a);
-    std::pair<Enum, unsigned> GetInverseAttribute(Enum t, const std::string& a);
-    Enum GetAttributeEnumerationClass(Enum t, unsigned char a);
-    void PopulateDerivedFields(IfcWrite::IfcWritableEntity* e);
-}}
-
-#endif
-"""
+lb_header = """"""
 
 implementation= """
 #include "../ifcparse/%(schema_name)s.h"
+#include "../ifcparse/IfcSchema.h"
 #include "../ifcparse/IfcException.h"
 #include "../ifcparse/IfcWrite.h"
-#include "../ifcparse/IfcWritableEntity.h"
 
-using namespace %(schema_name)s;
+#include <map>
+
+const char* const %(schema_name)s::Identifier = "%(schema_name_upper)s";
+
 using namespace IfcParse;
 using namespace IfcWrite;
 
-IfcUtil::IfcSchemaEntity %(schema_name)s::SchemaEntity(IfcAbstractEntityPtr e) {
-    switch(e->type()) {
-%(schema_entity_statements)s
-        default: throw IfcException("Unable to find find keyword in schema"); break;
-    }
-}
-
-std::string Type::ToString(Enum v) {
-    if (v < 0 || v >= %(max_id)d) throw IfcException("Unable to find find keyword in schema");
-    const char* names[] = { %(type_name_strings)s };
-    return names[v];
-}
-
-static std::map<std::string,Type::Enum> string_map;
-void %(schema_name)s::InitStringMap() {
-%(string_map_statements)s
-}
-
-Type::Enum Type::FromString(const std::string& s) {
-    if (string_map.empty()) InitStringMap();
-    std::map<std::string,Type::Enum>::const_iterator it = string_map.find(s);
-    if ( it == string_map.end() ) throw IfcException("Unable to find find keyword in schema");
-    else return it->second;
-}
-
-Type::Enum Type::Parent(Enum v){
-    if (v < 0 || v >= %(max_id)d) return (Enum)-1;
-%(parent_type_statements)s
-    return (Enum)-1;
-}
-
-bool Type::IsSimple(Enum v) {
-    return %(simple_type_statement)s;
-}
+// External definitions
+%(external_definitions)s
 
 %(enumeration_functions)s
 
-#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;
+%(simple_type_impl)s
 
 %(entity_implementations)s
 """
 
-rt_implementation = """
-#include <set>
-
-#include "../ifcparse/%(schema_name)s.h"
-#include "../ifcparse/%(schema_name)s-rt.h"
-#include "../ifcparse/IfcException.h"
-#include "../ifcparse/IfcWrite.h"
-#include "../ifcparse/IfcWritableEntity.h"
-#include "../ifcparse/IfcUtil.h"
-#include "../ifcparse/IfcEntityDescriptor.h"
-
-using namespace %(schema_name)s;
-using namespace IfcParse;
-using namespace IfcWrite;
-using namespace IfcUtil;
-
-std::map<Type::Enum,IfcEntityDescriptor*> entity_descriptor_map;
-std::map<Type::Enum,IfcEnumerationDescriptor*> enumeration_descriptor_map;
-std::map<std::pair<Type::Enum, std::string>, std::pair<Type::Enum, int> > inverse_map;
-std::map<Type::Enum,std::set<int> > derived_map;
-
-void InitDescriptorMap() {
-    IfcEntityDescriptor* current;
-%(entity_descriptors)s
-    // Enumerations
-    IfcEnumerationDescriptor* current_enum;
-    std::vector<std::string> values;
-%(enumeration_descriptors)s
-}
-
-void InitInverseMap() {
-%(inverse_implementations)s
-}
-
-void InitDerivedMap() {
-%(derived_field_statements)s
-}
-
-int Type::GetAttributeIndex(Enum t, const std::string& a) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else return i->second->getArgumentIndex(a);
-}
-
-int Type::GetAttributeCount(Enum t) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else return i->second->getArgumentCount();
-}
-
-ArgumentType Type::GetAttributeType(Enum t, unsigned char a) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else return i->second->getArgumentType(a);
-}
-
-const std::string& Type::GetAttributeName(Enum t, unsigned char a) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else return i->second->getArgumentName(a);
-}
-
-bool Type::GetAttributeOptional(Enum t, unsigned char a) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else return i->second->getArgumentOptional(a);
-}
-
-bool Type::GetAttributeDerived(Enum t, unsigned char a) {
-    if (derived_map.empty()) ::InitDerivedMap();
-    std::map<Type::Enum,std::set<int> >::const_iterator i = derived_map.find(t);
-    return i != derived_map.end() && i->second.find(a) != i->second.end();
-}
-
-std::pair<const char*, int> Type::GetEnumerationIndex(Enum t, const std::string& a) {
-    if (enumeration_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEnumerationDescriptor*>::const_iterator i = enumeration_descriptor_map.find(t);
-    if ( i == enumeration_descriptor_map.end() ) throw IfcException("Value not found");
-    else return i->second->getIndex(a);
-}
-
-std::pair<Type::Enum, unsigned> Type::GetInverseAttribute(Enum t, const std::string& a) {
-	if (inverse_map.empty()) ::InitInverseMap();
-	std::map<std::pair<Type::Enum, std::string>, std::pair<Type::Enum, int> >::const_iterator it;
-    std::pair<Type::Enum, std::string> key = std::make_pair(t, a);
-    while (true) {
-        it = inverse_map.find(key);
-        if (it != inverse_map.end()) return it->second;
-        if ((key.first = Parent(key.first)) == -1) break;
-    }
-    throw IfcException("Attribute not found");
-}
-
-Type::Enum Type::GetAttributeEnumerationClass(Enum t, unsigned char a) {
-    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
-    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
-    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
-    else {
-        Type::Enum t = i->second->getArgumentEnumerationClass(a);
-        if ( t == Type::ALL ) throw IfcException("Not an enumeration");
-        else return t;
-    }
-}
-
-void Type::PopulateDerivedFields(IfcWrite::IfcWritableEntity* e) {
-    std::map<Type::Enum, std::set<int> >::const_iterator i = derived_map.find(e->type());
-	if (i != derived_map.end()) {
-		for (std::set<int>::const_iterator it = i->second.begin(); it != i->second.end(); ++it) {
-			e->setArgumentDerived(*it);
-		}
-	}
-}
-"""
+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 = '    current->add("%(name)s",%(optional)s,%(type)s);'
-entity_descriptor_attribute_enum = '    current->add("%(name)s",%(optional)s,%(type)s,Type::%(enum_type)s);'
+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
-    current_enum = enumeration_descriptor_map[Type::%(type)s] = new IfcEnumerationDescriptor(Type::%(type)s, values);"""
+    enumeration_descriptor_map[Type::%(type)s] = new IfcEnumerationDescriptor(Type::%(type)s, values);"""
 
 enumeration_descriptor_value = '    values.push_back("%(name)s");'
 
@@ -303,98 +107,120 @@ derived_field_statement = '    {std::set<int> idxs; %(statements)sderived_map[Ty
 derived_field_statement_attrs = 'idxs.insert(%d); '
 
 simpletype = """%(documentation)s
-typedef %(type)s %(name)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::IfcSchemaEntity %(name)s;
+typedef IfcUtil::IfcBaseClass %(name)s;
 """
 
-enumeration = """namespace %(name)s {
+enumeration = """struct %(name)s {
 %(documentation)s
-typedef enum {%(values)s} %(name)s;
-const char* ToString(%(name)s v);
-%(name)s FromString(const std::string& 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 %(name)s %(superclass)s{
+class IFC_PARSE_API %(name)s %(superclass)s{
 public:
-%(attributes)s    virtual unsigned int getArgumentCount() const { return %(argument_count)d; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const {%(argument_type_function_body)s}
-    virtual const char* getArgumentName(unsigned int i) const {%(argument_name_function_body)s}
-    virtual ArgumentPtr getArgument(unsigned int i) const { return entity->getArgument(i); }
-%(inverse)s    bool is(Type::Enum v) const;
-    Type::Enum type() const;
-    static Type::Enum Class();
-    %(name)s (IfcAbstractEntityPtr e);
+%(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 %(name)s* ptr;
-    typedef SHARED_PTR< IfcTemplatedEntityList< %(name)s > > list;
-    typedef IfcTemplatedEntityList< %(name)s >::it it;
+    typedef IfcTemplatedEntityList< %(name)s > list;
 };
 """
 
 enumeration_function="""
-const char* %(name)s::ToString(%(name)s v) {
+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];
 }
 
-%(name)s::%(name)s %(name)s::FromString(const std::string& s) {
+%(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)sbool %(name)s::is(Type::Enum v) const { return v == Type::%(name)s%(parent_type_test)s; }
-Type::Enum %(name)s::type() const { return Type::%(name)s; }
-Type::Enum %(name)s::Class() { return Type::%(name)s; }
-%(name)s::%(name)s(IfcAbstractEntityPtr e) : %(superclass)s { if (!e) return; if (!e->is(Type::%(name)s)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
-%(name)s::%(name)s(%(constructor_arguments)s) : %(superclass)s { IfcWritableEntity* e = new IfcWritableEntity(Class());%(constructor_implementation)s entity = e; EntityBuffer::Add(this); }
+%(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 %(class_name)s::%(name)s(%(arguments)s) { %(body)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]*/"
-list_type = "SHARED_PTR< IfcTemplatedEntityList< %(instance_type)s > >"
-untyped_list = "IfcEntities"
-inverse_attr = "SHARED_PTR< IfcTemplatedEntityList< %(entity)s > > %(name)s(); // INVERSE %(entity)s::%(attribute)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;'
-schema_simple_stmt = '        case Type::%(name)s: return new IfcUtil::IfcEntitySelect(e); break;'
 string_map_statement = '    string_map["%(uppercase_name)s"%(padding)s] = Type::%(name)s;'
 parent_type_stmt = '    if(v==%(name)s%(padding)s) { return %(parent)s; }'
 
 parent_type_test = " || %s::is(v)"
 
-optional_attr_stmt = "return !entity->getArgument(%(index)d)->isNull();"
+optional_attr_stmt = "return !data_->getArgument(%(index)d)->isNull();"
 
-get_attr_stmt = "return *entity->getArgument(%(index)d);"
-get_attr_stmt_enum = "return %(type)s::FromString(*entity->getArgument(%(index)d));"
-get_attr_stmt_entity = "return (%(type)s)((IfcUtil::IfcSchemaEntity)(*entity->getArgument(%(index)d)));"
-get_attr_stmt_array = "RETURN_AS_LIST(%(list_instance_type)s,%(index)d)"
+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_INVERSE(%(type)s)"
+get_inverse = "return data_->getInverse(%(schema_name_upper)s_%(type)s_type, %(index)d)->as<%(type)s>();"
 
-set_attr_stmt = "if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%(index)d,v);"
-set_attr_stmt_enum = "if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%(index)d,v,%(type)s::ToString(v));"
-set_attr_stmt_array = "if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%(index)d,v->generalize());"
+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 = " e->setArgument(%(index)d,(%(name)s));"
-constructor_stmt_enum = " e->setArgument(%(index)d,%(name)s,%(type)s::ToString(%(name)s));"
-constructor_stmt_array = " e->setArgument(%(index)d,(%(name)s)->generalize());"
-constructor_stmt_optional = " if (%(name)s) {%(stmt)s } else { e->setArgument(%(index)d); }"
-constructor_stmt_derived = " e->setArgumentDerived(%(index)d);"
+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);}"
 
-inverse_implementation = "    inverse_map.insert(std::make_pair(std::make_pair(Type::%(type)s, \"%(name)s\"), std::make_pair(Type::%(related_type)s, %(index)d)));"
+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/ConversionSettings.cpp

@@ -0,0 +1,9 @@
+#include "ConversionSettings.h"
+
+void ifcopenshell::geometry::ConversionSettings::setValue(GeomValue var, double value) {
+	values_[var] = value;
+}
+
+double ifcopenshell::geometry::ConversionSettings::getValue(GeomValue var) const {
+	return values_[var];
+}

src/ifcgeom/ConversionSettings.h

@@ -0,0 +1,61 @@
+#ifndef CONVERSIONSETTINGS_H
+#define CONVERSIONSETTINGS_H
+
+#include <array>
+
+namespace ifcopenshell { namespace geometry {
+
+	class NativeElement;
+
+	class ConversionSettings {
+	public:
+		// Tolerances and settings for various geometrical operations:
+		enum GeomValue {
+			// Specifies the deflection of the mesher
+			// Default: 0.001m / 1mm
+			GV_DEFLECTION_TOLERANCE,
+			// Specifies the minimal area of a face to be included in an IfcConnectedFaceset
+			// Read-only
+			GV_MINIMAL_FACE_AREA,
+			// Specifies the threshold distance under which cartesian points are deemed equal
+			// Read-only
+			GV_POINT_EQUALITY_TOLERANCE,
+			// Specifies maximum number of faces for a shell to be reoriented.
+			// Default: -1
+			GV_MAX_FACES_TO_ORIENT,
+			// 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,
+			// Whether to process shapes of type Face or higher (1) Wire or lower (-1) or all (0)
+			GV_DIMENSIONALITY
+		};
+
+		void setValue(GeomValue var, double value);
+
+		double getValue(GeomValue var) const;
+
+	private:
+		std::array<double, 8> values_ = {
+			/* 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.,
+		};
+	};
+
+} }
+
+#endif

src/ifcgeom/IfcGeom.h

@@ -1,124 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-#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 "../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
-	};
-
-	const int DISABLE_OPENING_SUBTRACTIONS = 1 << 0;
-	const int DISABLE_OBJECT_PLACEMENT     = 1 << 1;
-	const int SEW_SHELLS                   = 1 << 2;
-	const int CONVERT_TO_METERS            = 1 << 3;
-	
-	bool convert_wire_to_face(const TopoDS_Wire& wire, TopoDS_Face& face);
-	bool convert_curve_to_wire(const Handle(Geom_Curve)& curve, TopoDS_Wire& wire);
-	bool convert_shapes(const IfcUtil::IfcBaseClass* L, IfcRepresentationShapeItems& result);
-	bool is_shape_collection(const IfcUtil::IfcBaseClass* L);
-	bool convert_shape(const IfcUtil::IfcBaseClass* L, TopoDS_Shape& result);
-	bool convert_wire(const IfcUtil::IfcBaseClass* L, TopoDS_Wire& result);
-	bool convert_curve(const IfcUtil::IfcBaseClass* L, Handle(Geom_Curve)& result);
-	bool convert_face(const IfcUtil::IfcBaseClass* L, TopoDS_Shape& result);
-	bool convert_openings(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::IfcRelVoidsElement::list& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
-	bool convert_openings_fast(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::IfcRelVoidsElement::list& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
-	IfcSchema::IfcSurfaceStyleShading* get_surface_style(IfcSchema::IfcRepresentationItem* item);
-	bool create_solid_from_compound(const TopoDS_Shape& compound, TopoDS_Shape& solid);
-	bool is_compound(const TopoDS_Shape& shape);
-	bool is_convex(const TopoDS_Wire& wire);
-	TopoDS_Shape halfspace_from_plane(const gp_Pln& pln,const gp_Pnt& cent);
-	gp_Pln plane_from_face(const TopoDS_Face& face);
-	gp_Pnt point_above_plane(const gp_Pln& pln, bool agree=true);
-	const TopoDS_Shape& ensure_fit_for_subtraction(const TopoDS_Shape& shape, TopoDS_Shape& solid);
-	bool profile_helper(int numVerts, double* verts, int numFillets, int* filletIndices, double* filletRadii, gp_Trsf2d trsf, TopoDS_Shape& face); 
-	double shape_volume(const TopoDS_Shape& s);
-	double face_area(const TopoDS_Face& f);
-	void apply_tolerance(TopoDS_Shape& s, double t);
-	void SetValue(GeomValue var, double value);
-	double GetValue(GeomValue var);
-	std::string create_brep_data(IfcSchema::IfcProduct* s, unsigned int settings);
-	void initialize_units_and_precision(IfcSchema::IfcProject* proj, double& unit_magnitude, std::string& unit_name);
-    bool fill_nonmanifold_wires_with_planar_faces(TopoDS_Shape& shape);
-	IfcSchema::IfcProductDefinitionShape* tesselate(TopoDS_Shape& shape, double deflection, IfcEntities es);
-
-	
-	
-	namespace Cache {
-		void Purge();
-		void PurgeShapeCache();
-	}
-#include "IfcRegisterGeomHeader.h"
-}
-#endif

src/ifcgeom/IfcGeomCurves.cpp

@@ -1,138 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * Implementations of the various conversion functions defined in IfcRegister.h *
- *                                                                              *
- ********************************************************************************/
-
-#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 "../ifcgeom/IfcGeom.h"
-
-bool IfcGeom::convert(const IfcSchema::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->entity);
-		return false;
-	}
-	gp_Trsf trsf;
-	IfcSchema::IfcAxis2Placement placement = l->Position();
-	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
-		IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
-	} else {
-		gp_Trsf2d 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::convert(const IfcSchema::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->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;
-	gp_Trsf trsf;
-	IfcSchema::IfcAxis2Placement placement = l->Position();
-	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
-		IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
-	} else {
-		gp_Trsf2d trsf2d;
-		IfcGeom::convert((IfcSchema::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);
-	curve = new Geom_Ellipse(ax, x, y);
-	return true;
-}
-bool IfcGeom::convert(const IfcSchema::IfcLine::ptr l, Handle(Geom_Curve)& curve) {
-	gp_Pnt pnt;gp_Vec 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;
-}

src/ifcgeom/IfcGeomFaces.cpp

@@ -1,770 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * 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 <Geom_OffsetCurve.hxx>
-
-#include <BRepPrimAPI_MakePrism.hxx>
-#include <BRepPrimAPI_MakeHalfSpace.hxx>
-
-#include <BRepOffsetAPI_Sewing.hxx>
-#include <BRepOffsetAPI_MakeOffset.hxx>
-
-#include <BRepBuilderAPI_MakeFace.hxx>
-#include <BRepBuilderAPI_MakeEdge.hxx>
-#include <BRepBuilderAPI_MakeWire.hxx>
-#include <BRepBuilderAPI_MakePolygon.hxx>
-#include <BRepBuilderAPI_MakeVertex.hxx>
-#include <BRepBuilderAPI_MakeShell.hxx>
-#include <BRepBuilderAPI_MakeSolid.hxx>
-
-#include <TopoDS.hxx>
-#include <TopoDS_Wire.hxx>
-#include <TopoDS_Face.hxx>
-#include <TopExp_Explorer.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 <Standard_Failure.hxx>
-
-#include <BRep_Tool.hxx>
-#include <BRepBuilderAPI_Transform.hxx>
-
-#include "../ifcgeom/IfcGeom.h"
-
-bool IfcGeom::convert(const IfcSchema::IfcFace::ptr l, TopoDS_Shape& face) {
-	IfcSchema::IfcFaceBound::list bounds = l->Bounds();
-	IfcSchema::IfcFaceBound::it it = bounds->begin();
-	IfcSchema::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) {
-			IfcSchema::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(TopoDS::Face(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_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 IfcSchema::IfcArbitraryClosedProfileDef::ptr l, TopoDS_Shape& face) {
-	TopoDS_Wire wire;
-	if ( ! IfcGeom::convert_wire(l->OuterCurve(),wire) ) return false;
-
-	TopoDS_Face f;
-	bool success = IfcGeom::convert_wire_to_face(wire, f);
-	if (success) face = f;
-	return success;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcArbitraryProfileDefWithVoids::ptr l, TopoDS_Shape& face) {
-	TopoDS_Wire profile;
-	if ( ! IfcGeom::convert_wire(l->OuterCurve(),profile) ) return false;
-	BRepBuilderAPI_MakeFace mf(profile);
-	IfcSchema::IfcCurve::list voids = l->InnerCurves();
-	for( IfcSchema::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 IfcSchema::IfcRectangleProfileDef::ptr l, TopoDS_Shape& 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 < ALMOST_ZERO || y < ALMOST_ZERO ) {
-		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 IfcSchema::IfcRoundedRectangleProfileDef::ptr l, TopoDS_Shape& 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);
-	const double r = l->RoundingRadius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-
-	if ( x < ALMOST_ZERO || y < ALMOST_ZERO || r < ALMOST_ZERO ) {
-		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};
-	int fillets[4] = {0,1,2,3};
-	double radii[4] = {r,r,r,r};
-	return IfcGeom::profile_helper(4,coords,4,fillets,radii,trsf2d,face);
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcRectangleHollowProfileDef::ptr l, TopoDS_Shape& 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);
-	const double d = l->WallThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-
-	const bool fr1 = l->hasInnerFilletRadius();
-	const bool fr2 = l->hasInnerFilletRadius();
-
-	const double r1 = fr2 ? l->OuterFilletRadius() * IfcGeom::GetValue(GV_LENGTH_UNIT) : 0.;
-	const double r2 = fr1 ? l->InnerFilletRadius() * IfcGeom::GetValue(GV_LENGTH_UNIT) : 0.;
-	
-	if ( x < ALMOST_ZERO || y < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
-		return false;
-	}
-
-	TopoDS_Face f1;
-	TopoDS_Face f2;
-
-	gp_Trsf2d trsf2d;
-	IfcGeom::convert(l->Position(),trsf2d);
-	double coords1[8] = {-x  ,-y,   x  ,-y,   x,  y,   -x,  y  };
-	double coords2[8] = {-x+d,-y+d, x-d,-y+d, x-d,y-d, -x+d,y-d};
-	double radii1[4] = {r1,r1,r1,r1};
-	double radii2[4] = {r2,r2,r2,r2};
-	int fillets[4] = {0,1,2,3};
-
-	bool s1 = IfcGeom::profile_helper(4,coords1,fr1 ? 4 : 0,fillets,radii1,trsf2d,f1);
-	bool s2 = IfcGeom::profile_helper(4,coords2,fr2 ? 4 : 0,fillets,radii2,trsf2d,f2);
-
-	if (!s1 || !s2) return false;
-
-	TopExp_Explorer exp1(f1, TopAbs_WIRE);
-	TopExp_Explorer exp2(f2, TopAbs_WIRE);
-
-	TopoDS_Wire w1 = TopoDS::Wire(exp1.Current());	
-	TopoDS_Wire w2 = TopoDS::Wire(exp2.Current());
-
-	BRepBuilderAPI_MakeFace mf(w1, false);
-	mf.Add(w2);
-
-	ShapeFix_Shape sfs(mf.Face());
-	sfs.Perform();
-	face = TopoDS::Face(sfs.Shape());	
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcTrapeziumProfileDef::ptr l, TopoDS_Shape& face) {
-	const double x1 = l->BottomXDim() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double w = l->TopXDim() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double dx = l->TopXOffset() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double y = l->YDim() / 2.0f  * IfcGeom::GetValue(GV_LENGTH_UNIT);
-
-	if ( x1 < ALMOST_ZERO || w < ALMOST_ZERO || y < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
-		return false;
-	}
-
-	gp_Trsf2d trsf2d;
-	IfcGeom::convert(l->Position(),trsf2d);
-	double coords[8] = {-x1,-y, x1,-y, dx+w-x1,y, dx-x1,y};
-	return IfcGeom::profile_helper(4,coords,0,0,0,trsf2d,face);
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcIShapeProfileDef::ptr l, TopoDS_Shape& 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 = 0.;
-	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 IfcSchema::IfcZShapeProfileDef::ptr l, TopoDS_Shape& face) {
-	const double x = l->FlangeWidth() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double y = l->Depth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double dx = l->WebThickness() / 2.0f  * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double dy = l->FlangeThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-
-	bool doFillet = l->hasFilletRadius();
-	bool doEdgeFillet = l->hasEdgeRadius();
-	
-	double f1 = 0.;
-	double f2 = 0.;
-
-	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 || dx == 0.0f || dy == 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[16] = {-dx,-y, x,-y, x,-y+dy, dx,-y+dy, dx,y, -x,y, -x,y-dy, -dx,y-dy};
-	int fillets[4] = {2,3,6,7};
-	double radii[4] = {f2,f1,f2,f1};
-	return IfcGeom::profile_helper(8,coords,(doFillet || doEdgeFillet) ? 4 : 0,fillets,radii,trsf2d,face);
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcCShapeProfileDef::ptr l, TopoDS_Shape& 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 = 0;
-	double f2 = 0;
-	if ( doFillet ) {
-		f1 = l->InternalFilletRadius() * IfcGeom::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->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 IfcSchema::IfcLShapeProfileDef::ptr l, TopoDS_Shape& face) {
-	const bool hasSlope = l->hasLegSlope();
-	const bool doEdgeFillet = l->hasEdgeRadius();
-	const bool doFillet = l->hasFilletRadius();
-
-	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);
-	const double slope = hasSlope ? (l->LegSlope() * IfcGeom::GetValue(GV_PLANEANGLE_UNIT)) : 0.;
-	
-	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 < ALMOST_ZERO || y < ALMOST_ZERO || d < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
-		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->entity);
-			return false;
-		}
-
-		xx = (b2*c1 - b1*c2) / det;
-		xy = (a1*c2 - a2*c1) / det;
-	}
-
-	gp_Trsf2d trsf2d;
-	IfcGeom::convert(l->Position(),trsf2d);
-
-	double coords[12] = {-x,-y, x,-y, x,-y+d-dy1, xx, xy, -x+d-dx1,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 IfcSchema::IfcUShapeProfileDef::ptr l, TopoDS_Shape& face) {
-	const bool doEdgeFillet = l->hasEdgeRadius();
-	const bool doFillet = l->hasFilletRadius();
-	const bool hasSlope = l->hasFlangeSlope();
-
-	const double y = l->Depth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double x = l->FlangeWidth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double d1 = l->WebThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double d2 = l->FlangeThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double slope = hasSlope ? (l->FlangeSlope() * IfcGeom::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() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	}
-	if (doEdgeFillet) {
-		f2 = l->EdgeRadius() * IfcGeom::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->entity);
-		return false;
-	}
-
-	gp_Trsf2d trsf2d;
-	IfcGeom::convert(l->Position(),trsf2d);
-
-	double coords[16] = {-x,-y, x,-y, x,-y+d2-dy2, -x+d1,-y+d2+dy1, -x+d1,y-d2-dy1, x,y-d2+dy2, x,y, -x,y};
-	int fillets[4] = {2,3,4,5};
-	double radii[4] = {f2,f1,f1,f2};
-	return IfcGeom::profile_helper(8, coords, (doFillet || doEdgeFillet) ? 4 : 0, fillets, radii, trsf2d, face);
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcTShapeProfileDef::ptr l, TopoDS_Shape& 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 * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double x = l->FlangeWidth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double d1 = l->WebThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double d2 = l->FlangeThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double flangeSlope = hasFlangeSlope ? (l->FlangeSlope() * IfcGeom::GetValue(GV_PLANEANGLE_UNIT)) : 0.;
-	const double webSlope = hasWebSlope ? (l->WebSlope() * IfcGeom::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->entity);
-		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() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	}
-	if (doWebEdgeFillet) {
-		f2 = l->WebEdgeRadius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	}
-	if (doFlangeEdgeFillet) {
-		f3 = l->FlangeEdgeRadius() * IfcGeom::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->entity);
-			return false;
-		}
-
-		xx = (b2*c1 - b1*c2) / det;
-		xy = (a1*c2 - a2*c1) / det;
-	} else {
-		xx = d1 / 2;
-		xy = y - d2;
-	}
-
-	gp_Trsf2d trsf2d;
-	IfcGeom::convert(l->Position(),trsf2d);
-
-	double coords[16] = {d1/2.-dx2,-y, xx,xy, x,y-d2+dy2, x,y, -x,y, -x,y-d2+dy2, -xx,xy, -d1/2.+dx2,-y};
-	int fillets[6] = {0,1,2,5,6,7};
-	double radii[6] = {f2,f1,f3,f3,f1,f2};
-	return IfcGeom::profile_helper(8, coords, (doFillet || doWebEdgeFillet || doFlangeEdgeFillet) ? 6 : 0, fillets, radii, trsf2d, face);
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcCircleProfileDef::ptr l, TopoDS_Shape& 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);
-
-	TopoDS_Face f;
-	bool success = IfcGeom::convert_wire_to_face(w, f);
-	if (success) face = f;
-	return success;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcCircleHollowProfileDef::ptr l, TopoDS_Shape& 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;		
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcEllipseProfileDef::ptr l, TopoDS_Shape& face) {
-	double rx = l->SemiAxis1() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	double ry = l->SemiAxis2() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-
-	if ( rx < ALMOST_ZERO || ry < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
-		return false;
-	}
-
-	const bool rotated = ry > rx;
-	gp_Trsf2d trsf;	
-	IfcGeom::convert(l->Position(),trsf);
-
-	gp_Ax2 ax = gp_Ax2();
-	if (rotated) {
-		ax.Rotate(ax.Axis(), M_PI / 2.);
-		std::swap(rx, ry);
-	}
-	ax.Transform(trsf);
-
-	BRepBuilderAPI_MakeWire w;
-	Handle(Geom_Ellipse) ellipse = new Geom_Ellipse(ax, rx, ry);
-	TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(ellipse);
-	w.Add(edge);
-
-	TopoDS_Face f;
-	bool success = IfcGeom::convert_wire_to_face(w, f);
-	if (success) face = f;
-	return success;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcCenterLineProfileDef::ptr l, TopoDS_Shape& face) {
-	const double d = l->Thickness() * IfcGeom::GetValue(GV_LENGTH_UNIT) / 2.;
-
-	TopoDS_Wire wire;
-	if (!IfcGeom::convert_wire(l->Curve(), wire)) return false;
-
-	// BRepOffsetAPI_MakeOffset insists on creating circular arc
-	// segments for joining the curves that constitute the center
-	// line. This is probably not in accordance with the IFC spec.
-	// Although it does not specify a method to join segments
-	// explicitly, it does dictate 'a constant thickness along the
-	// curve'. Therefore for simple singular wires a quick
-	// alternative is provided that uses a straight join.
-
-	TopExp_Explorer exp(wire, TopAbs_EDGE);
-	TopoDS_Edge edge = TopoDS::Edge(exp.Current());
-	exp.Next();
-
-	if (!exp.More()) {
-		double u1, u2;
-		Handle(Geom_Curve) curve = BRep_Tool::Curve(edge, u1, u2);
-
-		Handle(Geom_TrimmedCurve) trim = new Geom_TrimmedCurve(curve, u1, u2);
-
-		Handle(Geom_OffsetCurve) c1 = new Geom_OffsetCurve(trim,  d, gp::DZ());
-		Handle(Geom_OffsetCurve) c2 = new Geom_OffsetCurve(trim, -d, gp::DZ());
-
-		gp_Pnt c1a, c1b, c2a, c2b;
-		c1->D0(c1->FirstParameter(), c1a);
-		c1->D0(c1->LastParameter(), c1b);
-		c2->D0(c2->FirstParameter(), c2a);
-		c2->D0(c2->LastParameter(), c2b);
-
-		BRepBuilderAPI_MakeWire mw;
-		mw.Add(BRepBuilderAPI_MakeEdge(c1));
-		mw.Add(BRepBuilderAPI_MakeEdge(c1a, c2a));
-		mw.Add(BRepBuilderAPI_MakeEdge(c2));
-		mw.Add(BRepBuilderAPI_MakeEdge(c2b, c1b));
-		
-		face = BRepBuilderAPI_MakeFace(mw.Wire());
-	} else {
-		BRepOffsetAPI_MakeOffset offset(BRepBuilderAPI_MakeFace(gp_Pln(gp::Origin(), gp::DZ())));
-		offset.AddWire(wire);
-		offset.Perform(d);
-		face = BRepBuilderAPI_MakeFace(TopoDS::Wire(offset));
-	}
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcCompositeProfileDef::ptr l, TopoDS_Shape& face) {
-	// BRepBuilderAPI_MakeFace mf;
-
-	TopoDS_Compound compound;
-	BRep_Builder builder;
-	builder.MakeCompound(compound);
-
-	IfcSchema::IfcProfileDef::list profiles = l->Profiles();
-	bool first = true;
-	for (IfcSchema::IfcProfileDef::it it = profiles->begin(); it != profiles->end(); ++it) {
-		TopoDS_Face f;
-		if (IfcGeom::convert_face(*it, f)) {
-			builder.Add(compound, f);
-			/* TopExp_Explorer exp(f, TopAbs_WIRE);
-			for (; exp.More(); exp.Next()) {
-				const TopoDS_Wire& wire = TopoDS::Wire(exp.Current());
-				if (first) {
-					mf.Init(BRepBuilderAPI_MakeFace(wire));
-				} else {
-					mf.Add(wire);
-				}
-				first = false;
-			} */
-		}
-	}
-
-	face = compound;
-	return !face.IsNull();
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcDerivedProfileDef::ptr l, TopoDS_Shape& face) {
-	TopoDS_Face f;
-	gp_Trsf2d trsf2d;
-	if (IfcGeom::convert_face(l->ParentProfile(), f) && IfcGeom::convert(l->Operator(), trsf2d)) {
-		gp_Trsf trsf = trsf2d;
-		face = TopoDS::Face(BRepBuilderAPI_Transform(f, trsf));
-		return true;
-	} else {
-		return false;
-	}
-}

src/ifcgeom/IfcGeomFunctions.cpp

@@ -1,920 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * Implementations of the various conversion functions defined in IfcGeom.h     *
- *                                                                              *
- ********************************************************************************/
-
-#include <set>
-#include <cassert>
-#include <limits>
-
-#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.hxx>
-#include <BRepTools.hxx>
-
-#include <Poly_Triangulation.hxx>
-#include <Poly_Array1OfTriangle.hxx>
-
-#include <BRepTools.hxx>
-
-#include <TopExp.hxx>
-#include <TopTools_IndexedMapOfShape.hxx>
-#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
-#include <TopTools_ListIteratorOfListOfShape.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 shape;
-	IfcGeom::create_solid_from_compound(shape,solid);
-	return solid;
-}
-
-bool IfcGeom::convert_openings(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::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 ( IfcSchema::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
-		IfcSchema::IfcRelVoidsElement::ptr v = *it;
-		IfcSchema::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
-		if ( fes->is(IfcSchema::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());
-
-			IfcSchema::IfcProductRepresentation::ptr prodrep = fes->Representation();
-			IfcSchema::IfcRepresentation::list reps = prodrep->Representations();
-						
-			for ( IfcSchema::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 IfcSchema::IfcProduct::ptr entity, const IfcSchema::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 ( IfcSchema::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
-		IfcSchema::IfcRelVoidsElement::ptr v = *it;
-		IfcSchema::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
-		if ( fes->is(IfcSchema::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());
-
-			IfcSchema::IfcProductRepresentation::ptr prodrep = fes->Representation();
-			IfcSchema::IfcRepresentation::list reps = prodrep->Representations();
-
-			IfcGeom::IfcRepresentationShapeItems opening_shapes;
-						
-			for ( IfcSchema::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::convert_curve_to_wire(const Handle(Geom_Curve)& curve, TopoDS_Wire& wire) {
-	wire = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(curve));
-	return true;
-}
-
-bool IfcGeom::profile_helper(int numVerts, double* verts, int numFillets, int* filletIndices, double* filletRadii, gp_Trsf2d trsf, TopoDS_Shape& face_shape) {
-	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]));
-
-	TopoDS_Face face;
-	IfcGeom::convert_wire_to_face(w.Wire(),face);
-
-	if ( numFillets ) {
-		BRepFilletAPI_MakeFillet2d fillet (face);
-		for ( int i = 0; i < numFillets; i ++ ) {
-			const double radius = filletRadii[i];
-			if ( radius < ALMOST_ZERO ) continue;
-			fillet.AddFillet(vertices[filletIndices[i]],radius);
-		}
-		fillet.Build();
-		face = TopoDS::Face(fillet.Shape());
-	}
-
-	face_shape = face;
-
-	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;
-}
-
-IfcSchema::IfcProductDefinitionShape* IfcGeom::tesselate(TopoDS_Shape& shape, double deflection, IfcEntities es) {
-	BRepMesh::Mesh(shape, deflection);
-
-	IfcSchema::IfcFace::list faces (new IfcTemplatedEntityList<IfcSchema::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<IfcSchema::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());
-				IfcSchema::IfcCartesianPoint* cpnt = new IfcSchema::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);
-				IfcSchema::IfcCartesianPoint::list points (new IfcTemplatedEntityList<IfcSchema::IfcCartesianPoint>());
-				points->push(vertices[n1-1]);
-				points->push(vertices[n2-1]);
-				points->push(vertices[n3-1]);
-				IfcSchema::IfcPolyLoop* loop = new IfcSchema::IfcPolyLoop(points);
-				IfcSchema::IfcFaceOuterBound* bound = new IfcSchema::IfcFaceOuterBound(loop, face.Orientation() != TopAbs_REVERSED);
-				IfcSchema::IfcFaceBound::list bounds (new IfcTemplatedEntityList<IfcSchema::IfcFaceBound>());
-				bounds->push(bound);
-				IfcSchema::IfcFace* face = new IfcSchema::IfcFace(bounds);
-				es->push(loop);
-				es->push(bound);
-				es->push(face);
-				faces->push(face);
-			}
-		}
-	}
-	IfcSchema::IfcOpenShell* shell = new IfcSchema::IfcOpenShell(faces);
-	IfcSchema::IfcConnectedFaceSet::list shells (new IfcTemplatedEntityList<IfcSchema::IfcConnectedFaceSet>());
-	shells->push(shell);
-	IfcSchema::IfcFaceBasedSurfaceModel* surface_model = new IfcSchema::IfcFaceBasedSurfaceModel(shells);
-
-	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
-	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
-
-	items->push(surface_model);
-
-	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
-		0, std::string("Facetation"), std::string("SurfaceModel"), items);
-
-	reps->push(rep);
-	IfcSchema::IfcProductDefinitionShape* shapedef = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
-
-	es->push(shell);
-	es->push(surface_model);
-	es->push(rep);
-	es->push(shapedef);
-
-	return shapedef;
-}
-
-// Returns the vertex part of an TopoDS_Edge edge that is not TopoDS_Vertex vertex
-TopoDS_Vertex find_other(const TopoDS_Edge& edge, const TopoDS_Vertex& vertex) {
-	TopExp_Explorer exp(edge, TopAbs_VERTEX);
-	while (exp.More()) {
-		if (!exp.Current().IsSame(vertex)) {
-			return TopoDS::Vertex(exp.Current());
-		}
-		exp.Next();
-	}
-	return TopoDS_Vertex();
-}
-
-TopoDS_Edge find_next(const TopTools_IndexedMapOfShape& edge_set, const TopTools_IndexedDataMapOfShapeListOfShape& vertex_to_edges, const TopoDS_Vertex& current, const TopoDS_Edge& previous_edge) {
-	const TopTools_ListOfShape& edges = vertex_to_edges.FindFromKey(current);
-	TopTools_ListIteratorOfListOfShape eit;
-	for (eit.Initialize(edges); eit.More(); eit.Next()) {
-		const TopoDS_Edge& edge = TopoDS::Edge(eit.Value());
-		if (edge.IsSame(previous_edge)) continue;
-		if (edge_set.Contains(edge)) {
-			return edge;
-		}
-	}
-	return TopoDS_Edge();
-}
-
-bool IfcGeom::fill_nonmanifold_wires_with_planar_faces(TopoDS_Shape& shape) {
-	BRepOffsetAPI_Sewing sew;
-	sew.Add(shape);
-
-	TopTools_IndexedDataMapOfShapeListOfShape edge_to_faces;
-	TopTools_IndexedDataMapOfShapeListOfShape vertex_to_edges;
-	std::set<int> visited;
-	TopTools_IndexedMapOfShape edge_set;
-
-	TopExp::MapShapesAndAncestors (shape, TopAbs_EDGE, TopAbs_FACE, edge_to_faces);
-
-	const int num_edges = edge_to_faces.Extent();
-	for (int i = 1; i <= num_edges; ++i) {
-		const TopTools_ListOfShape& faces = edge_to_faces.FindFromIndex(i);
-		const int count = faces.Extent();
-		// Find only the non-manifold edges: Edges that are only part of a
-		// single face and therefore part of the wire(s) we want to fill.
-		if (count == 1) {
-			const TopoDS_Shape& edge = edge_to_faces.FindKey(i);
-			TopExp::MapShapesAndAncestors (edge, TopAbs_VERTEX, TopAbs_EDGE, vertex_to_edges);
-			edge_set.Add(edge);
-		}
-	}
-
-	const int num_verts = vertex_to_edges.Extent();
-	TopoDS_Vertex first, current;
-	TopoDS_Edge previous_edge;
-
-	// Now loop over all the vertices that are part of the wire(s) to be filled
-	for (int i = 1; i <= num_verts; ++i) {
-		first = current = TopoDS::Vertex(vertex_to_edges.FindKey(i));
-		const bool isSame = first.IsSame(current);
-		// We keep track of the vertices we already used
-		if (visited.find(vertex_to_edges.FindIndex(current)) != visited.end()) {
-			continue;
-		}
-		// Given these vertices, try to find closed loops and create new
-		// wires out of them.
-		BRepBuilderAPI_MakeWire w;
-		while (true) {
-			visited.insert(vertex_to_edges.FindIndex(current));
-			// Find the edge that the current vertex is part of and points
-			// away from the previous vertex (null for the first vertex).
-			TopoDS_Edge edge = find_next(edge_set, vertex_to_edges, current, previous_edge);
-			if (edge.IsNull()) {
-				return false;
-			}
-			TopoDS_Vertex other = find_other(edge, current);
-			if (other.IsNull()) {
-				// Dealing with a conical edge probably, for some reason
-				// this works better than adding the edge directly.
-				double u1, u2;
-				Handle(Geom_Curve) crv = BRep_Tool::Curve(edge, u1, u2);
-				w.Add(BRepBuilderAPI_MakeEdge(crv, u1, u2));
-				break;
-			} else {
-				w.Add(edge);
-			}
-			// See if the starting point of this loop has been reached. Note that
-			// additional wires after this one potentially will be created.
-			if (other.IsSame(first)) {
-				break;
-			}
-			previous_edge = edge;
-			current = other;
-		}
-		sew.Add(BRepBuilderAPI_MakeFace(w));
-		previous_edge.Nullify();
-	}
-		
-	sew.Perform();
-	shape = sew.SewedShape();
-
-	try {
-		ShapeFix_Solid solid;
-		solid.LimitTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
-		shape = solid.SolidFromShell(TopoDS::Shell(shape));
-	} catch(...) {}
-
-	return true;
-}
-
-std::string IfcGeom::create_brep_data(IfcSchema::IfcProduct* ifc_product, unsigned int settings) {
-	const bool no_openings = !!(settings & DISABLE_OPENING_SUBTRACTIONS);
-	const bool no_placement = !!(settings & DISABLE_OBJECT_PLACEMENT);
-	const bool sew_shells = !!(settings & SEW_SHELLS);
-	const bool convert_to_meters = !!(settings & CONVERT_TO_METERS);
-
-	const double old_max_faces_to_sew = GetValue(GV_MAX_FACES_TO_SEW);
-	const double inf = std::numeric_limits<double>::infinity();
-	SetValue(GV_MAX_FACES_TO_SEW, sew_shells ? inf : -inf);
-
-	std::string brep_data = "";
-
-	if (ifc_product->hasRepresentation()) {
-
-		IfcSchema::IfcProductRepresentation* prod_rep = ifc_product->Representation();
-		IfcSchema::IfcRepresentation::list li = prod_rep->Representations();
-		IfcSchema::IfcShapeRepresentation* shape_rep = 0;
-		for (IfcSchema::IfcRepresentation::it i = li->begin(); i != li->end(); ++i) {
-			const std::string representation_identifier = (*i)->RepresentationIdentifier();
-			if ((*i)->is(IfcSchema::Type::IfcShapeRepresentation) && (representation_identifier == "Body" || representation_identifier == "Facetation")) {
-				shape_rep = (IfcSchema::IfcShapeRepresentation*) *i;
-				break;
-			}
-		}
-
-		if (!!shape_rep) {
-
-			IfcGeom::IfcRepresentationShapeItems shapes;
-			if (IfcGeom::convert_shapes(shape_rep,shapes)) {
-		
-				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
-				IfcSchema::IfcRelVoidsElement::list openings = IfcSchema::IfcRelVoidsElement::list();
-				if ( ifc_product->is(IfcSchema::Type::IfcElement) && !ifc_product->is(IfcSchema::Type::IfcOpeningElement) ) {
-					IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcElement>(ifc_product);
-					openings = element->HasOpenings();
-				}
-				// Is the IfcElement a decomposition of an IfcElement with any IfcOpeningElements?
-				if ( ifc_product->is(IfcSchema::Type::IfcBuildingElementPart ) ) {
-					IfcSchema::IfcBuildingElementPart::ptr part = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcBuildingElementPart>(ifc_product);
-#ifdef USE_IFC4
-					IfcSchema::IfcRelAggregates::list decomposes = part->Decomposes();
-					for ( IfcSchema::IfcRelAggregates::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
-#else
-					IfcSchema::IfcRelDecomposes::list decomposes = part->Decomposes();
-					for ( IfcSchema::IfcRelDecomposes::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
-#endif
-						IfcSchema::IfcObjectDefinition::ptr obdef = (*it)->RelatingObject();
-						if ( obdef->is(IfcSchema::Type::IfcElement) ) {
-							IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcObjectDefinition,IfcSchema::IfcElement>(obdef);
-							openings->push(element->HasOpenings());
-						}
-					}
-				}
-
-				if (openings && openings->Size() && !no_openings) {
-					IfcGeom::IfcRepresentationShapeItems opened_shapes;
-					try {
-						IfcGeom::convert_openings(ifc_product,openings,shapes,trsf,opened_shapes);
-					} catch(...) { 
-						Logger::Message(Logger::LOG_ERROR,"Error processing openings for:",ifc_product->entity); 
-					}
-					shapes = opened_shapes;
-				}
-
-				if (!no_placement) {
-					for ( IfcGeom::IfcRepresentationShapeItems::iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
-						it->prepend(trsf);
-					}
-				}
-
-				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();
-					const gp_GTrsf& trsf = it->Placement();
-					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);
-				}
-				if (GetValue(GV_LENGTH_UNIT) != 1. && !convert_to_meters) {
-					gp_Trsf length_unit_scale;
-					length_unit_scale.SetScaleFactor(1. / GetValue(GV_LENGTH_UNIT));
-					compound.Move(length_unit_scale);
-				}
-				std::stringstream sstream;
-				BRepTools::Write(compound,sstream);
-				brep_data = sstream.str();
-			}
-		}
-	}
-	
-	SetValue(GV_MAX_FACES_TO_SEW, old_max_faces_to_sew);
-	
-	return brep_data;
-}
-
-double UnitPrefixToValue( IfcSchema::IfcSIPrefix::IfcSIPrefix v ) {
-	if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_EXA   ) return (double) 1e18;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_PETA  ) return (double) 1e15;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_TERA  ) return (double) 1e12;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_GIGA  ) return (double) 1e9;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_MEGA  ) return (double) 1e6;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_KILO  ) return (double) 1e3;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_HECTO ) return (double) 1e2;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_DECA  ) return (double) 1;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_DECI  ) return (double) 1e-1;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_CENTI ) return (double) 1e-2;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_MILLI ) return (double) 1e-3;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_MICRO ) return (double) 1e-6;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_NANO  ) return (double) 1e-9;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_PICO  ) return (double) 1e-12;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_FEMTO ) return (double) 1e-15;
-	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_ATTO  ) return (double) 1e-18;
-	else return 1.0f;
-}
-
-void IfcGeom::initialize_units_and_precision(IfcSchema::IfcProject* proj, double& unit_magnitude, std::string& unit_name) {
-
-	// IfcOpenShell measures internally in meters, therefore a conversion factor
-	// is obtained based on the length unit in the file.
-
-	// 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);
-	
-	IfcUtil::IfcAbstractSelect::list units = IfcUtil::IfcAbstractSelect::list();
-	try {
-		IfcSchema::IfcUnitAssignment* unit_assignment = proj->UnitsInContext();
-		units = unit_assignment->Units();
-	} catch (const IfcParse::IfcException&) {}
-
-	try {
-		for ( IfcUtil::IfcAbstractSelect::it it = units->begin(); it != units->end(); ++ it ) {
-			std::string current_unit_name = "";
-			const IfcUtil::IfcAbstractSelect::ptr base = *it;
-			IfcSchema::IfcSIUnit::ptr unit = IfcSchema::IfcSIUnit::ptr();
-			double value = 1.0f;
-			if ( base->is(IfcSchema::Type::IfcConversionBasedUnit) ) {
-				const IfcSchema::IfcConversionBasedUnit::ptr u = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcConversionBasedUnit>(base);
-				current_unit_name = u->Name();
-				const IfcSchema::IfcMeasureWithUnit::ptr u2 = u->ConversionFactor();
-				IfcSchema::IfcUnit u3 = u2->UnitComponent();
-				if ( u3->is(IfcSchema::Type::IfcSIUnit) ) {
-					unit = (IfcSchema::IfcSIUnit*) u3;
-				}
-				IfcSchema::IfcValue v = u2->ValueComponent();
-				const double f = *((IfcUtil::IfcBaseEntity*)v)->entity->getArgument(0);
-				value *= f;
-			} else if ( base->is(IfcSchema::Type::IfcSIUnit) ) {
-				unit = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcSIUnit>(base);
-			}
-			if ( unit ) {
-				if ( unit->hasPrefix() ) {
-					value *= UnitPrefixToValue(unit->Prefix());
-				}
-				IfcSchema::IfcUnitEnum::IfcUnitEnum type = unit->UnitType();
-				if ( type == IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT ) {
-					IfcGeom::SetValue(IfcGeom::GV_LENGTH_UNIT,value);
-					if (current_unit_name.empty()) {
-						if (unit->hasPrefix()) {
-							current_unit_name = IfcSchema::IfcSIPrefix::ToString(unit->Prefix());
-						}
-						current_unit_name += IfcSchema::IfcSIUnitName::ToString(unit->Name());
-					}
-					unit_magnitude = value;
-					unit_name = current_unit_name;
-				} else if ( type == IfcSchema::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());
-	}
-
-	// Boolean operations rely on a precision value for vertex and face coincedence. This
-	// value is obtained from the IfcGeometricRepresentationContexts in the file.
-
-	// Set an initial guess in case reading from file fails.
-	IfcGeom::SetValue(IfcGeom::GV_PRECISION, 0.00001);
-
-	try {
-		IfcSchema::IfcRepresentationContext::list rep_contexts = proj->RepresentationContexts();
-		// 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 (IfcSchema::IfcRepresentationContext::it it = rep_contexts->begin(); it != rep_contexts->end(); ++it) {
-			if ((*it)->is(IfcSchema::Type::IfcGeometricRepresentationContext)) {
-				IfcSchema::IfcGeometricRepresentationContext* rep_context = (IfcSchema::IfcGeometricRepresentationContext*)*it;
-				if (rep_context->is(IfcSchema::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) {
-			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());
-	}
-}

src/ifcgeom/IfcGeomHelpers.cpp

@@ -1,323 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * 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 IfcSchema::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 IfcSchema::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 IfcSchema::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 IfcSchema::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 IfcSchema::IfcAxis1Placement::ptr l, gp_Ax1& ax) {
-	IN_CACHE(IfcAxis1Placement,l,gp_Ax1,ax)
-	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);
-	IfcGeom::convert(l->Location(),o);
-	if ( l->hasAxis() ) IfcGeom::convert(l->Axis(), axis);
-	ax = gp_Ax1(o, axis);
-	CACHE(IfcAxis1Placement,l,ax)
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::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;
-	if ( l->hasAxis1() ) IfcGeom::convert(l->Axis1(),axis1);
-	if ( l->hasAxis2() ) IfcGeom::convert(l->Axis2(),axis2);
-	if ( l->hasAxis3() ) IfcGeom::convert(l->Axis3(),axis3);
-	else axis3 = axis1.Crossed(axis2);
-	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 IfcSchema::IfcCartesianTransformationOperator2D::ptr l, gp_Trsf2d& trsf) {
-	IN_CACHE(IfcCartesianTransformationOperator2D,l,gp_Trsf2d,trsf)
-
-	gp_Pnt origin;
-	gp_Dir axis1 (1.,0.,0.);
-	gp_Dir axis2 (0.,1.,0.);
-	
-	IfcGeom::convert(l->LocalOrigin(),origin);
-	if ( l->hasAxis1() ) IfcGeom::convert(l->Axis1(),axis1);
-	if ( l->hasAxis2() ) IfcGeom::convert(l->Axis2(),axis2);
-	
-	const gp_Pnt2d origin2d(origin.X(), origin.Y());
-	const gp_Dir2d axis12d(axis1.X(), axis1.Y());
-	const gp_Dir2d axis22d(axis2.X(), axis2.Y());
-
-	// A better match to represent the IfcCartesianTransformationOperator2D would
-	// be the gp_Ax22d, but to my knowledge no easy way exists to convert it into
-	// a gp_Trsf2d. Easiest would probably be to simply update the underlying
-	// gp_Mat2d directly.
-	
-	const gp_Ax2d ax2d (origin2d, axis12d);
-	trsf.SetTransformation(ax2d);
-	
-	if ( ax2d.Direction().Rotated(M_PI / 2.).Dot(axis22d) < 0. ) {
-		gp_Trsf2d mirror; mirror.SetMirror(ax2d);
-		trsf.Multiply(mirror);
-	}
-
-	trsf.Invert();
-	if ( l->hasScale() ) trsf.SetScaleFactor(l->Scale());
-	CACHE(IfcCartesianTransformationOperator2D,l,trsf)
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::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;
-	if ( l->hasAxis1() ) IfcGeom::convert(l->Axis1(),axis1);
-	if ( l->hasAxis2() ) IfcGeom::convert(l->Axis2(),axis2);
-	if ( l->hasAxis3() ) IfcGeom::convert(l->Axis3(),axis3);
-	else axis3 = axis1.Crossed(axis2);
-	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 IfcSchema::IfcCartesianTransformationOperator2DnonUniform::ptr l, gp_GTrsf2d& gtrsf) {
-	IN_CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gp_GTrsf2d,gtrsf)
-
-	gp_Trsf2d trsf;
-	gp_Pnt origin;
-	gp_Dir axis1 (1.,0.,0.);
-	gp_Dir axis2 (0.,1.,0.);
-	
-	IfcGeom::convert(l->LocalOrigin(),origin);
-	if ( l->hasAxis1() ) IfcGeom::convert(l->Axis1(),axis1);
-	if ( l->hasAxis2() ) IfcGeom::convert(l->Axis2(),axis2);
-
-	const gp_Pnt2d origin2d(origin.X(), origin.Y());
-	const gp_Dir2d axis12d(axis1.X(), axis1.Y());
-	const gp_Dir2d axis22d(axis2.X(), axis2.Y());
-	
-	const gp_Ax2d ax2d (origin2d, axis12d);
-	trsf.SetTransformation(ax2d);
-	
-	if ( ax2d.Direction().Rotated(M_PI / 2.).Dot(axis22d) < 0. ) {
-		gp_Trsf2d mirror; mirror.SetMirror(ax2d);
-		trsf.Multiply(mirror);
-	}
-
-	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 IfcSchema::IfcPlane::ptr pln, gp_Pln& plane) {
-	IN_CACHE(IfcPlane,pln,gp_Pln,plane)
-	IfcSchema::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 IfcSchema::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 IfcSchema::IfcObjectPlacement::ptr l, gp_Trsf& trsf) {
-	IN_CACHE(IfcObjectPlacement,l,gp_Trsf,trsf)
-	if ( ! l->is(IfcSchema::Type::IfcLocalPlacement) ) {
-		Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l->entity);
-		return false; 		
-	}
-	IfcSchema::IfcLocalPlacement::ptr current = reinterpret_pointer_cast<IfcSchema::IfcObjectPlacement,IfcSchema::IfcLocalPlacement>(l);
-	while (1) {
-		gp_Trsf trsf2;
-		IfcSchema::IfcAxis2Placement relplacement = current->RelativePlacement();
-		if ( relplacement->is(IfcSchema::Type::IfcAxis2Placement3D) ) {
-			IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)relplacement,trsf2);
-			trsf.PreMultiply(trsf2);
-		}
-		if ( current->hasPlacementRelTo() ) {
-			IfcSchema::IfcObjectPlacement::ptr relto = current->PlacementRelTo();
-			if ( relto->is(IfcSchema::Type::IfcLocalPlacement) )
-				current = reinterpret_pointer_cast<IfcSchema::IfcObjectPlacement,IfcSchema::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

@@ -1,727 +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 <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.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 "../ifcparse/IfcFile.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 {
-			// BRepTools::Clean(s);
-			BRepMesh::Mesh(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 IfcSchema::IfcShapeRepresentation::list shapereps;
-static IfcSchema::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 IfcSchema::IfcProduct::list entities;
-static IfcSchema::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 IfcSchema::IfcProduct::ptr ifc_product) {
-	int parent_id = -1;
-	// In case of an opening element, parent to the RelatingBuildingElement
-	if ( ifc_product->is(IfcSchema::Type::IfcOpeningElement ) ) {
-		IfcSchema::IfcOpeningElement::ptr opening = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcOpeningElement>(ifc_product);
-		IfcSchema::IfcRelVoidsElement::list voids = opening->VoidsElements();
-		if ( voids->Size() ) {
-			IfcSchema::IfcRelVoidsElement::ptr ifc_void = *voids->begin();
-			parent_id = ifc_void->RelatingBuildingElement()->entity->id();
-		}
-	} else if ( ifc_product->is(IfcSchema::Type::IfcElement ) ) {
-		IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcElement>(ifc_product);
-		IfcSchema::IfcRelFillsElement::list fills = element->FillsVoids();
-		// Incase of a RelatedBuildingElement parent to the opening element
-		if ( fills->Size() ) {
-			for ( IfcSchema::IfcRelFillsElement::it it = fills->begin(); it != fills->end(); ++ it ) {
-				IfcSchema::IfcRelFillsElement::ptr fill = *it;
-				IfcSchema::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 ) {
-			IfcSchema::IfcRelContainedInSpatialStructure::list parents = element->ContainedInStructure();
-			if ( parents->Size() ) {
-				IfcSchema::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(IfcSchema::Type::IfcRelAggregates);
-		parents->push(ifc_product->entity->getInverse(IfcSchema::Type::IfcRelNests));
-		for ( IfcEntityList::it it = parents->begin(); it != parents->end(); ++ it ) {
-			IfcSchema::IfcRelDecomposes::ptr decompose = reinterpret_pointer_cast<IfcUtil::IfcBaseClass,IfcSchema::IfcRelDecomposes>(*it);
-			IfcSchema::IfcObjectDefinition* ifc_objectdef;
-#ifdef USE_IFC4
-			if (decompose->is(IfcSchema::Type::IfcRelAggregates)) {
-				ifc_objectdef = ((IfcSchema::IfcRelAggregates*)decompose)->RelatingObject();
-			} else {
-				continue;
-			}
-#else
-			ifc_objectdef = decompose->RelatingObject();
-#endif
-			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 ) {
-		IfcSchema::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;
-				}
-			}
-			IfcSchema::IfcProductRepresentation::list prodreps = shaperep->OfProductRepresentation();
-			entities = IfcSchema::IfcProduct::list( new IfcTemplatedEntityList<IfcSchema::IfcProduct>() );
-			for ( IfcSchema::IfcProductRepresentation::it it = prodreps->begin(); it != prodreps->end(); ++it ) {
-				if ( (*it)->is(IfcSchema::Type::IfcProductDefinitionShape) ) {
-					IfcSchema::IfcProductDefinitionShape::ptr pds = reinterpret_pointer_cast<IfcSchema::IfcProductRepresentation,IfcSchema::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(IfcSchema::Type::IfcProduct);
-					for ( IfcEntityList::it it = products->begin(); it != products->end(); ++ it ) {
-						entities->push(reinterpret_pointer_cast<IfcUtil::IfcBaseClass,IfcSchema::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;
-		}
-
-		IfcSchema::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
-		IfcSchema::IfcRelVoidsElement::list openings = IfcSchema::IfcRelVoidsElement::list();
-		if ( ifc_product->is(IfcSchema::Type::IfcElement) && !ifc_product->is(IfcSchema::Type::IfcOpeningElement) ) {
-			IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcElement>(ifc_product);
-			openings = element->HasOpenings();
-		}
-		// Is the IfcElement a decomposition of an IfcElement with any IfcOpeningElements?
-		if ( ifc_product->is(IfcSchema::Type::IfcBuildingElementPart ) ) {
-			IfcSchema::IfcBuildingElementPart::ptr part = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcBuildingElementPart>(ifc_product);
-#ifdef USE_IFC4
-			IfcSchema::IfcRelAggregates::list decomposes = part->Decomposes();
-			for ( IfcSchema::IfcRelAggregates::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
-#else
-			IfcSchema::IfcRelDecomposes::list decomposes = part->Decomposes();
-			for ( IfcSchema::IfcRelDecomposes::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
-#endif
-				IfcSchema::IfcObjectDefinition::ptr obdef = (*it)->RelatingObject();
-				if ( obdef->is(IfcSchema::Type::IfcElement) ) {
-					IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcObjectDefinition,IfcSchema::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, 
-			IfcSchema::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(IfcSchema::Type::IfcProduct) ) {
-			IfcSchema::IfcProduct::ptr ifc_product = reinterpret_pointer_cast<IfcUtil::IfcBaseClass,IfcSchema::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,
-				IfcSchema::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;
-}
-
-static std::string unit_name = "METER";
-static float unit_magnitude = 1.0f;
-
-void IfcGeomObjects::InitUnits() {
-	IfcSchema::IfcProject::list projects = ifc_file->EntitiesByType<IfcSchema::IfcProject>();
-	if (projects->Size() == 1) {
-		double unit_magnitude_double;
-		IfcGeom::initialize_units_and_precision(*projects->begin(), unit_magnitude_double, unit_name);
-		unit_magnitude = static_cast<float>(unit_magnitude_double);
-	}
-}
-
-bool IfcGeomObjects::Init(const std::string fn) {
-	return IfcGeomObjects::Init(fn, 0, 0);
-}
-bool _Init() {
-	IfcGeomObjects::InitUnits();
-
-	shapereps = ifc_file->EntitiesByType<IfcSchema::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(); }
-bool IfcGeomObjects::Material::hasSpecular() const { return style->Specular(); }
-bool IfcGeomObjects::Material::hasTransparency() const { return style->Transparency(); }
-bool IfcGeomObjects::Material::hasSpecularity() const { return style->Specularity(); }
-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

@@ -1,286 +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).                *
- *                                                                              *
- * 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

@@ -1,161 +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 <map>
-
-#include "IfcGeomRenderStyles.h"
-
-namespace IfcGeom {
-	namespace Cache {
-		std::map<int,SurfaceStyle> Style;
-		void PurgeStyleCache() {
-			Style.clear();
-		}
-	}
-}
-
-bool process_colour(IfcSchema::IfcColourRgb* colour, std::tr1::array<double, 3>& rgb) {
-	if (colour != 0) {
-		rgb[0] = colour->Red();
-		rgb[1] = colour->Green();
-		rgb[2] = colour->Blue();
-	}
-	return colour != 0;
-}
-
-bool process_colour(IfcUtil::IfcBaseEntity* factor, std::tr1::array<double, 3>& rgb) {
-	if (factor != 0) {
-		const double f = *factor->entity->getArgument(0);
-		rgb[0] = rgb[1] = rgb[2] = f;
-	}
-	return factor != 0;
-}
-
-bool process_colour(IfcSchema::IfcColourOrFactor colour_or_factor, std::tr1::array<double, 3>& rgb) {
-	if (colour_or_factor == 0) {
-		return false;
-	} else if (colour_or_factor->is(IfcSchema::Type::IfcColourRgb)) {
-		return process_colour(static_cast<IfcSchema::IfcColourRgb*>(colour_or_factor), rgb);
-	} else if (colour_or_factor->is(IfcSchema::Type::IfcNormalisedRatioMeasure)) {
-		return process_colour(static_cast<IfcUtil::IfcBaseEntity*>(colour_or_factor), rgb);
-	} else {
-		return false;
-	}
-}
-
-const IfcGeom::SurfaceStyle* IfcGeom::get_style(IfcSchema::IfcRepresentationItem* item) {
-	std::pair<IfcSchema::IfcSurfaceStyle*, IfcSchema::IfcSurfaceStyleShading*> shading_styles = get_surface_style<IfcSchema::IfcSurfaceStyleShading>(item);
-	if (shading_styles.second == 0) {
-		return 0;
-	}
-	int surface_style_id = shading_styles.first->entity->id();
-	std::map<int,SurfaceStyle>::const_iterator it = Cache::Style.find(surface_style_id);
-	if (it != Cache::Style.end()) {
-		return &(it->second);
-	}
-	SurfaceStyle surface_style;
-	if (shading_styles.first->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(IfcSchema::Type::IfcSurfaceStyleRendering)) {
-		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()) {
-			// Not supported
-		}
-		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

@@ -1,152 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-#ifndef IFCGEOMRENDERSTYLES_H
-#define IFCGEOMRENDERSTYLES_H
-
-#ifdef __GNUC__
-#include <tr1/array>
-#else
-#include <array>
-#endif
-
-#ifdef USE_IFC4
-#include "../ifcparse/Ifc4.h"
-#else
-#include "../ifcparse/Ifc2x3.h"
-#endif
-
-namespace IfcGeom {
-	class SurfaceStyle {
-	public:
-		class ColorComponent {
-		private:
-			std::tr1::array<double, 3> data;
-		public:
-			ColorComponent(double r, double g, double b) {
-				data[0] = r; data[1] = g; data[2] = b;
-			}
-			const double& R() const { return data[0]; }
-			const double& G() const { return data[1]; }
-			const double& B() const { return data[2]; }
-			double& R() { return data[0]; }
-			double& G() { return data[1]; }
-			double& B() { return data[2]; }
-		};
-	private:
-		boost::optional<std::string> name;
-		boost::optional<int> id;
-		boost::optional<ColorComponent> diffuse, specular;
-		boost::optional<double> transparency;
-		boost::optional<double> specularity;
-	public:
-		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) {
-			if (name && other.name) {
-				return *name == *other.name;
-			} else if (id && other.id) {
-				return *id == *other.id;
-			} else {
-				return false;
-			}
-		}
-		
-		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; }
-		const boost::optional<double>& Transparency() const { return transparency; }
-		const boost::optional<double>& Specularity() const { return specularity; }
-		boost::optional<ColorComponent>& Diffuse() { return diffuse; }
-		boost::optional<ColorComponent>& Specular() { return specular; }
-		boost::optional<double>& Transparency() { return transparency; }
-		boost::optional<double>& Specularity() { return specularity; }
-	};
-
-	template <typename T> std::pair<IfcSchema::IfcSurfaceStyle*, T*> get_surface_style(IfcSchema::IfcRepresentationItem* representation_item) {
-		IfcSchema::IfcStyledItem::list styled_items = representation_item->StyledByItem();
-		for (IfcSchema::IfcStyledItem::it jt = styled_items->begin(); jt != styled_items->end(); ++jt) {
-#ifdef USE_IFC4
-			IfcUtil::IfcAbstractSelect::list style_assignments = (*jt)->Styles();
-			for (IfcUtil::IfcAbstractSelect::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
-				if (!(*kt)->is(IfcSchema::Type::IfcPresentationStyleAssignment)) {
-					continue;
-				}
-				IfcSchema::IfcPresentationStyleAssignment::ptr style_assignment = (IfcSchema::IfcPresentationStyleAssignment::ptr) *kt;
-#else
-			IfcSchema::IfcPresentationStyleAssignment::list style_assignments = (*jt)->Styles();
-			for (IfcSchema::IfcPresentationStyleAssignment::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
-				IfcSchema::IfcPresentationStyleAssignment::ptr style_assignment = *kt;
-#endif
-				IfcUtil::IfcAbstractSelect::list styles = style_assignment->Styles();
-				for (IfcUtil::IfcAbstractSelect::it lt = styles->begin(); lt != styles->end(); ++lt) {
-					IfcUtil::IfcAbstractSelect::ptr style = *lt;
-					if (style->is(IfcSchema::Type::IfcSurfaceStyle)) {
-						IfcSchema::IfcSurfaceStyle* surface_style = (IfcSchema::IfcSurfaceStyle*) style;
-						if (surface_style->Side() != IfcSchema::IfcSurfaceSide::IfcSurfaceSide_NEGATIVE) {
-							IfcUtil::IfcAbstractSelect::list styles_elements = surface_style->Styles();
-							for (IfcUtil::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<IfcSchema::IfcSurfaceStyle*, T*>(0,0);
-	}
-
-	const SurfaceStyle* get_style(IfcSchema::IfcRepresentationItem* representation_item);
-	const SurfaceStyle* get_default_style(const std::string& ifc_type);
-	
-	namespace Cache {
-		void PurgeStyleCache();
-	}
-}
-
-#endif

src/ifcgeom/IfcGeomShapes.cpp

@@ -1,725 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * Implementations of the various conversion functions defined in IfcRegister.h *
- *                                                                              *
- ********************************************************************************/
-
-#include <gp_Pnt.hxx>
-#include <gp_Vec.hxx>
-#include <gp_Dir.hxx>
-#include <gp_Pnt2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <gp_Dir2d.hxx>
-#include <gp_Mat.hxx>
-#include <gp_Mat2d.hxx>
-#include <gp_GTrsf.hxx>
-#include <gp_GTrsf2d.hxx>
-#include <gp_Trsf.hxx>
-#include <gp_Trsf2d.hxx>
-#include <gp_Ax1.hxx>
-#include <gp_Ax3.hxx>
-#include <gp_Ax2d.hxx>
-#include <gp_Pln.hxx>
-#include <gp_Circ.hxx>
-
-#include <TColgp_Array1OfPnt.hxx>
-#include <TColgp_Array1OfPnt2d.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <TColStd_Array1OfInteger.hxx>
-
-#include <Geom_Line.hxx>
-#include <Geom_Circle.hxx>
-#include <Geom_Ellipse.hxx>
-#include <Geom_TrimmedCurve.hxx>
-#include <Geom_CylindricalSurface.hxx>
-
-#include <BRepOffsetAPI_Sewing.hxx>
-#include <BRepOffsetAPI_MakePipe.hxx>
-#include <BRepOffsetAPI_MakePipeShell.hxx>
-
-#include <BRepBuilderAPI_MakeFace.hxx>
-#include <BRepBuilderAPI_MakeEdge.hxx>
-#include <BRepBuilderAPI_MakeWire.hxx>
-#include <BRepBuilderAPI_MakePolygon.hxx>
-#include <BRepBuilderAPI_MakeVertex.hxx>
-
-#include <TopoDS.hxx>
-#include <TopoDS_Wire.hxx>
-#include <TopoDS_Face.hxx>
-#include <TopExp_Explorer.hxx>
-
-#include <BRepPrimAPI_MakePrism.hxx>
-#include <BRepPrimAPI_MakeRevol.hxx>
-#include <BRepPrimAPI_MakeBox.hxx>
-#include <BRepPrimAPI_MakeCone.hxx>
-#include <BRepPrimAPI_MakeCylinder.hxx>
-#include <BRepPrimAPI_MakeSphere.hxx>
-#include <BRepPrimAPI_MakeWedge.hxx>
-
-#include <BRepBuilderAPI_Transform.hxx>
-#include <BRepBuilderAPI_MakeShell.hxx>
-#include <BRepBuilderAPI_MakeSolid.hxx>
-#include <BRepPrimAPI_MakeHalfSpace.hxx>
-
-#include <BRepAlgoAPI_Cut.hxx>
-#include <BRepAlgoAPI_Fuse.hxx>
-#include <BRepAlgoAPI_Common.hxx>
-
-#include <ShapeFix_Shape.hxx>
-#include <ShapeFix_ShapeTolerance.hxx>
-#include <ShapeFix_Solid.hxx>
-
-#include <TopLoc_Location.hxx>
-
-#include <BRepCheck_Analyzer.hxx>
-
-#include "../ifcgeom/IfcGeom.h"
-
-bool IfcGeom::convert(const IfcSchema::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 IfcSchema::IfcSurfaceOfLinearExtrusion::ptr l, TopoDS_Shape& shape) {
-	TopoDS_Wire wire;
-	if ( !IfcGeom::convert_wire(l->SweptCurve(), wire) ) {
-		TopoDS_Face face;
-		if ( !IfcGeom::convert_face(l->SweptCurve(),face) ) return false;
-		TopExp_Explorer exp(face, TopAbs_WIRE);
-		wire = TopoDS::Wire(exp.Current());
-	}
-	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(wire, height*dir);
-	shape.Move(trsf);
-	return !shape.IsNull();
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcSurfaceOfRevolution::ptr l, TopoDS_Shape& shape) {
-	TopoDS_Wire wire;
-	if ( !IfcGeom::convert_wire(l->SweptCurve(), wire) ) {
-		TopoDS_Face face;
-		if ( !IfcGeom::convert_face(l->SweptCurve(),face) ) return false;
-		TopExp_Explorer exp(face, TopAbs_WIRE);
-		wire = TopoDS::Wire(exp.Current());
-	}
-
-	gp_Ax1 ax1;
-	IfcGeom::convert(l->AxisPosition(), ax1);
-
-	gp_Trsf trsf;
-	IfcGeom::convert(l->Position(),trsf);
-	
-	shape = BRepPrimAPI_MakeRevol(wire, ax1);
-
-	shape.Move(trsf);
-	return !shape.IsNull();
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcRevolvedAreaSolid::ptr l, TopoDS_Shape& shape) {
-	const double ang = l->Angle() * IfcGeom::GetValue(GV_PLANEANGLE_UNIT);
-
-	TopoDS_Face face;
-	if ( ! IfcGeom::convert_face(l->SweptArea(),face) ) return false;
-
-	gp_Ax1 ax1;
-	IfcGeom::convert(l->Axis(), ax1);
-
-	gp_Trsf trsf;
-	IfcGeom::convert(l->Position(),trsf);
-
-	if (ang >= M_PI * 2. - ALMOST_ZERO) {
-		shape = BRepPrimAPI_MakeRevol(face, ax1);
-	} else {
-		shape = BRepPrimAPI_MakeRevol(face, ax1, ang);
-	}
-
-	shape.Move(trsf);
-	return !shape.IsNull();
-}
-
-bool IfcGeom::convert(const IfcSchema::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 IfcSchema::IfcFaceBasedSurfaceModel::ptr l, IfcRepresentationShapeItems& shapes) {
-	IfcSchema::IfcConnectedFaceSet::list facesets = l->FbsmFaces();
-	const SurfaceStyle* collective_style = get_style(l);
-	for( IfcSchema::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 IfcSchema::IfcHalfSpaceSolid::ptr l, TopoDS_Shape& shape) {
-	IfcSchema::IfcSurface::ptr surface = l->BaseSurface();
-	if ( ! surface->is(IfcSchema::Type::IfcPlane) ) {
-		Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface->entity);
-		return false;
-	}
-	gp_Pln pln;
-	IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcSurface,IfcSchema::IfcPlane>(surface),pln);
-	const gp_Pnt pnt = pln.Location().Translated( l->AgreementFlag() ? -pln.Axis().Direction() : pln.Axis().Direction());
-	shape = BRepPrimAPI_MakeHalfSpace(BRepBuilderAPI_MakeFace(pln),pnt).Solid();
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcPolygonalBoundedHalfSpace::ptr l, TopoDS_Shape& shape) {
-	TopoDS_Shape halfspace;
-	if ( ! IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcPolygonalBoundedHalfSpace,IfcSchema::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 IfcSchema::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(IfcSchema::Type::IfcRepresentationItem)) {
-			shell_style = get_style((IfcSchema::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 IfcSchema::IfcBooleanResult::ptr l, TopoDS_Shape& shape) {
-	TopoDS_Shape s1, s2;
-	TopoDS_Wire boundary_wire;
-	IfcSchema::IfcBooleanOperand operand1 = l->FirstOperand();
-	IfcSchema::IfcBooleanOperand operand2 = l->SecondOperand();
-	bool is_halfspace = operand2->is(IfcSchema::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);
-	}
-
-	const IfcSchema::IfcBooleanOperator::IfcBooleanOperator op = l->Operator();
-
-	if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_DIFFERENCE) {
-
-		bool valid_cut = false;
-		BRepAlgoAPI_Cut brep_cut(s1,s2);
-		if ( brep_cut.IsDone() ) {
-			TopoDS_Shape result = brep_cut;
-
-			ShapeFix_Shape fix(result);
-			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;
-
-	} else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_UNION) {
-
-		BRepAlgoAPI_Fuse brep_fuse(s1,s2);
-		if ( brep_fuse.IsDone() ) {
-			TopoDS_Shape result = brep_fuse;
-
-			ShapeFix_Shape fix(result);
-			fix.Perform();
-			result = fix.Shape();
-		
-			bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
-			if ( is_valid ) {
-				shape = result;
-			} 
-		}
-
-		return true;
-
-	} else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_INTERSECTION) {
-
-		BRepAlgoAPI_Common brep_common(s1,s2);
-		if ( brep_common.IsDone() ) {
-			TopoDS_Shape result = brep_common;
-
-			ShapeFix_Shape fix(result);
-			fix.Perform();
-			result = fix.Shape();
-		
-			bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
-			if ( is_valid ) {
-				shape = result;
-			} 
-		}
-
-		return true;
-
-	} else {
-		return false;
-	}
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcConnectedFaceSet::ptr l, TopoDS_Shape& shape) {
-	IfcSchema::IfcFace::list faces = l->CfsFaces();
-	bool facesAdded = false;
-	const unsigned int num_faces = faces->Size();
-	if ( num_faces < GetValue(GV_MAX_FACES_TO_SEW) ) {
-		BRepOffsetAPI_Sewing builder;
-		builder.SetTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
-		builder.SetMaxTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
-		builder.SetMinTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
-		for( IfcSchema::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
-			TopoDS_Face face;
-			if ( IfcGeom::convert_face(*it,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;
-		builder.Perform();
-		shape = builder.SewedShape();
-		try {
-			ShapeFix_Solid solid;
-			solid.LimitTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
-			shape = solid.SolidFromShell(TopoDS::Shell(shape));
-		} catch(...) {}
-	} else {
-		TopoDS_Compound compound;
-		BRep_Builder builder;
-		builder.MakeCompound(compound);
-		for( IfcSchema::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
-			TopoDS_Face face;
-			if ( IfcGeom::convert_face(*it,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 IfcSchema::IfcMappedItem::ptr l, IfcRepresentationShapeItems& shapes) {
-	gp_GTrsf gtrsf;
-	IfcSchema::IfcCartesianTransformationOperator::ptr transform = l->MappingTarget();
-	if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3DnonUniform) ) {
-		IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcCartesianTransformationOperator,
-			IfcSchema::IfcCartesianTransformationOperator3DnonUniform>(transform),gtrsf);
-	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform) ) {
-		Logger::Message(Logger::LOG_ERROR, "Unsupported MappingTarget:", transform->entity);
-		return false;
-	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3D) ) {
-		gp_Trsf trsf;
-		IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcCartesianTransformationOperator,
-			IfcSchema::IfcCartesianTransformationOperator3D>(transform),trsf);
-		gtrsf = trsf;
-	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2D) ) {
-		gp_Trsf2d trsf_2d;
-		IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcCartesianTransformationOperator,
-			IfcSchema::IfcCartesianTransformationOperator2D>(transform),trsf_2d);
-		gtrsf = (gp_Trsf) trsf_2d;
-	}
-	IfcSchema::IfcRepresentationMap::ptr map = l->MappingSource();
-	IfcSchema::IfcAxis2Placement placement = map->MappingOrigin();
-	gp_Trsf trsf;
-	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
-		IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
-	} else {
-		gp_Trsf2d trsf_2d;
-		IfcGeom::convert((IfcSchema::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 IfcSchema::IfcShapeRepresentation::ptr l, IfcRepresentationShapeItems& shapes) {
-	IfcSchema::IfcRepresentationItem::list items = l->Items();
-	if ( ! items->Size() ) return false;
-	for ( IfcSchema::IfcRepresentationItem::it it = items->begin(); it != items->end(); ++ it ) {
-		IfcSchema::IfcRepresentationItem* representation_item = *it;
-		if ( IfcGeom::is_shape_collection(representation_item) ) 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)));
-			}
-		}
-	}
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcGeometricSet::ptr l, IfcRepresentationShapeItems& shapes) {
-	IfcUtil::IfcAbstractSelect::list elements = l->Elements();
-	if ( !elements->Size() ) return false;
-	const IfcGeom::SurfaceStyle* parent_style = get_style(l);
-	for ( IfcUtil::IfcAbstractSelect::it it = elements->begin(); it != elements->end(); ++ it ) {
-		IfcSchema::IfcGeometricSetSelect element = *it;
-		if (element->is(IfcSchema::Type::IfcSurface)) {
-			IfcSchema::IfcSurface* surface = (IfcSchema::IfcSurface*) element;
-			TopoDS_Shape s;
-			if (IfcGeom::convert_shape(surface, s)) {
-				const IfcGeom::SurfaceStyle* style = get_style(surface);
-				shapes.push_back(IfcRepresentationShapeItem(s, style ? style : parent_style));
-			}
-		}
-	}
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcBlock::ptr l, TopoDS_Shape& shape) {
-	const double dx = l->XLength() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double dy = l->YLength() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double dz = l->ZLength() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-
-	BRepPrimAPI_MakeBox builder(dx, dy, dz);
-	gp_Trsf trsf;
-	IfcGeom::convert(l->Position(),trsf);
-	shape = builder.Solid().Moved(trsf);
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcRectangularPyramid::ptr l, TopoDS_Shape& shape) {
-	const double dx = l->XLength() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double dy = l->YLength() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double dz = l->Height() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	
-	BRepPrimAPI_MakeWedge builder(dx, dz, dy, dx / 2., dy / 2., dx / 2., dy / 2.);
-	
-	gp_Trsf trsf1, trsf2;
-	trsf2.SetValues(1, 0, 0, 0,
-					0, 0, 1, 0,
-					0, 1, 0, 0, Precision::Confusion(), Precision::Confusion());
-	
-	IfcGeom::convert(l->Position(), trsf1);
-	shape = BRepBuilderAPI_Transform(builder.Solid(), trsf1 * trsf2);
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcRightCircularCylinder::ptr l, TopoDS_Shape& shape) {
-	const double r = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double h = l->Height() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-
-	BRepPrimAPI_MakeCylinder builder(r, h);
-	gp_Trsf trsf;
-	IfcGeom::convert(l->Position(),trsf);
-	shape = builder.Solid().Moved(trsf);
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcRightCircularCone::ptr l, TopoDS_Shape& shape) {
-	const double r = l->BottomRadius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	const double h = l->Height() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-
-	BRepPrimAPI_MakeCone builder(r, 0., h);
-	gp_Trsf trsf;
-	IfcGeom::convert(l->Position(),trsf);
-	shape = builder.Solid().Moved(trsf);
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcSphere::ptr l, TopoDS_Shape& shape) {
-	const double r = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	
-	BRepPrimAPI_MakeSphere builder(r);
-	gp_Trsf trsf;
-	IfcGeom::convert(l->Position(),trsf);
-	shape = builder.Solid().Moved(trsf);
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcCsgSolid::ptr l, TopoDS_Shape& shape) {
-	return IfcGeom::convert_shape(l->TreeRootExpression(), shape);
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcCurveBoundedPlane::ptr l, TopoDS_Shape& face) {
-	gp_Pln pln;
-	IfcGeom::convert(l->BasisSurface(), pln);
-
-	gp_Trsf trsf;
-	trsf.SetTransformation(pln.Position());
-	
-	TopoDS_Wire outer;
-	IfcGeom::convert_wire(l->OuterBoundary(), outer);
-	
-	BRepBuilderAPI_MakeFace mf (outer);
-	mf.Add(outer);
-
-	IfcSchema::IfcCurve::list inner = l->InnerBoundaries();
-
-	for (IfcSchema::IfcCurve::it it = inner->begin(); it != inner->end(); ++it) {
-		TopoDS_Wire inner;
-		IfcGeom::convert_wire(*it, inner);
-		
-		mf.Add(inner);
-	}
-
-	ShapeFix_Shape sfs(mf.Face());
-	sfs.Perform();
-	face = TopoDS::Face(sfs.Shape()).Moved(trsf);
-	
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcRectangularTrimmedSurface::ptr l, TopoDS_Shape& face) {
-	if (!l->BasisSurface()->is(IfcSchema::Type::IfcPlane)) {
-		Logger::Message(Logger::LOG_ERROR, "Unsupported BasisSurface:", l->BasisSurface()->entity);
-		return false;
-	}
-	gp_Pln pln;
-	IfcGeom::convert((IfcSchema::IfcPlane*) l->BasisSurface(), pln);
-
-	BRepBuilderAPI_MakeFace mf(pln, l->U1(), l->U2(), l->V1(), l->V2());
-
-	face = mf.Face();
-
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcSurfaceCurveSweptAreaSolid::ptr l, TopoDS_Shape& shape) {
-	gp_Trsf directrix, position;
-	TopoDS_Shape face;
-	TopoDS_Wire wire, section;
-
-	if (!l->ReferenceSurface()->is(IfcSchema::Type::IfcPlane)) {
-		Logger::Message(Logger::LOG_WARNING, "Reference surface not supported", l->ReferenceSurface()->entity);
-		return false;
-	}
-	
-	if (!IfcGeom::convert(l->Position(), position)   || 
-		!IfcGeom::convert_face(l->SweptArea(), face) || 
-		!IfcGeom::convert_wire(l->Directrix(), wire)    ) {
-		return false;
-	}
-
-	gp_Pln pln;
-	gp_Pnt directrix_origin;
-	gp_Vec directrix_tangent;
-	bool directrix_on_plane = true;
-	IfcGeom::convert((IfcSchema::IfcPlane*) l->ReferenceSurface(), pln);
-
-	// As per Informal propositions 2: The Directrix shall lie on the ReferenceSurface.
-	// This is not always the case with the test files in the repository. I am not sure
-	// how to deal with this and whether my interpretation of the propositions is
-	// correct. However, if it has been asserted that the vertices of the directrix do
-	// not conform to the ReferenceSurface, the ReferenceSurface is ignored.
-	{ 
-		for (TopExp_Explorer exp(wire, TopAbs_VERTEX); exp.More(); exp.Next()) {
-			if (pln.Distance(BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()))) > ALMOST_ZERO) {
-				directrix_on_plane = false;
-				Logger::Message(Logger::LOG_WARNING, "The Directrix does not lie on the ReferenceSurface", l->entity);
-				break;
-			}
-		}
-	}
-
-	{ 
-		TopExp_Explorer exp(wire, TopAbs_EDGE);
-		TopoDS_Edge edge = TopoDS::Edge(exp.Current());
-		double u0, u1;
-		Handle(Geom_Curve) crv = BRep_Tool::Curve(edge, u0, u1);
-		crv->D1(u0, directrix_origin, directrix_tangent);
-	}
-
-	if (pln.Axis().Direction().IsNormal(directrix_tangent, Precision::Approximation()) && directrix_on_plane) {
-		directrix.SetTransformation(gp_Ax3(directrix_origin, directrix_tangent, pln.Axis().Direction()), gp::XOY());
-	} else {
-		directrix.SetTransformation(gp_Ax3(directrix_origin, directrix_tangent), gp::XOY());
-	}
-	face = BRepBuilderAPI_Transform(face, directrix);
-
-	// NB: Note that StartParam and EndParam param are ignored and the assumption is
-	// made that the parametric range over which to be swept matches the IfcCurve in
-	// its entirety.
-	BRepOffsetAPI_MakePipeShell builder(wire);
-
-	{ TopExp_Explorer exp(face, TopAbs_WIRE);
-	section = TopoDS::Wire(exp.Current()); }
-
-	builder.Add(section);
-	builder.SetTransitionMode(BRepBuilderAPI_RightCorner);
-	if (directrix_on_plane) {
-		builder.SetMode(pln.Axis().Direction());
-	}
-	builder.Build();
-	builder.MakeSolid();
-	shape = builder.Shape();
-	shape.Move(position);
-
-	return true;
-}
-
-bool IfcGeom::convert(const IfcSchema::IfcSweptDiskSolid::ptr l, TopoDS_Shape& shape) {
-	TopoDS_Wire wire, section1, section2;
-
-	const bool hasInnerRadius = l->hasInnerRadius();
-
-	if (!IfcGeom::convert_wire(l->Directrix(), wire)) {
-		return false;
-	}
-	
-	gp_Ax2 directrix;
-	{
-		gp_Pnt directrix_origin;
-		gp_Vec directrix_tangent;
-		TopExp_Explorer exp(wire, TopAbs_EDGE);
-		TopoDS_Edge edge = TopoDS::Edge(exp.Current());
-		double u0, u1;
-		Handle(Geom_Curve) crv = BRep_Tool::Curve(edge, u0, u1);
-		crv->D1(u0, directrix_origin, directrix_tangent);
-		directrix = gp_Ax2(directrix_origin, directrix_tangent);
-	}
-
-	const double r1 = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-	Handle(Geom_Circle) circle = new Geom_Circle(directrix, r1);
-	section1 = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(circle));
-
-	if (hasInnerRadius) {
-		const double r2 = l->InnerRadius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-		Handle(Geom_Circle) circle = new Geom_Circle(directrix, r2);
-		section2 = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(circle));
-	}
-
-	// NB: Note that StartParam and EndParam param are ignored and the assumption is
-	// made that the parametric range over which to be swept matches the IfcCurve in
-	// its entirety.
-	// NB2: Contrary to IfcSurfaceCurveSweptAreaSolid the transition mode has been
-	// set to create round corners as this has proven to work better with the types
-	// of directrices encountered, which do not necessarily conform to a surface.
-	{ BRepOffsetAPI_MakePipeShell builder(wire);
-	builder.Add(section1);
-	builder.SetTransitionMode(BRepBuilderAPI_RoundCorner);
-	builder.Build();
-	builder.MakeSolid();
-	shape = builder.Shape(); }
-
-	if (hasInnerRadius) {
-		BRepOffsetAPI_MakePipeShell builder(wire);
-		builder.Add(section2);
-		builder.SetTransitionMode(BRepBuilderAPI_RoundCorner);
-		builder.Build();
-		builder.MakeSolid();
-		TopoDS_Shape inner = builder.Shape();
-
-		BRepAlgoAPI_Cut brep_cut(shape, inner);
-		bool is_valid = false;
-		if (brep_cut.IsDone()) {
-			TopoDS_Shape result = brep_cut;
-
-			ShapeFix_Shape fix(result);
-			fix.Perform();
-			result = fix.Shape();
-		
-			is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
-			if (is_valid) {
-				shape = result;
-			}
-		}
-
-		if (!is_valid) {
-			Logger::Message(Logger::LOG_WARNING, "Failed to subtract inner radius void for:", l->entity);
-		}
-	}
-
-	return true;
-}
-
-#ifdef USE_IFC4
-
-bool IfcGeom::convert(const IfcSchema::IfcCylindricalSurface::ptr l, TopoDS_Shape& face) {
-	gp_Trsf trsf;
-	IfcGeom::convert(l->Position(),trsf);
-	
-	face = BRepBuilderAPI_MakeFace(new Geom_CylindricalSurface(gp::XOY(), l->Radius()), GetValue(GV_PRECISION)).Face().Moved(trsf);
-	return true;
-}
-
-#endif

src/ifcgeom/IfcGeomWires.cpp

@@ -1,312 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * 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 IfcSchema::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;
-	}
-	IfcSchema::IfcCompositeCurveSegment::list segments = l->Segments();
-	BRepBuilderAPI_MakeWire w;
-	//TopoDS_Vertex last_vertex;
-	for( IfcSchema::IfcCompositeCurveSegment::it it = segments->begin(); it != segments->end(); ++ it ) {
-		const IfcSchema::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 IfcSchema::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
-	IfcSchema::IfcCurve::ptr basis_curve = l->BasisCurve();
-	bool isConic = basis_curve->is(IfcSchema::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() == IfcSchema::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(IfcSchema::Type::IfcCartesianPoint) ) {
-			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcCartesianPoint>(i), pnts[sense_agreement] );
-			has_pnts[sense_agreement] = true;
-		} else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
-			const double value = *((IfcUtil::IfcBaseEntity*)i)->entity->getArgument(0);
-			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(IfcSchema::Type::IfcCartesianPoint) ) {
-			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcCartesianPoint>(i), pnts[1-sense_agreement] );
-			has_pnts[1-sense_agreement] = true;
-		} else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
-			const double value = *((IfcUtil::IfcBaseEntity*)i)->entity->getArgument(0);
-			flts[1-sense_agreement] = value * parameterFactor;
-			has_flts[1-sense_agreement] = true;
-		}
-	}
-	trim_cartesian &= has_pnts[0] && has_pnts[1];
-	bool trim_cartesian_failed = !trim_cartesian;
-	if ( trim_cartesian ) {
-		if ( pnts[0].Distance(pnts[1]) < GetValue(GV_WIRE_CREATION_TOLERANCE) ) {
-			Logger::Message(Logger::LOG_WARNING,"Skipping segment with length below tolerance level:",l->entity);
-			return false;
-		}
-		ShapeFix_ShapeTolerance FTol;
-		TopoDS_Vertex v1 = BRepBuilderAPI_MakeVertex(pnts[0]);
-		TopoDS_Vertex v2 = BRepBuilderAPI_MakeVertex(pnts[1]);
-		FTol.SetTolerance(v1, GetValue(GV_WIRE_CREATION_TOLERANCE), TopAbs_VERTEX);
-		FTol.SetTolerance(v2, GetValue(GV_WIRE_CREATION_TOLERANCE), TopAbs_VERTEX);
-		BRepBuilderAPI_MakeEdge e (curve,v1,v2);
-		if ( ! e.IsDone() ) {
-			BRepBuilderAPI_EdgeError err = e.Error();
-			if ( err == BRepBuilderAPI_PointProjectionFailed ) {
-				Logger::Message(Logger::LOG_WARNING,"Point projection failed for:",l->entity);
-				trim_cartesian_failed = true;
-			}
-		} else {
-			w.Add(e.Edge());
-		}
-	}
-	if ( (!trim_cartesian || trim_cartesian_failed) && (has_flts[0] && has_flts[1]) ) {
-		// The Geom_Line is constructed from a gp_Pnt and gp_Dir, whereas the IfcLine
-		// is defined by an IfcCartesianPoint and an IfcVector with Magnitude. Because
-		// the vector is normalised when passed to Geom_Line constructor the magnitude
-		// needs to be factored in with the IfcParameterValue here.
-		if ( basis_curve->is(IfcSchema::Type::IfcLine) ) {
-			IfcSchema::IfcLine* line = static_cast<IfcSchema::IfcLine*>(basis_curve);
-			const double magnitude = line->Dir()->Magnitude();
-			flts[0] *= magnitude; flts[1] *= magnitude;
-		}
-		if ( basis_curve->is(IfcSchema::Type::IfcEllipse) ) {
-			IfcSchema::IfcEllipse* ellipse = static_cast<IfcSchema::IfcEllipse*>(basis_curve);
-			double x = ellipse->SemiAxis1() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-			double y = ellipse->SemiAxis2() * IfcGeom::GetValue(GV_LENGTH_UNIT);
-			const bool rotated = y > x;
-			if (rotated) {
-				flts[0] -= M_PI / 2.;
-				flts[1] -= M_PI / 2.;
-			}
-		}
-		if ( isConic && ALMOST_THE_SAME(fmod(flts[1]-flts[0],(double)(M_PI*2.0)),0.0f) ) {
-			w.Add(BRepBuilderAPI_MakeEdge(curve));
-		} else {
-			BRepBuilderAPI_MakeEdge e (curve,flts[0],flts[1]);
-			w.Add(e.Edge());
-		}			
-	} else if ( trim_cartesian_failed && (has_pnts[0] && has_pnts[1]) ) {
-		w.Add(BRepBuilderAPI_MakeEdge(pnts[0],pnts[1]));
-	}
-	if ( w.IsDone() ) {
-		wire = w.Wire();
-		return true;
-	} else {
-		return false;
-	}
-}
-bool IfcGeom::convert(const IfcSchema::IfcPolyline::ptr l, TopoDS_Wire& result) {
-	IfcSchema::IfcCartesianPoint::list points = l->Points();
-
-	BRepBuilderAPI_MakeWire w;
-	gp_Pnt P1;gp_Pnt P2;
-	for( IfcSchema::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) {
-		IfcGeom::convert(*it,P2);
-		if ( it != points->begin() && ( !P1.IsEqual(P2,GetValue(GV_POINT_EQUALITY_TOLERANCE)) ) )
-			w.Add(BRepBuilderAPI_MakeEdge(P1,P2));
-		P1 = P2;
-	}
-
-	result = w.Wire();
-	return true;
-}
-bool IfcGeom::convert(const IfcSchema::IfcPolyLoop::ptr l, TopoDS_Wire& result) {
-	IfcSchema::IfcCartesianPoint::list points = l->Polygon();
-
-	BRepBuilderAPI_MakeWire w;
-	gp_Pnt P1;gp_Pnt P2;gp_Pnt F;
-	int count = 0;
-	for( IfcSchema::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) {
-		IfcGeom::convert(*it,P2);
-		if ( it != points->begin() && ( !P1.IsEqual(P2,GetValue(GV_POINT_EQUALITY_TOLERANCE)) ) ) {
-			w.Add(BRepBuilderAPI_MakeEdge(P1,P2));
-			count ++;
-		} else if ( ! count ) F = P2;		
-		P1 = P2;
-	}
-	if ( !P1.IsEqual(F,GetValue(GV_POINT_EQUALITY_TOLERANCE)) ) {
-		w.Add(BRepBuilderAPI_MakeEdge(P1,F));
-		count ++;
-	}
-	if ( count < 3 ) return false;
-
-	result = w.Wire();
-	return true;
-}
-bool IfcGeom::convert(const IfcSchema::IfcArbitraryOpenProfileDef::ptr l, TopoDS_Wire& result) {
-	return IfcGeom::convert_wire(l->Curve(), result);
-}

src/ifcgeom/IfcRegister.cpp

@@ -1,77 +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 "IfcGeom.h"
-
-namespace IfcGeom {
-	namespace Cache {
-		std::map<int,TopoDS_Shape> Shape;
-		void PurgeShapeCache() {
-			Shape.clear();
-		}
-	}
-}
-
-using namespace IfcSchema;
-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"
-	Handle(Geom_Curve) curve;
-	if (IfcGeom::convert_curve(l, curve)) {
-		return IfcGeom::convert_curve_to_wire(curve, r);
-	}
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
-	return false;
-}
-bool IfcGeom::convert_face(const IfcBaseClass* l, TopoDS_Shape& 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

@@ -1,116 +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 <TopoDS_Shape.hxx>
-#include <TopoDS_Wire.hxx>
-#include <TopoDS_Face.hxx>
-#include <gp_Pnt.hxx>
-#include <gp_Pln.hxx>
-#include <gp_Dir.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 "../ifcparse/IfcUtil.h"
-#include "../ifcparse/IfcParse.h"
-
-using namespace IfcSchema;
-
-SHAPES(IfcShellBasedSurfaceModel);
-SHAPES(IfcFaceBasedSurfaceModel);
-SHAPES(IfcShapeRepresentation);
-SHAPES(IfcMappedItem);
-SHAPES(IfcFacetedBrep);
-SHAPES(IfcGeometricSet);
-
-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);
-#ifdef USE_IFC4
-SHAPE(IfcCylindricalSurface);
-#endif
-
-FACE(IfcArbitraryProfileDefWithVoids);
-FACE(IfcArbitraryClosedProfileDef);
-FACE(IfcRoundedRectangleProfileDef);
-FACE(IfcRectangleHollowProfileDef);
-FACE(IfcRectangleProfileDef);
-FACE(IfcTrapeziumProfileDef)
-FACE(IfcCShapeProfileDef);
-FACE(IfcIShapeProfileDef);
-FACE(IfcLShapeProfileDef);
-FACE(IfcTShapeProfileDef);
-FACE(IfcUShapeProfileDef);
-FACE(IfcZShapeProfileDef);
-FACE(IfcCircleHollowProfileDef);
-FACE(IfcCircleProfileDef);
-FACE(IfcEllipseProfileDef);
-FACE(IfcCenterLineProfileDef);
-FACE(IfcCompositeProfileDef);
-FACE(IfcDerivedProfileDef);
-FACE(IfcFace);
-
-WIRE(IfcPolyline);
-WIRE(IfcPolyLoop);
-WIRE(IfcCompositeCurve);
-WIRE(IfcTrimmedCurve);
-WIRE(IfcArbitraryOpenProfileDef);
-
-CURVE(IfcCircle);
-CURVE(IfcEllipse);
-CURVE(IfcLine);
-
-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);
-CLASS(IfcCartesianTransformationOperator3D,gp_Trsf);
-CLASS(IfcObjectPlacement,gp_Trsf);
-CLASS(IfcVector,gp_Vec);
-CLASS(IfcPlane,gp_Pln);

src/ifcgeom/IfcRegisterConvertCurve.h

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

src/ifcgeom/IfcRegisterConvertFace.h

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

src/ifcgeom/IfcRegisterConvertShape.h

@@ -1,17 +0,0 @@
-#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

@@ -1,12 +0,0 @@
-#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 +0,0 @@
-#include "IfcRegisterUndef.h"
-#define WIRE(T) \
-	if ( l->is(T::Class()) ) return convert((T*)l,r);
-#include "IfcRegisterDef.h"
-
-#include "IfcRegister.h"

src/ifcgeom/IfcRegisterCreateCache.h

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

src/ifcgeom/IfcRegisterDef.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/IfcRegisterGeomHeader.h

@@ -1,10 +0,0 @@
-#include "IfcRegisterUndef.h"
-#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 CURVE(T) CLASS(T,Handle(Geom_Curve))
-#include "IfcRegisterDef.h"
-
-#include "IfcRegister.h"

src/ifcgeom/IfcRegisterIsShapeCollection.h

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

src/ifcgeom/IfcRegisterPurgeCache.h

@@ -1,6 +0,0 @@
-#include "IfcRegisterUndef.h"
-#define CLASS(T,V) \
-	T.clear();
-#include "IfcRegisterDef.h"
-
-#include "IfcRegister.h"

src/ifcgeom/IfcRegisterUndef.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/IfcRepresentationShapeItem.h

@@ -1,52 +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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-#ifndef IFCSHAPELIST_H
-#define IFCSHAPELIST_H
-
-#include <gp_GTrsf.hxx>
-#include <TopoDS_Shape.hxx>
-
-#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/abstract_mapping.cpp

@@ -0,0 +1,56 @@
+#include "abstract_mapping.h"
+
+#include "../ifcparse/IfcFile.h"
+
+ifcopenshell::geometry::impl::MappingFactoryImplementation& ifcopenshell::geometry::impl::mapping_implementations() {
+	static MappingFactoryImplementation impl;
+	return impl;
+}
+
+extern void init_MappingImplementation_Ifc2x3(ifcopenshell::geometry::impl::MappingFactoryImplementation*);
+extern void init_MappingImplementation_Ifc4(ifcopenshell::geometry::impl::MappingFactoryImplementation*);
+// extern void init_MappingImplementation_Ifc4x1(ifcopenshell::geometry::impl::MappingFactoryImplementation*);
+// extern void init_MappingImplementation_Ifc4x2(ifcopenshell::geometry::impl::MappingFactoryImplementation*);
+
+ifcopenshell::geometry::impl::MappingFactoryImplementation::MappingFactoryImplementation() {
+	init_MappingImplementation_Ifc2x3(this);
+	init_MappingImplementation_Ifc4(this);
+	// init_MappingImplementation_Ifc4x1(this);
+	// init_MappingImplementation_Ifc4x2(this);
+}
+
+void ifcopenshell::geometry::impl::MappingFactoryImplementation::bind(const std::string& schema_name, ifcopenshell::geometry::impl::mapping_fn fn) {
+	const std::string schema_name_lower = boost::to_lower_copy(schema_name);
+	this->insert(std::make_pair(schema_name_lower, fn));
+}
+
+ifcopenshell::geometry::abstract_mapping* ifcopenshell::geometry::impl::MappingFactoryImplementation::construct(IfcParse::IfcFile* file, settings& s) {
+	const std::string schema_name_lower = boost::to_lower_copy(file->schema()->name());
+	std::map<std::string, ifcopenshell::geometry::impl::mapping_fn>::const_iterator it;
+	it = this->find(schema_name_lower);
+	if (it == end()) {
+		throw IfcParse::IfcException("No geometry mapping registered for " + schema_name_lower);
+	}
+	return it->second(file, s);
+}
+
+void ifcopenshell::geometry::remove_duplicate_points_from_loop(std::vector<taxonomy::point3>& polygon, bool closed, double tol) {
+	for (;;) {
+		bool removed = false;
+		int n = polygon.size() - (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.size()) + 1;
+			double dist = (polygon.at(i - 1).components() - polygon.at(j - 1).components()).squaredNorm();
+			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.erase(polygon.begin() + i - 1);
+				else polygon.erase(polygon.begin() + j - 1);
+				removed = true;
+				break;
+			}
+		}
+		if (!removed) break;
+	}
+}

src/ifcgeom/abstract_mapping.h

@@ -0,0 +1,56 @@
+#ifndef ABSTRACT_MAPPING_H
+#define ABSTRACT_MAPPING_H
+
+#include "../ifcparse/IfcBaseClass.h"
+#include "../ifcparse/IfcEntityList.h"
+#include "../ifcgeom/taxonomy.h"
+#include "../ifcgeom/settings.h"
+
+#include <boost/function.hpp>
+
+#include <map>
+#include <string>
+
+namespace ifcopenshell {
+
+namespace geometry {
+
+	struct geometry_conversion_task {
+		int index;
+		IfcUtil::IfcBaseEntity* representation;
+		IfcEntityList::ptr products;
+	};
+
+	typedef boost::function<bool(IfcUtil::IfcBaseEntity*)> filter_t;
+    
+    class abstract_mapping {
+	protected:
+		settings settings_;
+	public:
+		abstract_mapping(settings& s) : settings_(s) {}
+
+		virtual ifcopenshell::geometry::taxonomy::item* map(const IfcUtil::IfcBaseClass*) = 0;
+		virtual void get_representations(std::vector<geometry_conversion_task>& tasks, std::vector<filter_t>& filters, settings& s) = 0;
+		virtual IfcUtil::IfcBaseEntity* get_decomposing_entity(IfcUtil::IfcBaseEntity* product, bool include_openings = true) = 0;
+		virtual std::map<std::string, IfcUtil::IfcBaseEntity*> get_layers(IfcUtil::IfcBaseEntity*) = 0;
+    };
+
+	namespace impl {
+		typedef boost::function2<abstract_mapping*, IfcParse::IfcFile*, settings&> mapping_fn;
+
+		class MappingFactoryImplementation : public std::map<std::string, mapping_fn> {
+		public:
+			MappingFactoryImplementation();
+			void bind(const std::string& schema_name, mapping_fn);
+			abstract_mapping* construct(IfcParse::IfcFile*, settings&);
+		};
+
+		MappingFactoryImplementation& mapping_implementations();
+	}
+
+	void remove_duplicate_points_from_loop(std::vector<taxonomy::point3>& polygon, bool closed, double tol);    
+}
+
+}
+
+#endif

src/ifcgeom/exceptions.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <string>
+#include <exception>
+
+#include "schema_agnostic/ifc_geom_api.h"
+
+namespace ifcopenshell {
+	namespace geometry {
+
+		class IFC_GEOM_API geometry_exception : public std::exception {
+		protected:
+			std::string message;
+		public:
+			geometry_exception(const std::string& m)
+				: message(m) {}
+			virtual ~geometry_exception() throw () {}
+			virtual const char* what() const throw() {
+				return message.c_str();
+			}
+		};
+
+		class IFC_GEOM_API too_many_faces_exception : public geometry_exception {
+		public:
+			too_many_faces_exception()
+				: geometry_exception("Too many faces for operation") {}
+		};
+	}
+}

src/ifcgeom/kernel_agnostic/AbstractKernel.cpp

@@ -0,0 +1,42 @@
+#include "AbstractKernel.h"
+
+#include "../../ifcgeom/schema_agnostic/IfcGeomElement.h"
+#include "../../ifcgeom/kernels/opencascade/OpenCascadeKernel.h"
+
+#undef Handle
+
+#include "../../ifcgeom/kernels/cgal/CgalKernel.h"
+
+bool ifcopenshell::geometry::kernels::AbstractKernel::convert(const taxonomy::item* item, ifcopenshell::geometry::ConversionResults& results) {
+	try {
+		return dispatch_conversion<0>::dispatch(this, item, results);
+	} catch (std::exception& e) {
+		Logger::Error(e, item->instance);
+		return false;
+	}
+}
+
+ifcopenshell::geometry::kernels::AbstractKernel* ifcopenshell::geometry::kernels::construct(const std::string& geometry_library, IfcParse::IfcFile* file) {
+	const std::string geometry_library_lower = boost::to_lower_copy(geometry_library);
+	if (geometry_library_lower == "opencascade") {
+		return new OpenCascadeKernel(settings);
+	} else if (geometry_library_lower == "cgal") {
+		return new CgalKernel(settings);
+	} else {
+		throw IfcParse::IfcException("No geometry kernel registered for " + geometry_library);
+	}
+}
+
+bool ifcopenshell::geometry::kernels::AbstractKernel::convert_impl(const taxonomy::collection* collection, ifcopenshell::geometry::ConversionResults& r) { 
+	auto s = r.size();
+	for (auto& c : collection->children) {
+		convert(c, r);
+	}
+	for (auto i = s; i < r.size(); ++i) {
+		r[i].prepend(collection->matrix);
+		if (!r[i].hasStyle()) {
+			r[i].setStyle(collection->surface_style);
+		}
+	}
+	return r.size() > s;
+}

src/ifcgeom/kernel_agnostic/AbstractKernel.h

@@ -0,0 +1,106 @@
+#ifndef ABSTRACT_KERNEL_H
+#define ABSTRACT_KERNEL_H
+
+#include "../../ifcparse/macros.h"
+#include "../../ifcgeom/schema_agnostic/ifc_geom_api.h"
+#include "../../ifcgeom/schema_agnostic/IfcGeomRepresentation.h"
+#include "../../ifcgeom/taxonomy.h"
+#include "../../ifcgeom/ConversionSettings.h"
+
+static const double ALMOST_ZERO = 1.e-9;
+
+template <typename T>
+inline static bool ALMOST_THE_SAME(const T& a, const T& b, double tolerance = ALMOST_ZERO) {
+	return fabs(a - b) < tolerance;
+}
+
+namespace ifcopenshell { namespace geometry { namespace kernels {
+
+	class IFC_GEOM_API AbstractKernel {
+	protected:
+		// For stopping PlacementRelTo recursion in convert(const IfcSchema::IfcObjectPlacement* l, gp_Trsf& trsf)
+		const IfcParse::declaration* placement_rel_to = nullptr;
+		std::string geometry_library_;
+		ConversionSettings settings_;
+
+	public:
+		AbstractKernel(const std::string& geometry_library, const ConversionSettings& settings)
+			: geometry_library_(geometry_library)
+			, settings_(settings)
+		{}
+
+		bool convert(const taxonomy::item*, ifcopenshell::geometry::ConversionResults&);
+
+		virtual bool convert_impl(const taxonomy::matrix4*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::point3*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::direction3*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::line*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::circle*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::ellipse*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::bspline_curve*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::edge*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::loop*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::shell*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::face*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::extrusion*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::node*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::colour*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::boolean_result*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::plane*, ifcopenshell::geometry::ConversionResults&) { throw std::runtime_error("Not implemented"); }
+		virtual bool convert_impl(const taxonomy::collection*, ifcopenshell::geometry::ConversionResults&);
+	};
+
+	AbstractKernel* construct(const std::string& geometry_library, IfcParse::IfcFile*);
+
+}
+}
+}
+
+
+namespace {
+	/* A compile-time for loop over the taxonomy kinds */
+	template <size_t N>
+	struct dispatch_conversion {
+		static bool dispatch(ifcopenshell::geometry::kernels::AbstractKernel* kernel, const ifcopenshell::geometry::taxonomy::item* item, ifcopenshell::geometry::ConversionResults& results) {
+			if (N == item->kind()) {
+				auto concrete_item = static_cast<const ifcopenshell::geometry::taxonomy::type_by_kind::type<N>*>(item);
+				return kernel->convert_impl(concrete_item, results);
+			} else {
+				return dispatch_conversion<N + 1>::dispatch(kernel, item, results);
+			}
+		}
+	};
+
+	template <>
+	struct dispatch_conversion<ifcopenshell::geometry::taxonomy::type_by_kind::max> {
+		static bool dispatch(ifcopenshell::geometry::kernels::AbstractKernel*, const ifcopenshell::geometry::taxonomy::item* item, ifcopenshell::geometry::ConversionResults&) {
+			Logger::Error("No conversion for " + std::to_string(item->kind()));
+			return false;
+		}
+	};
+
+	/* A compile-time for loop over the curve kinds */
+	template <typename T, size_t N = 0>
+	struct dispatch_curve_creation {
+		static bool dispatch(const ifcopenshell::geometry::taxonomy::item* item, T& visitor) {
+			// @todo it should be possible to eliminate this dynamic_cast when there is a static equivalent to kind()
+			const ifcopenshell::geometry::taxonomy::curves::type<N>* v = dynamic_cast<const ifcopenshell::geometry::taxonomy::curves::type<N>*>(item);
+			if (v) {
+				visitor(*v);
+				return true;
+			} else {
+				return dispatch_curve_creation<T, N + 1>::dispatch(item, visitor);
+			}
+		}
+	};
+
+	template <typename T>
+	struct dispatch_curve_creation<T, ifcopenshell::geometry::taxonomy::curves::max> {
+		static bool dispatch(const ifcopenshell::geometry::taxonomy::item* item, T&) {
+			Logger::Error("No conversion for " + std::to_string(item->kind()));
+			return false;
+		}
+	};
+}
+
+#endif

src/ifcgeom/kernels/cgal/CgalConversionFunctions.cpp_

@@ -0,0 +1,118 @@
+#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/CgalConversionResult.cpp

@@ -0,0 +1,125 @@
+#include "CgalConversionResult.h"
+#include "CgalKernel.h"
+
+#include "../../../ifcparse/IfcLogger.h"
+#include "../../../ifcgeom/schema_agnostic/IfcGeomRepresentation.h"
+
+void ifcopenshell::geometry::CgalShape::Triangulate(const settings& settings, const ifcopenshell::geometry::taxonomy::matrix4& place, Representation::Triangulation* t, int surface_style_id) const {
+	// Copy is made because triangulate_faces() does not accept a const argument
+  cgal_shape_t s = shape_;
+
+  if (!place.is_identity()) {
+	  const auto& m = place.ccomponents();
+
+	  // @todo check
+	  const cgal_placement_t trsf(
+		  m(0, 0), m(0, 1), m(0, 2), m(0, 3),
+		  m(1, 0), m(1, 1), m(1, 2), m(1, 3),
+		  m(2, 0), m(2, 1), m(2, 2), m(2, 3));
+
+	  // Apply transformation
+	  for (auto &vertex : vertices(s)) {
+		  vertex->point() = vertex->point().transform(trsf);
+	  }
+  }
+  
+  if (!s.is_valid()) {
+    Logger::Message(Logger::LOG_ERROR, "Invalid Polyhedron_3 in object (before triangulation)");
+    return;
+  }
+  
+  // Triangulate the shape and compute the normals
+//  std::map<cgal_vertex_descriptor_t, Kernel_::Vector_3> vertex_normals;
+//  boost::associative_property_map<std::map<cgal_vertex_descriptor_t, Kernel_::Vector_3>> vertex_normals_map(vertex_normals);
+  std::map<cgal_face_descriptor_t, Kernel_::Vector_3> face_normals;
+  boost::associative_property_map<std::map<cgal_face_descriptor_t, Kernel_::Vector_3>> face_normals_map(face_normals);
+
+  bool success = false;
+  try {
+    success = CGAL::Polygon_mesh_processing::triangulate_faces(s);
+  } catch (...) {
+    Logger::Message(Logger::LOG_ERROR, "Triangulation crashed");
+    return;
+  }
+  
+  if (!success) {
+    Logger::Message(Logger::LOG_ERROR, "Triangulation failed");
+    return;
+  }
+  //    std::cout << "Triangulated model: " << s.size_of_facets() << " facets and " << s.size_of_vertices() << " vertices" << std::endl;
+  
+  if (!s.is_valid()) {
+    Logger::Message(Logger::LOG_ERROR, "Invalid Polyhedron_3 in object (after triangulation)");
+    return;
+  }
+  
+//  CGAL::Polygon_mesh_processing::compute_normals(s, vertex_normals_map, face_normals_map);
+  try {
+	  CGAL::Polygon_mesh_processing::compute_face_normals(s, face_normals_map);
+  } catch (...) {
+	  Logger::Message(Logger::LOG_ERROR, "Face normal calculation failed");
+	  return;
+  }
+  
+  int num_faces = 0, num_vertices = 0;
+  for (auto &face: faces(s)) {
+    if (!face->is_triangle()) {
+      std::cout << "Warning: non-triangular face!" << std::endl;
+      continue;
+    }
+    CGAL::Polyhedron_3<Kernel_>::Halfedge_around_facet_const_circulator current_halfedge = face->facet_begin();
+	int vertexidx[3];
+	int i = 0;
+    do {
+		vertexidx[i++] = t->addVertex(surface_style_id,
+                   CGAL::to_double(current_halfedge->vertex()->point().cartesian(0)),
+                   CGAL::to_double(current_halfedge->vertex()->point().cartesian(1)),
+                   CGAL::to_double(current_halfedge->vertex()->point().cartesian(2)));
+
+		double nx = 0.;
+		double ny = 0.;
+		double nz = 1.;
+		// @todo normal calculation throws divide by zero?
+		// try {
+		if (false) {
+			nx = CGAL::to_double(face_normals_map[face].cartesian(0));
+			ny = CGAL::to_double(face_normals_map[face].cartesian(1));
+			nz = CGAL::to_double(face_normals_map[face].cartesian(2));
+		}
+		// catch (...) {
+		// 	Logger::Error("Error during normal calculation");
+		// }
+      t->addNormal(nx, ny, nz);
+
+      ++num_vertices;
+      ++current_halfedge;
+    } while (current_halfedge != face->facet_begin());
+
+    t->addFace(surface_style_id, vertexidx[0], vertexidx[1], vertexidx[2]);
+
+    ++num_faces;
+  }
+
+}
+
+#include <CGAL/Polygon_mesh_processing/bbox.h>
+
+double ifcopenshell::geometry::CgalShape::bounding_box(void *& b) const {
+	if (b == nullptr) {
+		b = new CGAL::Bbox_3;
+	}
+	auto& bb = (*((CGAL::Bbox_3*)b));
+	bb += CGAL::Polygon_mesh_processing::bbox(shape_);
+	return (bb.xmax() - bb.xmin()) * (bb.ymax() - bb.ymin()) * (bb.zmax() - bb.zmin());
+}
+
+int ifcopenshell::geometry::CgalShape::num_vertices() const {
+	return shape_.size_of_vertices();
+}
+
+void ifcopenshell::geometry::CgalShape::set_box(void * b) {
+	auto& bb = (*((CGAL::Bbox_3*)b));
+	Kernel_::Point_3 lower(bb.xmin(), bb.ymin(), bb.zmin());
+	Kernel_::Point_3 upper(bb.xmax(), bb.ymax(), bb.zmax());
+	shape_ = ifcopenshell::geometry::utils::create_cube(lower, upper);
+}

src/ifcgeom/kernels/cgal/CgalConversionResult.h

@@ -0,0 +1,97 @@
+/********************************************************************************
+*                                                                              *
+* 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 CGALCONVERSIONRESULT_H
+#define CGALCONVERSIONRESULT_H
+
+#include "../../../ifcgeom/schema_agnostic/IfcGeomElement.h"
+
+#include <boost/property_map/property_map.hpp>
+#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
+#include <CGAL/Polyhedron_3.h>
+#include <CGAL/boost/graph/graph_traits_Polyhedron_3.h>
+#include <CGAL/Polygon_mesh_processing/stitch_borders.h>
+#include <CGAL/Polygon_mesh_processing/orientation.h>
+#include <CGAL/Polygon_mesh_processing/triangulate_faces.h>
+#include <CGAL/Polygon_mesh_processing/compute_normal.h>
+#include <CGAL/Polygon_mesh_processing/self_intersections.h>
+#include <CGAL/Nef_polyhedron_3.h>
+
+typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel_;
+
+typedef Kernel_::Aff_transformation_3 cgal_placement_t;
+typedef Kernel_::Point_3 cgal_point_t;
+typedef Kernel_::Vector_3 cgal_direction_t;
+typedef Kernel_::Vector_3 cgal_vector_t;
+typedef Kernel_::Plane_3 cgal_plane_t;
+typedef std::vector<Kernel_::Point_3> cgal_curve_t;
+typedef std::vector<Kernel_::Point_3> cgal_wire_t;
+
+struct cgal_face_t {
+  cgal_wire_t outer;
+  std::vector<cgal_wire_t> inner;
+};
+
+typedef CGAL::Polyhedron_3<Kernel_> cgal_shape_t;
+typedef boost::graph_traits<CGAL::Polyhedron_3<Kernel_>>::vertex_descriptor cgal_vertex_descriptor_t;
+typedef boost::graph_traits<CGAL::Polyhedron_3<Kernel_>>::face_descriptor cgal_face_descriptor_t;
+
+#include "../../../ifcgeom/schema_agnostic/ConversionResult.h"
+
+namespace ifcopenshell { namespace geometry {
+
+	class CgalShape : public ConversionResultShape {
+    public:
+        CgalShape(const cgal_shape_t& shape)
+            : shape_(shape)
+        {}
+
+		const cgal_shape_t& shape() const { return shape_; }
+		operator const cgal_shape_t& () { return shape_; }
+
+		virtual void Triangulate(const settings& settings, const ifcopenshell::geometry::taxonomy::matrix4& place, Representation::Triangulation* t, int surface_style_id) const;
+		
+		virtual void Serialize(std::string&) const {
+			throw std::runtime_error("Not implemented");
+		}
+
+		virtual ConversionResultShape* clone() const {
+			return new CgalShape(shape_);
+		}
+
+		virtual double bounding_box(void*& b) const;
+
+		virtual int num_vertices() const;
+
+		virtual void set_box(void* b);
+
+		virtual bool is_manifold() const {
+			throw std::runtime_error("Not implemented");
+		}
+
+		virtual int surface_genus() const {
+			throw std::runtime_error("Not implemented");
+		}
+    private:
+        cgal_shape_t shape_;
+	};
+    
+}}
+
+#endif

src/ifcgeom/kernels/cgal/CgalIfcGeomCurves.cpp_

@@ -0,0 +1,78 @@
+#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_

@@ -0,0 +1,991 @@
+#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_

@@ -0,0 +1,323 @@
+#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_

@@ -0,0 +1,919 @@
+#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_

@@ -0,0 +1,166 @@
+#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_

@@ -0,0 +1,336 @@
+// 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;
+}

src/ifcgeom/kernels/cgal/CgalKernel.cpp_

@@ -0,0 +1,267 @@
+/********************************************************************************
+*                                                                              *
+* 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"
+
+namespace {
+	struct MAKE_TYPE_NAME(factory_t) {
+		IfcGeom::Kernel* operator()(IfcParse::IfcFile* file) const {
+			IfcGeom::MAKE_TYPE_NAME(CgalKernel)* k = new IfcGeom::MAKE_TYPE_NAME(CgalKernel);
+			return k;
+		}
+	};
+}
+
+void MAKE_INIT_FN(KernelImplementation_cgal_)(IfcGeom::impl::KernelFactoryImplementation* mapping) {
+	static const std::string schema_name = STRINGIFY(IfcSchema);
+	MAKE_TYPE_NAME(factory_t) factory;
+	mapping->bind(schema_name, "cgal", factory);
+}
+
+#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
+
+bool IfcGeom::CgalKernel::is_identity_transform(const IfcUtil::IfcBaseClass* l) {
+	Logger::Message(Logger::LOG_ERROR, "Not implemented is_identity_transform()");
+	return false;
+	/*
+	// OpenCascade kernel code below
+
+	IfcSchema::IfcAxis2Placement2D* ax2d;
+	IfcSchema::IfcAxis2Placement3D* ax3d;
+
+	IfcSchema::IfcCartesianTransformationOperator2D* op2d;
+	IfcSchema::IfcCartesianTransformationOperator3D* op3d;
+	IfcSchema::IfcCartesianTransformationOperator2DnonUniform* op2dnonu;
+	IfcSchema::IfcCartesianTransformationOperator3DnonUniform* op3dnonu;
+
+	if ((op2dnonu = l->as<IfcSchema::IfcCartesianTransformationOperator2DnonUniform>()) != 0) {
+		gp_GTrsf2d gtrsf2d;
+		convert(op2dnonu, gtrsf2d);
+		return gtrsf2d.Form() == gp_Identity;
+	} else if ((op2d = l->as<IfcSchema::IfcCartesianTransformationOperator2D>()) != 0) {
+		gp_Trsf2d trsf2d;
+		convert(op2d, trsf2d);
+		return trsf2d.Form() == gp_Identity;
+	} else if ((op3dnonu = l->as<IfcSchema::IfcCartesianTransformationOperator3DnonUniform>()) != 0) {
+		gp_GTrsf gtrsf;
+		convert(op3dnonu, gtrsf);
+		return gtrsf.Form() == gp_Identity;
+	} else if ((op3d = l->as<IfcSchema::IfcCartesianTransformationOperator3D>()) != 0) {
+		gp_Trsf trsf;
+		convert(op3d, trsf);
+		return trsf.Form() == gp_Identity;
+	} else if ((ax2d = l->as<IfcSchema::IfcAxis2Placement2D>()) != 0) {
+		gp_Trsf2d trsf2d;
+		convert(ax2d, trsf2d);
+		return trsf2d.Form() == gp_Identity;
+	} else if ((ax3d = l->as<IfcSchema::IfcAxis2Placement3D>()) != 0) {
+		gp_Trsf trsf;
+		convert(ax3d, trsf);
+		return trsf.Form() == gp_Identity;
+	} else {
+		throw IfcParse::IfcException("Invalid valuation for IfcAxis2Placement / IfcCartesianTransformationOperator");
+	}
+	*/
+}
+
+bool IfcGeom::CgalKernel::apply_layerset(const IfcSchema::IfcProduct* product, IfcGeom::ConversionResults& shapes) {
+	throw std::runtime_error("not implemented");
+}
+
+bool IfcGeom::CgalKernel::validate_quantities(const IfcSchema::IfcProduct* product, const IfcGeom::Representation::BRep& brep) {
+	throw std::runtime_error("not implemented");
+}
+
+bool IfcGeom::CgalKernel::convert_placement(IfcUtil::IfcBaseClass* item, ConversionResultPlacement*& trsf) {
+    if (item->as<IfcSchema::IfcObjectPlacement>()) {
+        cgal_placement_t cgal_trsf;
+        if (convert(item->as<IfcSchema::IfcObjectPlacement>(), cgal_trsf)) {
+            trsf = new CgalPlacement(cgal_trsf);
+            return true;
+        }
+    }
+    return false;
+}
+
+bool IfcGeom::CgalKernel::convert_openings(const IfcSchema::IfcProduct* product, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const IfcGeom::ConversionResults& entity_shapes, const IfcGeom::ConversionResultPlacement* trsf, IfcGeom::ConversionResults& opened_shapes) {
+  const cgal_placement_t& entity_trsf = ((CgalPlacement*) trsf)->trsf();
+  std::list<cgal_shape_t> opening_shapelist;
+  
+  for ( IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++ it ) {
+    IfcSchema::IfcRelVoidsElement* v = *it;
+    IfcSchema::IfcFeatureElementSubtraction* fes = v->RelatedOpeningElement();
+    if ( fes->as<IfcSchema::IfcOpeningElement>() ) {
+      if (!fes->hasRepresentation()) continue;
+      
+      // Convert the IfcRepresentation of the IfcOpeningElement
+      cgal_placement_t opening_trsf;
+      if (fes->hasObjectPlacement()) {
+        try {
+          convert(fes->ObjectPlacement(),opening_trsf);
+        } catch (...) {}
+      }
+      
+      // Move the opening into the coordinate system of the IfcProduct
+      opening_trsf = entity_trsf.inverse() * opening_trsf;
+      
+      IfcSchema::IfcProductRepresentation* prodrep = fes->Representation();
+      IfcSchema::IfcRepresentation::list::ptr reps = prodrep->Representations();
+      
+      IfcGeom::ConversionResults opening_shapes;
+						
+      for ( IfcSchema::IfcRepresentation::list::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
+        convert_shapes(*it2,opening_shapes);
+      }
+      
+      for ( unsigned int i = 0; i < opening_shapes.size(); ++ i ) {
+        cgal_placement_t gtrsf;
+        if (opening_shapes[i].Placement()) {
+          gtrsf = *(CgalPlacement*)opening_shapes[i].Placement();
+        }
+        gtrsf = opening_trsf * gtrsf;
+        cgal_shape_t opening_shape(((CgalShape*)opening_shapes[i].Shape())->shape());
+        for (auto &vertex: vertices(opening_shape)) vertex->point() = vertex->point().transform(gtrsf);
+        opening_shapelist.push_back(opening_shape);
+      }
+      
+    }
+  }
+  
+  // Iterate over the shapes of the IfcProduct
+  for ( IfcGeom::ConversionResults::const_iterator it3 = entity_shapes.begin(); it3 != entity_shapes.end(); ++ it3 ) {
+    const cgal_shape_t& entity_shape_unlocated(((CgalShape*)it3->Shape())->shape());
+    cgal_shape_t entity_shape(entity_shape_unlocated);
+    if (it3->Placement()) {
+      const cgal_placement_t& entity_shape_gtrsf = *(CgalPlacement*)it3->Placement();
+      for (auto &vertex: vertices(entity_shape)) vertex->point() = vertex->point().transform(entity_shape_gtrsf);
+    }
+    
+    cgal_shape_t original_entity_shape(entity_shape);
+    
+    if (!entity_shape.is_valid()) {
+      Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Invalid geometry:", product);
+      return false;
+    }
+    
+    if (!entity_shape.is_closed()) {
+      // TODO: There can be substractions to remove parts of non-volumetric objects. Maybe iterate over all faces of an entity and put them in a Nef_polyhedron_3 through Boolean union? Highly inefficient but maybe desirable...
+      Logger::Message(Logger::LOG_ERROR, "Subtraction of openings not supported for non-closed geometry:", product);
+      return false;
+    }
+    
+    bool success = false;
+    
+    try {
+      success = CGAL::Polygon_mesh_processing::triangulate_faces(entity_shape);
+    } catch (...) {
+      Logger::Message(Logger::LOG_ERROR, "Triangulation of geometry crashed:", product);
+      return false;
+    }
+    
+    if (!success) {
+      Logger::Message(Logger::LOG_ERROR, "Triangulation of geometry failed:", product);
+      return false;
+    }
+    
+    if (CGAL::Polygon_mesh_processing::does_self_intersect(entity_shape)) {
+      Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Self-intersecting geometry:", product);
+      return false;
+    }
+    
+    CGAL::Nef_polyhedron_3<Kernel_> nef_brep_cut_result;
+    
+    try {
+      nef_brep_cut_result = CGAL::Nef_polyhedron_3<Kernel_>(entity_shape);
+    } catch (...) {
+      Logger::Message(Logger::LOG_ERROR, "Could not convert geometry to Nef:", product);
+      return false;
+    }
+    
+    try {
+      cgal_shape_t brep_cut_result;
+      nef_brep_cut_result.convert_to_polyhedron(brep_cut_result);
+    } catch (...) {
+      Logger::Message(Logger::LOG_WARNING, "Final conversion will likely fail. Could not convert geometry from Nef:", product);
+    }
+    
+    for (auto &opening: opening_shapelist) {
+      
+      cgal_shape_t original_opening_shape(opening);
+      if (!opening.is_valid()) {
+        Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Invalid opening in geometry:", product);
+        return false;
+      } if (!opening.is_closed()) {
+        Logger::Message(Logger::LOG_ERROR, "Subtraction of opening makes no sense. Not closed opening in geometry:", product);
+        return false;
+      }
+      
+      success = false;
+      
+      try {
+        success = CGAL::Polygon_mesh_processing::triangulate_faces(opening);
+      } catch (...) {
+        Logger::Message(Logger::LOG_ERROR, "Triangulation of opening of geometry crashed:", product);
+        return false;
+      }
+      
+      if (!success) {
+        Logger::Message(Logger::LOG_ERROR, "Triangulation of opening of geometry failed:", product);
+        return false;
+      }
+      
+      if (CGAL::Polygon_mesh_processing::does_self_intersect(entity_shape)) {
+        Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Self-intersecting opening of geometry:", product);
+      }
+      
+      CGAL::Nef_polyhedron_3<Kernel_> nef_opening;
+      
+      try {
+        nef_opening = CGAL::Nef_polyhedron_3<Kernel_>(opening);
+      } catch (...) {
+        Logger::Message(Logger::LOG_ERROR, "Could not convert opening of geometry to Nef:", product);
+        return false;
+      }
+      
+      try {
+        cgal_shape_t opening_shape;
+        nef_opening.convert_to_polyhedron(opening_shape);
+      } catch (...) {
+        Logger::Message(Logger::LOG_WARNING, "Final conversion will likely fail. Could not convert opening of geometry from Nef:", product);
+        // return false;
+      }
+      
+      try {
+        nef_brep_cut_result -= nef_opening;
+      } catch (...) {
+        Logger::Message(Logger::LOG_ERROR, "Could not subtract Nef opening of geometry:", product);
+        return false;
+      }
+    }
+    
+    try {
+      nef_brep_cut_result.convert_to_polyhedron(entity_shape);
+    } catch (...) {
+      Logger::Message(Logger::LOG_ERROR, "Could not convert geometry with openings from Nef:", product);
+      return false;
+    }
+    
+    opened_shapes.push_back(IfcGeom::ConversionResult(it3->ItemId(), new CgalShape(entity_shape), &it3->Style()));
+    
+  } return true;
+}

src/ifcgeom/kernels/cgal/CgalKernel.h

@@ -0,0 +1,111 @@
+/********************************************************************************
+*                                                                              *
+* 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 CGAL_KERNEL_H
+#define CGAL_KERNEL_H
+
+/*
+#ifdef NO_CACHE
+
+#define IN_CACHE(T,E,t,e)
+#define CACHE(T,E,e)
+
+#else
+
+#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;
+
+#endif
+*/
+
+#include <cmath>
+
+#include "../../../ifcparse/macros.h"
+
+#include "../../../ifcgeom/kernel_agnostic/AbstractKernel.h"
+
+#include "../../../ifcgeom/schema_agnostic/IfcGeomElement.h"
+#include "../../../ifcgeom/kernels/cgal/CgalConversionResult.h"
+
+struct PolyhedronBuilder : public CGAL::Modifier_base<CGAL::Polyhedron_3<Kernel_>::HalfedgeDS> {
+private:
+	std::list<cgal_face_t> *face_list;
+public:
+	boost::optional<cgal_shape_t> from_soup;
+	PolyhedronBuilder(std::list<cgal_face_t> *face_list);
+	void operator()(CGAL::Polyhedron_3<Kernel_>::HalfedgeDS &hds);
+};
+
+namespace ifcopenshell {
+namespace geometry {
+namespace utils {
+	IFC_GEOM_API CGAL::Polyhedron_3<Kernel_> create_cube(double d);
+	IFC_GEOM_API CGAL::Polyhedron_3<Kernel_> create_cube(const Kernel_::Point_3& lower, const Kernel_::Point_3& upper);
+	IFC_GEOM_API CGAL::Polyhedron_3<Kernel_> create_polyhedron(std::list<cgal_face_t> &face_list, bool stitch_borders=false);
+	IFC_GEOM_API CGAL::Polyhedron_3<Kernel_> create_polyhedron(const CGAL::Nef_polyhedron_3<Kernel_> &nef_polyhedron);
+	IFC_GEOM_API CGAL::Nef_polyhedron_3<Kernel_> create_nef_polyhedron(std::list<cgal_face_t> &face_list);
+	IFC_GEOM_API CGAL::Nef_polyhedron_3<Kernel_> create_nef_polyhedron(CGAL::Polyhedron_3<Kernel_> &polyhedron);
+}
+
+namespace kernels {
+
+	class IFC_GEOM_API CgalKernel : public AbstractKernel {
+	private:
+		double precision_;
+		size_t circle_segments_;
+		// CGAL::Nef_polyhedron_3<Kernel_> precision_cube_;
+
+		bool preprocess_boolean_operand(const IfcUtil::IfcBaseClass* log_reference, const cgal_shape_t& shape_const, CGAL::Nef_polyhedron_3<Kernel_>& result, bool dilate);
+		bool thin_solid(const CGAL::Nef_polyhedron_3<Kernel_>& a, CGAL::Nef_polyhedron_3<Kernel_>& result);
+
+		CGAL::Nef_polyhedron_3<Kernel_> create_precision_cube_() const {
+			auto cc = utils::create_cube(precision_);
+			return CGAL::Nef_polyhedron_3<Kernel_>(cc);
+		}
+	public:
+
+		CgalKernel(const ConversionSettings& settings)
+			: AbstractKernel("cgal", settings)
+			, circle_segments_(16)
+		{}
+
+		void remove_duplicate_points_from_loop(cgal_wire_t& polygon);
+
+		bool convert(const taxonomy::extrusion*, cgal_shape_t&);
+		bool convert(const taxonomy::face*, cgal_face_t&);
+		bool convert(const taxonomy::loop*, cgal_wire_t&);
+		// bool convert(const taxonomy::matrix4*, cgal_placement_t&);
+		bool convert(const taxonomy::shell*, cgal_shape_t&);
+
+		bool process_extrusion(const cgal_face_t& bottom_face, const taxonomy::direction3& direction, double height, cgal_shape_t& shape);
+		bool process_as_2d_polygon(const taxonomy::boolean_result* br, std::list<CGAL::Polygon_2<Kernel_>>& loops, double& z0, double& z1);
+		bool process_as_2d_polygon(const std::list<std::list<std::pair<const IfcUtil::IfcBaseClass*, cgal_shape_t>>>& operands, std::list<CGAL::Polygon_2<Kernel_>>& loops, double& z0, double& z1);
+		
+		virtual bool convert_impl(const taxonomy::shell*, ifcopenshell::geometry::ConversionResults&);
+		virtual bool convert_impl(const taxonomy::extrusion*, ifcopenshell::geometry::ConversionResults&);
+		virtual bool convert_impl(const taxonomy::boolean_result*, ifcopenshell::geometry::ConversionResults&);
+
+		CGAL::Nef_polyhedron_3<Kernel_> precision_cube() const { return create_precision_cube_(); }
+	};
+
+}
+}
+}
+#endif

src/ifcgeom/kernels/opencascade/IfcGeomShapes.cpp

@@ -0,0 +1,718 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * Implementations of the various conversion functions defined in IfcRegister.h *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Vec2d.hxx>
+#include <gp_Dir2d.hxx>
+#include <gp_Mat.hxx>
+#include <gp_Mat2d.hxx>
+#include <gp_GTrsf.hxx>
+#include <gp_GTrsf2d.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Ax1.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Ax2d.hxx>
+#include <gp_Pln.hxx>
+#include <gp_Circ.hxx>
+
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_Array1OfInteger.hxx>
+
+#include <Geom_Line.hxx>
+#include <Geom_Circle.hxx>
+#include <Geom_Ellipse.hxx>
+#include <Geom_TrimmedCurve.hxx>
+#include <Geom_CylindricalSurface.hxx>
+
+#include <BRepOffsetAPI_Sewing.hxx>
+#include <BRepOffsetAPI_MakePipe.hxx>
+#include <BRepOffsetAPI_MakePipeShell.hxx>
+
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <BRepBuilderAPI_MakePolygon.hxx>
+#include <BRepBuilderAPI_MakeVertex.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_CompSolid.hxx>
+
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+
+#include <BRepPrimAPI_MakePrism.hxx>
+#include <BRepPrimAPI_MakeRevol.hxx>
+#include <BRepPrimAPI_MakeBox.hxx>
+#include <BRepPrimAPI_MakeCone.hxx>
+#include <BRepPrimAPI_MakeCylinder.hxx>
+#include <BRepPrimAPI_MakeSphere.hxx>
+#include <BRepPrimAPI_MakeWedge.hxx>
+#include <BRepBuilderAPI_MakePolygon.hxx>
+
+#include <BRepBuilderAPI_Transform.hxx>
+#include <BRepBuilderAPI_MakeShell.hxx>
+#include <BRepBuilderAPI_MakeSolid.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+
+#include <BRepAlgoAPI_Cut.hxx>
+#include <BRepAlgoAPI_Fuse.hxx>
+#include <BRepAlgoAPI_Common.hxx>
+
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <ShapeFix_Solid.hxx>
+
+#include <TopLoc_Location.hxx>
+
+#include <BRepCheck_Analyzer.hxx>
+#include <BRepClass3d_SolidClassifier.hxx>
+
+#include <Standard_Version.hxx>
+
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+
+#include "OpenCascadeKernel.h"
+
+#include <memory>
+
+#include "../../../ifcparse/IfcLogger.h"
+#include "../../../ifcgeom/kernels/opencascade/OpenCascadeConversionResult.h"
+#include "IfcGeomTree.h"
+
+using namespace ifcopenshell::geometry; 
+using namespace ifcopenshell::geometry::kernels;
+
+
+#include <TopTools_DataMapOfShapeInteger.hxx>
+#include <Geom_Plane.hxx>
+#include <BRepLib_FindSurface.hxx>
+#include <ShapeFix_Edge.hxx>
+#include <BRepBuilderAPI_GTransform.hxx>
+
+
+#include <Geom_Curve.hxx>
+#include <Geom_Line.hxx>
+#include <Approx_Curve3d.hxx>
+#include <BRepAdaptor_CompCurve.hxx>
+#include <BRepAdaptor_HCompCurve.hxx>
+#include <Approx_Curve3d.hxx>
+
+#include <ShapeBuild_ReShape.hxx>
+#include <GC_MakeCircle.hxx>
+
+
+
+
+#include <BRepTools_WireExplorer.hxx>
+
+
+#include <BRepGProp.hxx>
+#include <GProp_GProps.hxx>
+
+double OpenCascadeKernel::shape_volume(const TopoDS_Shape& s) {
+	GProp_GProps prop;
+	BRepGProp::VolumeProperties(s, prop);
+	return prop.Mass();
+}
+
+double OpenCascadeKernel::face_area(const TopoDS_Face& f) {
+	GProp_GProps prop;
+	BRepGProp::SurfaceProperties(f, prop);
+	return prop.Mass();
+}
+
+bool OpenCascadeKernel::create_solid_from_compound(const TopoDS_Shape& compound, TopoDS_Shape& shape) {
+	TopTools_ListOfShape face_list;
+	TopExp_Explorer exp(compound, TopAbs_FACE);
+	for (; exp.More(); exp.Next()) {
+		TopoDS_Face face = TopoDS::Face(exp.Current());
+		face_list.Append(face);
+	}
+
+	if (face_list.Extent() == 0) {
+		return false;
+	}
+
+	return create_solid_from_faces(face_list, shape);
+}
+
+bool OpenCascadeKernel::create_solid_from_faces(const TopTools_ListOfShape& face_list, TopoDS_Shape& shape) {
+	bool valid_shell = false;
+
+	if (face_list.Extent() == 1) {
+		shape = face_list.First();
+		// A bit dubious what to return here.
+		return true;
+	} else if (face_list.Extent() == 0) {
+		return false;
+	}
+
+	TopTools_ListIteratorOfListOfShape face_iterator;
+
+	bool has_shared_edges = false;
+	TopTools_MapOfShape edge_set;
+
+	// In case there are wire interesections or failures in non-planar wire triangulations
+	// the idea is to let occt do an exhaustive search of edge partners. But we have not
+	// found a case where this actually improves boolean ops later on.
+	// if (!faceset_helper_ || !faceset_helper_->non_manifold()) {
+
+	for (face_iterator.Initialize(face_list); face_iterator.More(); face_iterator.Next()) {
+		// As soon as is detected one of the edges is shared, the assumption is made no
+		// additional sewing is necessary.
+		if (!has_shared_edges) {
+			TopExp_Explorer exp(face_iterator.Value(), TopAbs_EDGE);
+			for (; exp.More(); exp.Next()) {
+				if (edge_set.Contains(exp.Current())) {
+					has_shared_edges = true;
+					break;
+				}
+				edge_set.Add(exp.Current());
+			}
+		}
+	}
+
+	BRepOffsetAPI_Sewing sewing_builder;
+	sewing_builder.SetTolerance(settings_.getValue(ConversionSettings::GV_PRECISION));
+	sewing_builder.SetMaxTolerance(settings_.getValue(ConversionSettings::GV_PRECISION));
+	sewing_builder.SetMinTolerance(settings_.getValue(ConversionSettings::GV_PRECISION));
+
+	BRep_Builder builder;
+	TopoDS_Shell shell;
+	builder.MakeShell(shell);
+
+	for (face_iterator.Initialize(face_list); face_iterator.More(); face_iterator.Next()) {
+		if (has_shared_edges) {
+			builder.Add(shell, face_iterator.Value());
+		} else {
+			sewing_builder.Add(face_iterator.Value());
+		}
+	}
+
+	try {
+		if (has_shared_edges) {
+			ShapeFix_Shell fix;
+			fix.FixFaceOrientation(shell);
+			shape = fix.Shape();
+		} else {
+			sewing_builder.Perform();
+			shape = sewing_builder.SewedShape();
+		}
+
+		BRepCheck_Analyzer ana(shape);
+		valid_shell = ana.IsValid();
+
+		if (!valid_shell) {
+			ShapeFix_Shape sfs(shape);
+			sfs.Perform();
+			shape = sfs.Shape();
+
+			BRepCheck_Analyzer reana(shape);
+			valid_shell = reana.IsValid();
+		}
+
+		valid_shell &= count(shape, TopAbs_SHELL) > 0;
+	} catch (const Standard_Failure& e) {
+		if (e.GetMessageString() && strlen(e.GetMessageString())) {
+			Logger::Error(e.GetMessageString());
+		} else {
+			Logger::Error("Unknown error sewing shell");
+		}
+	} catch (...) {
+		Logger::Error("Unknown error sewing shell");
+	}
+
+	if (valid_shell) {
+
+		TopoDS_Shape complete_shape;
+		TopExp_Explorer exp(shape, TopAbs_SHELL);
+
+		for (; exp.More(); exp.Next()) {
+			TopoDS_Shape result_shape = exp.Current();
+
+			try {
+				ShapeFix_Solid solid;
+				solid.SetMaxTolerance(settings_.getValue(ConversionSettings::GV_PRECISION));
+				TopoDS_Solid solid_shape = solid.SolidFromShell(TopoDS::Shell(exp.Current()));
+				// @todo: BRepClass3d_SolidClassifier::PerformInfinitePoint() is done by SolidFromShell
+				//        and this is done again, to be able to catch errors during this process.
+				//        This is double work that should be avoided.
+				if (!solid_shape.IsNull()) {
+					try {
+						BRepClass3d_SolidClassifier classifier(solid_shape);
+						result_shape = solid_shape;
+						classifier.PerformInfinitePoint(settings_.getValue(ConversionSettings::GV_PRECISION));
+						if (classifier.State() == TopAbs_IN) {
+							shape.Reverse();
+						}
+					} catch (const Standard_Failure& e) {
+						if (e.GetMessageString() && strlen(e.GetMessageString())) {
+							Logger::Error(e.GetMessageString());
+						} else {
+							Logger::Error("Unknown error classifying solid");
+						}
+					} catch (...) {
+						Logger::Error("Unknown error classifying solid");
+					}
+				}
+			} catch (const Standard_Failure& e) {
+				if (e.GetMessageString() && strlen(e.GetMessageString())) {
+					Logger::Error(e.GetMessageString());
+				} else {
+					Logger::Error("Unknown error creating solid");
+				}
+			} catch (...) {
+				Logger::Error("Unknown error creating solid");
+			}
+
+			if (complete_shape.IsNull()) {
+				complete_shape = result_shape;
+			} else {
+				BRep_Builder B;
+				if (complete_shape.ShapeType() != TopAbs_COMPOUND) {
+					TopoDS_Compound C;
+					B.MakeCompound(C);
+					B.Add(C, complete_shape);
+					complete_shape = C;
+					Logger::Warning("Multiple components in IfcConnectedFaceSet");
+				}
+				B.Add(complete_shape, result_shape);
+			}
+		}
+
+		TopExp_Explorer loose_faces(shape, TopAbs_FACE, TopAbs_SHELL);
+
+		for (; loose_faces.More(); loose_faces.Next()) {
+			BRep_Builder B;
+			if (complete_shape.ShapeType() != TopAbs_COMPOUND) {
+				TopoDS_Compound C;
+				B.MakeCompound(C);
+				B.Add(C, complete_shape);
+				complete_shape = C;
+				Logger::Warning("Loose faces in IfcConnectedFaceSet");
+			}
+			B.Add(complete_shape, loose_faces.Current());
+		}
+
+		shape = complete_shape;
+
+	} else {
+		Logger::Error("Failed to sew faceset");
+	}
+
+	return valid_shell;
+}
+
+int OpenCascadeKernel::count(const TopoDS_Shape& s, TopAbs_ShapeEnum t, bool unique) {
+	if (unique) {
+		TopTools_IndexedMapOfShape map;
+		TopExp::MapShapes(s, t, map);
+		return map.Extent();
+	} else {
+		int i = 0;
+		TopExp_Explorer exp(s, t);
+		for (; exp.More(); exp.Next()) {
+			++i;
+		}
+		return i;
+	}
+}
+
+bool is_manifold_occt(const TopoDS_Shape& a) {
+	if (a.ShapeType() == TopAbs_COMPOUND || a.ShapeType() == TopAbs_SOLID) {
+		TopoDS_Iterator it(a);
+		for (; it.More(); it.Next()) {
+			if (!is_manifold_occt(it.Value())) {
+				return false;
+			}
+		}
+		return true;
+	} else {
+		TopTools_IndexedDataMapOfShapeListOfShape map;
+		TopExp::MapShapesAndAncestors(a, TopAbs_EDGE, TopAbs_FACE, map);
+
+		for (int i = 1; i <= map.Extent(); ++i) {
+			if (map.FindFromIndex(i).Extent() != 2) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+}
+
+bool OpenCascadeKernel::boolean_operation(const TopoDS_Shape& a_, const TopTools_ListOfShape& b__, BOPAlgo_Operation op, TopoDS_Shape& result, double fuzziness) {
+
+	if (fuzziness < 0.) {
+		fuzziness = settings_.getValue(ConversionSettings::GV_PRECISION);
+	}
+
+	// @todo, it does seem a bit odd, we first triangulate non-planar faces
+	// to later unify them again. Can we make this a bit more intelligent?
+	TopoDS_Shape a = unify(a_, fuzziness);
+	TopTools_ListOfShape b_;
+	{
+		TopTools_ListIteratorOfListOfShape it(b__);
+		for (; it.More(); it.Next()) {
+			b_.Append(unify(it.Value(), fuzziness));
+		}
+	}
+
+	bool success = false;
+	BRepAlgoAPI_BooleanOperation* builder;
+	TopTools_ListOfShape B, b;
+	if (op == BOPAlgo_CUT) {
+		builder = new BRepAlgoAPI_Cut();
+		bounding_box_overlap(settings_.getValue(ConversionSettings::GV_PRECISION), a, b_, b);
+	} else if (op == BOPAlgo_COMMON) {
+		builder = new BRepAlgoAPI_Common();
+		b = b_;
+	} else if (op == BOPAlgo_FUSE) {
+		builder = new BRepAlgoAPI_Fuse();
+		b = b_;
+	} else {
+		return false;
+	}
+
+	if (b.Extent() == 0) {
+		result = a;
+		return true;
+	}
+
+	// Find a sensible value for the fuzziness, based on precision
+	// and limited by edge lengths and vertex-edge distances.
+	const double len_a = min_edge_length(a_);
+	double min_length_orig = (std::min)(len_a, min_vertex_edge_distance(a_, settings_.getValue(ConversionSettings::GV_PRECISION), len_a));
+	TopTools_ListIteratorOfListOfShape it(b__);
+	for (; it.More(); it.Next()) {
+		double d = min_edge_length(it.Value());
+		if (d < min_length_orig) {
+			min_length_orig = d;
+		}
+		d = min_vertex_edge_distance(it.Value(), settings_.getValue(ConversionSettings::GV_PRECISION), d);
+		if (d < min_length_orig) {
+			min_length_orig = d;
+		}
+	}
+
+	const double fuzz = (std::min)(min_length_orig / 3., fuzziness);
+
+	TopTools_ListOfShape s1s;
+	s1s.Append(copy_operand(a));
+#if OCC_VERSION_HEX >= 0x70000
+	builder->SetNonDestructive(true);
+#endif
+	builder->SetFuzzyValue(fuzz);
+	builder->SetArguments(s1s);
+	copy_operand(b, B);
+	builder->SetTools(B);
+	builder->Build();
+	if (builder->IsDone()) {
+		TopoDS_Shape r = *builder;
+
+		ShapeFix_Shape fix(r);
+		try {
+			fix.SetMinTolerance(fuzz);
+			fix.SetMaxTolerance(fuzz);
+			fix.SetPrecision(fuzz);
+			fix.Perform();
+			r = fix.Shape();
+		} catch (...) {
+			Logger::Error("Shape healing failed on boolean result");
+		}
+
+		success = BRepCheck_Analyzer(r).IsValid() != 0;
+
+		if (success) {
+
+			success = !is_manifold_occt(a) || is_manifold_occt(r);
+
+			if (success) {
+
+				// when there are edges or vertex-edge distances close to the used fuzziness, the  
+				// output is not trusted and the operation is attempted with a higher fuzziness.
+				int reason = 0;
+				double v;
+				if ((v = min_edge_length(r)) < fuzziness * 3.) {
+					reason = 0;
+					success = false;
+				} else if ((v = min_vertex_edge_distance(r, settings_.getValue(ConversionSettings::GV_PRECISION), fuzziness * 3.)) < fuzziness * 3.) {
+					reason = 1;
+					success = false;
+				} else if ((v = min_face_face_distance(r, fuzziness * 3.)) < fuzziness * 3.) {
+					reason = 2;
+					success = false;
+				}
+
+				if (success) {
+					result = r;
+				} else {
+					static const char* const reason_strings[] = { "edge length", "vertex-edge", "face-face" };
+					std::stringstream str;
+					str << "Boolean operation result failing " << reason_strings[reason] << " interference check, with fuzziness " << fuzziness << " with length " << v;
+					Logger::Notice(str.str());
+				}
+			} else {
+				Logger::Notice("Boolean operation yields non-manifold result");
+			}
+		} else {
+			Logger::Notice("Boolean operation yields invalid result");
+		}
+	} else {
+		std::stringstream str;
+#if OCC_VERSION_HEX >= 0x70000
+		builder->DumpErrors(str);
+#else
+		str << "Error code: " << builder->ErrorStatus();
+#endif
+		std::string str_str = str.str();
+		if (str_str.size()) {
+			Logger::Notice(str_str);
+		}
+	}
+	delete builder;
+	if (!success) {
+		const double new_fuzziness = fuzziness * 10.;
+		if (new_fuzziness - 1e-15 <= settings_.getValue(ConversionSettings::GV_PRECISION) * 10000. && new_fuzziness < min_length_orig) {
+			return boolean_operation(a, b, op, result, new_fuzziness);
+		} else {
+			Logger::Notice("No longer attempting boolean operation with higher fuzziness");
+		}
+	}
+	return success;
+}
+
+namespace {
+	BOPAlgo_Operation op_to_occt(taxonomy::boolean_result::operation_t t) {
+		switch (t) {
+		case taxonomy::boolean_result::UNION: return BOPAlgo_FUSE;
+		case taxonomy::boolean_result::INTERSECTION: return BOPAlgo_COMMON;
+		case taxonomy::boolean_result::SUBTRACTION: return BOPAlgo_CUT;
+		}
+	}
+}
+
+bool OpenCascadeKernel::convert_impl(const taxonomy::boolean_result* br, ifcopenshell::geometry::ConversionResults& results) {
+	bool first = true;
+
+	TopoDS_Shape a;
+	TopTools_ListOfShape b;
+
+	taxonomy::style* first_item_style = nullptr;
+
+	for (auto& c : br->children) {
+		// AbstractKernel::convert(c, results);
+		// continue;
+
+		ifcopenshell::geometry::ConversionResults cr;
+		// @todo half-space detection
+		AbstractKernel::convert(c, cr);
+		if (first && br->operation == taxonomy::boolean_result::SUBTRACTION) {
+			// @todo A will be null on union/intersection, intended?
+			flatten_shape_list(cr, a, false);
+			first_item_style = ((taxonomy::geom_item*)c)->surface_style;
+			if (!first_item_style && c->kind() == taxonomy::COLLECTION) {
+				// @todo recursively right?
+				first_item_style = ((taxonomy::geom_item*) ((taxonomy::collection*)c)->children[0])->surface_style;
+			}
+		} else {
+			for (auto& r : cr) {
+				auto S = ((OpenCascadeShape*)r.Shape())->shape();
+				gp_GTrsf trsf;
+				convert(&r.Placement(), trsf);
+				// @todo it really confuses me why I cannot use Moved() here instead
+				S.Location(S.Location() * trsf.Trsf());
+				b.Append(S);
+				/*results.emplace_back(ConversionResult(
+					r.ItemId(),
+					ifcopenshell::geometry::taxonomy::matrix4(),
+					new OpenCascadeShape(S),
+					r.Style()
+				));*/
+			}			
+		}
+		first = false;
+	}
+
+	TopoDS_Shape r;
+	if (!boolean_operation(a, b, op_to_occt(br->operation), r)) {
+		return false;
+	}
+
+	/*
+	TopoDS_Compound r;
+	BRep_Builder B;
+	B.MakeCompound(r);
+	B.Add(r, a);
+	for (auto& bb : b) {
+		B.Add(r, bb);
+	}
+	*/
+
+	results.emplace_back(ConversionResult(
+		br->instance->data().id(),
+		br->matrix,
+		new OpenCascadeShape(r),
+		br->surface_style ? br->surface_style : first_item_style
+	));
+	return true;
+}
+
+bool OpenCascadeKernel::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& OpenCascadeKernel::ensure_fit_for_subtraction(const TopoDS_Shape& shape, TopoDS_Shape& solid) {
+	const bool is_comp = is_compound(shape);
+	if (!is_comp) {
+		return solid = shape;
+	}
+
+	if (!create_solid_from_compound(shape, solid)) {
+		return solid = shape;
+	}
+
+	return solid;
+}
+
+bool OpenCascadeKernel::flatten_shape_list(const ifcopenshell::geometry::ConversionResults& shapes, TopoDS_Shape& result, bool fuse) {
+	TopoDS_Compound compound;
+	BRep_Builder builder;
+	builder.MakeCompound(compound);
+
+	result = TopoDS_Shape();
+
+	for (ifcopenshell::geometry::ConversionResults::const_iterator it = shapes.begin(); it != shapes.end(); ++it) {
+		TopoDS_Shape merged;
+		const TopoDS_Shape& s = *(OpenCascadeShape*)it->Shape();
+		if (fuse) {
+			ensure_fit_for_subtraction(s, merged);
+		} else {
+			merged = s;
+		}
+		const TopoDS_Shape moved_shape = apply_transformation(merged, it->Placement());
+
+		if (shapes.size() == 1) {
+			result = moved_shape;
+			return true;
+		}
+
+		if (fuse) {
+			if (result.IsNull()) {
+				result = moved_shape;
+			} else {
+				BRepAlgoAPI_Fuse brep_fuse(result, moved_shape);
+				if (brep_fuse.IsDone()) {
+					TopoDS_Shape fused = brep_fuse;
+
+					ShapeFix_Shape fix(result);
+					fix.Perform();
+					result = fix.Shape();
+
+					bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
+					if (is_valid) {
+						result = fused;
+					}
+				}
+			}
+		} else {
+			builder.Add(compound, moved_shape);
+		}
+	}
+
+	if (!fuse) {
+		result = compound;
+	}
+
+	const bool success = !result.IsNull();
+	return success;
+}
+
+TopoDS_Shape OpenCascadeKernel::apply_transformation(const TopoDS_Shape& s, const taxonomy::matrix4& t) {
+	if (t.is_identity()) {
+		return s;
+	} else {
+		gp_GTrsf trsf;
+		convert(&t, trsf);
+		return apply_transformation(s, trsf);
+	}
+}
+
+TopoDS_Shape OpenCascadeKernel::apply_transformation(const TopoDS_Shape& s, const gp_GTrsf& t) {
+	if (t.Form() == gp_Other) {
+		Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation");
+		return BRepBuilderAPI_GTransform(s, t, true);
+	} else {
+		return apply_transformation(s, t.Trsf());
+	}
+}
+
+TopoDS_Shape OpenCascadeKernel::apply_transformation(const TopoDS_Shape& s, const gp_Trsf& t) {
+	/// @todo set to 1. and exactly 1. or use epsilon?
+	if (t.ScaleFactor() != 1.) {
+		return BRepBuilderAPI_Transform(s, t, true);
+	} else {
+		return s.Moved(t);
+	}
+}
+
+bool OpenCascadeKernel::convert_impl(const taxonomy::face* face, ifcopenshell::geometry::ConversionResults& results) {
+	// Root level faces are only encountered in case of half spaces
+
+	if (face->basis == nullptr) {
+		Logger::Error("Half space without underlying surface:", face->instance);
+		return false;
+	}
+
+	if (face->basis->kind() != taxonomy::PLANE) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", face->basis->instance);
+		return false;
+	}
+
+	// @todo boundary
+	const auto& m = ((taxonomy::geom_item*)face->basis)->matrix.ccomponents();
+	gp_Pln pln(convert_xyz2<gp_Pnt>(m.col(3)), convert_xyz2<gp_Dir>(m.col(2)));
+	const gp_Pnt pnt = pln.Location().Translated(face->orientation.get_value_or(false) ? -pln.Axis().Direction() : pln.Axis().Direction());
+	TopoDS_Shape shape = BRepPrimAPI_MakeHalfSpace(BRepBuilderAPI_MakeFace(pln), pnt).Solid();
+	results.emplace_back(ConversionResult(
+		face->instance->data().id(),
+		new OpenCascadeShape(shape),
+		face->surface_style
+	));
+
+	return true;
+}

src/ifcgeom/kernels/opencascade/IfcGeomTree.h

@@ -0,0 +1,281 @@
+/********************************************************************************
+*                                                                              *
+* 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 IFCGEOMTREE_H
+#define IFCGEOMTREE_H
+
+#include "../../../ifcparse/IfcFile.h"
+#include "../../../ifcgeom/schema_agnostic/IfcGeomElement.h"
+#include "../../../ifcgeom/schema_agnostic/IfcGeomIterator.h"
+#include "../../../ifcgeom/schema_agnostic/Converter.h"
+#include "../../../ifcgeom/kernels/opencascade/OpenCascadeKernel.h"
+
+#include <NCollection_UBTree.hxx>
+#include <BRepBndLib.hxx>
+#include <Bnd_Box.hxx>
+#include <BRepAlgoAPI_Common.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+#include <BRepClass3d_SolidClassifier.hxx>
+
+namespace ifcopenshell { namespace geometry {
+
+	namespace impl {
+		template <typename T>
+		class tree {
+
+		public:
+
+			void add(const T& t, const Bnd_Box& b) {
+				tree_.Add(t, b);
+			}
+
+			void add(const T& t, const TopoDS_Shape& s) {
+				Bnd_Box b;
+				BRepBndLib::AddClose(s, b);
+				add(t, b);
+				shapes_[t] = s;
+			}
+
+			std::vector<T> select_box(const T& t, bool completely_within = false, double extend=-1.e-5) const {
+				typename map_t::const_iterator it = shapes_.find(t);
+				if (it == shapes_.end()) {
+					return std::vector<T>();
+				}
+
+				Bnd_Box b;
+				BRepBndLib::AddClose(it->second, b);
+
+				// Gap is assumed to be positive throughout the codebase,
+				// but at least for IsOut() in the selector a negative
+				// Gap should work as well.
+				b.SetGap(b.GetGap() + extend); 
+				
+				return select_box(b, completely_within);
+			}
+
+			std::vector<T> select_box(const gp_Pnt& p) const {
+				Bnd_Box b;
+				b.Add(p);
+				return select_box(b);
+			}
+
+			std::vector<T> select_box(const Bnd_Box& b, bool completely_within = false) const {
+				selector s(b);
+				tree_.Select(s);
+				if (completely_within) {
+					std::vector<T> ts = s.results();
+					std::vector<T> ts_filtered;
+					ts_filtered.reserve(ts.size());
+					typename std::vector<T>::const_iterator it = ts.begin();
+					for (; it != ts.end(); ++it) {
+						const TopoDS_Shape& shp = shapes_.find(*it)->second;
+						Bnd_Box B;
+						BRepBndLib::AddClose(shp, B);
+
+						// BndBox::CornerMin() /-Max() introduced in OCCT 6.8
+						double x1, y1, z1, x2, y2, z2;
+						b.Get(x1, y1, z1, x2, y2, z2);
+						double gap = B.GetGap();
+						gp_Pnt p1(x1 - gap, y1 - gap, z1 - gap);
+						gp_Pnt p2(x2 + gap, y2 + gap, z2 + gap);
+						
+						if (!b.IsOut(p1) && !b.IsOut(p2)) {
+							ts_filtered.push_back(*it);
+						}
+					}
+					return ts_filtered;
+				} else {
+					return s.results();
+				}
+			}
+
+			std::vector<T> select(const T& t, bool completely_within = false) const {
+				std::vector<T> ts = select_box(t);
+				if (ts.empty()) {
+					return ts;
+				}
+
+				std::vector<T> ts_filtered;
+
+				const TopoDS_Shape& A = shapes_.find(t)->second;
+				if (kernels::OpenCascadeKernel::count(A, TopAbs_SHELL) == 0) {
+					return ts_filtered;
+				}
+
+				ts_filtered.reserve(ts.size());
+
+				typename std::vector<T>::const_iterator it = ts.begin();
+				for (it = ts.begin(); it != ts.end(); ++it) {
+					const TopoDS_Shape& B = shapes_.find(*it)->second;
+					if (kernels::OpenCascadeKernel::count(B, TopAbs_SHELL) == 0) {
+						continue;
+					}
+
+					if (completely_within) {
+						BRepAlgoAPI_Cut cut(B, A);
+						if (cut.IsDone()) {
+							if (kernels::OpenCascadeKernel::count(cut.Shape(), TopAbs_SHELL) == 0) {
+								ts_filtered.push_back(*it);
+							}
+						}
+					} else {
+						BRepAlgoAPI_Common common(A, B);
+						if (common.IsDone()) {
+							if (kernels::OpenCascadeKernel::count(common.Shape(), TopAbs_SHELL) > 0) {
+								ts_filtered.push_back(*it);
+							}
+						}
+					}
+				}
+
+				return ts_filtered;
+			}
+
+			std::vector<T> select(const TopoDS_Shape& s) const {
+				Bnd_Box bb;
+				BRepBndLib::AddClose(s, bb);
+
+				std::vector<T> ts;
+
+				if (kernels::OpenCascadeKernel::count(s, TopAbs_SHELL) == 0) {
+					return ts;
+				}
+
+				ts = select_box(bb);
+
+				if (ts.empty()) {
+					return ts;
+				}
+
+				std::vector<T> ts_filtered;
+				ts_filtered.reserve(ts.size());
+
+				typename std::vector<T>::const_iterator it = ts.begin();
+				for (it = ts.begin(); it != ts.end(); ++it) {
+					const TopoDS_Shape& B = shapes_.find(*it)->second;
+					
+					if (kernels::OpenCascadeKernel::count(B, TopAbs_SHELL) == 0) {
+						continue;
+					}
+
+					BRepAlgoAPI_Common common(s, B);
+					if (common.IsDone()) {
+						if (kernels::OpenCascadeKernel::count(common.Shape(), TopAbs_SHELL) > 0) {
+							ts_filtered.push_back(*it);
+						}
+					}
+				}
+
+				return ts_filtered;
+			}
+
+			std::vector<T> select(const gp_Pnt& p) const {
+				std::vector<T> ts = select_box(p);
+				if (ts.empty()) {
+					return ts;
+				}
+
+				std::vector<T> ts_filtered;
+				ts_filtered.reserve(ts.size());
+
+				typename std::vector<T>::const_iterator it = ts.begin();
+				for (it = ts.begin(); it != ts.end(); ++it) {
+					const TopoDS_Shape& B = shapes_.find(*it)->second;
+					TopExp_Explorer exp(B, TopAbs_SOLID);
+					for (; exp.More(); exp.Next()) {
+						BRepClass3d_SolidClassifier cls(exp.Current(), p, 1e-5);
+						if (cls.State() != TopAbs_OUT) {
+							ts_filtered.push_back(*it);
+							break;
+						}
+					}					
+				}
+
+				return ts_filtered;
+			}
+
+		protected:
+
+			typedef NCollection_UBTree<T, Bnd_Box> tree_t;
+			typedef std::map<T, TopoDS_Shape> map_t;
+			tree_t tree_;
+			map_t shapes_;
+
+			class selector : public tree_t::Selector
+			{
+			public:
+				selector(const Bnd_Box& b)
+					: tree_t::Selector()
+					, bounds_(b)
+				{}
+
+				Standard_Boolean Reject(const Bnd_Box& b) const {
+					return bounds_.IsOut(b);
+				}
+
+				Standard_Boolean Accept(const T& o) {
+					results_.push_back(o);
+					return Standard_True;
+				}
+
+				const std::vector<T>& results() const {
+					return results_;
+				}
+
+			private:
+				std::vector<T> results_;
+				const Bnd_Box& bounds_;
+			};
+
+		};
+	}
+
+	class tree : public impl::tree<IfcUtil::IfcBaseEntity*> {
+	public:
+
+		tree() {};
+
+		tree(IfcParse::IfcFile& f) {
+			add_file(f, ifcopenshell::geometry::settings());
+		}
+
+		tree(IfcParse::IfcFile& f, const ifcopenshell::geometry::settings& settings) {
+			add_file(f, settings);
+		}
+
+		void add_file(IfcParse::IfcFile& f, const ifcopenshell::geometry::settings& settings) {
+			ifcopenshell::geometry::settings settings_ = settings;
+			settings_.set(ifcopenshell::geometry::settings::DISABLE_TRIANGULATION, true);
+			settings_.set(ifcopenshell::geometry::settings::USE_WORLD_COORDS, true);
+			settings_.set(ifcopenshell::geometry::settings::SEW_SHELLS, true);
+
+			Iterator it(settings_, &f);
+
+			if (it.initialize()) {
+				do {
+					NativeElement* elem = (NativeElement*)it.get();
+					add((IfcUtil::IfcBaseEntity*)f.instance_by_id(elem->id()), ((OpenCascadeShape*)elem->geometry().as_compound())->shape());
+				} while (it.next());
+			}
+		}
+	};
+
+}}
+
+#endif

src/ifcgeom/kernels/opencascade/OpenCascadeConversionResult.cpp

@@ -0,0 +1,219 @@
+#include "OpenCascadeConversionResult.h"
+
+#include "../../../ifcparse/IfcLogger.h"
+#include "../../../ifcgeom/schema_agnostic/IfcGeomRepresentation.h"
+
+#include <TopoDS.hxx>
+
+#include <map>
+
+namespace {
+	// We bypass the conversion to gp_GTrsf, because it does not work
+	void taxonomy_transform(const Eigen::Matrix4d* m, gp_XYZ& xyz) {
+		if (m) {
+			Eigen::Vector4d v(xyz.X(), xyz.Y(), xyz.Z(), 1.0);
+			auto v2 = (*m * v).eval();
+			xyz.ChangeData()[0] = v2(0);
+			xyz.ChangeData()[1] = v2(1);
+			xyz.ChangeData()[2] = v2(2);
+		}
+	}
+}
+
+void ifcopenshell::geometry::OpenCascadeShape::Triangulate(const settings& settings, const ifcopenshell::geometry::taxonomy::matrix4& place, Representation::Triangulation* t, int surface_style_id) const {
+
+	// @todo remove duplication with OpenCascadeKernel::convert(const taxonomy::matrix4* matrix, gp_GTrsf& trsf);
+	// above can be static?
+
+	// A 3x3 matrix to rotate the vertex normals
+	boost::optional<gp_Mat> rotation_matrix;
+	
+	if (place.components_) {
+		const auto& m = *place.components_;
+		rotation_matrix.emplace(
+			m(0, 0), m(0, 1), m(0, 2),
+			m(1, 0), m(1, 1), m(1, 2),
+			m(2, 0), m(2, 1), m(2, 2)
+		);
+	}
+
+	// Triangulate the shape
+	try {
+		BRepMesh_IncrementalMesh(shape_, settings.deflection_tolerance());
+	} catch (...) {
+
+		// TODO: Catch outside
+		// Logger::Message(Logger::LOG_ERROR,"Failed to triangulate shape:",ifc_file->entityById(_id)->entity);
+		Logger::Message(Logger::LOG_ERROR, "Failed to triangulate shape");
+		return;
+	}
+
+	// Iterates over the faces of the shape
+	int num_faces = 0;
+	TopExp_Explorer exp;
+	for (exp.Init(shape_, TopAbs_FACE); exp.More(); exp.Next(), ++num_faces) {
+		TopoDS_Face face = TopoDS::Face(exp.Current());
+		TopLoc_Location loc;
+		Handle_Poly_Triangulation tri = BRep_Tool::Triangulation(face, loc);
+
+		if (!tri.IsNull()) {
+
+			// 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 and calculation is not disable explicitly.
+			const bool calculate_normals = !settings.get(ifcopenshell::geometry::settings::WELD_VERTICES) &&
+				!settings.get(ifcopenshell::geometry::settings::NO_NORMALS);
+
+			for (int i = 1; i <= nodes.Length(); ++i) {
+				coords.push_back(nodes(i).Transformed(loc).XYZ());
+				taxonomy_transform(place.components_, *coords.rbegin());
+				const gp_XYZ& last = *coords.rbegin();
+				dict[i] = t->addVertex(surface_style_id, last.X(), last.Y(), last.Z());
+
+				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() > 1.e-9) {
+						if (rotation_matrix) {
+							normal = gp_Dir(normal_direction.XYZ() * *rotation_matrix);
+						} else {
+							normal = normal_direction;
+						}
+					}
+					t->addNormal(normal.X(), normal.Y(), 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());
+				*/
+
+				t->addFace(surface_style_id, dict[n1], dict[n2], dict[n3]);
+
+				t->addEdge(dict[n1], dict[n2], edgecount, edges_temp);
+				t->addEdge(dict[n2], dict[n3], edgecount, edges_temp);
+				t->addEdge(dict[n3], dict[n1], edgecount, edges_temp);
+			}
+			for (std::vector<std::pair<int, int> >::const_iterator jt = edges_temp.begin(); jt != edges_temp.end(); ++jt) {
+				if (edgecount[*jt] == 1) {
+					// non manifold edge, face boundary
+					t->registerEdge(jt->first, jt->second);
+				}
+			}
+		}
+	}
+
+	/*
+	TODO: Unimplemented
+	if (!t.normals().empty() && settings().get(IfcGeom::IteratorSettings::GENERATE_UVS)) {
+		t.uvs() = box_project_uvs(t.verts(), t.normals());
+	}
+
+	if (num_faces == 0) {
+		// Edges are only emitted if there are no faces. A mixed representation of faces
+		// and loose edges is discouraged by the standard. An alternative would be to use
+		// TopExp_Explorer texp(s, TopAbs_EDGE, TopAbs_FACE) to find edges that do not
+		// belong to any face.
+		for (TopExp_Explorer texp(s, TopAbs_EDGE); texp.More(); texp.Next()) {
+			BRepAdaptor_Curve crv(TopoDS::Edge(texp.Current()));
+			GCPnts_QuasiUniformDeflection tessellater(crv, settings.deflection_tolerance());
+			int n = tessellater.NbPoints();
+			int start = (int)t->verts().size() / 3;
+			for (int i = 1; i <= n; ++i) {
+				gp_XYZ p = tessellater.Value(i).XYZ();
+
+				// // In case you want direction arrows on your edges
+				// double u = tessellater.Parameter(i);
+				// gp_XYZ p2, p3;
+				// gp_Pnt tmp;
+				// gp_Vec tmp2;
+				// crv.D1(u, tmp, tmp2);
+				// gp_Dir d1, d2, d3, d4;
+				// d1 = tmp2;
+				// if (texp.Current().Orientation() == TopAbs_REVERSED) {
+				// d1 = -d1;
+				// }
+				// if (fabs(d1.Z()) < 0.5) {
+				// d2 = d1.Crossed(gp::DZ());
+				// } else {
+				// d2 = d1.Crossed(gp::DY());
+				// }
+				// d3 = d1.XYZ() + d2.XYZ();
+				// d4 = d1.XYZ() - d2.XYZ();
+				// p2 = p - d3.XYZ() / 10.;
+				// p3 = p - d4.XYZ() / 10.;
+				// trsf.Transforms(p2);
+				// trsf.Transforms(p3);
+				// _material_ids.push_back(surface_style_id);
+				// _material_ids.push_back(surface_style_id);
+				// _verts.push_back(static_cast<P>(p2.X()));
+				// _verts.push_back(static_cast<P>(p2.Y()));
+				// _verts.push_back(static_cast<P>(p2.Z()));
+				// _verts.push_back(static_cast<P>(p3.X()));
+				// _verts.push_back(static_cast<P>(p3.Y()));
+				// _verts.push_back(static_cast<P>(p3.Z()));
+
+				trsf.Transforms(p);
+
+				t->material_ids().push_back(surface_style_id);
+
+				t->verts().push_back(static_cast<double>(p.X()));
+				t->verts().push_back(static_cast<double>(p.Y()));
+				t->verts().push_back(static_cast<double>(p.Z()));
+
+				if (i > 1) {
+					t->edges().push_back(start + i - 2);
+					t->edges().push_back(start + i - 1);
+					// _edges.push_back(start + 3 * (i - 2) + 2);
+					// _edges.push_back(start + 3 * (i - 1) + 2);
+				}
+
+				// _edges.push_back(start + 3 * (i - 1) + 0);
+				// _edges.push_back(start + 3 * (i - 1) + 2);
+				// _edges.push_back(start + 3 * (i - 1) + 1);
+				// _edges.push_back(start + 3 * (i - 1) + 2);
+			}
+		}
+	}
+
+	*/
+
+	BRepTools::Clean(shape_);
+}
+
+int ifcopenshell::geometry::OpenCascadeShape::surface_genus() const {
+	throw std::runtime_error("Not implemented");
+}
+
+bool ifcopenshell::geometry::OpenCascadeShape::is_manifold() const {
+	throw std::runtime_error("Not implemented");
+}