Update README

# Conflicts:
#	cmake/CMakeLists.txt
#	src/ifcconvert/IfcConvert.cpp
#	src/ifcgeom/IfcGeomRepresentation.h
#	src/ifcgeom/IfcRepresentationShapeItem.h
#	src/ifcgeom/kernels/opencascade/IfcGeomFunctions.cpp
#	src/ifcgeom/schema_agnostic/IfcGeomRepresentation.cpp
#	src/ifcgeom/schema_agnostic/Kernel.cpp
#	src/ifcgeom/schema_agnostic/Kernel.h
#	src/ifcgeomserver/IfcGeomServer.cpp
#	src/serializers/schema_dependent/XmlSerializer.cpp

.gitignore

@@ -12,3 +12,5 @@ __pycache__
 .vscode
 # PyCharm files
 .idea
+# OSX files
+.DS_Store

README.md

@@ -1,3 +1,10 @@
+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 
 ============
 IfcOpenShell is an open source ([LGPL]) software library for working with the Industry Foundation Classes ([IFC]) 

cmake/CMakeLists.txt

@@ -42,6 +42,9 @@ 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)
@@ -111,6 +114,15 @@ 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)
@@ -140,8 +152,10 @@ ENDMACRO()
 # 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_STATIC_RUNTIME 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
@@ -154,20 +168,29 @@ ELSE()
 ENDIF()
 
 set(BOOST_COMPONENTS system program_options regex thread date_time)
-if(USE_MMAP)
+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()
-    add_definitions(-DUSE_MMAP)
+	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}")
@@ -255,6 +278,61 @@ foreach(lib ${OPENCASCADE_LIBRARY_NAMES})
 	list(APPEND OPENCASCADE_LIBRARIES "${lib_path}")
 endforeach()
 
+list(APPEND GEOMETRY_KERNELS opencascade)
+
+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()
+	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("${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()
+	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()
+
+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()
+
 if(MSVC)
     add_definitions(-DHAVE_NO_DLL)
     add_debug_variants(OPENCASCADE_LIBRARIES "${OPENCASCADE_LIBRARIES}" d)
@@ -274,7 +352,7 @@ endif()
 if(OCCT_STATIC)
     find_package(Threads)
     # OPENCASCADE_LIBRARIES repeated three times below in order to fix cyclic dependencies - use --start-group ... --end-group instead?
-    set(OPENCASCADE_LIBRARIES ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+    set(OPENCASCADE_LIBRARIES -Wl,--start-group ${OPENCASCADE_LIBRARIES} -Wl,--end-group ${CMAKE_THREAD_LIBS_INIT})
     if (NOT APPLE AND NOT WIN32)
         set(OPENCASCADE_LIBRARIES ${OPENCASCADE_LIBRARIES} "rt")
     endif()
@@ -412,22 +490,25 @@ IF(MSVC)
 	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))
-        add_definitions(-permissive-)
+		# @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()
-	# Link against the static VC runtime
-    # TODO Make this configurable
-	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()
 ElSE()
     add_definitions(-Wall -Wextra)
     if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
@@ -447,6 +528,7 @@ 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}
 )
 
 function(files_for_ifc_version IFC_VERSION RESULT_NAME)
@@ -526,15 +608,15 @@ endif()
 set(IFCOPENSHELL_LIBRARIES IfcParse)
 if (BUILD_IFCGEOM)
 	foreach(s ${SCHEMA_VERSIONS})
-		set(IFCGEOM_SCHEMA_LIBRARIES ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom_ifc${s})
+		set(IFCGEOM_SCHEMA_LIBRARIES ${IFCGEOM_SCHEMA_LIBRARIES} geometry_mapping_ifc${s})
 	endforeach()
-	set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES})
+	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})
+		set(SERIALIZER_SCHEMA_LIBRARIES ${SERIALIZER_SCHEMA_LIBRARIES} serializers_ifc${s})
 	endforeach()
-	set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} Serializers ${SERIALIZER_SCHEMA_LIBRARIES})
+	set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} serializers ${SERIALIZER_SCHEMA_LIBRARIES})
 endif()
 
 # IfcParse
@@ -549,36 +631,67 @@ TARGET_LINK_LIBRARIES(IfcParse ${Boost_LIBRARIES} ${BCRYPT_LIBRARIES} ${LIBXML2_
 
 if (BUILD_IFCGEOM)
 
-# IfcGeom
-file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/*.h)
-file(GLOB IFCGEOM_CPP_FILES ../src/ifcgeom/*.cpp)
+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})
 
-foreach(s ${SCHEMA_VERSIONS})
-	add_library(IfcGeom_ifc${s} STATIC ${IFCGEOM_FILES})
-	set_target_properties(IfcGeom_ifc${s} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIfcSchema=Ifc${s}")
-	TARGET_LINK_LIBRARIES(IfcGeom_ifc${s} IfcParse ${OPENCASCADE_LIBRARIES})
+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()
 
-# IfcGeom (schema agnostic)
-file(GLOB SCHEMA_AGNOSTIC_H_FILES ../src/ifcgeom_schema_agnostic/*.h)
-file(GLOB SCHEMA_AGNOSTIC_CPP_FILES ../src/ifcgeom_schema_agnostic/*.cpp)
+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(IfcGeom ${SCHEMA_AGNOSTIC_FILES})
-set_target_properties(IfcGeom PROPERTIES COMPILE_FLAGS -DIFC_GEOM_EXPORTS)
+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()
 
-TARGET_LINK_LIBRARIES(IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+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
+# 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})
@@ -587,15 +700,15 @@ 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})
+	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}")
+add_library(serializers ${SERIALIZERS_FILES})
+set_target_properties(serializers PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS ${CONVERT_PRECISION}")
 
-TARGET_LINK_LIBRARIES(Serializers ${SERIALIZER_SCHEMA_LIBRARIES})
+TARGET_LINK_LIBRARIES(serializers ${SERIALIZER_SCHEMA_LIBRARIES})
 
 # IfcConvert
 file(GLOB IFCCONVERT_CPP_FILES ../src/ifcconvert/*.cpp)
@@ -628,7 +741,7 @@ 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})
+TARGET_LINK_LIBRARIES(IfcGeomServer ${IFCOPENSHELL_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${Boost_LIBRARIES} ${VOXEL_LIBRARIES})
 
 if ((NOT WIN32) AND BUILD_SHARED_LIBS)
     SET_INSTALL_RPATHS(IfcGeomServer "${IFCOPENSHELL_LIBARY_DIR};${OCC_LIBRARY_DIR};${Boost_LIBRARY_DIRS}")
@@ -671,10 +784,10 @@ INSTALL(FILES ${IFCGEOM_H_FILES}
 )
 
 INSTALL(FILES  ${SCHEMA_AGNOSTIC_H_FILES} 
-	DESTINATION ${INCLUDEDIR}/ifcgeom_schema_agnostic
+	DESTINATION ${INCLUDEDIR}/ifcgeom/schema_agnostic
 )
 
-INSTALL(TARGETS ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom
+INSTALL(TARGETS IfcGeom ${IfcGeom_libraries}
 	ARCHIVE DESTINATION ${LIBDIR}
 	LIBRARY DESTINATION ${LIBDIR}
 	RUNTIME DESTINATION ${BINDIR}
@@ -682,7 +795,7 @@ INSTALL(TARGETS ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom
 endif()
 
 if(BUILD_CONVERT)
-INSTALL(TARGETS Serializers ${SERIALIZER_SCHEMA_LIBRARIES}
+INSTALL(TARGETS serializers ${SERIALIZER_SCHEMA_LIBRARIES}
 	ARCHIVE DESTINATION ${LIBDIR}
 	LIBRARY DESTINATION ${LIBDIR}
 	RUNTIME DESTINATION ${BINDIR}

nix/build-all.py

@@ -84,7 +84,7 @@ OCE_VERSION="0.18"
 # OCCT_VERSION="7.2.0"
 # OCCT_HASH="88af392"
 OCCT_VERSION="7.3.0p3"
-BOOST_VERSION="1.59.0"
+BOOST_VERSION="1.69.0"
 #PCRE_VERSION="8.39"
 PCRE_VERSION="8.41"
 #LIBXML2_VERSION="2.9.3"
@@ -95,8 +95,9 @@ SWIG_VERSION="3.0.12"
 #SWIG_VERSION="4.0.0"
 #OPENCOLLADA_VERSION="v1.6.63"
 OPENCOLLADA_VERSION="v1.6.68"
-
-
+GMP_VERSION="6.1.2"
+MPFR_VERSION="3.1.5"
+CGAL_VERSION="4.13"
 
 # binaries
 cp="cp"
@@ -216,17 +217,19 @@ cecho(""" - How many compiler processes may be run in parallel.
 
 dependency_tree = {
     'IfcParse': ('boost',  'libxml2'),
-    'IfcGeom': ('IfcParse',  'occ'),
+    'IfcGeom': ('IfcParse',  'occ',  'cgal', 'voxel'),
     'IfcConvert': ('IfcGeom',  'OpenCOLLADA', 'json'),
     'OpenCOLLADA': ('libxml2',  'pcre'),
-    'IfcGeomServer': ('IfcGeom',),
+    'IfcGeomServer': ('IfcGeom', ),
     'IfcOpenShell-Python': ('python',  'swig',  'IfcGeom'),
+    'voxel': ('occ',),
     'swig': ('pcre',),
     'boost': (),
     'libxml2': (),
     'python': (),
     'swig': (),
     'occ': (),
+    'cgal': (),
     'pcre': (),
     'json': ()
 }
@@ -257,7 +260,7 @@ 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"]:
+for cmd in [git, bunzip2, tar, cc, cplusplus, autoconf, automake, yacc, make, "patch", "m4"]:
     if which(cmd) is None:
         raise ValueError("Required tool '%s' not installed or not added to PATH" % (cmd,))
 
@@ -310,10 +313,14 @@ BOOST_LOCATION="http://downloads.sourceforge.net/project/boost/boost/%s/boost_%s
 
 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" % (os.path.realpath("%s/install/%s" % (DEPS_DIR, arg1)),)], cwd=cwd)
+    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:
@@ -547,6 +554,8 @@ if USE_OCCT and "occ" in targets:
         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()),
@@ -563,6 +572,9 @@ elif "occ" in targets:
         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(
@@ -656,6 +668,34 @@ if "boost" in targets:
         download_name="boost_{BOOST_VERSION_UNDERSCORE}.tar.bz2".format(**locals())
     )
     
+if "cgal" in targets:
+    build_dependency(name="gmp-%s" % (GMP_VERSION,), mode="autoconf", build_tool_args=["--disable-shared", "--with-pic"], download_url="https://ftp.gnu.org/gnu/gmp/", download_name="gmp-%s.tar.bz2" % (GMP_VERSION,))
+    build_dependency(name="mpfr-%s" % (MPFR_VERSION,), mode="autoconf", build_tool_args=["--disable-shared", "--with-gmp=%s/install/gmp-%s" % (DEPS_DIR, GMP_VERSION)], download_url="http://www.mpfr.org/mpfr-%s/" % (MPFR_VERSION,), download_name="mpfr-%s.tar.bz2" % (MPFR_VERSION,))
+    
+    OLD_BUILD_CFG = BUILD_CFG
+    if BUILD_CFG != "Debug":
+        # CGAL only supports Debug and Release for CMAKE_BUILD_TYPE
+        BUILD_CFG = "Release"
+    build_dependency(name="cgal-{CGAL_VERSION}".format(**locals()), mode="cmake", build_tool_args=["-DGMP_LIBRARIES=%s/install/gmp-%s/lib/libgmp.a" % (DEPS_DIR, GMP_VERSION), "-DGMP_INCLUDE_DIR=%s/install/gmp-%s/include" % (DEPS_DIR, GMP_VERSION), "-DMPFR_LIBRARIES=%s/install/mpfr-%s/lib/libmpfr.a" % (DEPS_DIR, MPFR_VERSION), "-DMPFR_INCLUDE_DIR=%s/install/mpfr-%s/include" % (DEPS_DIR, MPFR_VERSION), "-DBoost_INCLUDE_DIR=%s/install/boost-%s" % (DEPS_DIR, BOOST_VERSION), "-DCMAKE_INSTALL_PREFIX=%s/install/cgal-%s/" % (DEPS_DIR, CGAL_VERSION), "-DBUILD_SHARED_LIBS=Off"], download_url="https://github.com/CGAL/cgal.git", download_name="cgal", download_tool=download_tool_git, revision="releases/CGAL-{CGAL_VERSION}".format(**locals()))
+    BUILD_CFG = OLD_BUILD_CFG
+    
+if "voxel" in targets:
+    build_dependency(
+        "voxel",
+        "cmake",
+        build_tool_args=[
+            "-DIFC_SUPPORT=Off",
+            "-DOCC_INCLUDE_DIR="    +occ_include_dir,
+            "-DOCC_LIBRARY_DIR="    +occ_library_dir,
+            "-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/voxel".format(**locals()),
+            "-DBOOST_ROOT="        "{DEPS_DIR}/install/boost-{BOOST_VERSION}".format(**locals())
+        ],
+        download_url="https://github.com/opensourceBIM/voxel.git",
+        download_name="voxel",
+        download_tool=download_tool_git,
+        revision="master"
+    )
+
 cecho("Building IfcOpenShell:", GREEN)
 
 IFCOS_DIR=os.path.join(DEPS_DIR, "build", "ifcopenshell")
@@ -685,21 +725,27 @@ cmake_args=[
     "-DJSON_INCLUDE_DIR="              "{DEPS_DIR}/install/json".format(**locals())
 ]
 
-if "occ" in targets and USE_OCCT:
-    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())
+if "occ" in targets:
     cmake_args.extend([
         "-DOCC_INCLUDE_DIR="           +occ_include_dir,
         "-DOCC_LIBRARY_DIR="           +occ_library_dir
     ])
 elif "occ" in targets:
-    occ_include_dir =                  "{DEPS_DIR}/install/oce-{OCE_VERSION}/include/oce".format(**locals())
-    occ_library_dir =                  "{DEPS_DIR}/install/oce-{OCE_VERSION}/lib"
     cmake_args.extend([
         "-DOCC_INCLUDE_DIR="           +occ_include_dir,
         "-DOCC_LIBRARY_DIR="           +occ_library_dir
     ])
 
+if "cgal" in targets:
+    cmake_args.extend([
+        "-DCGAL_INCLUDE_DIR="          "{DEPS_DIR}/install/cgal-{CGAL_VERSION}/include".format(**locals()),
+        "-DCGAL_LIBRARY_DIR="          "{DEPS_DIR}/install/cgal-{CGAL_VERSION}/lib".format(**locals()),
+        "-DGMP_INCLUDE_DIR="           "{DEPS_DIR}/install/gmp-{GMP_VERSION}/include".format(**locals()),
+        "-DGMP_LIBRARY_DIR="           "{DEPS_DIR}/install/gmp-{GMP_VERSION}/lib".format(**locals()),
+        "-DMPFR_INCLUDE_DIR="          "{DEPS_DIR}/install/mpfr-{MPFR_VERSION}/include".format(**locals()),
+        "-DMPFR_LIBRARY_DIR="          "{DEPS_DIR}/install/mpfr-{MPFR_VERSION}/lib".format(**locals())
+    ])
+
 if "OpenCOLLADA" in targets:
     cmake_args.extend([
         "-DOPENCOLLADA_INCLUDE_DIR="   "{DEPS_DIR}/install/OpenCOLLADA/include/opencollada".format(**locals()),

src/examples/IfcAdvancedHouse.cpp

@@ -38,18 +38,13 @@
 
 #include <Standard_Version.hxx>
 
-#ifdef USE_IFC4
-#include "../ifcparse/Ifc4.h"
-#define IfcSchema Ifc4
-#else
-#include "../ifcparse/Ifc2x3.h"
 #define IfcSchema Ifc2x3
-#endif
-
+#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"
+
+#include "../ifcgeom/schema_agnostic/Serialization.h"
 
 #if USE_VLD
 #include <vld.h>

src/examples/IfcOpenHouse.cpp

@@ -33,18 +33,15 @@
 #include <BRepGProp.hxx>
 #include <GProp_GProps.hxx>
 
-#ifdef USE_IFC4
-#include "../ifcparse/Ifc4.h"
-#define IfcSchema Ifc4
-#else
-#include "../ifcparse/Ifc2x3.h"
-#define IfcSchema Ifc2x3
-#endif
+#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"
+
+#include "../ifcgeom/schema_agnostic/Serialization.h"
 
 #if USE_VLD
 #include <vld.h>

src/ifcconvert/IfcConvert.cpp

@@ -34,9 +34,9 @@
 #include "../serializers/XmlSerializer.h"
 #include "../serializers/SvgSerializer.h"
 
-#include "../ifcgeom_schema_agnostic/IfcGeomFilter.h"
-#include "../ifcgeom_schema_agnostic/IfcGeomIterator.h"
-#include "../ifcgeom_schema_agnostic/IfcGeomRenderStyles.h"
+#include "../ifcgeom/schema_agnostic/IfcGeomFilter.h"
+#include "../ifcgeom/schema_agnostic/IfcGeomIterator.h"
+#include "../ifcgeom/schema_agnostic/IfcGeomRenderStyles.h"
 
 #include "../ifcparse/utils.h"
 
@@ -143,8 +143,13 @@ bool file_exists(const std::string& filename) {
 static std::basic_stringstream<path_t::value_type> log_stream;
 void write_log(bool);
 void fix_quantities(IfcParse::IfcFile&, bool, bool, bool);
+void fix_spaceboundaries(IfcParse::IfcFile&, bool, bool, bool);
+void fix_storeycontainment(IfcParse::IfcFile&, bool, bool, bool);
+void fix_wallconnectivity(IfcParse::IfcFile&, bool, bool, bool);
+
 std::string format_duration(time_t start, time_t end);
 
+
 /// @todo make the filters non-global
 IfcGeom::entity_filter entity_filter; // Entity filter is used always by default.
 IfcGeom::layer_filter layer_filter;
@@ -194,6 +199,7 @@ int main(int argc, char** argv) {
 	exclusion_traverse_filter exclude_traverse_filter;
 	path_t filter_filename;
 	path_t default_material_filename;
+	std::string geometry_kernel;
 	std::string log_format;
 
     po::options_description generic_options("Command line options");
@@ -214,16 +220,22 @@ int main(int argc, char** argv) {
 #endif
 		("input-file", new po::typed_value<path_t, char_t>(0), "input IFC file")
 		("output-file", new po::typed_value<path_t, char_t>(0), "output geometry file");
-	
+		
 	po::options_description ifc_options("IFC options");
 	ifc_options.add_options()
 		("calculate-quantities", "Calculate or fix the physical quantity definitions "
-			"based on an interpretation of the geometry when exporting IFC");
+			"based on an interpretation of the geometry when exporting IFC")
+		("fix-space-boundaries", "Calculate or fix space boundary geometries "
+			"when exporting IFC")
+		("fix-storey-containment", "Calculate or fix containment in building storeys")
+		("fix-wall-connectivity", "Calculate or fix wall connectivity relationships");
 
 	int num_threads;
     
 	po::options_description geom_options("Geometry options");
 	geom_options.add_options()
+		("kernel", po::value<std::string>(&geometry_kernel)->default_value("opencascade"), 
+			"Geometry kernel to use (opencascade or cgal).")
 		("threads,j", po::value<int>(&num_threads)->default_value(1),
 			"Number of parallel processing threads for geometry interpretation.")
 		("plan",
@@ -574,6 +586,15 @@ int main(int argc, char** argv) {
 					if (vmap.count("calculate-quantities")) {
 						fix_quantities(*ifc_file, no_progress, quiet, stderr_progress);
 					}
+					if (vmap.count("fix-space-boundaries")) {
+						fix_spaceboundaries(*ifc_file, no_progress, quiet, stderr_progress);
+					}
+					if (vmap.count("fix-storey-containment")) {
+						fix_storeycontainment(*ifc_file, no_progress, quiet, stderr_progress);
+					}
+					if (vmap.count("fix-wall-connectivity")) {
+						fix_wallconnectivity(*ifc_file, no_progress, quiet, stderr_progress);
+					}
 					fs << *ifc_file;
 					exit_code = EXIT_SUCCESS;
 				} else {
@@ -630,24 +651,24 @@ int main(int argc, char** argv) {
 
 	SerializerSettings settings;
 	/// @todo Make APPLY_DEFAULT_MATERIALS configurable? Quickly tested setting this to false and using obj exporter caused the program to crash and burn.
-	settings.set(IfcGeom::IteratorSettings::APPLY_DEFAULT_MATERIALS,      true);
-	settings.set(IfcGeom::IteratorSettings::USE_WORLD_COORDS,             use_world_coords || output_extension == SVG || output_extension == OBJ);
-	settings.set(IfcGeom::IteratorSettings::WELD_VERTICES,                weld_vertices);
-	settings.set(IfcGeom::IteratorSettings::SEW_SHELLS,                   orient_shells);
-	settings.set(IfcGeom::IteratorSettings::CONVERT_BACK_UNITS,           convert_back_units);
+	settings.set(ifcopenshell::geometry::settings::APPLY_DEFAULT_MATERIALS,      true);
+	settings.set(ifcopenshell::geometry::settings::USE_WORLD_COORDS,             use_world_coords || output_extension == SVG || output_extension == OBJ);
+	settings.set(ifcopenshell::geometry::settings::WELD_VERTICES,                weld_vertices);
+	settings.set(ifcopenshell::geometry::settings::SEW_SHELLS,                   orient_shells);
+	settings.set(ifcopenshell::geometry::settings::CONVERT_BACK_UNITS,           convert_back_units);
 #if OCC_VERSION_HEX < 0x60900
-	settings.set(IfcGeom::IteratorSettings::FASTER_BOOLEANS,              merge_boolean_operands);
+	settings.set(ifcopenshell::geometry::settings::FASTER_BOOLEANS,              merge_boolean_operands);
 #endif
-	settings.set(IfcGeom::IteratorSettings::DISABLE_OPENING_SUBTRACTIONS, disable_opening_subtractions);
-	settings.set(IfcGeom::IteratorSettings::INCLUDE_CURVES,               include_plan);
-	settings.set(IfcGeom::IteratorSettings::EXCLUDE_SOLIDS_AND_SURFACES,  !include_model);
-	settings.set(IfcGeom::IteratorSettings::APPLY_LAYERSETS,              enable_layerset_slicing);
-    settings.set(IfcGeom::IteratorSettings::NO_NORMALS, no_normals);
-    settings.set(IfcGeom::IteratorSettings::GENERATE_UVS, generate_uvs);
-	settings.set(IfcGeom::IteratorSettings::SEARCH_FLOOR, use_element_hierarchy || output_extension == SVG);
-	settings.set(IfcGeom::IteratorSettings::SITE_LOCAL_PLACEMENT, site_local_placement);
-	settings.set(IfcGeom::IteratorSettings::BUILDING_LOCAL_PLACEMENT, building_local_placement);
-	settings.set(IfcGeom::IteratorSettings::VALIDATE_QUANTITIES, validate);
+	settings.set(ifcopenshell::geometry::settings::DISABLE_OPENING_SUBTRACTIONS, disable_opening_subtractions);
+	settings.set(ifcopenshell::geometry::settings::INCLUDE_CURVES,               include_plan);
+	settings.set(ifcopenshell::geometry::settings::EXCLUDE_SOLIDS_AND_SURFACES,  !include_model);
+	settings.set(ifcopenshell::geometry::settings::APPLY_LAYERSETS,              enable_layerset_slicing);
+    settings.set(ifcopenshell::geometry::settings::NO_NORMALS, no_normals);
+    settings.set(ifcopenshell::geometry::settings::GENERATE_UVS, generate_uvs);
+	settings.set(ifcopenshell::geometry::settings::SEARCH_FLOOR, use_element_hierarchy || output_extension == SVG);
+	settings.set(ifcopenshell::geometry::settings::SITE_LOCAL_PLACEMENT, site_local_placement);
+	settings.set(ifcopenshell::geometry::settings::BUILDING_LOCAL_PLACEMENT, building_local_placement);
+	settings.set(ifcopenshell::geometry::settings::VALIDATE_QUANTITIES, validate);
 
     settings.set(SerializerSettings::USE_ELEMENT_NAMES, use_element_names);
     settings.set(SerializerSettings::USE_ELEMENT_GUIDS, use_element_guids);
@@ -679,7 +700,7 @@ int main(int argc, char** argv) {
 #endif
 		serializer = boost::make_shared<IgesSerializer>(IfcUtil::path::to_utf8(output_temp_filename), settings);
 	} else if (output_extension == SVG) {
-		settings.set(IfcGeom::IteratorSettings::DISABLE_TRIANGULATION, true);
+		settings.set(ifcopenshell::geometry::settings::DISABLE_TRIANGULATION, true);
 		serializer = boost::make_shared<SvgSerializer>(IfcUtil::path::to_utf8(output_temp_filename), settings);
 		if (vmap.count("section-height") != 0) {
 			Logger::Notice("Overriding section height");
@@ -716,7 +737,7 @@ int main(int argc, char** argv) {
             Logger::Notice("Centering/offsetting model setting ignored when writing non-tesselated output");
         }
 
-        settings.set(IfcGeom::IteratorSettings::DISABLE_TRIANGULATION, true);
+        settings.set(ifcopenshell::geometry::settings::DISABLE_TRIANGULATION, true);
 	}
 
 	if (!serializer->ready()) {
@@ -746,7 +767,7 @@ int main(int argc, char** argv) {
 
 	Logger::SetOutput(quiet ? nullptr : &cout_, &log_stream);
 
-	IfcGeom::Iterator<real_t> context_iterator(settings, ifc_file, filter_funcs, num_threads);
+    ifcopenshell::geometry::Iterator context_iterator(geometry_kernel, settings, ifc_file, filter_funcs, num_threads);
     if (!context_iterator.initialize()) {
         /// @todo It would be nice to know and print separate error prints for a case where we found no entities
         /// and for a case we found no entities that satisfy our filtering criteria.
@@ -810,7 +831,7 @@ int main(int argc, char** argv) {
 	// The functions IfcGeom::Iterator::get() and IfcGeom::Iterator::next() 
 	// wrap an iterator of all geometrical products in the Ifc file. 
 	// IfcGeom::Iterator::get() returns an IfcGeom::TriangulationElement or 
-	// -BRepElement pointer, based on current settings. (see IfcGeomIterator.h 
+	// -NativeElement pointer, based on current settings. (see IfcGeomIterator.h 
 	// for definition) IfcGeom::Iterator::next() is used to poll whether more 
 	// geometrical entities are available. None of these functions throw 
 	// exceptions, neither for parsing errors or geometrical errors. Upon 
@@ -820,15 +841,15 @@ int main(int argc, char** argv) {
 	size_t num_created = 0;
 	
 	do {
-        IfcGeom::Element<real_t> *geom_object = context_iterator.get();
+        ifcopenshell::geometry::Element* geom_object = context_iterator.get();
 
 		if (is_tesselated)
 		{
-			serializer->write(static_cast<const IfcGeom::TriangulationElement<real_t>*>(geom_object));
+			serializer->write(static_cast<const ifcopenshell::geometry::TriangulationElement*>(geom_object));
 		}
 		else
 		{
-			serializer->write(static_cast<const IfcGeom::BRepElement<real_t>*>(geom_object));
+			serializer->write(static_cast<const ifcopenshell::geometry::NativeElement*>(geom_object));
 		}
 
         if (!no_progress) {
@@ -925,14 +946,14 @@ void write_log(bool header) {
 }
 
 #include <boost/algorithm/string/predicate.hpp>
+#include <chrono>
 
 bool init_input_file(const std::string& filename, IfcParse::IfcFile*& ifc_file, bool no_progress, bool mmap) {
-    time_t start, end;
+	std::clock_t c_start = std::clock();
 
     // Prevent IfcFile::Init() prints by setting output to null temporarily
     if (no_progress) { Logger::SetOutput(NULL, &log_stream); }
 
-    time(&start);
 #ifdef USE_MMAP
 	ifc_file = new IfcParse::IfcFile(filename, mmap);
 #else
@@ -949,10 +970,15 @@ bool init_input_file(const std::string& filename, IfcParse::IfcFile*& ifc_file,
         Logger::Error("Unable to parse input file '" + filename + "'");
         return false;
     }
-    time(&end);
+
+	std::clock_t c_end = std::clock();
 
     if (no_progress) { Logger::SetOutput(&cout_, &log_stream); }
-    else {  Logger::Status("Parsing input file took " + format_duration(start, end)); }
+	else { 
+		std::stringstream ss;
+		ss << std::setprecision(14) << (c_end - c_start) / (double)CLOCKS_PER_SEC;
+		Logger::Status("total_ifc_parse_time " + ss.str()); 
+	}
 
     return true;
 
@@ -1216,14 +1242,14 @@ void fix_quantities(IfcParse::IfcFile& f, bool no_progress, bool quiet, bool std
 		}
 	}
 
-	IfcGeom::IteratorSettings settings;
-	settings.set(IfcGeom::IteratorSettings::USE_WORLD_COORDS, false);
-	settings.set(IfcGeom::IteratorSettings::WELD_VERTICES, false);
-	settings.set(IfcGeom::IteratorSettings::SEW_SHELLS, true);
-	settings.set(IfcGeom::IteratorSettings::CONVERT_BACK_UNITS, true);
-	settings.set(IfcGeom::IteratorSettings::DISABLE_TRIANGULATION, true);
+	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);
 
-	IfcGeom::Iterator<double> context_iterator(settings, &f);
+	ifcopenshell::geometry::Iterator context_iterator(settings, &f);
 
 	if (!context_iterator.initialize()) {
 		return;
@@ -1257,14 +1283,14 @@ void fix_quantities(IfcParse::IfcFile& f, bool no_progress, bool quiet, bool std
 
 	IfcUtil::IfcBaseClass* quantity = nullptr;
 	IfcEntityList::ptr objects;
-	boost::shared_ptr<IfcGeom::Representation::BRep> previous_geometry_pointer;
+	boost::shared_ptr<ifcopenshell::geometry::Representation::BRep> previous_geometry_pointer;
 
 	for (;; ++num_created) {
 		bool has_more = true;
 		if (num_created) {
 			has_more = context_iterator.next();
 		}
-		IfcGeom::BRepElement<double>* geom_object = nullptr;
+		ifcopenshell::geometry::NativeElement* geom_object = nullptr;
 		if (has_more) {
 			geom_object = context_iterator.get_native();
 		}
@@ -1317,7 +1343,7 @@ void fix_quantities(IfcParse::IfcFile& f, bool no_progress, bool quiet, bool std
 				auto quantity_count = latebound_access::create(f, "IfcQuantityCount");
 				latebound_access::set(quantity_count, "Name", std::string("Surface Genus"));
 				latebound_access::set(quantity_count, "Description", '#' + boost::lexical_cast<std::string>(part.ItemId()));
-				latebound_access::set(quantity_count, "CountValue", IfcGeom::Kernel::surface_genus(part.Shape()));
+				latebound_access::set(quantity_count, "CountValue", part.Shape()->surface_genus());
 
 				quantities_2->push(quantity_count);				
 			}

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.components * p3.components.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 auto& 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().components;
+			const auto& n = geom_object->transformation().data().components;
+
+			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.components * p0.components.homogeneous();
+					auto v1 = ((taxonomy::geom_item*)item)->matrix.components * p1.components.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](auto& 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,580 @@
+#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) {
+	T::NT min[3];
+	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 cube = ifcopenshell::geometry::utils::create_nef_polyhedron(ifcopenshell::geometry::utils::create_cube(eps));
+
+		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().components;
+				const auto& n = geom_object->transformation().data().components;
+
+				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(), [](auto& x, auto& 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/ifcgeom/IfcGeom.h

@@ -1,457 +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
-
-#include <cmath>
-
-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; 
-}
-
-#include <gp_Pnt.hxx>
-#include <gp_Vec.hxx>
-#include <gp_Mat.hxx>
-#include <gp_Mat2d.hxx>
-#include <gp_GTrsf.hxx>
-#include <gp_GTrsf2d.hxx>
-#include <gp_Trsf.hxx>
-#include <gp_Trsf2d.hxx>
-#include <TopoDS.hxx>
-#include <TopoDS_Wire.hxx>
-#include <TopoDS_Face.hxx>
-#include <Geom_Curve.hxx>
-#include <gp_Pln.hxx>
-#include <TColgp_SequenceOfPnt.hxx>
-#include <TopTools_ListOfShape.hxx>
-#include <BOPAlgo_Operation.hxx>
-#include <BRep_Builder.hxx>
-#include <BRepBuilderAPI_MakeEdge.hxx>
-
-#include "../ifcparse/macros.h"
-#include "../ifcparse/IfcParse.h"
-#include "../ifcparse/IfcBaseClass.h"
-
-#include "../ifcgeom/IfcGeomElement.h" 
-#include "../ifcgeom/IfcGeomRepresentation.h" 
-#include "../ifcgeom/IfcRepresentationShapeItem.h"
-#include "../ifcgeom/IfcGeomShapeType.h"
-
-#include "../ifcgeom_schema_agnostic/Kernel.h"
-
-#include "ifc_geom_api.h"
-
-// Define this in case you want to conserve memory usage at all cost. This has been
-// benchmarked extensively: https://github.com/IfcOpenShell/IfcOpenShell/pull/47
-// #define NO_CACHE
-
-#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->data().id());\
-if ( it != cache.T.end() ) { e = it->second; return true; }
-#define CACHE(T,E,e) cache.T[E->data().id()] = e;
-
-#endif
-
-#define INCLUDE_PARENT_DIR(x) STRINGIFY(../ifcparse/x.h)
-#include INCLUDE_PARENT_DIR(IfcSchema)
-#undef INCLUDE_PARENT_DIR
-#define INCLUDE_PARENT_DIR(x) STRINGIFY(../ifcparse/x-definitions.h)
-#include INCLUDE_PARENT_DIR(IfcSchema)
-
-namespace IfcGeom {
-	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") {}
-	};
-
-class IFC_GEOM_API MAKE_TYPE_NAME(Cache) {
-public:
-#include "IfcRegisterCreateCache.h"
-	std::map<int, TopoDS_Shape> Shape;
-};
-
-class IFC_GEOM_API MAKE_TYPE_NAME(Kernel) : public IfcGeom::Kernel {
-private:
-
-	/*
-	faceset_helper traverses the forward instance references of IfcConnectedFaceSet and then provides a mapping
-	M of (IfcCartesianPoint, IfcCartesianPoint) -> TopoDS_Edge, where M(a, b) is a partner of M(b, a), ie share
-	the same underlying edge but with orientation reversed. This then later speeds op the process of creating a
-	manifold Shell / Solid from this set of faces. Only IfcPolyLoop instances are used. Points within the tolerance
-	threshiold are merged, so consider points a, b, c, distance(a, b) < eps then M(a, b) = Null, M(a, b) = M(a, c).
-	*/
-	class faceset_helper {
-	private:
-		MAKE_TYPE_NAME(Kernel)* kernel_;
-		std::set<const IfcSchema::IfcPolyLoop*> duplicates_;
-		std::map<int, int> vertex_mapping_;
-		std::map<std::pair<int, int>, TopoDS_Edge> edges_;
-		double eps_;
-		bool non_manifold_;
-
-		template <typename Fn>
-		void loop_(IfcSchema::IfcCartesianPoint::list::ptr& ps, const Fn& callback) {
-			if (ps->size() < 3) {
-				return;
-			}
-
-			auto a = *(ps->end() - 1);
-			auto A = a->data().id();
-			for (auto& b : *ps) {
-				auto B = b->data().id();
-				auto C = vertex_mapping_[A], D = vertex_mapping_[B];
-				bool fwd = C < D;
-				if (!fwd) {
-					std::swap(C, D);
-				}
-				if (C != D) {
-					callback(C, D, fwd);
-					A = B;
-				}
-			}
-		}
-	public:
-		faceset_helper(MAKE_TYPE_NAME(Kernel)* kernel, const IfcSchema::IfcConnectedFaceSet* l);
-
-		~faceset_helper();
-
-		bool non_manifold() const { return non_manifold_; }
-		bool& non_manifold() { return non_manifold_; }
-
-		bool edge(const IfcSchema::IfcCartesianPoint* a, const IfcSchema::IfcCartesianPoint* b, TopoDS_Edge& e) {
-			int A = vertex_mapping_[a->data().id()];
-			int B = vertex_mapping_[b->data().id()];
-			if (A == B) {
-				return false;
-			}
-
-			return edge(A, B, e);
-		}
-
-		bool edge(int A, int B, TopoDS_Edge& e) {
-			auto it = edges_.find({A, B});
-			if (it == edges_.end()) {
-				return false;
-			}
-			e = it->second;
-			return true;
-		}
-
-		bool wire(const IfcSchema::IfcPolyLoop* loop, TopoDS_Wire& wire) {
-			if (duplicates_.find(loop) != duplicates_.end()) {
-				return false;
-			}
-			BRep_Builder builder;
-			builder.MakeWire(wire);
-			int count = 0;
-			auto ps = loop->Polygon();
-			loop_(ps, [this, &builder, &wire, &count](int A, int B, bool fwd) {
-				TopoDS_Edge e;
-				if (edge(A, B, e)) {
-					if (!fwd) {
-						e.Reverse();
-					}
-					builder.Add(wire, e);
-					count += 1;
-				}
-			});
-			if (count >= 3) {
-				wire.Closed(true);
-
-				TopTools_ListOfShape results;
-				if (kernel_->wire_intersections(wire, results)) {
-					Logger::Warning("Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected", loop);
-					kernel_->select_largest(results, wire);
-					non_manifold_ = true;
-				}
-
-				return true;
-			} else {
-				return false;
-			}
-		}
-
-		double epsilon() const {
-			return eps_;
-		}
-	};
-
-	double deflection_tolerance;
-	double ifc_length_unit;
-	double ifc_planeangle_unit;
-	double modelling_precision;
-	double dimensionality;
-	double max_faces_to_orient;
-
-#ifndef NO_CACHE
-	MAKE_TYPE_NAME(Cache) cache;
-#endif
-
-	std::map<int, SurfaceStyle> style_cache;
-
-	const SurfaceStyle* internalize_surface_style(const std::pair<IfcUtil::IfcBaseClass*, IfcUtil::IfcBaseClass*>& shading_style);
-
-	 // For stopping PlacementRelTo recursion in convert(const IfcSchema::IfcObjectPlacement* l, gp_Trsf& trsf)
-	const IfcParse::declaration* placement_rel_to;
-
-	faceset_helper* faceset_helper_;
-
-public:
-	MAKE_TYPE_NAME(Kernel)()
-		: IfcGeom::Kernel(0)
-		, deflection_tolerance(0.001)
-		, max_faces_to_orient(-1.0)
-		, ifc_length_unit(1.0)
-		, ifc_planeangle_unit(-1.0)
-		, modelling_precision(0.00001)
-		, dimensionality(1.)
-		, placement_rel_to(0)
-		, faceset_helper_(nullptr)
-	{}
-
-	MAKE_TYPE_NAME(Kernel)(const MAKE_TYPE_NAME(Kernel)& other) : IfcGeom::Kernel(0) {
-		*this = other;
-	}
-
-	MAKE_TYPE_NAME(Kernel)& operator=(const MAKE_TYPE_NAME(Kernel)& other) {
-		setValue(GV_DEFLECTION_TOLERANCE,     other.getValue(GV_DEFLECTION_TOLERANCE));
-		setValue(GV_MAX_FACES_TO_ORIENT,      other.getValue(GV_MAX_FACES_TO_ORIENT));
-		setValue(GV_LENGTH_UNIT,              other.getValue(GV_LENGTH_UNIT));
-		setValue(GV_PLANEANGLE_UNIT,          other.getValue(GV_PLANEANGLE_UNIT));
-		setValue(GV_PRECISION,                other.getValue(GV_PRECISION));
-		setValue(GV_DIMENSIONALITY,           other.getValue(GV_DIMENSIONALITY));
-		setValue(GV_DEFLECTION_TOLERANCE,     other.getValue(GV_DEFLECTION_TOLERANCE));
-		return *this;
-	}
-
-	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);
-	IfcGeom::ShapeType shape_type(const IfcUtil::IfcBaseClass* L);
-	bool convert_shape(const IfcUtil::IfcBaseClass* L, TopoDS_Shape& result);
-	bool flatten_shape_list(const IfcGeom::IfcRepresentationShapeItems& shapes, TopoDS_Shape& result, bool fuse);
-	bool convert_wire(const IfcUtil::IfcBaseClass* L, TopoDS_Wire& result);
-	bool convert_curve(const IfcUtil::IfcBaseClass* L, Handle(Geom_Curve)& result);
-	bool convert_face(const IfcUtil::IfcBaseClass* L, TopoDS_Shape& result);
-	bool convert_openings(const IfcSchema::IfcProduct* entity, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
-	bool convert_openings_fast(const IfcSchema::IfcProduct* entity, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
-	void assert_closed_wire(TopoDS_Wire& wire);
-
-	bool convert_layerset(const IfcSchema::IfcProduct*, std::vector<Handle_Geom_Surface>&, std::vector<const SurfaceStyle*>&, std::vector<double>&);
-	bool apply_layerset(const IfcRepresentationShapeItems&, const std::vector<Handle_Geom_Surface>&, const std::vector<const SurfaceStyle*>&, IfcRepresentationShapeItems&);
-	bool apply_folded_layerset(const IfcRepresentationShapeItems&, const std::vector< std::vector<Handle_Geom_Surface> >&, const std::vector<const SurfaceStyle*>&, IfcRepresentationShapeItems&);
-	bool fold_layers(const IfcSchema::IfcWall*, const IfcRepresentationShapeItems&, const std::vector<Handle_Geom_Surface>&, const std::vector<double>&, std::vector< std::vector<Handle_Geom_Surface> >&);
-
-	bool split_solid_by_surface(const TopoDS_Shape&, const Handle_Geom_Surface&, TopoDS_Shape&, TopoDS_Shape&);
-	bool split_solid_by_shell(const TopoDS_Shape&, const TopoDS_Shape& s, TopoDS_Shape&, TopoDS_Shape&);
-
-#if OCC_VERSION_HEX < 0x60900
-	bool boolean_operation(const TopoDS_Shape&, const TopTools_ListOfShape&, BOPAlgo_Operation, TopoDS_Shape&);
-	bool boolean_operation(const TopoDS_Shape&, const TopoDS_Shape&, BOPAlgo_Operation, TopoDS_Shape&);
-#else
-	bool boolean_operation(const TopoDS_Shape&, const TopTools_ListOfShape&, BOPAlgo_Operation, TopoDS_Shape&, double fuzziness = -1.);
-	bool boolean_operation(const TopoDS_Shape&, const TopoDS_Shape&, BOPAlgo_Operation, TopoDS_Shape&, double fuzziness = -1.);
-#endif
-
-	bool fit_halfspace(const TopoDS_Shape& a, const TopoDS_Shape& b, TopoDS_Shape& box, double& height);
-
-	const Handle_Geom_Curve intersect(const Handle_Geom_Surface&, const Handle_Geom_Surface&);
-	const Handle_Geom_Curve intersect(const Handle_Geom_Surface&, const TopoDS_Face&);
-	const Handle_Geom_Curve intersect(const TopoDS_Face&, const Handle_Geom_Surface&);
-	bool intersect(const Handle_Geom_Curve&, const Handle_Geom_Surface&, gp_Pnt&);
-	bool intersect(const Handle_Geom_Curve&, const TopoDS_Face&, gp_Pnt&);
-	bool intersect(const Handle_Geom_Curve&, const TopoDS_Shape&, std::vector<gp_Pnt>&);
-	bool intersect(const Handle_Geom_Surface&, const TopoDS_Shape&, std::vector< std::pair<Handle_Geom_Surface, Handle_Geom_Curve> >&);
-	bool closest(const gp_Pnt&, const std::vector<gp_Pnt>&, gp_Pnt&);
-	bool project(const Handle_Geom_Curve&, const gp_Pnt&, gp_Pnt& p, double& u, double& d);
-	bool project(const Handle_Geom_Surface&, const TopoDS_Shape&, double& u1, double& v1, double& u2, double& v2, double widen=0.1);
-	
-	bool find_wall_end_points(const IfcSchema::IfcWall*, gp_Pnt& start, gp_Pnt& end);
-
-	IfcSchema::IfcSurfaceStyleShading* get_surface_style(IfcSchema::IfcRepresentationItem* item);
-	const IfcSchema::IfcRepresentationItem* find_item_carrying_style(const IfcSchema::IfcRepresentationItem* item);
-	bool create_solid_from_compound(const TopoDS_Shape& compound, TopoDS_Shape& solid);
-	bool create_solid_from_faces(const TopTools_ListOfShape& face_list, 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); 
-	void apply_tolerance(TopoDS_Shape& s, double t);
-	bool fill_nonmanifold_wires_with_planar_faces(TopoDS_Shape& shape);
-	void remove_duplicate_points_from_loop(TColgp_SequenceOfPnt& polygon, bool closed, double tol=-1.);
-	void remove_collinear_points_from_loop(TColgp_SequenceOfPnt& polygon, bool closed, double tol=-1.);
-	bool wire_to_sequence_of_point(const TopoDS_Wire&, TColgp_SequenceOfPnt&);
-	void sequence_of_point_to_wire(const TColgp_SequenceOfPnt&, TopoDS_Wire&, bool closed);
-	bool approximate_plane_through_wire(const TopoDS_Wire&, gp_Pln&, double eps=-1.);
-	bool flatten_wire(TopoDS_Wire&);
-	/// Triangulate the set of wires. The firstmost wire is assumed to be the outer wire.
-	bool triangulate_wire(const std::vector<TopoDS_Wire>&, TopTools_ListOfShape&);
-	bool wire_intersections(const TopoDS_Wire & wire, TopTools_ListOfShape & wires);
-	void select_largest(const TopTools_ListOfShape& shapes, TopoDS_Shape& largest);
-
-	static double shape_volume(const TopoDS_Shape& s);
-	static double face_area(const TopoDS_Face& f);
-
-	static TopoDS_Shape apply_transformation(const TopoDS_Shape&, const gp_Trsf&);
-	static TopoDS_Shape apply_transformation(const TopoDS_Shape&, const gp_GTrsf&);
-	
-	bool is_identity_transform(IfcUtil::IfcBaseClass*);
-
-	IfcSchema::IfcRelVoidsElement::list::ptr find_openings(IfcSchema::IfcProduct* product);
-
-	IfcSchema::IfcRepresentation* find_representation(const IfcSchema::IfcProduct*, const std::string&);
-
-	std::pair<std::string, double> initializeUnits(IfcSchema::IfcUnitAssignment*);
-
-    template <typename P, typename PP>
-    IfcGeom::BRepElement<P, PP>* create_brep_for_representation_and_product(
-        const IteratorSettings&, IfcSchema::IfcRepresentation*, IfcSchema::IfcProduct*);
-
-	template <typename P, typename PP>
-    IfcGeom::BRepElement<P, PP>* create_brep_for_processed_representation(
-        const IteratorSettings&, IfcSchema::IfcRepresentation*, IfcSchema::IfcProduct*, IfcGeom::BRepElement<P, PP>*);
-
-	const IfcSchema::IfcMaterial* get_single_material_association(const IfcSchema::IfcProduct*);
-	IfcSchema::IfcRepresentation* representation_mapped_to(const IfcSchema::IfcRepresentation* representation);
-	IfcSchema::IfcProduct::list::ptr products_represented_by(const IfcSchema::IfcRepresentation*);
-	const SurfaceStyle* get_style(const IfcSchema::IfcRepresentationItem*);
-	const SurfaceStyle* get_style(const IfcSchema::IfcMaterial*);
-	
-	template <typename T> std::pair<IfcSchema::IfcSurfaceStyle*, T*> _get_surface_style(const IfcSchema::IfcStyledItem* si) {
-#ifdef SCHEMA_HAS_IfcStyleAssignmentSelect
-		IfcEntityList::ptr style_assignments = si->Styles();
-		for (IfcEntityList::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
-			if (!(*kt)->declaration().is(IfcSchema::IfcPresentationStyleAssignment::Class())) {
-				continue;
-			}
-			IfcSchema::IfcPresentationStyleAssignment* style_assignment = (IfcSchema::IfcPresentationStyleAssignment*) *kt;
-#else
-		IfcSchema::IfcPresentationStyleAssignment::list::ptr style_assignments = si->Styles();
-		for (IfcSchema::IfcPresentationStyleAssignment::list::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
-			IfcSchema::IfcPresentationStyleAssignment* style_assignment = *kt;
-#endif
-			IfcEntityList::ptr styles = style_assignment->Styles();
-			for (IfcEntityList::it lt = styles->begin(); lt != styles->end(); ++lt) {
-				IfcUtil::IfcBaseClass* style = *lt;
-				if (style->declaration().is(IfcSchema::IfcSurfaceStyle::Class())) {
-					IfcSchema::IfcSurfaceStyle* surface_style = (IfcSchema::IfcSurfaceStyle*) style;
-					if (surface_style->Side() != IfcSchema::IfcSurfaceSide::IfcSurfaceSide_NEGATIVE) {
-						IfcEntityList::ptr styles_elements = surface_style->Styles();
-						for (IfcEntityList::it mt = styles_elements->begin(); mt != styles_elements->end(); ++mt) {
-							if ((*mt)->declaration().is(T::Class())) {
-								return std::make_pair(surface_style, (T*) *mt);
-							}
-						}
-					}
-				}
-			}
-		}
-
-		return std::make_pair<IfcSchema::IfcSurfaceStyle*, T*>(0,0);
-	}
-
-	template <typename T> std::pair<IfcSchema::IfcSurfaceStyle*, T*> get_surface_style(const IfcSchema::IfcRepresentationItem* representation_item) {
-  		// For certain representation items, most notably boolean operands,
-		// a style definition might reside on one of its operands.
-		representation_item = find_item_carrying_style(representation_item);
-
-		if (representation_item->as<IfcSchema::IfcStyledItem>()) {
-			return _get_surface_style<T>(representation_item->as<IfcSchema::IfcStyledItem>());
-		}
-		IfcSchema::IfcStyledItem::list::ptr styled_items = representation_item->StyledByItem();
-		if (styled_items->size()) {
-			// StyledByItem is a SET [0:1] OF IfcStyledItem, so we return after the first IfcStyledItem:
-			return _get_surface_style<T>(*styled_items->begin());
-		}
-		return std::make_pair<IfcSchema::IfcSurfaceStyle*, T*>(0,0);
-	}
-
-	void purge_cache() { 
-		// Rather hack-ish, but a stopgap solution to keep memory under control
-		// for large files. SurfaceStyles need to be kept at all costs, as they
-		// are read later on when serializing Collada files.
-#ifndef NO_CACHE
-		cache = MAKE_TYPE_NAME(Cache)();
-#endif
-	}
-
-	void set_conversion_placement_rel_to(const IfcParse::declaration* type);
-
-#include "IfcRegisterGeomHeader.h"
-
-	virtual void setValue(GeomValue var, double value);
-	virtual double getValue(GeomValue var) const;
-
-	virtual IfcGeom::BRepElement<double>* convert(
-		const IteratorSettings& settings, IfcUtil::IfcBaseClass* representation,
-		IfcUtil::IfcBaseClass* product)
-	{
-		return create_brep_for_representation_and_product<double, double>(settings, (IfcSchema::IfcRepresentation*) representation, (IfcSchema::IfcProduct*) product);
-	}
-
-	virtual IfcRepresentationShapeItems convert(IfcUtil::IfcBaseClass* item) {
-		IfcRepresentationShapeItems items;
-		bool success = convert_shapes(item, items);
-		if (!success) {
-			throw IfcParse::IfcException("Failed to process representation item");
-		}
-		return items;
-	}
-
-	virtual bool convert_placement(IfcUtil::IfcBaseClass* item, gp_Trsf& trsf) {
-		if (item->as<IfcSchema::IfcObjectPlacement>()) {
-			return convert(item->as<IfcSchema::IfcObjectPlacement>(), trsf);
-		} else {
-			return false;
-		}
-	}
-
-};
-
-IfcUtil::IfcBaseClass* MAKE_TYPE_NAME(tesselate_)(const TopoDS_Shape& shape, double deflection);
-IfcUtil::IfcBaseClass* MAKE_TYPE_NAME(serialise_)(const TopoDS_Shape& shape, bool advanced);
-
-}
-#endif

src/ifcgeom/IfcGeomIteratorImplementation.cpp

@@ -1,32 +0,0 @@
-#include "IfcGeomIteratorImplementation.h"
-#include "../ifcgeom_schema_agnostic/IteratorImplementation.h"
-
-namespace IfcGeom {
-	template class MAKE_TYPE_NAME(IteratorImplementation_)<float, float>;
-	template class MAKE_TYPE_NAME(IteratorImplementation_)<float, double>;
-	template class MAKE_TYPE_NAME(IteratorImplementation_)<double, double>;
-}
-
-#define MAKE_INIT_FN__(a, b) init_ ## a ## b
-#define MAKE_INIT_FN_(a, b) MAKE_INIT_FN__(a, b)
-#define MAKE_INIT_FN(t) MAKE_INIT_FN_(t, IfcSchema)
-
-namespace {
-	template <typename P, typename PP>
-	struct MAKE_TYPE_NAME(factory_t) {
-		IfcGeom::IteratorImplementation<P, PP>* operator()(const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters, int num_threads) const {
-			return new IfcGeom::MAKE_TYPE_NAME(IteratorImplementation_)<P, PP>(settings, file, filters, num_threads);
-		}
-	};
-}
-
-template <typename P, typename PP>
-void MAKE_INIT_FN(IteratorImplementation_)(IteratorFactoryImplementation<P, PP>* mapping) {
-	static const std::string schema_name = STRINGIFY(IfcSchema);
-	MAKE_TYPE_NAME(factory_t)<P, PP> factory;
-	mapping->bind(schema_name, factory);
-}
-
-template void MAKE_INIT_FN(IteratorImplementation_)<float, float>(IteratorFactoryImplementation<float, float>*);
-template void MAKE_INIT_FN(IteratorImplementation_)<float, double>(IteratorFactoryImplementation<float, double>*);
-template void MAKE_INIT_FN(IteratorImplementation_)<double, double>(IteratorFactoryImplementation<double, double>*);

src/ifcgeom/IfcGeomIteratorImplementation.h

@@ -1,988 +0,0 @@
-/********************************************************************************
- *                                                                              *
- * This file is part of IfcOpenShell.                                           *
- *                                                                              *
- * IfcOpenShell is free software: you can redistribute it and/or modify         *
- * it under the terms of the Lesser GNU General Public License as published by  *
- * the Free Software Foundation, either version 3.0 of the License, or          *
- * (at your option) any later version.                                          *
- *                                                                              *
- * IfcOpenShell is distributed in the hope that it will be useful,              *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
- * Lesser GNU General Public License for more details.                          *
- *                                                                              *
- * You should have received a copy of the Lesser GNU General Public License     *
- * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * Geometrical data in an IFC file consists of shapes (IfcShapeRepresentation)  *
- * and instances (SUBTYPE OF IfcBuildingElement e.g. IfcWindow).                *
- *                                                                              *
- * IfcGeom::Representation::Triangulation is a class that represents a          *
- * triangulated IfcShapeRepresentation.                                         *
- *   Triangulation.verts is a 1 dimensional vector of float defining the        *
- *      cartesian coordinates of the vertices of the triangulated shape in the  *
- *      format of [x1,y1,z1,..,xn,yn,zn]                                        *
- *   Triangulation.faces is a 1 dimensional vector of int containing the        *
- *     indices of the triangles referencing positions in Triangulation.verts    *
- *   Triangulation.edges is a 1 dimensional vector of int in {0,1} that dictates*
- *	   the visibility of the edges that span the faces in Triangulation.faces   *
- *                                                                              *
- * IfcGeom::Element represents the actual IfcBuildingElements.                  *
- *   IfcGeomObject.name is the GUID of the element                              *
- *   IfcGeomObject.type is the datatype of the element e.g. IfcWindow           *
- *   IfcGeomObject.mesh is a pointer to an IfcMesh                              *
- *   IfcGeomObject.transformation.matrix is a 4x3 matrix that defines the       *
- *     orientation and translation of the mesh in relation to the world origin  *
- *                                                                              *
- * IfcGeom::Iterator::initialize()                                              *
- *   finds the most suitable representation contexts. Returns true iff          *
- *   at least a single representation will process successfully                 *
- *                                                                              *
- * IfcGeom::Iterator::get()                                                     *
- *   returns a pointer to the current IfcGeom::Element                          *
- *                                                                              * 
- * IfcGeom::Iterator::next()                                                    *
- *   returns true iff a following entity is available for a successive call to  *
- *   IfcGeom::Iterator::get()                                                   *
- *                                                                              *
- * IfcGeom::Iterator::progress()                                                *
- *   returns an int in [0..100] that indicates the overall progress             *
- *                                                                              *
- ********************************************************************************/
-
-#ifndef IFCGEOMITERATOR_H
-#define IFCGEOMITERATOR_H
-
-#include <map>
-#include <set>
-#include <vector>
-#include <limits>
-#include <algorithm>
-#include <atomic>
-
-#include <future>
-#include <thread>
-#include <chrono>
-
-#include <boost/algorithm/string.hpp>
-
-#include <gp_Mat.hxx>
-#include <gp_Mat2d.hxx>
-#include <gp_GTrsf.hxx>
-#include <gp_GTrsf2d.hxx>
-#include <gp_Trsf.hxx>
-#include <gp_Trsf2d.hxx>
-
-#include "../ifcparse/IfcFile.h"
-
-#include "../ifcgeom/IfcGeom.h"
-#include "../ifcgeom/IfcGeomElement.h"
-#include "../ifcgeom_schema_agnostic/IfcGeomMaterial.h"
-#include "../ifcgeom/IfcGeomIteratorSettings.h"
-#include "../ifcgeom/IfcRepresentationShapeItem.h"
-
-#include "../ifcgeom_schema_agnostic/IfcGeomFilter.h"
-#include "../ifcgeom_schema_agnostic/IteratorImplementation.h"
-
-#include <atomic>
-
-// The infamous min & max Win32 #defines can leak here from OCE depending on the build configuration
-#ifdef min
-#undef min
-#endif
-#ifdef max
-#undef max
-#endif
-
-namespace {
-	template <typename P, typename PP=P>
-	struct geometry_conversion_task {
-		int index;
-		IfcSchema::IfcRepresentation *representation;
-		IfcSchema::IfcProduct::list::ptr products;
-		std::vector<IfcGeom::BRepElement<P, PP>*> breps;
-		std::vector<IfcGeom::Element<P, PP>*> elements;
-	};
-
-	template <typename P, typename PP=P>
-	IfcGeom::Element<P, PP>* process_based_on_settings(
-		const IfcGeom::IteratorSettings& settings,
-		IfcGeom::BRepElement<P, PP>* elem, 
-		IfcGeom::TriangulationElement<P, PP>* previous=nullptr)
-	{
-		if (settings.get(IfcGeom::IteratorSettings::USE_BREP_DATA)) {
-			try {
-				return new IfcGeom::SerializedElement<P, PP>(*elem);
-			} catch (...) {
-				Logger::Message(Logger::LOG_ERROR, "Getting a serialized element from model failed.");
-				return nullptr;
-			}
-		} else if (!settings.get(IfcGeom::IteratorSettings::DISABLE_TRIANGULATION)) {
-			try {
-				if (!previous) {
-					return  new IfcGeom::TriangulationElement<P, PP>(*elem);
-				} else {
-					return  new IfcGeom::TriangulationElement<P, PP>(*elem, previous->geometry_pointer());
-				}
-			} catch (...) {
-				Logger::Message(Logger::LOG_ERROR, "Getting a triangulation element from model failed.");
-				return nullptr;
-			}
-		} else {
-			return elem;
-		}
-	}
-
-	template <typename P, typename PP = P>
-	void create_element(
-		IfcGeom::MAKE_TYPE_NAME(Kernel)* kernel, 
-		const IfcGeom::IteratorSettings& settings,
-		geometry_conversion_task<P, PP>* rep) 
-	{
-		IfcSchema::IfcRepresentation *representation = rep->representation;
-		IfcSchema::IfcProduct *product = *rep->products->begin();
-		auto brep = kernel->create_brep_for_representation_and_product<P, PP>(settings, representation, product);
-		if (!brep) {
-			return;
-		}
-
-		auto elem = process_based_on_settings(settings, brep);
-		if (!elem) {
-			return;
-		}
-
-		rep->breps = { brep };
-		rep->elements = { elem };
-
-		for (auto it = rep->products->begin() + 1; it != rep->products->end(); ++it) {
-			auto brep2 = kernel->create_brep_for_processed_representation<P, PP>(settings, representation, *it, brep);
-			if (brep2) {
-				auto elem2 = process_based_on_settings(settings, brep, dynamic_cast<IfcGeom::TriangulationElement<P, PP>*>(elem));
-				if (elem2) {
-					rep->breps.push_back(brep2);
-					rep->elements.push_back(elem2);
-				}
-			}
-		}
-	}
-}
-
-namespace IfcGeom {
-	
-	template <typename P, typename PP>
-	class MAKE_TYPE_NAME(IteratorImplementation_) : public IteratorImplementation<P, PP> {
-	private:
-
-		int num_threads_;
-		std::atomic<int> progress_;
-		std::vector<geometry_conversion_task<P, PP>> tasks_;
-		std::vector<IfcGeom::Element<P, PP>*> all_processed_elements_;
-		std::vector<IfcGeom::BRepElement<P, PP>*> all_processed_native_elements_;
-		typename std::vector<IfcGeom::Element<P, PP>*>::const_iterator task_result_iterator_;
-		typename std::vector<IfcGeom::BRepElement<P, PP>*>::const_iterator native_task_result_iterator_;
-
-		MAKE_TYPE_NAME(IteratorImplementation_)(const MAKE_TYPE_NAME(IteratorImplementation_)&); // N/I
-		MAKE_TYPE_NAME(IteratorImplementation_)& operator=(const MAKE_TYPE_NAME(IteratorImplementation_)&); // N/I
-
-		MAKE_TYPE_NAME(Kernel) kernel;
-		IteratorSettings settings;
-
-		IfcParse::IfcFile* ifc_file;
-
-		// A container and iterator for IfcRepresentations
-		IfcSchema::IfcRepresentation::list::ptr representations;
-		IfcSchema::IfcRepresentation::list::it representation_iterator;
-
-		// The object is fetched beforehand to be sure that get() returns a valid element
-		TriangulationElement<P, PP>* current_triangulation;
-		BRepElement<P, PP>* current_shape_model;
-		SerializedElement<P, PP>* current_serialization;
-		
-		// A container and iterator for IfcBuildingElements for the current IfcRepresentation referenced by *representation_iterator
-		IfcSchema::IfcProduct::list::ptr ifcproducts;
-		IfcSchema::IfcProduct::list::it ifcproduct_iterator;
-
-
-        IfcSchema::IfcRepresentation::list::ptr ok_mapped_representations;
-
-		int done;
-		int total;
-
-		std::string unit_name;
-		double unit_magnitude;
-
-        gp_XYZ bounds_min_;
-        gp_XYZ bounds_max_;
-
-        std::vector<filter_t> filters_;
-
-        struct filter_match
-        {
-            filter_match(IfcSchema::IfcProduct *prod) : product(prod) {}
-            bool operator()(const filter_t& filter) const { return filter(product);  }
-
-            IfcSchema::IfcProduct* product;
-        };
-
-		void initUnits() {
-			IfcSchema::IfcProject::list::ptr projects = ifc_file->instances_by_type<IfcSchema::IfcProject>();
-			if (projects->size() == 1) {
-				IfcSchema::IfcProject* project = *projects->begin();
-				std::pair<std::string, double> length_unit = kernel.initializeUnits(project->UnitsInContext());
-				unit_name = length_unit.first;
-				unit_magnitude = length_unit.second;
-			} else {
-				Logger::Warning("A single IfcProject is expected (encountered " + boost::lexical_cast<std::string>(projects->size()) + "); unable to read unit information.");
-			}
-		}
-
-        /// @todo public/private sections all over the place: move all public to the beginning of the class
-	public:
-		typedef P Precision;
-		typedef PP PlacementPrecision;
-
-		bool initialize() {
-			try {
-				initUnits();
-			} catch (const std::exception& e) {
-				Logger::Error(e);
-			}
-
-			std::set<std::string> allowed_context_types;
-			allowed_context_types.insert("model");
-			allowed_context_types.insert("plan");
-			allowed_context_types.insert("notdefined");
-
-			std::set<std::string> context_types;
-            if (!settings.get(IteratorSettings::EXCLUDE_SOLIDS_AND_SURFACES)) {
-				// Really this should only be 'Model', as per 
-				// the standard 'Design' is deprecated. So,
-				// just for backwards compatibility:
-				context_types.insert("model");
-				context_types.insert("design");
-				// Some earlier (?) versions DDS-CAD output their own ContextTypes
-				context_types.insert("model view");
-				context_types.insert("detail view");
-			}
-            if (settings.get(IteratorSettings::INCLUDE_CURVES)) {
-				context_types.insert("plan");
-			}			
-
-			double lowest_precision_encountered = std::numeric_limits<double>::infinity();
-			bool any_precision_encountered = false;
-
-			representations = IfcSchema::IfcRepresentation::list::ptr(new IfcSchema::IfcRepresentation::list);
-            ok_mapped_representations = IfcSchema::IfcRepresentation::list::ptr(new IfcSchema::IfcRepresentation::list);
-
-			IfcSchema::IfcGeometricRepresentationContext::list::it it;
-			IfcSchema::IfcGeometricRepresentationSubContext::list::it jt;
-			IfcSchema::IfcGeometricRepresentationContext::list::ptr contexts = 
-				ifc_file->instances_by_type<IfcSchema::IfcGeometricRepresentationContext>();
-
-			IfcSchema::IfcGeometricRepresentationContext::list::ptr filtered_contexts (new IfcSchema::IfcGeometricRepresentationContext::list);
-
- 			for (it = contexts->begin(); it != contexts->end(); ++it) {
-				IfcSchema::IfcGeometricRepresentationContext* context = *it;
-				if (context->declaration().is(IfcSchema::IfcGeometricRepresentationSubContext::Class())) {
-					// Continue, as the list of subcontexts will be considered
-					// by the parent's context inverse attributes.
-					continue;
-				}
-				try {
-					if (context->hasContextType()) {
-						std::string context_type = context->ContextType();
-						boost::to_lower(context_type);
-
-						if (allowed_context_types.find(context_type) == allowed_context_types.end()) {
-							Logger::Warning(std::string("ContextType '") + context->ContextType() + "' not allowed:", context);
-						}
-						if (context_types.find(context_type) != context_types.end()) {
-							filtered_contexts->push(context);
-						}
-					}
-				} catch (const std::exception& e) {
-					Logger::Error(e);
-				}
-			}
-
-			// In case no contexts are identified based on their ContextType, all contexts are
-			// considered. Note that sub contexts are excluded as they are considered later on.
-			if (filtered_contexts->size() == 0) {
-				for (it = contexts->begin(); it != contexts->end(); ++it) {
-					IfcSchema::IfcGeometricRepresentationContext* context = *it;
-					if (!context->declaration().is(IfcSchema::IfcGeometricRepresentationSubContext::Class())) {
-						filtered_contexts->push(context);
-					}
-				}
-			}
-
-			for (it = filtered_contexts->begin(); it != filtered_contexts->end(); ++it) {
-				IfcSchema::IfcGeometricRepresentationContext* context = *it;
-
-				representations->push(context->RepresentationsInContext());
-				try {
-					if (context->hasPrecision() && context->Precision() < lowest_precision_encountered) {
-						lowest_precision_encountered = context->Precision();
-						any_precision_encountered = true;
-					}
-				} catch (const std::exception& e) {
-					Logger::Error(e);
-				}
-
-				IfcSchema::IfcGeometricRepresentationSubContext::list::ptr sub_contexts = context->HasSubContexts();
-				for (jt = sub_contexts->begin(); jt != sub_contexts->end(); ++jt) {
-					representations->push((*jt)->RepresentationsInContext());
-				}
-				// There is no need for full recursion as the following is governed by the schema:
-				// WR31: The parent context shall not be another geometric representation sub context. 
-			}
-
-			if (any_precision_encountered) {
-				// Some arbitrary factor that has proven to work better for the models in the set of test files.
-				lowest_precision_encountered *= 10.;
-
-				lowest_precision_encountered *= unit_magnitude;
-				if (lowest_precision_encountered < 1.e-7) {
-					Logger::Message(Logger::LOG_WARNING, "Precision lower than 0.0000001 meter not enforced");
-					kernel.setValue(IfcGeom::Kernel::GV_PRECISION, 1.e-7);
-				} else {
-					kernel.setValue(IfcGeom::Kernel::GV_PRECISION, lowest_precision_encountered);
-				}
-			} else {
-				kernel.setValue(IfcGeom::Kernel::GV_PRECISION, 1.e-5);
-			}
-
-            if (representations->size() == 0) {
-                Logger::Warning("No representations encountered in relevant contexts, using all");
-				representations = ifc_file->instances_by_type<IfcSchema::IfcRepresentation>();
-            }
-
-			if (representations->size() == 0) {
-				Logger::Warning("No representations encountered, aborting");
-				return false;
-			}
-
-			representation_iterator = representations->begin();
-			ifcproducts.reset();
-
-			done = 0;
-			total = representations->size();
-
-			if (num_threads_ != 1) {
-				collect();
-				process_concurrently();
-			} else {
-				if (!create()) {
-					return false;
-				}
-			}
-			
-			return true;
-		}
-
-		void collect() {
-			int i = 0;
-			IfcSchema::IfcProduct::list* previous = nullptr;
-			while (auto rp = get_next_task()) {
-				// Note that get_next_task() mutates the state of the iterator
-				// we use that capture all products that can be processed as
-				// part of this representation and then keep iterating until
-				// the underlying list of products changes.
-				if (ifcproducts.get() != previous) {
-					previous = ifcproducts.get();
-					geometry_conversion_task<P, PP> t;
-					t.index = i++;
-					t.representation = *representation_iterator;
-					t.products = ifcproducts;
-					tasks_.emplace_back(t);
-				}
-
-				_nextShape();
-			}
-		}
-
-		void process_concurrently() {
-			size_t conc_threads = num_threads_;
-			if (conc_threads > tasks_.size()) {
-				conc_threads = tasks_.size();
-			}
-			
-			std::vector<MAKE_TYPE_NAME(Kernel)*> kernel_pool;
-			kernel_pool.reserve(conc_threads);
-			for (unsigned i = 0; i < conc_threads; ++i) {
-				kernel_pool.push_back(new MAKE_TYPE_NAME(Kernel)(kernel));
-			}
-
-			std::vector<std::future<void>> threadpool;
-
-			int old_progress = -1;
-			int processed = 0;
-
-			Logger::ProgressBar(0);
-
-			for (auto& rep : tasks_) {
-				MAKE_TYPE_NAME(Kernel)* K = nullptr;
-				if (threadpool.size() < kernel_pool.size()) {
-					K = kernel_pool[threadpool.size()];
-				}
-
-				while (threadpool.size() == conc_threads) {
-					for (int i = 0; i < (int)threadpool.size(); i++) {
-						std::future<void> &fu = threadpool[i];
-						std::future_status status;
-						status = fu.wait_for(std::chrono::seconds(0));
-						if (status == std::future_status::ready) {
-							fu.get();
-							
-							processed += 1;
-							progress_ = processed * 50 / tasks_.size();
-							if (progress_ != old_progress) {
-								Logger::ProgressBar(progress_);
-								old_progress = progress_;
-							}
-								
-							std::swap(threadpool[i], threadpool.back());
-							threadpool.pop_back();
-							std::swap(kernel_pool[i], kernel_pool.back());
-							K = kernel_pool.back();
-							break;
-						} // if
-					}   // for
-				}     // while
-
-				std::future<void> fu = std::async(std::launch::async, create_element<P, PP>, K, std::ref(settings), &rep);
-				threadpool.emplace_back(std::move(fu));
-			}
-
-			for (std::future<void> &fu : threadpool) {
-				fu.get();
-
-				processed += 1;
-				progress_ = processed * 50 / tasks_.size();
-				if (progress_ != old_progress) {
-					Logger::ProgressBar(progress_);
-					old_progress = progress_;
-				}
-			}
-
-			for (auto& rep : tasks_) {
-				all_processed_elements_.insert(all_processed_elements_.end(), rep.elements.begin(), rep.elements.end());
-				all_processed_native_elements_.insert(all_processed_native_elements_.end(), rep.breps.begin(), rep.breps.end());
-			}
-
-			task_result_iterator_ = all_processed_elements_.begin();
-			native_task_result_iterator_ = all_processed_native_elements_.begin();
-
-			Logger::Status("\rDone creating geometry (" + boost::lexical_cast<std::string>(all_processed_elements_.size()) +
-				" objects)                                ");
-		}
-
-        /// Computes model's bounding box (bounds_min and bounds_max).
-        /// @note Can take several minutes for large files.
-        void compute_bounds()
-        {
-            for (int i = 1; i < 4; ++i) {
-                bounds_min_.SetCoord(i, std::numeric_limits<double>::infinity());
-                bounds_max_.SetCoord(i, -std::numeric_limits<double>::infinity());
-            }
-
-            IfcSchema::IfcProduct::list::ptr products = ifc_file->instances_by_type<IfcSchema::IfcProduct>();
-            for (IfcSchema::IfcProduct::list::it iter = products->begin(); iter != products->end(); ++iter) {
-                IfcSchema::IfcProduct* product = *iter;
-                if (product->hasObjectPlacement()) {
-                    // Use a fresh trsf every time in order to prevent the result to be concatenated
-                    gp_Trsf trsf; 
-                    bool success = false;
-
-                    try {
-                        success = kernel.convert(product->ObjectPlacement(), trsf);
-                    } catch (const std::exception& e) {
-                        Logger::Error(e);
-                    } catch (...) {
-                        Logger::Error("Failed to construct placement");
-                    }
-
-                    if (!success) {
-                        continue;
-                    }
-
-                    const gp_XYZ& pos = trsf.TranslationPart();
-                    bounds_min_.SetX(std::min(bounds_min_.X(), pos.X()));
-                    bounds_min_.SetY(std::min(bounds_min_.Y(), pos.Y()));
-                    bounds_min_.SetZ(std::min(bounds_min_.Z(), pos.Z()));
-                    bounds_max_.SetX(std::max(bounds_max_.X(), pos.X()));
-                    bounds_max_.SetY(std::max(bounds_max_.Y(), pos.Y()));
-                    bounds_max_.SetZ(std::max(bounds_max_.Z(), pos.Z()));
-                }
-            }
-        }
-
-		int progress() const { 
-			if (num_threads_ == 1) {
-				return 100 * done / total;
-			} else {
-				return progress_;
-			}
-		}
-
-		const std::string& getUnitName() const { return unit_name; }
-
-        /// @note Double always as per IFC specification.
-        double getUnitMagnitude() const { return unit_magnitude; }
-	
-		std::string getLog() const { return Logger::GetLog(); }
-
-		IfcParse::IfcFile* file() const { return ifc_file; }
-
-        const std::vector<IfcGeom::filter_t>& filters() const { return filters_; }
-        std::vector<IfcGeom::filter_t>& filters() { return filters_; }
-
-        const gp_XYZ& bounds_min() const { return bounds_min_; }
-        const gp_XYZ& bounds_max() const { return bounds_max_; }
-
-	private:
-		// Move to the next IfcRepresentation
-		void _nextShape() {
-			// In order to conserve memory and reduce cache insertion times, the cache is
-			// cleared after an arbitrary number of processed representations. This has been
-			// benchmarked extensively: https://github.com/IfcOpenShell/IfcOpenShell/pull/47
-			static const int clear_interval = 64;
-			if (done % clear_interval == clear_interval - 1) {
-				kernel.purge_cache();
-			}
-			ifcproducts.reset();
-			++ representation_iterator;
-			++ done;
-		}
-
-		bool geometry_reuse_ok_for_current_representation_;
-
-		bool reuse_ok_(const IfcSchema::IfcProduct::list::ptr& products) {
-			// With world coords enabled, object transformations are directly applied to
-			// the BRep. There is no way to re-use the geometry for multiple products.
-			if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
-				return false;
-			}
-
-			std::set<const IfcSchema::IfcMaterial*> associated_single_materials;
-
-			for (IfcSchema::IfcProduct::list::it it = products->begin(); it != products->end(); ++it) {
-				IfcSchema::IfcProduct* product = *it;
-
-				if (!settings.get(IteratorSettings::DISABLE_OPENING_SUBTRACTIONS) && kernel.find_openings(product)->size()) {
-					return false;
-				}
-
-				if (settings.get(IteratorSettings::APPLY_LAYERSETS)) {
-					IfcSchema::IfcRelAssociates::list::ptr associations = product->HasAssociations();
-					for (IfcSchema::IfcRelAssociates::list::it jt = associations->begin(); jt != associations->end(); ++jt) {
-						IfcSchema::IfcRelAssociatesMaterial* assoc = (*jt)->as<IfcSchema::IfcRelAssociatesMaterial>();
-						if (assoc) {
-							if (assoc->RelatingMaterial()->declaration().is(IfcSchema::IfcMaterialLayerSetUsage::Class())) {
-								// TODO: Check whether single layer? 
-								return false;
-							}
-						}
-					}
-				}
-
-				// Note that this can be a nullptr (!), but the fact that set size should be one still holds
-				associated_single_materials.insert(kernel.get_single_material_association(product));
-                if (associated_single_materials.size() > 1) return false;
-			}
-
-			return associated_single_materials.size() == 1;
-		}
-
-		boost::optional<std::pair<IfcSchema::IfcRepresentation*, IfcSchema::IfcProduct*>> get_next_task() {
-			for (;;) {
-				IfcSchema::IfcRepresentation* representation;
-
-				if (representation_iterator == representations->end()) {
-					representations.reset();
-					return boost::none; // reached the end of our list of representations
-				}
-				representation = *representation_iterator;
-
-				if (!ifcproducts) {
-					// Init. the list of filtered IfcProducts for this representation
-					ifcproducts = IfcSchema::IfcProduct::list::ptr(new IfcSchema::IfcProduct::list);
-					IfcSchema::IfcProduct::list::ptr unfiltered_products = kernel.products_represented_by(representation);
-					// Include only the desired products for processing.
-					for (IfcSchema::IfcProduct::list::it jt = unfiltered_products->begin(); jt != unfiltered_products->end(); ++jt) {
-						IfcSchema::IfcProduct* prod = *jt;
-						if (boost::all(filters_, filter_match(prod))) {
-							ifcproducts->push(prod);
-						}
-					}
-
-					if (ifcproducts->size() == 0) {
-						_nextShape();
-						continue;
-					}
-
-					geometry_reuse_ok_for_current_representation_ = reuse_ok_(ifcproducts);
-
-					IfcSchema::IfcRepresentationMap::list::ptr maps = representation->RepresentationMap();
-
-					if (!geometry_reuse_ok_for_current_representation_ && maps->size() == 1) {
-						// unfiltered_products contains products represented by this representation by means of mapped items.
-						// For example because of openings applied to products, reuse might not be acceptable and then the
-						// products will be processed by means of their immediate representation and not the mapped representation.
-
-						// IfcRepresentationMaps are also used for IfcTypeProducts, so an additional check is performed whether the map
-						// is indeed used by IfcMappedItems.
-						IfcSchema::IfcRepresentationMap* map = *maps->begin();
-						if (map->MapUsage()->size() > 0) {
-							_nextShape();
-							continue;
-						}
-					}
-
-					// Check if this represenation has (or will be) processed as part its mapped representation
-					bool representation_processed_as_mapped_item = false;
-					IfcSchema::IfcRepresentation* representation_mapped_to = kernel.representation_mapped_to(representation);
-					if (representation_mapped_to) {
-						representation_processed_as_mapped_item = geometry_reuse_ok_for_current_representation_ && (
-							ok_mapped_representations->contains(representation_mapped_to) || reuse_ok_(kernel.products_represented_by(representation_mapped_to)));
-					}
-
-					if (representation_processed_as_mapped_item) {
-						ok_mapped_representations->push(representation_mapped_to);
-						_nextShape();
-						continue;
-					}
-
-					ifcproduct_iterator = ifcproducts->begin();
-				}
-
-				// Have we reached the end of our list of IfcProducts?
-				if (ifcproduct_iterator == ifcproducts->end()) {
-					_nextShape();
-					continue;
-				}
-
-				IfcSchema::IfcProduct* product = *ifcproduct_iterator;
-
-
-				return std::make_pair(representation, product);
-			}
-		}
-
-		BRepElement<P, PP>* create_shape_model_for_next_entity() {
-			for (;;) {
-				auto rp = get_next_task();
-				if (!rp) {
-					return nullptr;
-				}
-				auto representation = rp->first;
-				auto product = rp->second;
-
-				Logger::SetProduct(product);
-
-				BRepElement<P, PP>* element;
-				if (ifcproduct_iterator == ifcproducts->begin() || !geometry_reuse_ok_for_current_representation_) {
-					element = kernel.create_brep_for_representation_and_product<P, PP>(settings, representation, product);
-				} else {
-					element = kernel.create_brep_for_processed_representation(settings, representation, product, current_shape_model);
-				}
-
-				Logger::SetProduct(boost::none);
-
-				if (!element) {
-					_nextShape();
-					continue;
-				}
-
-				return element;
-			}
-		}
-
-		void free_shapes() {
-			// Free all possible representations of the current geometrical entity
-			delete current_triangulation;
-			current_triangulation = 0;
-			delete current_serialization;
-			current_serialization = 0;
-			delete current_shape_model;
-			current_shape_model = 0;
-		}
-
-    public:
-        /// Returns what would be the product for the next shape representation
-        /// @todo Double-check and test the impl.
-        //IfcSchema::IfcProduct* peek_next() const
-        //{
-        //    if (ifcproducts && ifcproduct_iterator + 1 != ifcproducts->end()){
-        //        return *(ifcproduct_iterator + 1);
-        //    } else {
-        //        return 0;
-        //    }
-        //}
-
-        /// @todo Would this be as simple as the following code?
-        //void skip_next() { if (ifcproducts) { ++ifcproduct_iterator; } }
-
-        /// Moves to the next shape representation, create its geometry, and returns the associated product.
-        /// Use get() to retrieve the created geometry.
-		IfcUtil::IfcBaseClass* next() {
-			if (num_threads_ != 1) {
-				task_result_iterator_++;
-				native_task_result_iterator_++;
-				if (task_result_iterator_ == all_processed_elements_.end()) {
-					return nullptr;
-				} else {
-					return (*task_result_iterator_)->product();
-				}
-			} else {
-				// Increment the iterator over the list of products using the current
-				// shape representation
-				if (ifcproducts) {
-					++ifcproduct_iterator;
-				}
-
-				return create();
-			}
-		}
-
-        /// Gets the representation of the current geometrical entity.
-        Element<P, PP>* get()
-        {
-            // TODO: Test settings and throw
-            Element<P, PP>* ret = 0;
-
-			if (num_threads_ != 1) {
-				ret = *task_result_iterator_;
-			} else {
-				if (current_triangulation) { 
-					ret = current_triangulation; 
-				} else if (current_serialization) { 
-					ret = current_serialization; 
-				} else if (current_shape_model) { 
-					ret = current_shape_model; 
-				}
-			}
-
-			// If we want to organize the element considering their hierarchy
-			if (settings.get(IteratorSettings::SEARCH_FLOOR))
-			{
-				// We are going to build a vector with the element parents.
-				// First, create the parent vector
-				std::vector<const IfcGeom::Element<P, PP>*> parents;
-				
-				// if the element has a parent
-				if (ret->parent_id() != -1)
-				{
-					const IfcGeom::Element<P, PP>* parent_object = NULL;
-					bool hasParent = true;
-
-					// get the parent 
-					try {
-						parent_object = get_object(ret->parent_id());
-					} catch (const std::exception& e) {
-						Logger::Error(e);
-						hasParent = false;
-					}
-
-					// Add the previously found parent to the vector
-					if (hasParent) parents.insert(parents.begin(), parent_object);
-					
-					// We need to find all the parents
-					while (parent_object != NULL && hasParent && parent_object->parent_id() != -1)
-					{
-						// Find the next parent
-						try {
-							parent_object = get_object(parent_object->parent_id());
-						} catch (const std::exception& e) {
-							Logger::Error(e);
-							hasParent = false;
-						}
-
-						// Add the previously found parent to the vector
-						if (hasParent) parents.insert(parents.begin(), parent_object);
-
-						hasParent = hasParent && parent_object->parent_id() != -1;
-					}
-
-					// when done push the parent list in the Element object
-					ret->SetParents(parents);
-				}
-			}
-
-            return ret;
-        }
-
-		/// Gets the native (Open Cascade) representation of the current geometrical entity.
-		BRepElement<P, PP>* get_native()
-		{
-			// TODO: Test settings and throw
-			if (num_threads_ != 1) {
-				return *native_task_result_iterator_;
-			} else {
-				return current_shape_model;
-			}
-		}
-
-		const Element<P, PP>* get_object(int id) {
-			gp_Trsf trsf;
-			int parent_id = -1;
-			std::string instance_type, product_name, product_guid;
-            IfcSchema::IfcProduct* ifc_product = 0;
-
-			try {
-				IfcUtil::IfcBaseClass* ifc_entity = ifc_file->instance_by_id(id);
-				instance_type = ifc_entity->declaration().name();
-
-				if (ifc_entity->declaration().is(IfcSchema::IfcRoot::Class())) {
-					IfcSchema::IfcRoot* ifc_root = ifc_entity->as<IfcSchema::IfcRoot>();
-					product_guid = ifc_root->GlobalId();
-					product_name = ifc_root->hasName() ? ifc_root->Name() : "";
-				}
-
-				if (ifc_entity->declaration().is(IfcSchema::IfcProduct::Class())) {
-					ifc_product = ifc_entity->as<IfcSchema::IfcProduct>();
-					parent_id = -1;
-					try {
-						IfcSchema::IfcObjectDefinition* parent_object = kernel.get_decomposing_entity(ifc_product)->template as<IfcSchema::IfcObjectDefinition>();
-						if (parent_object) {
-							parent_id = parent_object->data().id();
-						}
-					} catch (const std::exception& e) {
-						Logger::Error(e);
-					} catch (...) {
-						Logger::Error("Failed to find decomposing entity");
-					}
-
-					try {
-						kernel.convert(ifc_product->ObjectPlacement(), trsf);
-					} catch (const std::exception& e) {
-						Logger::Error(e);
-					} catch (...) {
-						Logger::Error("Failed to construct placement");
-					}
-				}
-			} catch (const std::exception& e) {
-				Logger::Error(e);
-			} catch (const Standard_Failure& e) {
-				if (e.GetMessageString() && strlen(e.GetMessageString())) {
-					Logger::Error(e.GetMessageString());
-				} else {
-					Logger::Error("Unknown error returning product");
-				}
-			} catch (...) {
-				Logger::Error("Unknown error returning product");
-			}
-
-			ElementSettings element_settings(settings, unit_magnitude, instance_type);
-
-			Element<P, PP>* ifc_object = new Element<P, PP>(element_settings, id, parent_id, product_name, instance_type, product_guid, "", trsf, ifc_product);
-			return ifc_object;
-		}
-
-		IfcUtil::IfcBaseClass* create() {
-			IfcGeom::BRepElement<P, PP>* next_shape_model = 0;
-			IfcGeom::SerializedElement<P, PP>* next_serialization = 0;
-			IfcGeom::TriangulationElement<P, PP>* next_triangulation = 0;
-
-			try {
-				next_shape_model = create_shape_model_for_next_entity();
-			} catch (const std::exception& e) {
-				Logger::Error(e);
-			} catch (const Standard_Failure& e) {
-				if (e.GetMessageString() && strlen(e.GetMessageString())) {
-					Logger::Error(e.GetMessageString());
-				} else {
-					Logger::Error("Unknown error creating geometry");
-				}
-			} catch (...) {
-				Logger::Error("Unknown error creating geometry");
-			}
-
-			if (next_shape_model) {
-				if (settings.get(IteratorSettings::USE_BREP_DATA)) {
-					try {
-						next_serialization = new SerializedElement<P, PP>(*next_shape_model);
-					} catch (...) {
-                        Logger::Message(Logger::LOG_ERROR, "Getting a serialized element from model failed.");
-					}
-				} else if (!settings.get(IteratorSettings::DISABLE_TRIANGULATION)) {
-					try {
-						if (ifcproduct_iterator == ifcproducts->begin() || !geometry_reuse_ok_for_current_representation_) {
-							next_triangulation = new TriangulationElement<P, PP>(*next_shape_model);
-						} else {
-							next_triangulation = new TriangulationElement<P, PP>(*next_shape_model, current_triangulation->geometry_pointer());
-						}
-					} catch (...) {
-                        Logger::Message(Logger::LOG_ERROR, "Getting a triangulation element from model failed.");
-					}
-				}
-			}
-
-			free_shapes();
-
-			current_shape_model = next_shape_model;
-			current_serialization = next_serialization;
-			current_triangulation = next_triangulation;
-
-            return next_shape_model ? next_shape_model->product() : 0;
-		}
-	private:
-		void _initialize() {
-			current_triangulation = 0;
-			current_shape_model = 0;
-			current_serialization = 0;
-
-			unit_name = "METER";
-			unit_magnitude = 1.f;
-
-            kernel.setValue(IfcGeom::Kernel::GV_MAX_FACES_TO_ORIENT, settings.get(IteratorSettings::SEW_SHELLS) ? std::numeric_limits<double>::infinity() : -1);
-            kernel.setValue(IfcGeom::Kernel::GV_DIMENSIONALITY, (settings.get(IteratorSettings::INCLUDE_CURVES)
-                ? (settings.get(IteratorSettings::EXCLUDE_SOLIDS_AND_SURFACES) ? -1. : 0.) : +1.));
-			if (settings.get(IteratorSettings::BUILDING_LOCAL_PLACEMENT)) {
-				if (settings.get(IteratorSettings::SITE_LOCAL_PLACEMENT)) {
-					Logger::Message(Logger::LOG_WARNING, "building-local-placement takes precedence over site-local-placement");
-				}
-				kernel.set_conversion_placement_rel_to(&IfcSchema::IfcBuilding::Class());
-			} else if (settings.get(IteratorSettings::SITE_LOCAL_PLACEMENT)) {
-				kernel.set_conversion_placement_rel_to(&IfcSchema::IfcSite::Class());
-			}
-		}
-
-		bool owns_ifc_file;
-	public:
-		MAKE_TYPE_NAME(IteratorImplementation_)(const IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters, int num_threads)
-			: settings(settings)
-			, ifc_file(file)
-			, filters_(filters)
-			, owns_ifc_file(false)
-			, num_threads_(num_threads)
-		{
-			_initialize();
-		}
-
-		~MAKE_TYPE_NAME(IteratorImplementation_)() {
-			if (owns_ifc_file) {
-				delete ifc_file;
-			}
-
-			if (settings.get(IfcGeom::IteratorSettings::DISABLE_TRIANGULATION)) {
-				for (auto& p : all_processed_native_elements_) {
-					delete p;
-				}
-			}
-
-			for (auto& p : all_processed_elements_) {
-				delete p;
-			}
-
-			free_shapes();
-		}
-	};
-}
-
-#endif

src/ifcgeom/IfcGeomRenderStyles.cpp

@@ -1,140 +0,0 @@
-/********************************************************************************
- *                                                                              *
- * This file is part of IfcOpenShell.                                           *
- *                                                                              *
- * IfcOpenShell is free software: you can redistribute it and/or modify         *
- * it under the terms of the Lesser GNU General Public License as published by  *
- * the Free Software Foundation, either version 3.0 of the License, or          *
- * (at your option) any later version.                                          *
- *                                                                              *
- * IfcOpenShell is distributed in the hope that it will be useful,              *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
- * Lesser GNU General Public License for more details.                          *
- *                                                                              *
- * You should have received a copy of the Lesser GNU General Public License     *
- * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
- *                                                                              *
- ********************************************************************************/
-
-#include <map>
-
-#include "IfcGeom.h"
-
-namespace {
-
-	bool process_colour(IfcSchema::IfcColourRgb* colour, double* rgb) {
-		if (colour != 0) {
-			rgb[0] = colour->Red();
-			rgb[1] = colour->Green();
-			rgb[2] = colour->Blue();
-		}
-		return colour != 0;
-	}
-
-	bool process_colour(IfcSchema::IfcNormalisedRatioMeasure* factor, double* rgb) {
-		if (factor != 0) {
-			const double f = *factor;
-			rgb[0] = rgb[1] = rgb[2] = f;
-		}
-		return factor != 0;
-	}
-
-	bool process_colour(IfcSchema::IfcColourOrFactor* colour_or_factor, double* rgb) {
-		if (colour_or_factor == 0) {
-			return false;
-		} else if (colour_or_factor->declaration().is(IfcSchema::IfcColourRgb::Class())) {
-			return process_colour(static_cast<IfcSchema::IfcColourRgb*>(colour_or_factor), rgb);
-		} else if (colour_or_factor->declaration().is(IfcSchema::IfcNormalisedRatioMeasure::Class())) {
-			return process_colour(static_cast<IfcSchema::IfcNormalisedRatioMeasure*>(colour_or_factor), rgb);
-		} else {
-			return false;
-		}
-	}
-
-}
-
-#define Kernel MAKE_TYPE_NAME(Kernel)
-
-const IfcGeom::SurfaceStyle* IfcGeom::Kernel::internalize_surface_style(const std::pair<IfcUtil::IfcBaseClass*, IfcUtil::IfcBaseClass*>& shading_styles) {
-	if (shading_styles.second == 0) {
-		return 0;
-	}
-	int surface_style_id = shading_styles.first->data().id();
-	std::map<int,SurfaceStyle>::const_iterator it = style_cache.find(surface_style_id);
-	if (it != style_cache.end()) {
-		return &(it->second);
-	}
-	SurfaceStyle surface_style;
-
-	IfcSchema::IfcSurfaceStyle* style = shading_styles.first->as<IfcSchema::IfcSurfaceStyle>();
-	IfcSchema::IfcSurfaceStyleShading* shading = shading_styles.second->as<IfcSchema::IfcSurfaceStyleShading>();
-
-	if (style->hasName()) {
-		surface_style = SurfaceStyle(surface_style_id, style->Name());
-	} else {
-		surface_style = SurfaceStyle(surface_style_id);
-	}
-	double rgb[3];
-	if (process_colour(shading->SurfaceColour(), rgb)) {
-		surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]));
-	}
-	if (shading_styles.second->declaration().is(IfcSchema::IfcSurfaceStyleRendering::Class())) {
-		IfcSchema::IfcSurfaceStyleRendering* rendering_style = static_cast<IfcSchema::IfcSurfaceStyleRendering*>(shading_styles.second);
-		if (rendering_style->hasDiffuseColour() && process_colour(rendering_style->DiffuseColour(), rgb)) {
-			SurfaceStyle::ColorComponent diffuse = surface_style.Diffuse().get_value_or(SurfaceStyle::ColorComponent(1,1,1));
-			surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(diffuse.R() * rgb[0], diffuse.G() * rgb[1], diffuse.B() * rgb[2]));
-		}
-		if (rendering_style->hasDiffuseTransmissionColour()) {
-			// Not supported
-		}
-		if (rendering_style->hasReflectionColour()) {
-			// Not supported
-		}
-		if (rendering_style->hasSpecularColour() && process_colour(rendering_style->SpecularColour(), rgb)) {
-			surface_style.Specular().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]));
-		}
-		if (rendering_style->hasSpecularHighlight()) {
-			IfcSchema::IfcSpecularHighlightSelect* highlight = rendering_style->SpecularHighlight();
-			if (highlight->declaration().is(IfcSchema::IfcSpecularRoughness::Class())) {
-				double roughness = *((IfcSchema::IfcSpecularRoughness*)highlight);
-				if (roughness >= 1e-9) {
-					surface_style.Specularity().reset(1.0 / roughness);
-				}
-			} else if (highlight->declaration().is(IfcSchema::IfcSpecularExponent::Class())) {
-				surface_style.Specularity().reset(*((IfcSchema::IfcSpecularExponent*)highlight));
-			}
-		}
-		if (rendering_style->hasTransmissionColour()) {
-			// Not supported
-		}
-		if (rendering_style->hasTransparency()) {
-			const double d = rendering_style->Transparency();
-			surface_style.Transparency().reset(d);
-		}
-	}
-	return &(style_cache[surface_style_id] = surface_style);
-}
-
-const IfcGeom::SurfaceStyle* IfcGeom::Kernel::get_style(const IfcSchema::IfcRepresentationItem* item) {
-	return internalize_surface_style(get_surface_style<IfcSchema::IfcSurfaceStyleShading>(item));	
-}
-
-const IfcGeom::SurfaceStyle* IfcGeom::Kernel::get_style(const IfcSchema::IfcMaterial* material) {
-	IfcSchema::IfcMaterialDefinitionRepresentation::list::ptr defs = material->HasRepresentation();
-	for (IfcSchema::IfcMaterialDefinitionRepresentation::list::it jt = defs->begin(); jt != defs->end(); ++jt) {
-		IfcSchema::IfcRepresentation::list::ptr reps = (*jt)->Representations();
-		IfcSchema::IfcStyledItem::list::ptr styles(new IfcSchema::IfcStyledItem::list);
-		for (IfcSchema::IfcRepresentation::list::it it = reps->begin(); it != reps->end(); ++it) {
-			styles->push((**it).Items()->as<IfcSchema::IfcStyledItem>());
-		}
-		for (IfcSchema::IfcStyledItem::list::it it = styles->begin(); it != styles->end(); ++it) {
-			const std::pair<IfcSchema::IfcSurfaceStyle*, IfcSchema::IfcSurfaceStyleShading*> ss = get_surface_style<IfcSchema::IfcSurfaceStyleShading>(*it);
-			if (ss.second) {
-				return internalize_surface_style(ss);
-			}
-		}
-	}
-	IfcGeom::SurfaceStyle material_style = IfcGeom::SurfaceStyle(material->data().id(), material->Name());
-	return &(style_cache[material->data().id()] = material_style);
-}

src/ifcgeom/IfcGeomRepresentation.h

@@ -1,415 +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 IFCGEOMREPRESENTATION_H
-#define IFCGEOMREPRESENTATION_H
-
-#include <BRepMesh_IncrementalMesh.hxx>
-#include <BRepGProp_Face.hxx>
-
-#include <Poly_Triangulation.hxx>
-#include <TColgp_Array1OfPnt.hxx>
-#include <TColgp_Array1OfPnt2d.hxx>
-
-#include <TopoDS.hxx>
-#include <BRepTools.hxx>
-#include <TopExp_Explorer.hxx>
-
-#include <BRepAdaptor_Curve.hxx>
-#include <GCPnts_QuasiUniformDeflection.hxx>
-#include <Geom_SphericalSurface.hxx>
-
-#include "../ifcgeom/IfcGeomIteratorSettings.h"
-#include "../ifcgeom_schema_agnostic/IfcGeomMaterial.h"
-#include "../ifcgeom/IfcRepresentationShapeItem.h"
-
-#include <TopoDS_Compound.hxx>
-
-namespace IfcGeom {
-
-	namespace Representation {
-
-		class IFC_GEOM_API Representation {
-			Representation(const Representation&); //N/A
-			Representation& operator =(const Representation&); //N/A
-		protected:
-			const ElementSettings settings_;
-		public:
-			explicit Representation(const ElementSettings& settings)
-				: settings_(settings) 
-			{}
-			const ElementSettings& settings() const { return settings_; }
-			virtual ~Representation() {}
-		};
-
-		class IFC_GEOM_API BRep : public Representation {
-		private:
-			std::string id_;
-			const IfcGeom::IfcRepresentationShapeItems shapes_;
-			BRep(const BRep& other);
-			BRep& operator=(const BRep& other);
-		public:
-			BRep(const ElementSettings& settings, const std::string& id, const IfcGeom::IfcRepresentationShapeItems& shapes)
-				: Representation(settings)
-				, id_(id)
-				, shapes_(shapes)
-			{}
-			virtual ~BRep() {}
-			IfcGeom::IfcRepresentationShapeItems::const_iterator begin() const { return shapes_.begin(); }
-			IfcGeom::IfcRepresentationShapeItems::const_iterator end() const { return shapes_.end(); }
-			const IfcGeom::IfcRepresentationShapeItems& shapes() const { return shapes_; }
-			const std::string& id() const { return id_; }
-			TopoDS_Compound as_compound(bool force_meters = false) const;
-
-			bool calculate_volume(double&) const;
-			bool calculate_surface_area(double&) const;
-			bool calculate_projected_surface_area(const gp_Ax3& ax, double& along_x, double& along_y, double& along_z) const;
-		};
-
-		class IFC_GEOM_API Serialization : public Representation  {
-		private:
-			std::string id_;
-			std::string brep_data_;
-			std::vector<double> surface_styles_;
-		public:
-			const std::string& brep_data() const { return brep_data_; }
-			const std::vector<double>& surface_styles() const { return surface_styles_; }
-			Serialization(const BRep& brep);
-			virtual ~Serialization() {}
-			const std::string& id() const { return id_; }
-		private:
-			Serialization();
-			Serialization(const Serialization&);
-			Serialization& operator=(const Serialization&);
-		};
-
-		template <typename P>
-		class Triangulation : public Representation {
-		private:
-			// A nested pair of floats and a material index to be able to store an XYZ coordinate in a map.
-			// TODO: Make this a std::tuple when compilers add support for that.
-			typedef typename std::pair<P, std::pair<P, P> > Coordinate;
-			typedef typename std::pair<int, Coordinate> VertexKey;
-			typedef std::map<VertexKey, int> VertexKeyMap;
-			typedef std::pair<int, int> Edge;
-
-			std::string id_;
-			std::vector<P> _verts;
-			std::vector<int> _faces;
-			std::vector<int> _edges;
-			std::vector<P> _normals;
-            std::vector<P> uvs_;
-			std::vector<int> _material_ids;
-			std::vector<Material> _materials;
-			VertexKeyMap welds;
-
-		public:
-			const std::string& id() const { return id_; }
-			const std::vector<P>& verts() const { return _verts; }
-			const std::vector<int>& faces() const { return _faces; }
-			const std::vector<int>& edges() const { return _edges; }
-			const std::vector<P>& normals() const { return _normals; }
-            const std::vector<P>& uvs() const { return uvs_; }
-			const std::vector<int>& material_ids() const { return _material_ids; }
-			const std::vector<Material>& materials() const { return _materials; }
-
-			Triangulation(const BRep& shape_model)
-					: Representation(shape_model.settings())
-					, id_(shape_model.id())
-			{
-				for ( IfcGeom::IfcRepresentationShapeItems::const_iterator iit = shape_model.begin(); iit != shape_model.end(); ++ iit ) {
-
-					int surface_style_id = -1;
-					if (iit->hasStyle()) {
-						Material adapter(&iit->Style());
-						std::vector<Material>::const_iterator jt = std::find(_materials.begin(), _materials.end(), adapter);
-						if (jt == _materials.end()) {
-							surface_style_id = (int)_materials.size();
-							_materials.push_back(adapter);
-						} else {
-							surface_style_id = (int)(jt - _materials.begin());
-						}
-					}
-
-					if (settings().get(IteratorSettings::APPLY_DEFAULT_MATERIALS) && surface_style_id == -1) {
-						Material material(IfcGeom::get_default_style(settings().element_type()));
-						std::vector<Material>::const_iterator mit = std::find(_materials.begin(), _materials.end(), material);
-						if (mit == _materials.end()) {
-							surface_style_id = (int)_materials.size();
-							_materials.push_back(material);
-						} else {
-							surface_style_id = (int)(mit - _materials.begin());
-						}
-					}
-
-					const TopoDS_Shape& s = iit->Shape();
-					const gp_GTrsf& trsf = iit->Placement();
-
-					// Triangulate the shape
-					try {
-						BRepMesh_IncrementalMesh(s, settings().deflection_tolerance());
-					} catch(...) {
-						Logger::Message(Logger::LOG_ERROR, "Failed to triangulate shape");
-						continue;
-					}
-
-					// Iterates over the faces of the shape
-					int num_faces = 0;
-					TopExp_Explorer exp;
-					for ( exp.Init(s,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() ) {
-
-							// 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 and calculation is not disable explicitly.
-                            const bool calculate_normals = !settings().get(IteratorSettings::WELD_VERTICES) &&
-                                !settings().get(IteratorSettings::NO_NORMALS);
-
-							for( int i = 1; i <= nodes.Length(); ++ i ) {
-								coords.push_back(nodes(i).Transformed(loc).XYZ());
-								trsf.Transforms(*coords.rbegin());
-								dict[i] = addVertex(surface_style_id, *coords.rbegin());
-					
-								if ( calculate_normals ) {
-									const gp_Pnt2d& uv = uvs(i);
-									gp_Pnt p;
-									gp_Vec normal_direction;
-									prop.Normal(uv.X(),uv.Y(),p,normal_direction);
-									gp_Vec normal(0., 0., 0.);
-									if (normal_direction.Magnitude() > 1.e-9) {
-										normal = gp_Dir(normal_direction.XYZ() * rotation_matrix);
-									} else {
-										Handle_Geom_Surface surf = BRep_Tool::Surface(face);
-										// Special case the normal at the poles of a spherical surface
-										if (surf->DynamicType() == STANDARD_TYPE(Geom_SphericalSurface)) {
-											if (fabs(fabs(uv.Y()) - M_PI / 2.) < 1.e-9) {
-												const bool is_top = uv.Y() > 0;
-												const bool is_forward = face.Orientation() == TopAbs_FORWARD;
-												const double z = (is_top == is_forward) ? 1. : -1.;
-												normal = gp_Dir(gp_XYZ(0, 0, z) * rotation_matrix);
-											}
-										}
-										// TODO: Do the same for conical surfaces, but they are rare in IFC.
-									}
-									_normals.push_back(static_cast<P>(normal.X()));
-									_normals.push_back(static_cast<P>(normal.Y()));
-									_normals.push_back(static_cast<P>(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(dict[n1], dict[n2], edgecount, edges_temp);
-								addEdge(dict[n2], dict[n3], edgecount, edges_temp);
-								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
-									_edges.push_back(jt->first);
-									_edges.push_back(jt->second);
-								}
-							}
-						}
-					}
-
-                    if (!_normals.empty() && settings().get(IfcGeom::IteratorSettings::GENERATE_UVS)) {
-                        uvs_ = box_project_uvs(_verts, _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)_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);
-								
-								_material_ids.push_back(surface_style_id);
-
-								_verts.push_back(static_cast<P>(p.X()));
-								_verts.push_back(static_cast<P>(p.Y()));
-								_verts.push_back(static_cast<P>(p.Z()));
-
-								if (i > 1) {
-									_edges.push_back(start + i - 2);
-									_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(s);
-				}
-			}
-			virtual ~Triangulation() {}
-
-            /// Generates UVs for a single mesh using box projection.
-            /// @todo Very simple impl. Assumes that input vertices and normals match 1:1.
-            static std::vector<P> box_project_uvs(const std::vector<P> &vertices, const std::vector<P> &normals)
-            {
-                std::vector<P> uvs;
-                uvs.resize(vertices.size() / 3 * 2);
-                for (size_t uv_idx = 0, v_idx = 0;
-                uv_idx < uvs.size() && v_idx < vertices.size() && v_idx < normals.size();
-                    uv_idx += 2, v_idx += 3) {
-
-                    P n_x = normals[v_idx], n_y = normals[v_idx + 1], n_z = normals[v_idx + 2];
-                    P v_x = vertices[v_idx], v_y = vertices[v_idx + 1], v_z = vertices[v_idx + 2];
-
-                    if (std::abs(n_x) > std::abs(n_y) && std::abs(n_x) > std::abs(n_z)) {
-                        uvs[uv_idx] = v_z;
-                        uvs[uv_idx + 1] = v_y;
-                    }
-                    if (std::abs(n_y) > std::abs(n_x) && std::abs(n_y) > std::abs(n_z)) {
-                        uvs[uv_idx] = v_x;
-                        uvs[uv_idx + 1] = v_z;
-                    }
-                    if (std::abs(n_z) > std::abs(n_x) && std::abs(n_z) > std::abs(n_y)) {
-                        uvs[uv_idx] = v_x;
-                        uvs[uv_idx + 1] = v_y;
-                    }
-                }
-
-                return uvs;
-            }
-
-		private:
-			// Welds vertices that belong to different faces
-			int addVertex(int material_index, const gp_XYZ& p) {
-                const bool convert = settings().get(IteratorSettings::CONVERT_BACK_UNITS);
-				const P X = static_cast<P>(convert ? (p.X() / settings().unit_magnitude()) : p.X());
-				const P Y = static_cast<P>(convert ? (p.Y() / settings().unit_magnitude()) : p.Y());
-				const P Z = static_cast<P>(convert ? (p.Z() / settings().unit_magnitude()) : p.Z());
-				int i = (int) _verts.size() / 3;
-				if (settings().get(IteratorSettings::WELD_VERTICES)) {
-					const VertexKey key = std::make_pair(material_index, std::make_pair(X, std::make_pair(Y, Z)));
-					typename VertexKeyMap::const_iterator it = welds.find(key);
-					if ( it != welds.end() ) return it->second;
-					i = (int) welds.size();
-					welds[key] = i;
-				}
-				_verts.push_back(X);
-				_verts.push_back(Y);
-				_verts.push_back(Z);
-				return i;
-			}
-			inline void addEdge(int n1, int n2, std::map<std::pair<int,int>,int>& edgecount, std::vector<std::pair<int,int> >& edges_temp) {
-				const Edge e = Edge( (std::min)(n1,n2),(std::max)(n1,n2) );
-				if ( edgecount.find(e) == edgecount.end() ) edgecount[e] = 1;
-				else edgecount[e] ++;
-				edges_temp.push_back(e);
-			}
-			Triangulation();
-			Triangulation(const Triangulation&);
-			Triangulation& operator=(const Triangulation&);
-		};
-
-	}
-}
-
-#endif

src/ifcgeom/IfcRegister.cpp

@@ -1,123 +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"
-#include "IfcGeomShapeType.h"
-
-#define Kernel MAKE_TYPE_NAME(Kernel)
-
-using namespace IfcUtil;
-
-bool IfcGeom::Kernel::convert_shapes(const IfcBaseClass* l, IfcRepresentationShapeItems& r) {
-	if (shape_type(l) != ST_SHAPELIST) {
-		TopoDS_Shape shp;
-		if (convert_shape(l, shp)) {
-			r.push_back(IfcGeom::IfcRepresentationShapeItem(l->data().id(), shp, get_style(l->as<IfcSchema::IfcRepresentationItem>())));
-			return true;
-		}
-		return false;
-	}
-
-#include "IfcRegisterConvertShapes.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
-	return false;
-}
-
-IfcGeom::ShapeType IfcGeom::Kernel::shape_type(const IfcBaseClass* l) {
-#include "IfcRegisterShapeType.h"
-	return ST_OTHER;
-}
-
-bool IfcGeom::Kernel::convert_shape(const IfcBaseClass* l, TopoDS_Shape& r) {
-	const unsigned int id = l->data().id();
-	bool success = false;
-	bool processed = false;
-	bool ignored = false;
-
-#ifndef NO_CACHE
-	std::map<int,TopoDS_Shape>::const_iterator it = cache.Shape.find(id);
-	if ( it != cache.Shape.end() ) { r = it->second; return true; }
-#endif
-	const bool include_curves = getValue(GV_DIMENSIONALITY) != +1;
-	const bool include_solids_and_surfaces = getValue(GV_DIMENSIONALITY) != -1;
-
-	IfcGeom::ShapeType st = shape_type(l);
-	ignored = (!include_solids_and_surfaces && (st == ST_SHAPE || st == ST_FACE)) || (!include_curves && (st == ST_WIRE || st == ST_CURVE));
-	if (st == ST_SHAPELIST) {
-		processed = true;
-		IfcRepresentationShapeItems items;
-		success = convert_shapes(l, items) && flatten_shape_list(items, r, false);
-	} else if (st == ST_SHAPE && include_solids_and_surfaces) {
-#include "IfcRegisterConvertShape.h"
-	} else if (st == ST_FACE && include_solids_and_surfaces) {
-		processed = true;
-		success = convert_face(l, r);
-	} else if (st == ST_WIRE && include_curves) {
-		processed = true;
-		TopoDS_Wire w;
-		success = convert_wire(l, w);
-		if (success) {
-			r = w;
-		}
-	} else if (st == ST_CURVE && include_curves) {
-		processed = true;
-		Handle(Geom_Curve) crv;
-		TopoDS_Wire w;
-		success = convert_curve(l, crv) && convert_curve_to_wire(crv, w);
-		if (success) {
-			r = w;
-		}
-	}
-
-	if ( processed && success ) { 
-		const double precision = getValue(GV_PRECISION);
-		apply_tolerance(r, precision);
-#ifndef NO_CACHE
-		cache.Shape[id] = r;
-#endif
-	} else if (!ignored) {
-		const char* const msg = processed
-			? "Failed to convert:"
-			: "No operation defined for:";
-		Logger::Message(Logger::LOG_ERROR, msg, l);
-	}
-	return success;
-}
-
-bool IfcGeom::Kernel::convert_wire(const IfcBaseClass* l, TopoDS_Wire& r) {
-#include "IfcRegisterConvertWire.h"
-	Handle(Geom_Curve) curve;
-	if (IfcGeom::Kernel::convert_curve(l, curve)) {
-		return IfcGeom::Kernel::convert_curve_to_wire(curve, r);
-	}
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
-	return false;
-}
-
-bool IfcGeom::Kernel::convert_face(const IfcBaseClass* l, TopoDS_Shape& r) {
-#include "IfcRegisterConvertFace.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
-	return false;
-}
-
-bool IfcGeom::Kernel::convert_curve(const IfcBaseClass* l, Handle(Geom_Curve)& r) {
-#include "IfcRegisterConvertCurve.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
-	return false;
-}

src/ifcgeom/IfcRegister.h

@@ -1,148 +0,0 @@
-/********************************************************************************
-*                                                                              *
-* This file is part of IfcOpenShell.                                           *
-*                                                                              *
-* IfcOpenShell is free software: you can redistribute it and/or modify         *
-* it under the terms of the Lesser GNU General Public License as published by  *
-* the Free Software Foundation, either version 3.0 of the License, or          *
-* (at your option) any later version.                                          *
-*                                                                              *
-* IfcOpenShell is distributed in the hope that it will be useful,              *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
-* Lesser GNU General Public License for more details.                          *
-*                                                                              *
-* You should have received a copy of the Lesser GNU General Public License     *
-* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
-*                                                                              *
-********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * 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/IfcBaseClass.h"
-#include "../ifcparse/IfcParse.h"
-
-SHAPES(IfcShellBasedSurfaceModel);
-SHAPES(IfcFaceBasedSurfaceModel);
-SHAPES(IfcRepresentation);
-SHAPES(IfcMappedItem);
-// IfcFacetedBrep included
-// IfcAdvancedBrep included
-// IfcFacetedBrepWithVoids included
-// IfcAdvancedBrepWithVoids included
-SHAPES(IfcManifoldSolidBrep);
-SHAPES(IfcGeometricSet);
-
-#ifdef SCHEMA_HAS_IfcCylindricalSurface
-SHAPE(IfcCylindricalSurface);
-#endif
-#ifdef SCHEMA_HAS_IfcAdvancedBrep
-SHAPE(IfcAdvancedBrep);
-#endif
-// FIXME: Surfaces should have a shape type of their own
-#ifdef SCHEMA_HAS_IfcBSplineSurfaceWithKnots
-SHAPE(IfcBSplineSurfaceWithKnots);
-#endif
-#ifdef SCHEMA_HAS_IfcTriangulatedFaceSet
-SHAPE(IfcTriangulatedFaceSet);
-#endif
-#ifdef SCHEMA_HAS_IfcExtrudedAreaSolidTapered
-SHAPE(IfcExtrudedAreaSolidTapered);
-#endif
-SHAPE(IfcPlane);
-SHAPE(IfcExtrudedAreaSolid);
-SHAPE(IfcRevolvedAreaSolid);
-SHAPE(IfcConnectedFaceSet);
-SHAPE(IfcBooleanResult);
-SHAPE(IfcPolygonalBoundedHalfSpace);
-SHAPE(IfcHalfSpaceSolid);
-// FIXME: Surfaces should have a shape type of their own
-SHAPE(IfcSurfaceOfLinearExtrusion);
-SHAPE(IfcSurfaceOfRevolution);
-SHAPE(IfcBlock);
-SHAPE(IfcRectangularPyramid);
-SHAPE(IfcRightCircularCylinder);
-SHAPE(IfcRightCircularCone);
-SHAPE(IfcSphere);
-SHAPE(IfcCsgSolid);
-SHAPE(IfcCurveBoundedPlane);
-SHAPE(IfcRectangularTrimmedSurface);
-SHAPE(IfcSurfaceCurveSweptAreaSolid);
-SHAPE(IfcSweptDiskSolid);
-
-FACE(IfcArbitraryProfileDefWithVoids);
-FACE(IfcArbitraryClosedProfileDef);
-FACE(IfcRoundedRectangleProfileDef);
-FACE(IfcRectangleHollowProfileDef);
-FACE(IfcRectangleProfileDef);
-FACE(IfcTrapeziumProfileDef)
-FACE(IfcCShapeProfileDef);
-// IfcAsymmetricIShapeProfileDef included
-FACE(IfcIShapeProfileDef);
-FACE(IfcLShapeProfileDef);
-FACE(IfcTShapeProfileDef);
-FACE(IfcUShapeProfileDef);
-FACE(IfcZShapeProfileDef);
-FACE(IfcCircleHollowProfileDef);
-FACE(IfcCircleProfileDef);
-FACE(IfcEllipseProfileDef);
-FACE(IfcCenterLineProfileDef);
-FACE(IfcCompositeProfileDef);
-FACE(IfcDerivedProfileDef);
-// IfcFaceSurface included
-// IfcAdvancedFace included in case of IFC4
-FACE(IfcFace);
-
-WIRE(IfcEdgeCurve);
-WIRE(IfcSubedge);
-WIRE(IfcOrientedEdge);
-WIRE(IfcEdge);
-WIRE(IfcEdgeLoop);
-WIRE(IfcPolyline);
-WIRE(IfcPolyLoop);
-WIRE(IfcCompositeCurve);
-WIRE(IfcTrimmedCurve);
-WIRE(IfcArbitraryOpenProfileDef);
-#ifdef SCHEMA_HAS_IfcIndexedPolyCurve
-WIRE(IfcIndexedPolyCurve)
-#endif
-
-CURVE(IfcCircle);
-CURVE(IfcEllipse);
-CURVE(IfcLine);
-#ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
-// IfcRationalBSplineCurveWithKnots included
-CURVE(IfcBSplineCurveWithKnots);
-#endif
-
-CLASS(IfcCartesianPoint,gp_Pnt);
-CLASS(IfcDirection,gp_Dir);
-CLASS(IfcAxis2Placement2D,gp_Trsf2d);
-CLASS(IfcAxis2Placement3D,gp_Trsf);
-CLASS(IfcAxis1Placement,gp_Ax1);
-CLASS(IfcCartesianTransformationOperator2DnonUniform,gp_GTrsf2d);
-CLASS(IfcCartesianTransformationOperator3DnonUniform,gp_GTrsf);
-CLASS(IfcCartesianTransformationOperator2D,gp_Trsf2d);
-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->declaration().is(IfcSchema::T::Class()) ) return convert((IfcSchema::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->declaration().is(IfcSchema::T::Class()) ) return convert((IfcSchema::T*)l,r);
-#include "IfcRegisterDef.h"
-
-#include "IfcRegister.h"

src/ifcgeom/IfcRegisterConvertShape.h

@@ -1,26 +0,0 @@
-#include "IfcRegisterUndef.h"
-#define SHAPE(T) \
-	if ( !processed && l->declaration().is(IfcSchema::T::Class()) ) { \
-		processed = true; \
-		try { \
-			if ( convert((IfcSchema::T*)l,r) ) { \
-				success = true; \
-			} \
-		} catch (const std::exception& e) { \
-			Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + "\nFailed to convert:", l); \
-			return false; \
-		} catch (const Standard_Failure& f) { \
-			if (f.GetMessageString() && strlen(f.GetMessageString())) \
-				Logger::Message(Logger::LOG_ERROR, std::string("Error in: ") + f.GetMessageString() + "\nFailed to convert:", l); \
-			else \
-				Logger::Message(Logger::LOG_ERROR, "Failed to convert:", l); \
-			return false; \
-		} \
-		if (!success) { \
-			Logger::Message(Logger::LOG_ERROR,"Failed to convert:",l); \
-			return false; \
-		} \
-	}
-#include "IfcRegisterDef.h"
-
-#include "IfcRegister.h"

src/ifcgeom/IfcRegisterConvertShapes.h

@@ -1,18 +0,0 @@
-#include "IfcRegisterUndef.h"
-#define SHAPES(T) \
-	if ( l->declaration().is(IfcSchema::T::Class()) ) { \
-		try { \
-			return convert((IfcSchema::T*)l,r); \
-		} catch (const std::exception& e) { \
-			Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + "\nFailed to convert:", l); \
-		} catch (const Standard_Failure& f) { \
-			if (f.GetMessageString()) \
-				Logger::Message(Logger::LOG_ERROR, std::string("Error in: ") + f.GetMessageString() + "\nFailed to convert:", l); \
-			else \
-				Logger::Message(Logger::LOG_ERROR, "Failed to convert:", l); \
-		} \
-		return false; \
-	}
-#include "IfcRegisterDef.h"
-
-#include "IfcRegister.h"

src/ifcgeom/IfcRegisterConvertWire.h

@@ -1,6 +0,0 @@
-#include "IfcRegisterUndef.h"
-#define WIRE(T) \
-	if ( l->declaration().is(IfcSchema::T::Class()) ) return convert((IfcSchema::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 IfcSchema::T* 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/IfcRegisterPurgeCache.h

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

src/ifcgeom/IfcRegisterShapeType.h

@@ -1,14 +0,0 @@
-#include "IfcRegisterUndef.h"
-#define SHAPES(T) \
-	if ( l->declaration().is(IfcSchema::T::Class()) ) return ST_SHAPELIST;
-#define SHAPE(T) \
-	if ( l->declaration().is(IfcSchema::T::Class()) ) return ST_SHAPE;
-#define WIRE(T) \
-	if ( l->declaration().is(IfcSchema::T::Class()) ) return ST_WIRE;
-#define FACE(T) \
-	if ( l->declaration().is(IfcSchema::T::Class()) ) return ST_FACE;
-#define CURVE(T) \
-	if ( l->declaration().is(IfcSchema::T::Class()) ) return ST_CURVE;
-#include "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,55 +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_schema_agnostic/IfcGeomRenderStyles.h"
-
-namespace IfcGeom {	
-	class IFC_GEOM_API IfcRepresentationShapeItem {
-	private:
-		int id;
-		gp_GTrsf placement;
-		TopoDS_Shape shape;
-		const SurfaceStyle* style;
-	public:
-		IfcRepresentationShapeItem(int id, const gp_GTrsf& placement, const TopoDS_Shape& shape, const SurfaceStyle* style)
-			: id(id), placement(placement), shape(shape), style(style) {}
-		IfcRepresentationShapeItem(int id, const gp_GTrsf& placement, const TopoDS_Shape& shape)
-			: id(id), placement(placement), shape(shape), style(0) {}
-		IfcRepresentationShapeItem(int id, const TopoDS_Shape& shape, const SurfaceStyle* style)
-			: id(id), shape(shape), style(style) {}
-		IfcRepresentationShapeItem(int id, const TopoDS_Shape& shape)
-			: id(id), 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; }
-		void setStyle(const SurfaceStyle* newStyle) { style = newStyle; }
-		int ItemId() const { return id; }
-	};
-	typedef std::vector<IfcRepresentationShapeItem> IfcRepresentationShapeItems;
-}
-#endif

src/ifcgeom/abstract_mapping.cpp

@@ -0,0 +1,35 @@
+#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);
+}

src/ifcgeom/abstract_mapping.h

@@ -0,0 +1,60 @@
+#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 {
+
+	class Element;
+	class NativeElement;
+
+	struct geometry_conversion_task {
+		int index;
+		IfcUtil::IfcBaseEntity* representation;
+		IfcEntityList::ptr products;
+		std::vector<ifcopenshell::geometry::NativeElement*> breps;
+		std::vector<ifcopenshell::geometry::Element*> elements;
+	};
+
+	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();
+	}
+    
+}
+
+}
+
+#endif

src/ifcgeom/kernel_agnostic/AbstractKernel.cpp

@@ -0,0 +1,135 @@
+#include "AbstractKernel.h"
+
+#include "../../ifcgeom/schema_agnostic/IfcGeomElement.h"
+#include "../../ifcgeom/kernels/opencascade/OpenCascadeKernel.h"
+
+#undef Handle
+
+#include "../../ifcgeom/kernels/cgal/CgalKernel.h"
+
+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;
+		}
+	};
+}
+
+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;
+	} else if (geometry_library_lower == "cgal") {
+		return new CgalKernel;
+	} 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);
+	}
+	return r.size() > s;
+}
+
+//void ifcopenshell::geometry::kernels::AbstractKernel::set_conversion_placement_rel_to(const IfcParse::declaration* type) {
+//	placement_rel_to = type;
+//}
+//
+//void ifcopenshell::geometry::kernels::AbstractKernel::setValue(GeomValue var, double value) {
+//	switch (var) {
+//	case GV_DEFLECTION_TOLERANCE:
+//		deflection_tolerance = value;
+//		break;
+//	case GV_POINT_EQUALITY_TOLERANCE:
+//		point_equality_tolerance = value;
+//		break;
+//	case GV_LENGTH_UNIT:
+//		ifc_length_unit = value;
+//		break;
+//	case GV_PLANEANGLE_UNIT:
+//		ifc_planeangle_unit = value;
+//		break;
+//	case GV_PRECISION:
+//		modelling_precision = value;
+//		break;
+//	case GV_DIMENSIONALITY:
+//		dimensionality = value;
+//		break;
+//	default:
+//		assert(!"never reach here");
+//	}
+//}
+//
+//double ifcopenshell::geometry::kernels::AbstractKernel::getValue(GeomValue var) const {
+//	switch (var) {
+//	case GV_DEFLECTION_TOLERANCE:
+//		return deflection_tolerance;
+//	case GV_MINIMAL_FACE_AREA:
+//		// Considering a right-angled triangle, this about the smallest
+//		// area you can obtain without the vertices being confused.
+//		return modelling_precision * modelling_precision / 2.;
+//	case GV_POINT_EQUALITY_TOLERANCE:
+//		return point_equality_tolerance;
+//	case GV_LENGTH_UNIT:
+//		return ifc_length_unit;
+//		break;
+//	case GV_PLANEANGLE_UNIT:
+//		return ifc_planeangle_unit;
+//		break;
+//	case GV_PRECISION:
+//		return modelling_precision;
+//		break;
+//	case GV_DIMENSIONALITY:
+//		return dimensionality;
+//		break;
+//	}
+//	assert(!"never reach here");
+//	return 0;
+//}
+//
+//
+//
+//
+//template IFC_GEOM_API ifcopenshell::geometry::kernels::NativeElement<float, float>* ifcopenshell::geometry::kernels::AbstractKernel::create_brep_for_representation_and_product<float, float>(
+//	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product);
+//template IFC_GEOM_API ifcopenshell::geometry::kernels::NativeElement<float, double>* ifcopenshell::geometry::kernels::AbstractKernel::create_brep_for_representation_and_product<float, double>(
+//	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product);
+//template IFC_GEOM_API ifcopenshell::geometry::kernels::NativeElement<double, double>* ifcopenshell::geometry::kernels::AbstractKernel::create_brep_for_representation_and_product<double, double>(
+//	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product);
+//
+//template IFC_GEOM_API ifcopenshell::geometry::kernels::NativeElement<float, float>* ifcopenshell::geometry::kernels::AbstractKernel::create_brep_for_processed_representation<float, float>(
+//	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product, ifcopenshell::geometry::kernels::NativeElement<float, float>* brep);
+//template IFC_GEOM_API ifcopenshell::geometry::kernels::NativeElement<float, double>* ifcopenshell::geometry::kernels::AbstractKernel::create_brep_for_processed_representation<float, double>(
+//	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product, ifcopenshell::geometry::kernels::NativeElement<float, double>* brep);
+//template IFC_GEOM_API ifcopenshell::geometry::kernels::NativeElement<double, double>* ifcopenshell::geometry::kernels::AbstractKernel::create_brep_for_processed_representation<double, double>(
+//	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product, ifcopenshell::geometry::kernels::NativeElement<double, double>* brep);

src/ifcgeom/kernel_agnostic/AbstractKernel.h

@@ -0,0 +1,74 @@
+#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"
+
+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;
+
+		double deflection_tolerance;
+		double wire_creation_tolerance;
+		double point_equality_tolerance;
+		double max_faces_to_sew;
+		double ifc_length_unit;
+		double ifc_planeangle_unit;
+		double modelling_precision;
+		double dimensionality;
+
+		std::string geometry_library;
+
+	public:
+		AbstractKernel(const std::string& geometry_library)
+			: geometry_library(geometry_library)
+			, deflection_tolerance(0.001)
+			, wire_creation_tolerance(0.0001)
+			, point_equality_tolerance(0.00001)
+			, max_faces_to_sew(-1.0)
+			, ifc_length_unit(1.0)
+			, ifc_planeangle_unit(-1.0)
+			, modelling_precision(0.00001)
+			, dimensionality(1.)
+			, placement_rel_to(0) {}
+
+		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*);
+
+}
+}
+}
+
+#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,102 @@
+#include "CgalConversionResult.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.components.isIdentity()) {
+	  const auto& m = place.components;
+
+	  // @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;
+  }
+
+}

src/ifcgeom/kernels/cgal/CgalConversionResult.h

@@ -0,0 +1,91 @@
+/********************************************************************************
+*                                                                              *
+* 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 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,686 @@
+/********************************************************************************
+ *                                                                              *
+ * 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"
+
+#include "../../../ifcparse/IfcLogger.h"
+#include "../../../ifcgeom/kernels/cgal/CgalConversionResult.h"
+
+#include <CGAL/minkowski_sum_3.h>
+
+using namespace ifcopenshell::geometry; 
+using namespace ifcopenshell::geometry::kernels;
+
+void 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_> ifcopenshell::geometry::utils::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_> ifcopenshell::geometry::utils::create_polyhedron(const 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_> ifcopenshell::geometry::utils::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;
+}
+
+CGAL::Nef_polyhedron_3<Kernel_> ifcopenshell::geometry::utils::create_nef_polyhedron(CGAL::Polyhedron_3<Kernel_> &polyhedron) {
+	if (polyhedron.is_valid() && polyhedron.is_closed()) {
+		// @todo is it necessary to triangulat?
+		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;
+	} else {
+		Logger::Message(Logger::LOG_ERROR, "Polyhedron not valid: cannot create Nef polyhedron!");
+		return CGAL::Nef_polyhedron_3<Kernel_>();
+	}
+}
+
+bool CgalKernel::convert(const taxonomy::shell* l, cgal_shape_t& shape) {
+	auto faces = l->children_as<taxonomy::face>();
+
+	std::list<cgal_face_t> face_list;
+	for (auto& f : faces) {
+		bool success = false;
+		cgal_face_t face;
+
+		try {
+			success = convert(f, face);
+		} catch (...) {}
+
+		if (!success) {
+			Logger::Message(Logger::LOG_WARNING, "Failed to convert face:", f->instance);
+			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 = utils::create_polyhedron(face_list);
+	return true;
+}
+
+bool CgalKernel::convert(const taxonomy::face* face, cgal_face_t& result) {
+	auto bounds = face->children_as<taxonomy::loop>();
+
+	int num_outer_bounds = 0;
+
+	for (auto& bound : bounds) {
+		if (bound->external.get_value_or(false)) num_outer_bounds++;
+	}
+
+	if (num_outer_bounds != 1) {
+		Logger::Message(Logger::LOG_ERROR, "Invalid configuration of boundaries for:", face->instance);
+		return false;
+	}
+
+	cgal_face_t mf;
+
+	for (auto& bound : bounds) {
+
+		const bool is_interior = !bound->external.get_value_or(false);
+
+		cgal_wire_t wire;
+		if (!convert(bound, wire)) {
+			Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary loop", bound->instance);
+			return false;
+		}
+
+		if (!is_interior) {
+			mf.outer = wire;
+		} else {
+			mf.inner.push_back(wire);
+		}
+	}
+
+	result = mf;
+
+	//  std::cout << "Face: " << std::endl;
+	//  for (auto &point: face.outer) {
+	//    std::cout << "\tPoint(" << point << ")" << std::endl;
+	//  }
+
+	return true;
+}
+
+namespace {
+	bool convert_curve(CgalKernel* kernel, const taxonomy::item* curve, cgal_wire_t& builder) {
+		if (curve->kind() == taxonomy::EDGE) {
+			auto e = (taxonomy::edge*) curve;
+			if (true || e->basis == nullptr) {
+				if (builder.empty()) {
+					const auto& p = boost::get<taxonomy::point3>(e->start);
+					cgal_point_t pnt(p.components(0), p.components(1), p.components(2));
+					builder.push_back(pnt);
+				}
+				const auto& p = boost::get<taxonomy::point3>(e->end);
+				cgal_point_t pnt(p.components(0), p.components(1), p.components(2));
+				builder.push_back(pnt);
+			} else if (e->basis->kind() == taxonomy::CIRCLE) {
+				// @todo
+			} else if (e->basis->kind() == taxonomy::ELLIPSE) {
+
+			} else {
+				throw std::runtime_error("Not implemented basis kind");
+			}
+		} else if (curve->kind() == taxonomy::LOOP) {
+			const auto& edges = ((taxonomy::loop*) curve)->children;
+			for (auto& c : edges) {
+				convert_curve(kernel, c, builder);
+			}
+		} else {
+			throw std::runtime_error("Not implemented curve");
+		}
+	}
+}
+
+bool CgalKernel::convert(const taxonomy::loop* loop, cgal_wire_t& result) {
+	// @todo only implement polygonal loops
+
+	auto edges = loop->children_as<taxonomy::edge>();
+	std::vector<taxonomy::point3> points;
+
+	for (auto& e : edges) {
+		if (e->basis) {
+			Logger::Error("Only polyhedra supported :(");
+			return false;
+		}
+		points.push_back(boost::get<taxonomy::point3>(e->start));
+	}
+
+	// Parse and store the points in a sequence
+	cgal_wire_t polygon = std::vector<Kernel_::Point_3>();
+	for (auto& p : points) {
+		cgal_point_t pnt(p.components(0), p.components(1), p.components(2));
+		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:", loop->instance);
+		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(), loop->instance);
+	}
+
+	if (count < 3) {
+		Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", loop->instance);
+		return false;
+	}
+
+	result = polygon;
+
+	//  std::cout << "PolyLoop: " << std::endl;
+	//  for (auto &point: polygon) {
+	//    std::cout << "\tPoint(" << point << ")" << std::endl;
+	//  }
+
+	return true;
+}
+
+
+bool CgalKernel::convert_impl(const taxonomy::shell *shell, ifcopenshell::geometry::ConversionResults& results) {
+	cgal_shape_t shape;
+	if (!convert(shell, shape)) {
+		return false;
+	}
+	results.emplace_back(ConversionResult(
+		shell->instance->data().id(),
+		shell->matrix,
+		new CgalShape(shape),
+		shell->surface_style
+	));
+	return true;
+}
+
+bool CgalKernel::convert_impl(const taxonomy::extrusion* extrusion, ifcopenshell::geometry::ConversionResults& results) {
+	cgal_shape_t shape;
+	if (!convert(extrusion, shape)) {
+		return false;
+	}
+	results.emplace_back(ConversionResult(
+		extrusion->instance->data().id(),
+		extrusion->matrix,
+		new CgalShape(shape),
+		extrusion->surface_style
+	));
+	return true;
+}
+
+bool CgalKernel::convert(const taxonomy::extrusion* extrusion, cgal_shape_t &shape) {
+	const double& height = extrusion->depth;
+	if (height < precision_) {
+		Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", extrusion->instance);
+		return false;
+	}
+
+	// Outer
+	cgal_face_t bottom_face;
+	if (!convert(&extrusion->basis, bottom_face)) {
+		return false;
+	}
+	//  std::cout << "Face vertices: " << face.outer.size() << std::endl;
+
+	auto fs = extrusion->direction.components;
+	cgal_direction_t dir(fs(0), fs(1), fs(2));
+	//  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 = utils::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 = utils::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 -= utils::create_nef_polyhedron(face_list);
+		} catch (...) {
+			Logger::Message(Logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot subtract opening for:", extrusion->instance);
+			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:", extrusion->instance);
+		return false;
+	}
+
+}
+
+CGAL::Polyhedron_3<Kernel_> ifcopenshell::geometry::utils::create_cube(double d) {
+	cgal_face_t bottom_face;
+	bottom_face.outer.push_back(Kernel_::Point_3(-d, -d, -d));
+	bottom_face.outer.push_back(Kernel_::Point_3(+d, -d, -d));
+	bottom_face.outer.push_back(Kernel_::Point_3(+d, +d, -d));
+	bottom_face.outer.push_back(Kernel_::Point_3(-d, +d, -d));
+
+	cgal_direction_t dir(0, 0, 2 * d);
+
+	std::list<cgal_face_t> face_list = { 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 + dir);
+		side_face.outer.push_back(*next_vertex + 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 + dir);
+	}
+		
+	face_list.push_back(top_face);
+
+	return create_polyhedron(face_list);
+}
+
+
+CGAL::Polyhedron_3<Kernel_> ifcopenshell::geometry::utils::create_cube(const Kernel_::Point_3& lower, const Kernel_::Point_3& upper) {
+	cgal_face_t bottom_face;
+
+	auto& a0 = lower.cartesian(0);
+	auto& a1 = lower.cartesian(1);
+	auto& a2 = lower.cartesian(2);
+
+	auto& b0 = upper.cartesian(0);
+	auto& b1 = upper.cartesian(1);
+	auto& b2 = upper.cartesian(2);
+
+	bottom_face.outer.push_back(Kernel_::Point_3(a0, a1, a2));
+	bottom_face.outer.push_back(Kernel_::Point_3(b0, a1, a2));
+	bottom_face.outer.push_back(Kernel_::Point_3(b0, b1, a2));
+	bottom_face.outer.push_back(Kernel_::Point_3(a0, b1, a2));
+
+	cgal_direction_t dir(0, 0, b2 - a2);
+
+	std::list<cgal_face_t> face_list = { 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 + dir);
+		side_face.outer.push_back(*next_vertex + 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 + dir);
+	}
+		
+	face_list.push_back(top_face);
+
+	return create_polyhedron(face_list);
+}
+
+bool CgalKernel::thin_solid(const CGAL::Nef_polyhedron_3<Kernel_>& a, CGAL::Nef_polyhedron_3<Kernel_>& result) {
+	// @todo this should be possible as a minkowski sum of facet & cube. rather than a set of boolean ops.
+
+	auto a_nonconst = a;
+	auto ax = CGAL::minkowski_sum_3(a_nonconst, precision_cube_);
+	auto x = ax - a;
+
+	result = x;
+	return true;
+
+	auto yxy = CGAL::minkowski_sum_3(x, precision_cube_);
+	auto y = yxy * a;
+	auto zyz = CGAL::minkowski_sum_3(y, precision_cube_);
+	result = yxy * zyz;
+
+	return true;
+}
+
+bool CgalKernel::preprocess_boolean_operand(const IfcUtil::IfcBaseClass* log_reference, const cgal_shape_t& shape_const, CGAL::Nef_polyhedron_3<Kernel_>& result, bool dilate) {
+	cgal_shape_t shape = shape_const;
+
+	if (!shape.is_valid()) {
+		Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Invalid geometry:", log_reference);
+		return false;
+	}
+
+	if (!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:", log_reference);
+		return false;
+	}
+
+	bool success = false;
+
+	try {
+		success = CGAL::Polygon_mesh_processing::triangulate_faces(shape);
+	} catch (...) {
+		Logger::Message(Logger::LOG_ERROR, "Triangulation of geometry crashed:", log_reference);
+		return false;
+	}
+
+	if (!success) {
+		Logger::Message(Logger::LOG_ERROR, "Triangulation of geometry failed:", log_reference);
+		return false;
+	}
+
+	if (CGAL::Polygon_mesh_processing::does_self_intersect(shape)) {
+		Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Self-intersecting geometry:", log_reference);
+		return false;
+	}
+
+	try {
+		result = CGAL::Nef_polyhedron_3<Kernel_>(shape);
+	} catch (...) {
+		Logger::Message(Logger::LOG_ERROR, "Could not convert geometry to Nef:", log_reference);
+		return false;
+	}
+
+	if (dilate) {
+		try {
+			// @todo don't dilate in 3 dimensions but only in the XY plane, orthogonal to wall axis.
+			result = CGAL::minkowski_sum_3(result, precision_cube_);
+		} catch (...) {
+			Logger::Message(Logger::LOG_ERROR, "Could not dilate boolean operand", log_reference);
+			return false;
+		}
+	}		
+
+	try {
+		cgal_shape_t convert_back;
+		result.convert_to_polyhedron(convert_back);
+	} catch (...) {
+		Logger::Message(Logger::LOG_WARNING, "Final conversion will likely fail. Could not convert geometry from Nef:", log_reference);
+	}
+
+	return true;
+}
+
+namespace {
+	bool convert_placement(const ifcopenshell::geometry::taxonomy::matrix4& place, cgal_placement_t& trsf) {
+		const auto& m = place.components;
+
+		// @todo check
+		trsf = cgal_placement_t(
+			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));
+
+		return true;
+	}
+}
+
+
+
+bool CgalKernel::convert_impl(const taxonomy::boolean_result* br, ifcopenshell::geometry::ConversionResults& results) {
+	bool first = true;
+
+	CGAL::Nef_polyhedron_3<Kernel_> a;
+
+	taxonomy::style first_item_style;
+
+	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) {
+			first_item_style = ((taxonomy::geom_item*)c)->surface_style;
+			if (!first_item_style.diffuse && c->kind() == taxonomy::COLLECTION) {
+				first_item_style = ((taxonomy::geom_item*) ((taxonomy::collection*)c)->children[0])->surface_style;
+			}
+		}
+
+		for (auto it = cr.begin(); it != cr.end(); ++it) {
+			const cgal_shape_t& entity_shape_unlocated(((CgalShape*)it->Shape())->shape());
+			cgal_shape_t entity_shape(entity_shape_unlocated);
+			if (!it->Placement().components.isIdentity()) {
+				cgal_placement_t trsf;
+				convert_placement(it->Placement(), trsf);
+				for (auto &vertex : vertices(entity_shape)) {
+					if (false) {
+						auto x = CGAL::to_double(vertex->point().x());
+						auto y = CGAL::to_double(vertex->point().y());
+						auto z = CGAL::to_double(vertex->point().z());
+						std::wcout << x << " " << y << " " << z << std::endl;
+					}
+					vertex->point() = vertex->point().transform(trsf);
+					if (false) {
+						auto x = CGAL::to_double(vertex->point().x());
+						auto y = CGAL::to_double(vertex->point().y());
+						auto z = CGAL::to_double(vertex->point().z());
+						std::wcout << x << " " << y << " " << z << std::endl;
+					}
+				}
+			}
+
+			CGAL::Nef_polyhedron_3<Kernel_> nef;
+			preprocess_boolean_operand(c->instance, entity_shape, nef,
+				// Dilate boolean subtraction operands
+				(!first && br->operation == taxonomy::boolean_result::SUBTRACTION));
+
+			if (first) {
+				a = nef;
+			} else {
+				if (br->operation == taxonomy::boolean_result::SUBTRACTION) {
+					a -= nef;
+				} else if (br->operation == taxonomy::boolean_result::INTERSECTION) {
+					a *= nef;
+				} else if (br->operation == taxonomy::boolean_result::UNION) {
+					a += nef;
+				}
+			}
+		}
+
+		first = false;
+	}
+
+	cgal_shape_t a_poly, b_poly;
+
+	// CGAL::Nef_polyhedron_3<Kernel_> b;
+	// thin_solid(a, b);
+
+	try {
+		a.convert_to_polyhedron(a_poly);
+	} catch (...) {
+		Logger::Message(Logger::LOG_ERROR, "Could not convert geometry with openings from Nef:", br->instance);
+		return false;
+	}
+
+	results.emplace_back(ConversionResult(
+		br->instance->data().id(),
+		br->matrix,
+		new CgalShape(a_poly),
+		br->surface_style.diffuse ? br->surface_style : first_item_style
+	));
+	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,142 @@
+/********************************************************************************
+*                                                                              *
+* 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:
+  PolyhedronBuilder(std::list<cgal_face_t> *face_list) {
+    this->face_list = face_list;
+  }
+  
+  void operator()(CGAL::Polyhedron_3<Kernel_>::HalfedgeDS &hds) {
+    std::list<Kernel_::Point_3> points;
+    std::list<std::list<std::size_t>> facet_vertices;
+    CGAL::Polyhedron_incremental_builder_3<CGAL::Polyhedron_3<Kernel_>::HalfedgeDS> builder(hds, true);
+    
+    for (auto &face: *face_list) {
+      facet_vertices.push_back(std::list<std::size_t>());
+      for (auto &point: face.outer) {
+        facet_vertices.back().push_back(points.size());
+        points.push_back(point);
+      }
+    }
+    
+    builder.begin_surface(points.size(), facet_vertices.size());
+    
+    for (auto &point: points) {
+//      std::cout << "Adding point " << point << std::endl;
+      builder.add_vertex(point);
+    }
+    
+    for (auto &facet: facet_vertices) {
+      builder.begin_facet();
+//      std::cout << "Adding facet ";
+      for (auto &vertex: facet) {
+//        std::cout << vertex << " ";
+        builder.add_vertex_to_facet(vertex);
+      }
+//      std::cout << std::endl;
+      builder.end_facet();
+    }
+    
+    builder.end_surface();
+  }
+};
+
+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);
+	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);
+	public:
+
+		CgalKernel()
+			: AbstractKernel("cgal")
+			// @todo
+			, precision_(1.e-5)
+			, circle_segments_(16)
+		{
+			auto cc = utils::create_cube(precision_);
+			precision_cube_ = CGAL::Nef_polyhedron_3<Kernel_>(cc);
+		}
+
+		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&);
+		
+		// virtual bool convert_impl(const taxonomy::face*, ifcopenshell::geometry::ConversionResults&);
+		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&);
+
+		const CGAL::Nef_polyhedron_3<Kernel_>& precision_cube() const { return precision_cube_; }
+	};
+
+}
+}
+}
+#endif

src/ifcgeom/kernels/opencascade/IfcGeomCurves.cpp_

@@ -77,13 +77,13 @@
 
 #include <TopLoc_Location.hxx>
 
-#include "../ifcgeom/IfcGeom.h"
+#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
 
 #ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
 #include <Geom_BSplineCurve.hxx>
 #endif
 
-#define Kernel MAKE_TYPE_NAME(Kernel)
+#define Kernel POSTFIX_SCHEMA(Kernel)
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircle* l, Handle(Geom_Curve)& curve) {
 	const double r = l->Radius() * getValue(GV_LENGTH_UNIT);

src/ifcgeom/kernels/opencascade/IfcGeomFaces.cpp_

@@ -97,7 +97,7 @@
 
 #include <BRepLib_FindSurface.hxx>
 
-#include "../ifcgeom/IfcGeom.h"
+#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
 
 #ifdef SCHEMA_HAS_IfcBSplineSurfaceWithKnots
 #include <Geom_BSplineSurface.hxx>
@@ -106,7 +106,7 @@
 #include <TColStd_Array1OfInteger.hxx>
 #endif
 
-#define Kernel MAKE_TYPE_NAME(Kernel)
+#define Kernel POSTFIX_SCHEMA(Kernel)
 
 namespace {
 	/* Returns whether wire conforms to a polyhedron, i.e. only edges with linear curves*/

src/ifcgeom/kernels/opencascade/IfcGeomHelpers.cpp_

@@ -75,9 +75,9 @@
 
 #include <TopLoc_Location.hxx>
 
-#include "../ifcgeom/IfcGeom.h"
+#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
 
-#define Kernel MAKE_TYPE_NAME(Kernel)
+#define Kernel POSTFIX_SCHEMA(Kernel)
 
 namespace {
 
@@ -385,10 +385,6 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcAxis2Placement2D* l, gp_Trsf2d
 	return true;
 }
 
-void IfcGeom::Kernel::set_conversion_placement_rel_to(const IfcParse::declaration* type) {
-	placement_rel_to = type;
-}
-
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcObjectPlacement* l, gp_Trsf& trsf) {
 	IN_CACHE(IfcObjectPlacement,l,gp_Trsf,trsf)
 	if ( ! l->declaration().is(IfcSchema::IfcLocalPlacement::Class()) ) {

src/ifcgeom/kernels/opencascade/IfcGeomSerialisation.cpp_

@@ -493,7 +493,7 @@ int convert_to_ifc(const TopoDS_Shape& s, U*& item, bool advanced) {
 	return faces->size();
 }
 
-IfcUtil::IfcBaseClass* IfcGeom::MAKE_TYPE_NAME(serialise_)(const TopoDS_Shape& shape, bool advanced) {
+IfcUtil::IfcBaseClass* IfcGeom::POSTFIX_SCHEMA(serialise_)(const TopoDS_Shape& shape, bool advanced) {
 #ifndef USE_IFC4
 	advanced = false;
 #endif
@@ -604,7 +604,7 @@ IfcUtil::IfcBaseClass* IfcGeom::MAKE_TYPE_NAME(serialise_)(const TopoDS_Shape& s
 	return new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
 }
 
-IfcUtil::IfcBaseClass* IfcGeom::MAKE_TYPE_NAME(tesselate_)(const TopoDS_Shape& shape, double deflection) {
+IfcUtil::IfcBaseClass* IfcGeom::POSTFIX_SCHEMA(tesselate_)(const TopoDS_Shape& shape, double deflection) {
 	BRepMesh_IncrementalMesh(shape, deflection);
 
 	IfcSchema::IfcFace::list::ptr faces(new IfcSchema::IfcFace::list);

src/ifcgeom/kernels/opencascade/IfcGeomShapes.cpp_

@@ -101,11 +101,11 @@
 
 #include <TopTools_ListIteratorOfListOfShape.hxx>
 
-#include "../ifcgeom/IfcGeom.h"
+#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
 
 #include <memory>
 
-#define Kernel MAKE_TYPE_NAME(Kernel)
+#define Kernel POSTFIX_SCHEMA(Kernel)
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolid* l, TopoDS_Shape& shape) {
 	const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
@@ -366,7 +366,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRevolvedAreaSolid* l, TopoDS_S
 	return !shape.IsNull();
 }
 
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, IfcRepresentationShapeItems& shape) {
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, ConversionResults& shape) {
 	TopoDS_Shape s;
 	const SurfaceStyle* collective_style = get_style(l);
 	if (convert_shape(l->Outer(),s) ) {
@@ -391,13 +391,13 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, IfcRepre
 			}
 		}
 
-		shape.push_back(IfcRepresentationShapeItem(l->data().id(), s, indiv_style ? indiv_style : collective_style));
+		shape.push_back(ConversionResult(l->data().id(), new OpenCascadeShape(s), indiv_style ? indiv_style : collective_style));
 		return true;
 	}
 	return false;
 }
 
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcFaceBasedSurfaceModel* l, IfcRepresentationShapeItems& shapes) {
+bool IfcGeom::Kernel::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);
@@ -405,7 +405,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFaceBasedSurfaceModel* l, IfcR
 		TopoDS_Shape s;
 		const SurfaceStyle* shell_style = get_style(*it);
 		if (convert_shape(*it,s)) {
-			shapes.push_back(IfcRepresentationShapeItem(l->data().id(), s, shell_style ? shell_style : collective_style));
+			shapes.push_back(ConversionResult(l->data().id(), new OpenCascadeShape(s), shell_style ? shell_style : collective_style));
 			part_success |= true;
 		}
 	}
@@ -459,7 +459,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolygonalBoundedHalfSpace* l,
 	return true;
 }
 
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, IfcRepresentationShapeItems& shapes) {
+bool IfcGeom::Kernel::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 ) {
@@ -469,7 +469,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, Ifc
 			shell_style = get_style((IfcSchema::IfcRepresentationItem*)*it);
 		}
 		if (convert_shape(*it,s)) {
-			shapes.push_back(IfcRepresentationShapeItem(l->data().id(), s, shell_style ? shell_style : collective_style));
+			shapes.push_back(ConversionResult(l->data().id(), new OpenCascadeShape(s), shell_style ? shell_style : collective_style));
 		}
 	}
 	return true;
@@ -477,8 +477,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, Ifc
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape& shape) {
 
-	TopoDS_Shape s1;
-	IfcRepresentationShapeItems items1;
+	TopoDS_Shape s1, s2;
+	ConversionResults items1;
 	TopoDS_Wire boundary_wire;
 	IfcSchema::IfcBooleanOperand* operand1 = l->FirstOperand();
 	IfcSchema::IfcBooleanOperand* operand2 = l->SecondOperand();
@@ -556,7 +556,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape
 
 		{
 			if (shape_type(op2) == ST_SHAPELIST) {
-				IfcRepresentationShapeItems items2;
+				ConversionResults items2;
 				shape2_processed = convert_shapes(op2, items2) && flatten_shape_list(items2, s2, true);
 			} else if (shape_type(op2) == ST_SHAPE) {
 				shape2_processed = convert_shape(op2, s2);
@@ -711,7 +711,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh
 	return true;
 }
 
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, IfcRepresentationShapeItems& shapes) {
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, ConversionResults& shapes) {
 	gp_GTrsf gtrsf;
 	IfcSchema::IfcCartesianTransformationOperator* transform = l->MappingTarget();
 	if ( transform->declaration().is(IfcSchema::IfcCartesianTransformationOperator3DnonUniform::Class()) ) {
@@ -746,7 +746,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, IfcRepresentati
 	bool b = convert_shapes(map->MappedRepresentation(), shapes);
 	
 	for (size_t i = previous_size; i < shapes.size(); ++ i ) {
-		shapes[i].prepend(gtrsf);
+		OpenCascadePlacement p(gtrsf);
+		shapes[i].prepend(&p);
 
 		// Apply styles assigned to the mapped item only if on
 		// a more granular level no styles have been applied
@@ -758,7 +759,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, IfcRepresentati
 	return b;
 }
 
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcRepresentation* l, IfcRepresentationShapeItems& shapes) {
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRepresentation* l, ConversionResults& shapes) {
 	IfcSchema::IfcRepresentationItem::list::ptr items = l->Items();
 	bool part_succes = false;
 	if ( items->size() ) {
@@ -769,7 +770,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRepresentation* l, IfcRepresen
 			} else {
 				TopoDS_Shape s;
 				if (convert_shape(representation_item,s)) {
-					shapes.push_back(IfcRepresentationShapeItem(representation_item->data().id(), s, get_style(representation_item)));
+					shapes.push_back(ConversionResult(representation_item->data().id(), new OpenCascadeShape(s), get_style(representation_item)));
 					part_succes |= true;
 				}
 			}
@@ -778,7 +779,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRepresentation* l, IfcRepresen
 	return part_succes;
 }
 
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcGeometricSet* l, IfcRepresentationShapeItems& shapes) {
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcGeometricSet* l, ConversionResults& shapes) {
 	IfcEntityList::ptr elements = l->Elements();
 	if ( !elements->size() ) return false;
 	bool part_succes = false;
@@ -796,7 +797,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcGeometricSet* l, IfcRepresenta
 			} else if (element->declaration().is(IfcSchema::IfcSurface::Class())) {
 				style = get_style((IfcSchema::IfcSurface*) element);
 			}
-			shapes.push_back(IfcRepresentationShapeItem(l->data().id(), s, style ? style : parent_style));
+			shapes.push_back(ConversionResult(l->data().id(), new OpenCascadeShape(s), style ? style : parent_style));
 		}
 	}
 	return part_succes;

src/ifcgeom/kernels/opencascade/IfcGeomTree.h

@@ -20,10 +20,11 @@
 #ifndef IFCGEOMTREE_H
 #define IFCGEOMTREE_H
 
-#include "../ifcparse/IfcFile.h"
-#include "../ifcgeom/IfcGeomElement.h"
-#include "../ifcgeom_schema_agnostic/IfcGeomIterator.h"
-#include "../ifcgeom_schema_agnostic/Kernel.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/OpenCascadeConversionResult.h"
 
 #include <NCollection_UBTree.hxx>
 #include <BRepBndLib.hxx>
@@ -32,7 +33,7 @@
 #include <BRepAlgoAPI_Cut.hxx>
 #include <BRepClass3d_SolidClassifier.hxx>
 
-namespace IfcGeom {
+namespace ifcopenshell { namespace geometry {
 
 	namespace impl {
 		template <typename T>
@@ -113,7 +114,8 @@ namespace IfcGeom {
 				std::vector<T> ts_filtered;
 
 				const TopoDS_Shape& A = shapes_.find(t)->second;
-				if (IfcGeom::Kernel::count(A, TopAbs_SHELL) == 0) {
+				OpenCascadeShape SA(A);
+				if (IfcGeom::Kernel::count(&SA, (int) TopAbs_SHELL) == 0) {
 					return ts_filtered;
 				}
 
@@ -122,21 +124,24 @@ namespace IfcGeom {
 				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 (IfcGeom::Kernel::count(B, TopAbs_SHELL) == 0) {
+					OpenCascadeShape SB(B);
+					if (IfcGeom::Kernel::count(&SB, (int) TopAbs_SHELL) == 0) {
 						continue;
 					}
 
 					if (completely_within) {
 						BRepAlgoAPI_Cut cut(B, A);
 						if (cut.IsDone()) {
-							if (IfcGeom::Kernel::count(cut.Shape(), TopAbs_SHELL) == 0) {
+							OpenCascadeShape Sc(cut.Shape());
+							if (IfcGeom::Kernel::count(&Sc, (int) TopAbs_SHELL) == 0) {
 								ts_filtered.push_back(*it);
 							}
 						}
 					} else {
 						BRepAlgoAPI_Common common(A, B);
 						if (common.IsDone()) {
-							if (IfcGeom::Kernel::count(common.Shape(), TopAbs_SHELL) > 0) {
+							OpenCascadeShape Sc(common.Shape());
+							if (IfcGeom::Kernel::count(&Sc, (int) TopAbs_SHELL) > 0) {
 								ts_filtered.push_back(*it);
 							}
 						}
@@ -152,7 +157,8 @@ namespace IfcGeom {
 
 				std::vector<T> ts;
 
-				if (IfcGeom::Kernel::count(s, TopAbs_SHELL) == 0) {
+				OpenCascadeShape Ss(s);
+				if (IfcGeom::Kernel::count(&Ss, (int) TopAbs_SHELL) == 0) {
 					return ts;
 				}
 
@@ -169,13 +175,15 @@ namespace IfcGeom {
 				for (it = ts.begin(); it != ts.end(); ++it) {
 					const TopoDS_Shape& B = shapes_.find(*it)->second;
 					
-					if (IfcGeom::Kernel::count(B, TopAbs_SHELL) == 0) {
+					OpenCascadeShape SB(B);
+					if (IfcGeom::Kernel::count(&SB, (int) TopAbs_SHELL) == 0) {
 						continue;
 					}
 
 					BRepAlgoAPI_Common common(s, B);
 					if (common.IsDone()) {
-						if (IfcGeom::Kernel::count(common.Shape(), TopAbs_SHELL) > 0) {
+						OpenCascadeShape Sc(common.Shape());;
+						if (IfcGeom::Kernel::count(&Sc, (int) TopAbs_SHELL) > 0) {
 							ts_filtered.push_back(*it);
 						}
 					}
@@ -251,30 +259,30 @@ namespace IfcGeom {
 		tree() {};
 
 		tree(IfcParse::IfcFile& f) {
-			add_file(f, IfcGeom::IteratorSettings());
+			add_file(f, ifcopenshell::geometry::settings());
 		}
 
-		tree(IfcParse::IfcFile& f, const IfcGeom::IteratorSettings& settings) {
+		tree(IfcParse::IfcFile& f, const ifcopenshell::geometry::settings& settings) {
 			add_file(f, settings);
 		}
 
-		void add_file(IfcParse::IfcFile& f, const IfcGeom::IteratorSettings& settings) {
-			IfcGeom::IteratorSettings settings_ = settings;
-			settings_.set(IfcGeom::IteratorSettings::DISABLE_TRIANGULATION, true);
-			settings_.set(IfcGeom::IteratorSettings::USE_WORLD_COORDS, true);
-			settings_.set(IfcGeom::IteratorSettings::SEW_SHELLS, true);
+		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);
 
-			IfcGeom::Iterator<double> it(settings_, &f);
+			Iterator it(settings_, &f);
 
 			if (it.initialize()) {
 				do {
-					IfcGeom::BRepElement<double>* elem = (IfcGeom::BRepElement<double>*)it.get();
-					add((IfcUtil::IfcBaseEntity*)f.instance_by_id(elem->id()), elem->geometry().as_compound());
+					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/IfcGeomWires.cpp_

@@ -95,9 +95,9 @@
 #include <BRepAdaptor_HCompCurve.hxx>
 #include <Approx_Curve3d.hxx>
 
-#include "../ifcgeom/IfcGeom.h"
+#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
 
-#define Kernel MAKE_TYPE_NAME(Kernel)
+#define Kernel POSTFIX_SCHEMA(Kernel)
 
 namespace {
 	// Returns the other vertex of an edge

src/ifcgeom/kernels/opencascade/OpenCascadeConversionResult.cpp

@@ -0,0 +1,201 @@
+#include "OpenCascadeConversionResult.h"
+
+#include "../../../ifcparse/IfcLogger.h"
+#include "../../../ifcgeom/schema_agnostic/IfcGeomRepresentation.h"
+
+#include <TopoDS.hxx>
+
+#include <map>
+
+void ifcopenshell::geometry::OpenCascadeShape::Triangulate(const settings& settings, const ifcopenshell::geometry::taxonomy::matrix4& place, Representation::Triangulation* t, int surface_style_id) const {
+
+	// @todo check
+	gp_GTrsf trsf;
+	gp_Trsf tr;
+	const auto& m = place.components;
+	tr.SetValues(
+		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)
+	);
+	trsf = tr;
+
+	// 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()) {
+
+			// 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 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());
+				trsf.Transforms(*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) {
+						normal = gp_Dir(normal_direction.XYZ() * rotation_matrix);
+					}
+					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");
+}

src/ifcgeom/kernels/opencascade/OpenCascadeConversionResult.h

@@ -1,4 +1,4 @@
-/********************************************************************************
+/********************************************************************************
 *                                                                              *
 * This file is part of IfcOpenShell.                                           *
 *                                                                              *
@@ -17,22 +17,54 @@
 *                                                                              *
 ********************************************************************************/
 
-#ifndef IFCGEOMSHAPETYPE_H
-#define IFCGEOMSHAPETYPE_H
+#ifndef IFCGEOMOPENCASCADEREPRESENTATION_H
+#define IFCGEOMOPENCASCADEREPRESENTATION_H
 
-namespace IfcGeom {
+#include <BRepMesh_IncrementalMesh.hxx>
+#include <BRepGProp_Face.hxx>
 
-	enum ShapeType {
-		ST_SHAPELIST,
-		ST_SHAPE,
-		ST_FACE,
-		ST_WIRE,
-		ST_CURVE,
-		ST_EDGE,
-		ST_VERTEX,
-		ST_OTHER
-	};
+#include <Poly_Triangulation.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
 
+#include <TopExp_Explorer.hxx>
+#include <BRepTools.hxx>
+
+#include <gp_GTrsf.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <GCPnts_QuasiUniformDeflection.hxx>
+
+#include "../../../ifcgeom/schema_agnostic/ConversionResult.h"
+
+namespace ifcopenshell {
+	namespace geometry {
+
+		class OpenCascadeShape : public ConversionResultShape {
+		public:
+			OpenCascadeShape(const TopoDS_Shape& shape)
+				: shape_(shape) {}
+
+			const TopoDS_Shape& shape() const { return shape_; }
+			operator const TopoDS_Shape& () { 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 OpenCascadeShape(shape_);
+			}
+
+			virtual bool is_manifold() const;
+
+			virtual int surface_genus() const;
+		private:
+			TopoDS_Shape shape_;
+		};
+
+	}
 }
 
 #endif

src/ifcgeom/kernels/opencascade/OpenCascadeKernel.h

@@ -0,0 +1,269 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 OPENCASCADEKERNEL_H
+#define OPENCASCADEKERNEL_H
+
+#include <cmath>
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Mat.hxx>
+#include <gp_Mat2d.hxx>
+#include <gp_GTrsf.hxx>
+#include <gp_GTrsf2d.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <Geom_Curve.hxx>
+#include <gp_Pln.hxx>
+#include <TColgp_SequenceOfPnt.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <BOPAlgo_Operation.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+
+#include "../../../ifcgeom/kernel_agnostic/AbstractKernel.h" 
+
+#include "../../../ifcgeom/schema_agnostic/IfcGeomElement.h" 
+#include "../../../ifcgeom/schema_agnostic/IfcGeomRepresentation.h" 
+#include "../../../ifcgeom/schema_agnostic/ConversionResult.h"
+
+#include "../../../ifcgeom/kernels/opencascade/OpenCascadeConversionResult.h"
+
+#include "../../../ifcgeom/schema_agnostic/ifc_geom_api.h"
+
+#include "../../../ifcgeom/taxonomy.h"
+
+// Define this in case you want to conserve memory usage at all cost. This has been
+// benchmarked extensively: https://github.com/IfcOpenShell/IfcOpenShell/pull/47
+// #define NO_CACHE
+
+#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->data().id());\
+if ( it != cache.T.end() ) { e = it->second; return true; }
+#define CACHE(T,E,e) cache.T[E->data().id()] = e;
+
+#endif
+
+namespace ifcopenshell {
+namespace geometry {
+namespace kernels {
+
+	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") {}
+	};
+
+	/*
+	class IFC_GEOM_API POSTFIX_SCHEMA(Cache) {
+	public:
+#include "IfcRegisterCreateCache.h"
+		std::map<int, TopoDS_Shape> Shape;
+	};
+	*/
+
+	
+	class IFC_GEOM_API OpenCascadeKernel : public AbstractKernel {
+	private:
+		// faceset_helper traverses the forward instance references of IfcConnectedFaceSet and then provides a mapping
+		// M of (IfcCartesianPoint, IfcCartesianPoint) -> TopoDS_Edge, where M(a, b) is a partner of M(b, a), ie share
+		// the same underlying edge but with orientation reversed. This then later speeds op the process of creating a
+		// manifold Shell / Solid from this set of faces. Only IfcPolyLoop instances are used. Points within the tolerance
+		// threshiold are merged, so consider points a, b, c, distance(a, b) < eps then M(a, b) = Null, M(a, b) = M(a, c).
+		class faceset_helper {
+		private:
+			OpenCascadeKernel* kernel_;
+			std::set<int> duplicates_;
+			std::map<int, int> vertex_mapping_;
+			std::map<std::pair<int, int>, TopoDS_Edge> edges_;
+			double eps_;
+			bool non_manifold_;
+
+			template <typename Fn>
+			void loop_(const taxonomy::loop* ps, const Fn& callback) {
+				if (ps->children.size() < 3) {
+					return;
+				}
+
+				auto a = boost::get<taxonomy::point3>(((taxonomy::edge*) ps->children.back())->start).instance;
+				auto A = a->data().id();
+				for (auto& b : ps->children) {
+					auto B = boost::get<taxonomy::point3>(((taxonomy::edge*) b)->start).instance->data().id();
+					auto C = vertex_mapping_[A], D = vertex_mapping_[B];
+					bool fwd = C < D;
+					if (!fwd) {
+						std::swap(C, D);
+					}
+					if (C != D) {
+						callback(C, D, fwd);
+						A = B;
+					}
+				}
+			}
+		public:
+			faceset_helper(OpenCascadeKernel* kernel, const taxonomy::shell* l);
+
+			~faceset_helper();
+
+			bool non_manifold() const { return non_manifold_; }
+			bool& non_manifold() { return non_manifold_; }
+
+			bool edge(const taxonomy::point3& a, const taxonomy::point3& b, TopoDS_Edge& e) {
+				int A = vertex_mapping_[a.instance->data().id()];
+				int B = vertex_mapping_[b.instance->data().id()];
+				if (A == B) {
+					return false;
+				}
+
+				return edge(A, B, e);
+			}
+
+			bool edge(int A, int B, TopoDS_Edge& e) {
+				auto it = edges_.find({ A, B });
+				if (it == edges_.end()) {
+					return false;
+				}
+				e = it->second;
+				return true;
+			}
+
+			bool wire(const taxonomy::loop* loop, TopoDS_Wire& wire) {
+				if (duplicates_.find(loop->instance->data().id()) != duplicates_.end()) {
+					return false;
+				}
+				BRep_Builder builder;
+				builder.MakeWire(wire);
+				int count = 0;
+				loop_(loop, [this, &builder, &wire, &count](int A, int B, bool fwd) {
+					TopoDS_Edge e;
+					if (edge(A, B, e)) {
+						if (!fwd) {
+							e.Reverse();
+						}
+						builder.Add(wire, e);
+						count += 1;
+					}
+				});
+				if (count >= 3) {
+					wire.Closed(true);
+
+					/*
+					@todo
+					TopTools_ListOfShape results;
+					if (kernel_->wire_intersections(wire, results)) {
+						Logger::Warning("Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected", loop);
+						kernel_->select_largest(results, wire);
+						non_manifold_ = true;
+					}
+					*/
+
+					return true;
+				} else {
+					return false;
+				}
+			}
+
+			double epsilon() const {
+				return eps_;
+			}
+		};		
+
+/*
+#ifndef NO_CACHE
+		POSTFIX_SCHEMA(Cache) cache;
+#endif
+*/
+
+	faceset_helper* faceset_helper_;
+	double precision_;
+
+	public:
+		OpenCascadeKernel()
+			: AbstractKernel("opencascade")
+			, faceset_helper_(nullptr)
+			// @todo
+			, precision_(1.e-5) {}
+
+		OpenCascadeKernel(const OpenCascadeKernel& other)
+			: AbstractKernel("opencascade") {
+			*this = other;
+		}
+
+		double shape_volume(const TopoDS_Shape&);
+		double face_area(const TopoDS_Face&);
+		int count(const TopoDS_Shape& s, TopAbs_ShapeEnum t, bool unique = false);
+
+		bool create_solid_from_compound(const TopoDS_Shape& compound, TopoDS_Shape& shape);
+		bool create_solid_from_faces(const TopTools_ListOfShape& face_list, TopoDS_Shape& shape);
+
+		bool convert(const taxonomy::extrusion*, TopoDS_Shape&);
+		bool convert(const taxonomy::face*, TopoDS_Shape&);
+		bool convert(const taxonomy::loop*, TopoDS_Wire&);
+		bool convert(const taxonomy::matrix4*, gp_GTrsf&);
+		bool convert(const taxonomy::shell*, TopoDS_Shape&);
+
+		bool approximate_plane_through_wire(const TopoDS_Wire& wire, gp_Pln& plane, double eps = -1.);
+		bool triangulate_wire(const std::vector<TopoDS_Wire>& wires, TopTools_ListOfShape& faces);
+		bool boolean_operation(const TopoDS_Shape& a_, const TopTools_ListOfShape& b__, BOPAlgo_Operation op, TopoDS_Shape& result, double fuzziness = -1.);
+		const TopoDS_Shape& ensure_fit_for_subtraction(const TopoDS_Shape& shape, TopoDS_Shape& solid);
+		bool flatten_shape_list(const ifcopenshell::geometry::ConversionResults& shapes, TopoDS_Shape& result, bool fuse);
+		bool is_compound(const TopoDS_Shape& shape);
+
+		TopoDS_Shape apply_transformation(const TopoDS_Shape& s, const taxonomy::matrix4& t);
+		TopoDS_Shape apply_transformation(const TopoDS_Shape& s, const gp_GTrsf& t);
+		TopoDS_Shape apply_transformation(const TopoDS_Shape& s, const gp_Trsf& t);
+
+		virtual bool convert_impl(const taxonomy::face*, ifcopenshell::geometry::ConversionResults&);
+		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&);
+	};
+
+	/*
+	IfcUtil::IfcBaseClass* POSTFIX_SCHEMA(tesselate_)(const TopoDS_Shape& shape, double deflection);
+	IfcUtil::IfcBaseClass* POSTFIX_SCHEMA(serialise_)(const TopoDS_Shape& shape, bool advanced);
+	*/
+
+}
+}
+}
+
+#endif

src/ifcgeom/schema/bind_convert_decl.i

@@ -0,0 +1,7 @@
+#ifdef BIND
+#undef BIND
+#endif
+
+#define BIND(T) ifcopenshell::geometry::taxonomy::item* map_impl(const IfcSchema::T*);
+
+#include "mapping.i"

src/ifcgeom/schema/bind_convert_impl.i

@@ -0,0 +1,29 @@
+#ifdef BIND
+#undef BIND
+#endif
+
+#define BIND(T) \
+	if (l->declaration().is(IfcSchema::T::Class())) { \
+		try { \
+			taxonomy::item* item = map_impl((IfcSchema::T*)l); \
+			if (item != nullptr) { \
+				item->instance = l; \
+				try { \
+					if (l->as<IfcSchema::IfcRepresentationItem>() && !l->as<IfcSchema::IfcStyledItem>()) { \
+						auto style = find_style(l->as<IfcSchema::IfcRepresentationItem>()); \
+						if (style) { \
+							((taxonomy::geom_item*)item)->surface_style = as<taxonomy::style>(map(style)); \
+						} \
+					} \
+				} catch (const std::exception& e) { \
+					Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + "\nFailed to convert:", l); \
+				} \
+			} \
+			return item; \
+		} catch (const std::exception& e) { \
+			Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + "\nFailed to convert:", l); \
+		} \
+		return false; \
+	}
+
+#include "mapping.i"

src/ifcgeom/schema/mapping.h

@@ -0,0 +1,44 @@
+#include "../abstract_mapping.h"
+#include "../../ifcparse/macros.h"
+#include "../../ifcparse/IfcFile.h"
+
+#define INCLUDE_SCHEMA(x) STRINGIFY(../../ifcparse/x.h)
+#include INCLUDE_SCHEMA(IfcSchema)
+#undef INCLUDE_SCHEMA
+#define INCLUDE_SCHEMA(x) STRINGIFY(../../ifcparse/x-definitions.h)
+#include INCLUDE_SCHEMA(IfcSchema)
+#undef INCLUDE_SCHEMA
+
+namespace ifcopenshell {
+
+namespace geometry {
+    
+    class POSTFIX_SCHEMA(mapping) : public abstract_mapping {
+	private:
+		IfcParse::IfcFile* file_;
+		double length_unit_, angle_unit_;
+		std::string length_unit_name_;
+		const IfcParse::declaration* placement_rel_to_;
+		
+		void initialize_units_();
+	public:
+		POSTFIX_SCHEMA(mapping)(IfcParse::IfcFile* file, settings& settings) : abstract_mapping(settings), file_(file), placement_rel_to_(0) {
+			initialize_units_();
+		}
+		virtual ifcopenshell::geometry::taxonomy::item* map(const IfcUtil::IfcBaseClass*);
+		virtual void get_representations(std::vector<geometry_conversion_task>& tasks, std::vector<filter_t>& filters, settings& s);
+		virtual std::map<std::string, IfcUtil::IfcBaseEntity*> get_layers(IfcUtil::IfcBaseEntity*);
+		
+		const IfcSchema::IfcMaterial* get_single_material_association(const IfcSchema::IfcProduct* product);
+		IfcSchema::IfcRepresentation* representation_mapped_to(const IfcSchema::IfcRepresentation* representation);
+		IfcSchema::IfcProduct::list::ptr products_represented_by(const IfcSchema::IfcRepresentation* representation);
+		bool reuse_ok_(settings& s, const IfcSchema::IfcProduct::list::ptr& products);
+		IfcEntityList::ptr find_openings(const IfcSchema::IfcProduct* product);
+		IfcUtil::IfcBaseEntity* get_decomposing_entity(IfcUtil::IfcBaseEntity* product, bool include_openings);
+
+#include "bind_convert_decl.i"
+    };
+    
+}
+
+}

src/ifcgeom/schema/mapping.i

@@ -0,0 +1,135 @@
+/********************************************************************************
+*                                                                              *
+* 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.																	*
+ *                                                                              *
+ ********************************************************************************/
+
+BIND(IfcProduct);
+
+// BIND(IfcShellBasedSurfaceModel);
+BIND(IfcFaceBasedSurfaceModel);
+BIND(IfcRepresentation);
+BIND(IfcMappedItem);
+// IfcFacetedBrep included
+// IfcAdvancedBrep included
+// IfcFacetedBrepWithVoids included
+// IfcAdvancedBrepWithVoids included
+BIND(IfcManifoldSolidBrep);
+BIND(IfcGeometricSet);
+
+#ifdef SCHEMA_HAS_IfcCylindricalSurface
+// BIND(IfcCylindricalSurface);
+#endif
+#ifdef SCHEMA_HAS_IfcAdvancedBrep
+// BIND(IfcAdvancedBrep);
+#endif
+// FIXME: Surfaces should have a shape type of their own
+#ifdef SCHEMA_HAS_IfcBSplineSurfaceWithKnots
+// BIND(IfcBSplineSurfaceWithKnots);
+#endif
+#ifdef SCHEMA_HAS_IfcTriangulatedFaceSet
+// BIND(IfcTriangulatedFaceSet);
+#endif
+#ifdef SCHEMA_HAS_IfcExtrudedAreaSolidTapered
+// BIND(IfcExtrudedAreaSolidTapered);
+#endif
+BIND(IfcExtrudedAreaSolid);
+// BIND(IfcRevolvedAreaSolid);
+BIND(IfcConnectedFaceSet);
+BIND(IfcBooleanResult);
+BIND(IfcPolygonalBoundedHalfSpace);
+BIND(IfcHalfSpaceSolid);
+// BIND(IfcSurfaceOfLinearExtrusion);
+// BIND(IfcSurfaceOfRevolution);
+// BIND(IfcBlock);
+// BIND(IfcRectangularPyramid);
+// BIND(IfcRightCircularCylinder);
+// BIND(IfcRightCircularCone);
+// BIND(IfcSphere);
+// BIND(IfcCsgSolid);
+// BIND(IfcCurveBoundedPlane);
+// BIND(IfcRectangularTrimmedSurface);
+// BIND(IfcSurfaceCurveSweptAreaSolid);
+// BIND(IfcSweptDiskSolid);
+
+// IfcArbitraryProfileDefWithVoids included
+BIND(IfcArbitraryClosedProfileDef);
+// BIND(IfcRoundedRectangleProfileDef);
+// BIND(IfcRectangleHollowProfileDef);
+BIND(IfcRectangleProfileDef);
+// BIND(IfcTrapeziumProfileDef)
+// BIND(IfcCShapeProfileDef);
+// IfcAsymmetricIShapeProfileDef included
+// BIND(IfcIShapeProfileDef);
+// BIND(IfcLShapeProfileDef);
+// BIND(IfcTShapeProfileDef);
+// BIND(IfcUShapeProfileDef);
+// BIND(IfcZShapeProfileDef);
+// BIND(IfcCircleHollowProfileDef);
+// BIND(IfcCircleProfileDef);
+// BIND(IfcEllipseProfileDef);
+// BIND(IfcCenterLineProfileDef);
+// BIND(IfcCompositeProfileDef);
+// BIND(IfcDerivedProfileDef);
+// IfcFaceSurface included
+// IfcAdvancedFace included in case of IFC4
+BIND(IfcFace);
+
+// BIND(IfcEdgeCurve);
+// BIND(IfcSubedge);
+// BIND(IfcOrientedEdge);
+// BIND(IfcEdge);
+// BIND(IfcEdgeLoop);
+BIND(IfcPolyline);
+BIND(IfcPolyLoop);
+BIND(IfcCompositeCurve);
+BIND(IfcTrimmedCurve);
+// BIND(IfcArbitraryOpenProfileDef);
+#ifdef SCHEMA_HAS_IfcIndexedPolyCurve
+// BIND(IfcIndexedPolyCurve)
+#endif
+
+BIND(IfcCircle);
+// BIND(IfcEllipse);
+// BIND(IfcLine);
+#ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
+// IfcRationalBSplineCurveWithKnots included
+// BIND(IfcBSplineCurveWithKnots);
+#endif
+
+BIND(IfcCartesianPoint);
+BIND(IfcDirection);
+BIND(IfcAxis2Placement2D);
+BIND(IfcAxis2Placement3D);
+// BIND(IfcAxis1Placement);
+BIND(IfcCartesianTransformationOperator2DnonUniform);
+BIND(IfcCartesianTransformationOperator3DnonUniform);
+BIND(IfcCartesianTransformationOperator2D);
+BIND(IfcCartesianTransformationOperator3D);
+BIND(IfcLocalPlacement);
+// BIND(IfcVector);
+// BIND(IfcPlane);
+
+// BIND(IfcColourRgb);
+BIND(IfcMaterial);
+BIND(IfcStyledItem);

src/ifcgeom/schema_agnostic/ConversionResult.h

@@ -0,0 +1,95 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 "../../ifcgeom/schema_agnostic/IfcGeomRenderStyles.h"
+#include "../../ifcgeom/settings.h"
+#include "../../ifcgeom/taxonomy.h"
+
+namespace ifcopenshell { namespace geometry {
+
+	namespace Representation {
+		class IFC_GEOM_API Triangulation;
+	}
+
+	// @todo, this class is no longer necessary, we can directly use
+	// taxonomy::matrix4, which does not need to be implemented specifically
+	// in the respective kernels
+	/*
+	class IFC_GEOM_API ConversionResultPlacement {
+	public:
+		virtual void Multiply(const ifcopenshell::geometry::taxonomy::matrix4&) = 0;
+		virtual void PreMultiply(const ifcopenshell::geometry::taxonomy::matrix4&) = 0;
+		virtual void TranslationPart(double& X, double& Y, double& Z) const = 0;
+		virtual ConversionResultPlacement* inverted() const = 0;
+		virtual ConversionResultPlacement* multiplied(const ifcopenshell::geometry::taxonomy::matrix4&) const = 0;
+		virtual double Value(int i, int j) const = 0;
+		virtual ConversionResultPlacement* clone() const = 0;
+		virtual ~ConversionResultPlacement() {}
+	};
+	*/
+
+	class IFC_GEOM_API ConversionResultShape {
+	public:
+		virtual void Triangulate(const ifcopenshell::geometry::settings & settings, const ifcopenshell::geometry::taxonomy::matrix4& place, ifcopenshell::geometry::Representation::Triangulation* t, int surface_style_id) const = 0;
+
+		virtual void Serialize(std::string&) const = 0;
+		virtual ConversionResultShape* clone() const = 0;
+		virtual int surface_genus() const = 0;
+		virtual bool is_manifold() const = 0;
+		virtual ~ConversionResultShape() {}
+	};
+
+	class IFC_GEOM_API ConversionResult {
+	private:
+		int id;
+		ifcopenshell::geometry::taxonomy::matrix4 placement;
+		ConversionResultShape* shape;
+		ifcopenshell::geometry::taxonomy::style style;
+	public:
+		ConversionResult(int id, const ifcopenshell::geometry::taxonomy::matrix4& placement, const ConversionResultShape* shape, const ifcopenshell::geometry::taxonomy::style& style)
+			: id(id), placement(placement), shape(shape->clone()), style(style) {}
+		ConversionResult(int id, const ifcopenshell::geometry::taxonomy::matrix4& placement, const ConversionResultShape* shape)
+			: id(id), placement(placement), shape(shape->clone()) {}
+		ConversionResult(int id, const ConversionResultShape* shape, const ifcopenshell::geometry::taxonomy::style& style)
+			: id(id), shape(shape->clone()), style(style) {}
+		ConversionResult(int id, const ConversionResultShape* shape)
+			: id(id), shape(shape->clone()) {}
+		void append(const ifcopenshell::geometry::taxonomy::matrix4& trsf) {
+			// @todo verify order
+			placement.components = placement.components * trsf.components;
+		}
+		void prepend(const ifcopenshell::geometry::taxonomy::matrix4& trsf) {
+			// @todo verify order
+			placement.components = trsf.components * placement.components;
+		}
+		const ConversionResultShape* Shape() const { return shape; }
+		const ifcopenshell::geometry::taxonomy::matrix4& Placement() const { return placement; }
+		// @todo
+		bool hasStyle() const { return style.diffuse.is_initialized(); }
+		const ifcopenshell::geometry::taxonomy::style& Style() const { return style; }
+		void setStyle(const ifcopenshell::geometry::taxonomy::style& newStyle) { style = newStyle; }
+		int ItemId() const { return id; }
+	};
+    
+	typedef std::vector<ConversionResult> ConversionResults;
+}}
+#endif

src/ifcgeom/schema_agnostic/Converter.cpp

@@ -0,0 +1,364 @@
+#include "Converter.h"
+
+#include "../../ifcgeom/schema_agnostic/IfcGeomElement.h"
+
+ifcopenshell::geometry::Converter::Converter(const std::string& geometry_library, IfcParse::IfcFile* file, settings& s)
+	: settings_(s)
+{
+	kernel_ = kernels::construct(geometry_library, file);
+	mapping_ = impl::mapping_implementations().construct(file, settings_);
+}
+
+ifcopenshell::geometry::NativeElement* ifcopenshell::geometry::Converter::create_brep_for_representation_and_product(
+	IfcUtil::IfcBaseEntity* representation, IfcUtil::IfcBaseEntity* product) {
+
+	std::stringstream representation_id_builder;
+
+	const std::string product_type = product->declaration().name();
+	// @todo
+	element_settings s(settings_, 1.0 /*getValue(GV_LENGTH_UNIT) */, product_type);
+
+	int parent_id = -1;
+	try {
+		IfcUtil::IfcBaseEntity* parent_object = mapping_->get_decomposing_entity(product);
+		if (parent_object) {
+			parent_id = parent_object->data().id();
+		}
+	} catch (const std::exception& e) {
+		Logger::Error(e);
+	}
+
+	const std::string guid = product->get_value<std::string>("GlobalId");
+	const std::string name = product->get_value_or<std::string>("Name", "");
+	
+	representation_id_builder << representation->data().id();
+
+	ifcopenshell::geometry::Representation::BRep* shape;
+	ifcopenshell::geometry::ConversionResults shapes;
+
+	/*
+	auto rep_item = mapping_->map(representation);
+	// @todo should map() throw an exception instead?
+	if (rep_item == nullptr) {
+		return nullptr;
+	}
+	*/
+
+
+	std::clock_t map_start = std::clock();
+
+	// @todo how to combine product_node and rep_item?
+	auto product_node = (taxonomy::geom_item*) mapping_->map(product);
+	if (product_node == nullptr) {
+		return nullptr;
+	}
+
+	std::clock_t geom_start = std::clock();
+	
+	auto place = taxonomy::matrix4();
+	std::swap(place, product_node->matrix);
+
+	kernel_->convert(product_node, shapes);
+
+	shape = new ifcopenshell::geometry::Representation::BRep(s, representation_id_builder.str(), shapes);
+
+	std::clock_t geom_end = std::clock();
+
+	total_map_time += (geom_start - map_start) / (double) CLOCKS_PER_SEC;
+	total_geom_time += (geom_end - geom_start) / (double) CLOCKS_PER_SEC;
+
+	return new NativeElement(
+		product->data().id(),
+		parent_id,
+		name,
+		product_type,
+		guid,
+		// @todo
+		"",
+		place,
+		// product_node->matrix,
+		boost::shared_ptr<ifcopenshell::geometry::Representation::BRep>(shape),
+		product
+	);
+	
+	/*
+	std::stringstream representation_id_builder;
+
+	representation_id_builder << representation->data().id();
+
+	ifcopenshell::geometry::kernels::Representation::BRep* shape;
+	ifcopenshell::geometry::kernels::ConversionResults shapes;
+
+	if (!convert_shapes(representation, shapes)) {
+		return 0;
+	}
+
+	if (settings.get(IteratorSettings::APPLY_LAYERSETS)) {
+		if (apply_layerset(product, shapes)) {
+
+			IfcSchema::IfcRelAssociates::list::ptr associations = product->HasAssociations();
+			for (IfcSchema::IfcRelAssociates::list::it it = associations->begin(); it != associations->end(); ++it) {
+				IfcSchema::IfcRelAssociatesMaterial* associates_material = (**it).as<IfcSchema::IfcRelAssociatesMaterial>();
+				if (associates_material) {
+					unsigned layerset_id = associates_material->RelatingMaterial()->data().id();
+					representation_id_builder << "-layerset-" << layerset_id;
+					break;
+				}
+			}
+
+		}
+	}
+
+	bool material_style_applied = false;
+
+	const IfcSchema::IfcMaterial* single_material = get_single_material_association(product);
+	if (single_material) {
+		const ifcopenshell::geometry::kernels::SurfaceStyle* s = get_style(single_material);
+		for (ifcopenshell::geometry::kernels::ConversionResults::iterator it = shapes.begin(); it != shapes.end(); ++it) {
+			if (!it->hasStyle() && s) {
+				it->setStyle(s);
+				material_style_applied = true;
+			}
+		}
+	} else {
+		bool some_items_without_style = false;
+		for (ifcopenshell::geometry::kernels::ConversionResults::iterator it = shapes.begin(); it != shapes.end(); ++it) {
+			if (!it->hasStyle()) {
+				some_items_without_style = true;
+				break;
+			}
+		}
+		if (some_items_without_style) {
+			Logger::Warning("No material and surface styles for:", product);
+		}
+	}
+
+	if (material_style_applied) {
+		representation_id_builder << "-material-" << single_material->data().id();
+	}
+
+	ConversionResultPlacement* trsf = nullptr;
+	try {
+		convert_placement(product->ObjectPlacement(), trsf);
+	} catch (const std::exception& e) {
+		Logger::Error(e);
+	} catch (...) {
+		Logger::Error("Failed to construct placement");
+	}
+
+	// Does the IfcElement have any IfcOpenings?
+	// Note that openings for IfcOpeningElements are not processed
+	IfcSchema::IfcRelVoidsElement::list::ptr openings = find_openings(product)->as<IfcSchema::IfcRelVoidsElement>();
+
+	const std::string product_type = product->declaration().name();
+	ElementSettings element_settings(settings, getValue(GV_LENGTH_UNIT), product_type);
+
+	if (!settings.get(ifcopenshell::geometry::kernels::IteratorSettings::DISABLE_OPENING_SUBTRACTIONS) && openings && openings->size()) {
+		representation_id_builder << "-openings";
+		for (IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++it) {
+			representation_id_builder << "-" << (*it)->data().id();
+		}
+
+		ifcopenshell::geometry::kernels::ConversionResults opened_shapes;
+		bool caught_error = false;
+		try {
+			convert_openings(product, openings, shapes, trsf, opened_shapes);
+		} catch (const std::exception& e) {
+			Logger::Message(Logger::LOG_ERROR, std::string("Error processing openings for: ") + e.what() + ":", product);
+			caught_error = true;
+		} catch (...) {
+			Logger::Message(Logger::LOG_ERROR, "Error processing openings for:", product);
+		}
+
+		if (caught_error && opened_shapes.size() < shapes.size()) {
+			opened_shapes = shapes;
+		}
+
+		if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
+			for (ifcopenshell::geometry::kernels::ConversionResults::iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++it) {
+				it->prepend(trsf);
+			}
+			trsf = nullptr;
+			representation_id_builder << "-world-coords";
+		}
+		shape = new ifcopenshell::geometry::kernels::Representation::BRep(element_settings, representation_id_builder.str(), opened_shapes);
+	} else if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
+		for (ifcopenshell::geometry::kernels::ConversionResults::iterator it = shapes.begin(); it != shapes.end(); ++it) {
+			it->prepend(trsf);
+		}
+		trsf = nullptr;
+		representation_id_builder << "-world-coords";
+		shape = new ifcopenshell::geometry::kernels::Representation::BRep(element_settings, representation_id_builder.str(), shapes);
+	} else {
+		shape = new ifcopenshell::geometry::kernels::Representation::BRep(element_settings, representation_id_builder.str(), shapes);
+	}
+
+	std::string context_string = "";
+	if (representation->hasRepresentationIdentifier()) {
+		context_string = representation->RepresentationIdentifier();
+	} else if (representation->ContextOfItems()->hasContextType()) {
+		context_string = representation->ContextOfItems()->ContextType();
+	}
+
+	auto elem = new NativeElement<P, PP>(
+		product->data().id(),
+		parent_id,
+		name,
+		product_type,
+		guid,
+		context_string,
+		trsf,
+		boost::shared_ptr<ifcopenshell::geometry::kernels::Representation::BRep>(shape),
+		product
+	);
+
+	if (settings.get(IteratorSettings::VALIDATE_QUANTITIES)) {
+		validate_quantities(product, elem->geometry());
+	}
+
+	return elem;
+
+	*/
+}
+
+ifcopenshell::geometry::NativeElement* ifcopenshell::geometry::Converter::create_brep_for_processed_representation(
+	IfcUtil::IfcBaseEntity* /* representation */, IfcUtil::IfcBaseEntity* product,
+	ifcopenshell::geometry::NativeElement* brep)
+{
+	int parent_id = -1;
+	try {
+		IfcUtil::IfcBaseEntity* parent_object = mapping_->get_decomposing_entity(product);
+		if (parent_object) {
+			parent_id = parent_object->data().id();
+		}
+	} catch (const std::exception& e) {
+		Logger::Error(e);
+	}
+
+	const std::string guid = product->get_value<std::string>("GlobalId");
+	const std::string name = product->get_value_or<std::string>("Name", "");
+
+	auto placement = (taxonomy::geom_item*) mapping_->map(product);
+
+	/*
+	std::string context_string = "";
+	if (representation->hasRepresentationIdentifier()) {
+		context_string = representation->RepresentationIdentifier();
+	} else if (representation->ContextOfItems()->hasContextType()) {
+		context_string = representation->ContextOfItems()->ContextType();
+	}
+	*/
+
+	const std::string product_type = product->declaration().name();
+
+	return new NativeElement(
+		product->data().id(),
+		parent_id,
+		name,
+		product_type,
+		guid,
+		// @todo
+		"",
+		placement->matrix,
+		brep->geometry_pointer(),
+		product
+		);
+}
+
+//#include "../../ifcparse/Ifc2x3.h"
+//#include "../../ifcparse/Ifc4.h"
+//
+//// @todo remove
+//#include "../../ifcgeom/schema_agnostic/opencascade/OpenCascadeConversionResult.h"
+//
+//#include <TopExp.hxx>
+//#include <TopTools_ListOfShape.hxx>
+//#include <TopTools_IndexedMapOfShape.hxx>
+//#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+//
+//IfcGeom::Kernel::Kernel(const std::string& geometry_library, IfcParse::IfcFile* file) {
+//	if (file != 0) {
+//		if (file->schema() == 0) {
+//			throw IfcParse::IfcException("No schema associated with file");
+//		}
+//
+//		const std::string& schema_name = file->schema()->name();
+//		implementation_ = impl::kernel_implementations().construct(schema_name, geometry_library, file);
+//	}
+//}
+//
+//int IfcGeom::Kernel::count(const ConversionResultShape* s_, int t_, bool unique) {
+//	// @todo make kernel agnostic
+//	const TopoDS_Shape& s = ((OpenCascadeShape*) s_)->shape();
+//	TopAbs_ShapeEnum t = (TopAbs_ShapeEnum) t_;
+//
+//	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;
+//	}
+//}
+//
+//
+//int IfcGeom::Kernel::surface_genus(const ConversionResultShape* s_) {
+//	// @todo make kernel agnostic
+//	const TopoDS_Shape& s = ((OpenCascadeShape*) s_)->shape();
+//	OpenCascadeShape Ss(s);
+//
+//	int nv = count(&Ss, (int) TopAbs_VERTEX, true);
+//	int ne = count(&Ss, (int) TopAbs_EDGE, true);
+//	int nf = count(&Ss, (int) TopAbs_FACE, true);
+//
+//	const int euler = nv - ne + nf;
+//	const int genus = (2 - euler) / 2;
+//
+//	return genus;
+//}
+//
+//
+//IfcUtil::IfcBaseEntity* IfcGeom::Kernel::get_decomposing_entity(IfcUtil::IfcBaseEntity* inst, bool include_openings) {
+//	if (inst->as<Ifc2x3::IfcProduct>()) {
+//		return get_decomposing_entity_impl(inst->as<Ifc2x3::IfcProduct>(), include_openings);
+//	} else if (inst->as<Ifc4::IfcProduct>()) {
+//		return get_decomposing_entity_impl(inst->as<Ifc4::IfcProduct>(), include_openings);
+//	} else if (inst->declaration().name() == "IfcProject") {
+//		return nullptr;
+//	} else {
+//		throw IfcParse::IfcException("Unexpected entity " + inst->declaration().name());
+//	}
+//}
+//
+//
+//bool IfcGeom::Kernel::is_manifold(const ConversionResultShape* s_) {
+//        // @todo make kernel agnostic
+//        const TopoDS_Shape& a = ((OpenCascadeShape*) s_)->shape();
+//
+//	if (a.ShapeType() == TopAbs_COMPOUND || a.ShapeType() == TopAbs_SOLID) {
+//		TopoDS_Iterator it(a);
+//		for (; it.More(); it.Next()) {
+//			OpenCascadeShape s(it.Value());
+//			if (!is_manifold(&s)) {
+//				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;
+//	}
+//}

src/ifcgeom/schema_agnostic/Converter.h

@@ -0,0 +1,108 @@
+#ifndef ITERATOR_KERNEL_H
+#define ITERATOR_KERNEL_H
+
+#include "../../ifcparse/IfcFile.h"
+#include "../../ifcgeom/settings.h"
+#include "../../ifcgeom/schema_agnostic/ConversionResult.h"
+#include "../../ifcgeom/abstract_mapping.h"
+#include "../../ifcgeom/kernel_agnostic/AbstractKernel.h"
+
+#include <boost/function.hpp>
+
+namespace ifcopenshell { namespace geometry {
+
+	class NativeElement;
+
+	class Converter {
+	private:
+		abstract_mapping* mapping_;
+		kernels::AbstractKernel* kernel_;
+		ifcopenshell::geometry::settings settings_;
+	public:
+		kernels::AbstractKernel* kernel() { return kernel_; }
+
+		// 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
+		};
+
+		Converter(const std::string& geometry_library, IfcParse::IfcFile* file, ifcopenshell::geometry::settings& settings);
+		
+		~Converter() {}
+
+		abstract_mapping* mapping() const { return mapping_; }
+
+		/*
+		virtual void setValue(GeomValue var, double value) {
+			implementation_->setValue(var, value);
+		}
+
+		virtual double getValue(GeomValue var) const {
+			return implementation_->getValue(var);
+		}
+		*/
+
+		/*
+		virtual NativeElement<double, double>* convert(
+			const IteratorSettings& settings, IfcUtil::IfcBaseClass* representation,
+			IfcUtil::IfcBaseClass* product)
+		{
+			return implementation_->convert(settings, representation, product);
+		}
+		*/
+
+		double total_map_time = 0.;
+		double total_geom_time = 0.;
+
+		ifcopenshell::geometry::ConversionResults convert(IfcUtil::IfcBaseClass* item) {
+			std::clock_t map_start = std::clock();
+			auto geom_item = mapping_->map(item);
+			std::clock_t geom_start = std::clock();
+			ifcopenshell::geometry::ConversionResults results;
+			kernel_->convert(geom_item, results);
+			std::clock_t geom_end = std::clock();
+			total_map_time += (geom_start - map_start) / (double) CLOCKS_PER_SEC;
+			total_geom_time += (geom_end - geom_start) / (double) CLOCKS_PER_SEC;
+			return results;
+		}
+
+		ifcopenshell::geometry::NativeElement* create_brep_for_representation_and_product(IfcUtil::IfcBaseEntity* representation, IfcUtil::IfcBaseEntity* product);
+		ifcopenshell::geometry::NativeElement* create_brep_for_processed_representation(IfcUtil::IfcBaseEntity* representation, IfcUtil::IfcBaseEntity* product, ifcopenshell::geometry::NativeElement* brep);
+
+		/*
+		static int count(const ifcopenshell::geometry::ConversionResultShape*, int, bool unique=false);
+		static int surface_genus(const ifcopenshell::geometry::ConversionResultShape*);
+
+		static bool is_manifold(const ifcopenshell::geometry::ConversionResultShape*);
+		static IfcUtil::IfcBaseEntity* get_decomposing_entity(IfcUtil::IfcBaseEntity*, bool include_openings=true);
+		static IfcEntityList::ptr find_openings(IfcUtil::IfcBaseEntity* product);
+		*/
+	};
+}}
+
+#endif

src/ifcgeom/schema_agnostic/IfcGeomElement.h

@@ -23,64 +23,42 @@
 #include <string>
 #include <algorithm>
 
-#include "../ifcparse/Argument.h"
-#include "../ifcparse/IfcGlobalId.h"
+#include "../../ifcparse/IfcGlobalId.h"
+#include "../../ifcparse/Argument.h"
+
+#include "../../ifcgeom/schema_agnostic/IfcGeomRepresentation.h"
+#include "../../ifcgeom/settings.h"
+#include "../../ifcgeom/taxonomy.h"
 
-#include "../ifcgeom/IfcGeomRepresentation.h"
-#include "../ifcgeom/IfcGeomIteratorSettings.h"
 #include "ifc_geom_api.h"
 
-namespace IfcGeom {
+namespace ifcopenshell { namespace geometry {
 
-	template <typename P>
-	class Matrix {
+	class Transformation {
 	private:
-		std::vector<P> _data;
+		element_settings settings_;
+		ifcopenshell::geometry::taxonomy::matrix4 matrix_;
 	public:
-		Matrix(const ElementSettings& settings, const gp_Trsf& trsf) {
-			// Convert the gp_Trsf into a 4x3 Matrix
+		Transformation(const element_settings& settings, const ifcopenshell::geometry::taxonomy::matrix4& trsf)
+			: settings_(settings)
+			, matrix_(trsf)
+		{
 			// Note that in case the CONVERT_BACK_UNITS setting is enabled
 			// the translation component of the matrix needs to be divided
 			// by the magnitude of the IFC model length unit because
 			// internally in IfcOpenShell everything is measured in meters.
-			for(int i = 1; i < 5; ++i) {
-				for (int j = 1; j < 4; ++j) {
-					const double trsf_value = trsf.Value(j,i);
-                    const double matrix_value = i == 4 && settings.get(IteratorSettings::CONVERT_BACK_UNITS)
-						? trsf_value / settings.unit_magnitude()
-						: trsf_value;
-					_data.push_back(static_cast<P>(matrix_value));
+			if (settings.get(settings::CONVERT_BACK_UNITS)) {
+				for (int i = 0; i <= 2; ++i) {
+					matrix_.components(3, i) /= settings.unit_magnitude();
 				}
 			}
 		}
-		const std::vector<P>& data() const { return _data; }
+		const ifcopenshell::geometry::taxonomy::matrix4& data() const { return matrix_; }
+		const element_settings& settings() const { return settings_; }
+
+		EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 	};
 
-	template <typename P>
-	class Transformation {
-	private:
-		ElementSettings settings_;
-		gp_Trsf trsf_;
-		Matrix<P> matrix_;
-	public:
-		Transformation(const ElementSettings& settings, const gp_Trsf& trsf)
-			: settings_(settings)
-			, trsf_(trsf)
-			, matrix_(settings, trsf) 
-		{}
-		const gp_Trsf& data() const { return trsf_; }
-		const Matrix<P>& matrix() const { return matrix_; }
-
-		Transformation inverted() const {
-			return Transformation(settings_, trsf_.Inverted());
-		}
-
-		Transformation multiplied(const Transformation& other) const {
-			return Transformation(settings_, trsf_.Multiplied(other.data()));
-		}
-	};
-
-	template <typename P = double, typename PP = P>
 	class Element {
 	private:
 		int _id;
@@ -90,17 +68,17 @@ namespace IfcGeom {
 		std::string _guid;
 		std::string _context;
 		std::string _unique_id;
-		Transformation<PP> _transformation;
+		Transformation _transformation;
         IfcUtil::IfcBaseEntity* product_;
-		std::vector<const IfcGeom::Element<P, PP>*> _parents;
+		std::vector<const Element*> _parents;
 	public:
 
-		friend bool operator == (const Element<P, PP> & element1, const Element<P, PP> & element2) {
+		friend bool operator == (const Element & element1, const Element & element2) {
 			return element1.id() == element2.id();
 		}
 
 		// Use the id to compare, or the elevation is the elements are IfcBuildingStoreys and the elevation is set
-		friend bool operator < (const Element<P, PP> & element1, const Element<P, PP> & element2) {
+		friend bool operator < (const Element & element1, const Element & element2) {
 			if (element1.type() == "IfcBuildingStorey" && element2.type() == "IfcBuildingStorey") {
 				size_t attr_index = element1.product()->declaration().attribute_index("Elevation");
 				Argument* elev_attr1 = element1.product()->data().getArgument(attr_index);
@@ -124,13 +102,13 @@ namespace IfcGeom {
 		const std::string& guid() const { return _guid; }
 		const std::string& context() const { return _context; }
 		const std::string& unique_id() const { return _unique_id; }
-		const Transformation<PP>& transformation() const { return _transformation; }
+		const Transformation& transformation() const { return _transformation; }
         IfcUtil::IfcBaseEntity* product() const { return product_; }
-		const std::vector<const IfcGeom::Element<P, PP>*> parents() const { return _parents; }
-		void SetParents(std::vector<const IfcGeom::Element<P, PP>*> newparents) { _parents = newparents; }
+		const std::vector<const Element*> parents() const { return _parents; }
+		void SetParents(std::vector<const Element*> newparents) { _parents = newparents; }
 
-		Element(const ElementSettings& settings, int id, int parent_id, const std::string& name, const std::string& type,
-            const std::string& guid, const std::string& context, const gp_Trsf& trsf, IfcUtil::IfcBaseEntity* product)
+		Element(const element_settings& settings, int id, int parent_id, const std::string& name, const std::string& type,
+            const std::string& guid, const std::string& context, const ifcopenshell::geometry::taxonomy::matrix4& trsf, IfcUtil::IfcBaseEntity* product)
 			: _id(id), _parent_id(parent_id), _name(name), _type(type), _guid(guid), _context(context), _transformation(settings, trsf)
             , product_(product)
 		{ 
@@ -156,47 +134,45 @@ namespace IfcGeom {
 
 			_unique_id = oss.str();
 		}
+
 		virtual ~Element() {}
+
+		EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 	};
 
-	template <typename P = double, typename PP = P>
-	class BRepElement : public Element<P, PP> {
+	class NativeElement : public Element {
 	private:
 		boost::shared_ptr<Representation::BRep> _geometry;
 	public:
 		const boost::shared_ptr<Representation::BRep>& geometry_pointer() const { return _geometry; }
 		const Representation::BRep& geometry() const { return *_geometry; }
-		BRepElement(int id, int parent_id, const std::string& name, const std::string& type, const std::string& guid,
-            const std::string& context, const gp_Trsf& trsf, const boost::shared_ptr<Representation::BRep>& geometry,
+		NativeElement(int id, int parent_id, const std::string& name, const std::string& type, const std::string& guid,
+            const std::string& context, const ifcopenshell::geometry::taxonomy::matrix4& trsf, const boost::shared_ptr<Representation::BRep>& geometry,
 			IfcUtil::IfcBaseEntity* product)
-			: Element<P, PP>(geometry->settings() ,id, parent_id, name, type, guid, context, trsf, product)
+			: Element(geometry->settings() ,id, parent_id, name, type, guid, context, trsf, product)
 			, _geometry(geometry)
 		{}
 
 		bool calculate_projected_surface_area(double& along_x, double& along_y, double& along_z) const {
-			const auto& trsf = this->transformation().data();
-			const gp_Mat& mat = trsf.HVectorialPart();
-			gp_Ax3 ax(trsf.TranslationPart(), mat.Column(3), mat.Column(1));
-			return geometry().calculate_projected_surface_area(ax, along_x, along_y, along_z);
+			return geometry().calculate_projected_surface_area(this->transformation().data(), along_x, along_y, along_z);
 		}
 	private:
-		BRepElement(const BRepElement& other);
-		BRepElement& operator=(const BRepElement& other);		
+		NativeElement(const NativeElement& other);
+		NativeElement& operator=(const NativeElement& other);		
 	};
 
-	template <typename P = double, typename PP = P>
-	class TriangulationElement : public Element<P, PP> {
+	class TriangulationElement : public Element {
 	private:
-		boost::shared_ptr< Representation::Triangulation<P> > _geometry;
+		boost::shared_ptr<Representation::Triangulation> _geometry;
 	public:
-		const Representation::Triangulation<P>& geometry() const { return *_geometry; }
-		const boost::shared_ptr< Representation::Triangulation<P> >& geometry_pointer() const { return _geometry; }
-		TriangulationElement(const BRepElement<P, PP>& shape_model)
-			: Element<P, PP>(shape_model)
-			, _geometry(boost::shared_ptr<Representation::Triangulation<P> >(new Representation::Triangulation<P>(shape_model.geometry())))
+		const Representation::Triangulation& geometry() const { return *_geometry; }
+		const boost::shared_ptr< Representation::Triangulation >& geometry_pointer() const { return _geometry; }
+		TriangulationElement(const NativeElement& shape_model)
+			: Element(shape_model)
+			, _geometry(boost::shared_ptr<Representation::Triangulation >(new Representation::Triangulation(shape_model.geometry())))
 		{}
-		TriangulationElement(const Element<P, PP>& element, const boost::shared_ptr<Representation::Triangulation<P> >& geometry)
-			: Element<P, PP>(element)
+		TriangulationElement(const Element& element, const boost::shared_ptr<Representation::Triangulation >& geometry)
+			: Element(element)
 			, _geometry(geometry)
 		{}
 	private:
@@ -204,14 +180,13 @@ namespace IfcGeom {
 		TriangulationElement& operator=(const TriangulationElement& other);
 	};
 
-	template <typename P = double, typename PP = P>
-	class SerializedElement : public Element<P, PP> {
+	class SerializedElement : public Element {
 	private:
 		Representation::Serialization* _geometry;
 	public:
 		const Representation::Serialization& geometry() const { return *_geometry; }
-		SerializedElement(const BRepElement<P, PP>& shape_model)
-			: Element<P, PP>(shape_model)
+		SerializedElement(const NativeElement& shape_model)
+			: Element(shape_model)
 			, _geometry(new Representation::Serialization(shape_model.geometry()))
 		{}
 		virtual ~SerializedElement() {
@@ -221,6 +196,6 @@ namespace IfcGeom {
 		SerializedElement(const SerializedElement& other);
 		SerializedElement& operator=(const SerializedElement& other);
 	};
-}
+}}
 
 #endif

src/ifcgeom/schema_agnostic/IfcGeomFilter.h

@@ -23,8 +23,9 @@
 #ifndef IFCGEOMFILTER_H
 #define IFCGEOMFILTER_H
 
-#include "Kernel.h"
-#include "../ifcparse/IfcFile.h"
+#include "../../ifcgeom/kernel_agnostic/AbstractKernel.h"
+#include "../../ifcparse/IfcFile.h"
+#include "../../ifcgeom/abstract_mapping.h"
 
 #include <boost/foreach.hpp>
 #include <boost/function.hpp>
@@ -65,7 +66,13 @@ namespace IfcGeom {
         bool traverse_match(IfcUtil::IfcBaseEntity* prod, const filter_t& pred) const
         {
             IfcUtil::IfcBaseEntity* parent, *current = prod;
-            while ((parent = IfcGeom::Kernel::get_decomposing_entity(current, traverse_openings)) != nullptr) {
+			// @todo examine if this can indeed be static. For now usage is only
+			// in IfcConvert so invocation is bound to a single file with a single
+			// schema.
+			// @todo pass settings
+			ifcopenshell::geometry::settings s;
+			static auto mapping = ifcopenshell::geometry::impl::mapping_implementations().construct(prod->data().file, s);
+            while ((parent = mapping->get_decomposing_entity(current, traverse_openings)) != nullptr) {
                 if (pred(parent)) {
                     return true;
                 }
@@ -170,7 +177,10 @@ namespace IfcGeom {
 			: wildcard_filter(include, traverse, patterns) {}
 
 		bool match(IfcUtil::IfcBaseEntity* prod) const {
-            layer_map_t layers = IfcGeom::Kernel::get_layers(prod);
+			// @todo
+			ifcopenshell::geometry::settings s;
+			static auto mapping = ifcopenshell::geometry::impl::mapping_implementations().construct(prod->data().file, s);
+            layer_map_t layers = mapping->get_layers(prod);
             return std::find_if(layers.begin(), layers.end(), wildcards_match(values)) != layers.end();
         }
 

src/ifcgeom/schema_agnostic/IfcGeomIterator.h

@@ -0,0 +1,638 @@
+/********************************************************************************
+ *                                                                              *
+ * 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).                *
+ *                                                                              *
+ * ifcopenshell::geometry::Representation::Triangulation is a class that represents a          *
+ * triangulated IfcShapeRepresentation.                                         *
+ *   Triangulation.verts is a 1 dimensional vector of float defining the        *
+ *      cartesian coordinates of the vertices of the triangulated shape in the  *
+ *      format of [x1,y1,z1,..,xn,yn,zn]                                        *
+ *   Triangulation.faces is a 1 dimensional vector of int containing the        *
+ *     indices of the triangles referencing positions in Triangulation.verts    *
+ *   Triangulation.edges is a 1 dimensional vector of int in {0,1} that dictates*
+ *	   the visibility of the edges that span the faces in Triangulation.faces   *
+ *                                                                              *
+ * ifcopenshell::geometry::Element represents the actual IfcBuildingElements.                  *
+ *   IfcGeomObject.name is the GUID of the element                              *
+ *   IfcGeomObject.type is the datatype of the element e.g. IfcWindow           *
+ *   IfcGeomObject.mesh is a pointer to an IfcMesh                              *
+ *   IfcGeomObject.transformation.matrix is a 4x3 matrix that defines the       *
+ *     orientation and translation of the mesh in relation to the world origin  *
+ *                                                                              *
+ * ifcopenshell::geometry::Iterator::initialize()                                              *
+ *   finds the most suitable representation contexts. Returns true iff          *
+ *   at least a single representation will process successfully                 *
+ *                                                                              *
+ * ifcopenshell::geometry::Iterator::get()                                                     *
+ *   returns a pointer to the current ifcopenshell::geometry::Element                          *
+ *                                                                              * 
+ * ifcopenshell::geometry::Iterator::next()                                                    *
+ *   returns true iff a following entity is available for a successive call to  *
+ *   ifcopenshell::geometry::Iterator::get()                                                   *
+ *                                                                              *
+ * ifcopenshell::geometry::Iterator::progress()                                                *
+ *   returns an int in [0..100] that indicates the overall progress             *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCGEOMITERATOR_H
+#define IFCGEOMITERATOR_H
+
+#include <map>
+#include <set>
+#include <vector>
+#include <limits>
+#include <algorithm>
+#include <atomic>
+
+#include <future>
+#include <thread>
+#include <chrono>
+
+#include <boost/algorithm/string.hpp>
+
+#include <gp_Mat.hxx>
+#include <gp_Mat2d.hxx>
+#include <gp_GTrsf.hxx>
+#include <gp_GTrsf2d.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+
+#include "../../ifcparse/macros.h"
+#include "../../ifcparse/IfcFile.h"
+
+#include "../../ifcgeom/schema_agnostic/IfcGeomElement.h"
+#include "../../ifcgeom/settings.h"
+#include "../../ifcgeom/schema_agnostic/ConversionResult.h"
+
+#include "../../ifcgeom/schema_agnostic/IfcGeomFilter.h"
+
+#include "../../ifcgeom/kernel_agnostic/AbstractKernel.h"
+
+#include "../../ifcgeom/schema_agnostic/Converter.h"
+
+#define INCLUDE_SCHEMA(x) STRINGIFY(../../ifcparse/x.h)
+#include INCLUDE_SCHEMA(IfcSchema)
+#undef INCLUDE_SCHEMA
+
+#include <atomic>
+
+// The infamous min & max Win32 #defines can leak here from OCE depending on the build configuration
+#ifdef min
+#undef min
+#endif
+#ifdef max
+#undef max
+#endif
+
+namespace {
+	ifcopenshell::geometry::Element* process_based_on_settings(
+		const ifcopenshell::geometry::settings& settings,
+		ifcopenshell::geometry::NativeElement* elem, 
+		ifcopenshell::geometry::TriangulationElement* previous=nullptr)
+	{
+		if (settings.get(ifcopenshell::geometry::settings::USE_BREP_DATA)) {
+			try {
+				return new ifcopenshell::geometry::SerializedElement(*elem);
+			} catch (...) {
+				Logger::Message(Logger::LOG_ERROR, "Getting a serialized element from model failed.");
+				return nullptr;
+			}
+		} else if (!settings.get(ifcopenshell::geometry::settings::DISABLE_TRIANGULATION)) {
+			try {
+				if (!previous) {
+					return  new ifcopenshell::geometry::TriangulationElement(*elem);
+				} else {
+					return  new ifcopenshell::geometry::TriangulationElement(*elem, previous->geometry_pointer());
+				}
+			} catch (...) {
+				Logger::Message(Logger::LOG_ERROR, "Getting a triangulation element from model failed.");
+				return nullptr;
+			}
+		} else {
+			return elem;
+		}
+	}
+
+	void create_element(
+		ifcopenshell::geometry::Converter* converter, 
+		const ifcopenshell::geometry::settings& settings,
+		ifcopenshell::geometry::geometry_conversion_task* rep)
+	{
+		IfcUtil::IfcBaseEntity* representation = rep->representation;
+		IfcUtil::IfcBaseEntity* product = (IfcUtil::IfcBaseEntity*) *rep->products->begin();
+		auto brep = converter->create_brep_for_representation_and_product(representation, product);
+		if (!brep) {
+			return;
+		}
+
+		auto elem = process_based_on_settings(settings, brep);
+		if (!elem) {
+			return;
+		}
+
+		rep->breps = { brep };
+		rep->elements = { elem };
+
+		for (auto it = rep->products->begin() + 1; it != rep->products->end(); ++it) {
+			auto brep2 = converter->create_brep_for_processed_representation(representation, (IfcUtil::IfcBaseEntity*) *it, brep);
+			if (brep2) {
+				auto elem2 = process_based_on_settings(settings, brep, dynamic_cast<ifcopenshell::geometry::TriangulationElement*>(elem));
+				if (elem2) {
+					rep->breps.push_back(brep2);
+					rep->elements.push_back(elem2);
+				}
+			}
+		}
+	}
+}
+
+namespace ifcopenshell { namespace geometry {
+	
+	class Iterator {
+	private:
+
+		int num_threads_;
+		std::atomic<int> progress_;
+		std::vector<geometry_conversion_task> tasks_;
+		std::vector<geometry_conversion_task>::iterator task_iterator_;
+
+		std::vector<ifcopenshell::geometry::Element*> all_processed_elements_;
+		std::vector<ifcopenshell::geometry::NativeElement*> all_processed_native_elements_;
+		size_t task_result_index_;
+
+		std::string geometry_library_;
+
+		Iterator(const Iterator&); // N/I
+		Iterator& operator=(const Iterator&); // N/I
+
+		Converter* converter_;
+		settings settings_;
+
+		IfcParse::IfcFile* ifc_file;
+
+		int done;
+		int total;
+
+		std::string unit_name_;
+		double unit_magnitude_;
+
+        gp_XYZ bounds_min_;
+        gp_XYZ bounds_max_;
+
+        std::vector<filter_t> filters_;
+
+        /// @todo public/private sections all over the place: move all public to the beginning of the class
+	public:
+
+		const std::string& unit_name() const { return unit_name_; }
+		const double unit_magnitude() const { return unit_magnitude_; }
+
+		bool initialize() {
+			converter_ = new Converter(geometry_library_, ifc_file, settings_);
+			converter_->mapping()->get_representations(tasks_, filters_, settings_);
+
+			if (tasks_.size() == 0) {
+				Logger::Warning("No representations encountered, aborting");
+				return false;
+			}
+
+			task_iterator_ = tasks_.begin();
+
+			task_result_index_ = 0;
+			done = 0;
+			total = tasks_.size();
+
+			if (num_threads_ != 1) {
+				process_concurrently();
+			} else {
+				if (!create()) {
+					return false;
+				}
+			}
+			
+			return true;
+		}
+
+		void process_concurrently() {
+			size_t conc_threads = num_threads_;
+			if (conc_threads > tasks_.size()) {
+				conc_threads = tasks_.size();
+			}
+			
+			std::vector<Converter*> kernel_pool;
+			kernel_pool.reserve(conc_threads);
+			for (unsigned i = 0; i < conc_threads; ++i) {
+				kernel_pool.push_back(new Converter(geometry_library_, ifc_file, settings_));
+			}
+
+			std::vector<std::future<void>> threadpool;
+
+			int old_progress = -1;
+			int processed = 0;
+
+			Logger::ProgressBar(0);
+
+			for (auto& rep : tasks_) {
+				Converter* K = nullptr;
+				if (threadpool.size() < kernel_pool.size()) {
+					K = kernel_pool[threadpool.size()];
+				}
+
+				while (threadpool.size() == conc_threads) {
+					for (int i = 0; i < (int)threadpool.size(); i++) {
+						std::future<void> &fu = threadpool[i];
+						std::future_status status;
+						status = fu.wait_for(std::chrono::seconds(0));
+						if (status == std::future_status::ready) {
+							fu.get();
+							
+							processed += 1;
+							progress_ = processed * 50 / tasks_.size();
+							if (progress_ != old_progress) {
+								Logger::ProgressBar(progress_);
+								old_progress = progress_;
+							}
+								
+							std::swap(threadpool[i], threadpool.back());
+							threadpool.pop_back();
+							std::swap(kernel_pool[i], kernel_pool.back());
+							K = kernel_pool.back();
+							break;
+						} // if
+					}   // for
+				}     // while
+
+				std::future<void> fu = std::async(std::launch::async, create_element, K, std::ref(settings_), &rep);
+				threadpool.emplace_back(std::move(fu));
+			}
+
+			for (std::future<void> &fu : threadpool) {
+				fu.get();
+
+				processed += 1;
+				progress_ = processed * 50 / tasks_.size();
+				if (progress_ != old_progress) {
+					Logger::ProgressBar(progress_);
+					old_progress = progress_;
+				}
+			}
+
+			for (auto& rep : tasks_) {
+				all_processed_elements_.insert(all_processed_elements_.end(), rep.elements.begin(), rep.elements.end());
+				all_processed_native_elements_.insert(all_processed_native_elements_.end(), rep.breps.begin(), rep.breps.end());
+			}
+
+			task_result_index_ = 0;
+
+			Logger::Status("\rDone creating geometry (" + boost::lexical_cast<std::string>(all_processed_elements_.size()) +
+				" objects)                                ");
+		}
+
+        /// Computes model's bounding box (bounds_min and bounds_max).
+        /// @note Can take several minutes for large files.
+        void compute_bounds()
+        {
+			// @todo
+
+			/*
+            for (int i = 1; i < 4; ++i) {
+                bounds_min_.SetCoord(i, std::numeric_limits<double>::infinity());
+                bounds_max_.SetCoord(i, -std::numeric_limits<double>::infinity());
+            }
+
+            IfcSchema::IfcProduct::list::ptr products = ifc_file->instances_by_type<IfcSchema::IfcProduct>();
+            for (IfcSchema::IfcProduct::list::it iter = products->begin(); iter != products->end(); ++iter) {
+                IfcSchema::IfcProduct* product = *iter;
+                if (product->hasObjectPlacement()) {
+                    // Use a fresh trsf every time in order to prevent the result to be concatenated
+                    ConversionResultPlacement* trsf; 
+                    bool success = false;
+
+                    try {
+                        success = kernel->convert_placement(product->ObjectPlacement(), trsf);
+                    } catch (const std::exception& e) {
+                        Logger::Error(e);
+                    } catch (...) {
+                        Logger::Error("Failed to construct placement");
+                    }
+
+                    if (!success) {
+                        continue;
+                    }
+
+					double X, Y, Z;
+                    trsf->TranslationPart(X, Y, Z);
+                    bounds_min_.SetX(std::min(bounds_min_.X(), X));
+                    bounds_min_.SetY(std::min(bounds_min_.Y(), Y));
+                    bounds_min_.SetZ(std::min(bounds_min_.Z(), Z));
+                    bounds_max_.SetX(std::max(bounds_max_.X(), X));
+                    bounds_max_.SetY(std::max(bounds_max_.Y(), Y));
+                    bounds_max_.SetZ(std::max(bounds_max_.Z(), Z));
+                }
+            }
+			*/
+        }
+
+		int progress() const { 
+			if (num_threads_ == 1) {
+				return 100 * done / total;
+			} else {
+				return progress_;
+			}
+		}
+
+		const std::string& getUnitName() const { return unit_name_; }
+
+        /// @note Double always as per IFC specification.
+        double getUnitMagnitude() const { return unit_magnitude_; }
+	
+		std::string getLog() const { return Logger::GetLog(); }
+
+		IfcParse::IfcFile* file() const { return ifc_file; }
+
+        const std::vector<ifcopenshell::geometry::filter_t>& filters() const { return filters_; }
+        std::vector<ifcopenshell::geometry::filter_t>& filters() { return filters_; }
+
+        const gp_XYZ& bounds_min() const { return bounds_min_; }
+        const gp_XYZ& bounds_max() const { return bounds_max_; }
+
+		Converter& converter() { return *converter_; }
+
+	private:
+		// Move to the next IfcRepresentation
+		void _nextShape() {
+			++task_iterator_;
+			++done;
+		}		
+
+		IfcUtil::IfcBaseClass* create_shape_model_for_next_entity() {
+			geometry_conversion_task* task = nullptr;
+			while (task_iterator_ != tasks_.end()) {
+				task = &*task_iterator_++;
+				create_element(converter_, settings_, task);
+				if (task->elements.empty()) {
+					task = nullptr;
+				} else {
+					break;
+				}
+			}
+			if (task) {
+				all_processed_elements_.insert(all_processed_elements_.end(), task->elements.begin(), task->elements.end());
+				all_processed_native_elements_.insert(all_processed_native_elements_.end(), task->breps.begin(), task->breps.end());
+				return (*task->products)[0];
+			} else {
+				return nullptr;
+			}
+		}
+
+    public:
+
+        /// Moves to the next shape representation, create its geometry, and returns the associated product.
+        /// Use get() to retrieve the created geometry.
+		IfcUtil::IfcBaseClass* next() {
+			if (num_threads_ != 1) {
+				task_result_index_++;
+				if (task_result_index_ == all_processed_elements_.size()) {
+					return nullptr;
+				} else {
+					return all_processed_elements_[task_result_index_]->product();
+				}
+			} else {
+				// Increment the iterator over the list of products using the current
+				// shape representation
+				++task_result_index_;
+				if (task_result_index_ == all_processed_elements_.size()) {
+					return create();
+				}
+				if (task_result_index_ == all_processed_elements_.size()) {
+					return nullptr;
+				}
+				return all_processed_elements_[task_result_index_]->product();
+			}
+		}
+
+        /// Gets the representation of the current geometrical entity.
+        Element* get()
+        {
+            // TODO: Test settings and throw
+            Element* ret = 0;
+
+			ret = all_processed_elements_[task_result_index_];
+
+			// If we want to organize the element considering their hierarchy
+			if (settings_.get(settings::SEARCH_FLOOR))
+			{
+				// We are going to build a vector with the element parents.
+				// First, create the parent vector
+				std::vector<const ifcopenshell::geometry::Element*> parents;
+				
+				// if the element has a parent
+				if (ret->parent_id() != -1)
+				{
+					const ifcopenshell::geometry::Element* parent_object = NULL;
+					bool hasParent = true;
+
+					// get the parent 
+					try {
+						parent_object = get_object(ret->parent_id());
+					} catch (const std::exception& e) {
+						Logger::Error(e);
+						hasParent = false;
+					}
+
+					// Add the previously found parent to the vector
+					if (hasParent) parents.insert(parents.begin(), parent_object);
+					
+					// We need to find all the parents
+					while (parent_object != NULL && hasParent && parent_object->parent_id() != -1)
+					{
+						// Find the next parent
+						try {
+							parent_object = get_object(parent_object->parent_id());
+						} catch (const std::exception& e) {
+							Logger::Error(e);
+							hasParent = false;
+						}
+
+						// Add the previously found parent to the vector
+						if (hasParent) parents.insert(parents.begin(), parent_object);
+
+						hasParent = hasParent && parent_object->parent_id() != -1;
+					}
+
+					// when done push the parent list in the Element object
+					ret->SetParents(parents);
+				}
+			}
+
+            return ret;
+        }
+
+		/// Gets the native (Open Cascade) representation of the current geometrical entity.
+		NativeElement* get_native()
+		{
+			return all_processed_native_elements_[task_result_index_];
+		}
+
+		const Element* get_object(int id) {
+			// @todo
+			return nullptr;
+			/*
+			ConversionResultPlacement* trsf;
+			int parent_id = -1;
+			std::string instance_type, product_name, product_guid;
+            IfcSchema::IfcProduct* ifc_product = 0;
+
+			try {
+				IfcUtil::IfcBaseClass* ifc_entity = ifc_file->instance_by_id(id);
+				instance_type = ifc_entity->declaration().name();
+
+				if (ifc_entity->declaration().is(IfcSchema::IfcRoot::Class())) {
+					IfcSchema::IfcRoot* ifc_root = ifc_entity->as<IfcSchema::IfcRoot>();
+					product_guid = ifc_root->GlobalId();
+					product_name = ifc_root->hasName() ? ifc_root->Name() : "";
+				}
+
+				if (ifc_entity->declaration().is(IfcSchema::IfcProduct::Class())) {
+					ifc_product = ifc_entity->as<IfcSchema::IfcProduct>();
+					parent_id = -1;
+					try {
+						IfcSchema::IfcObjectDefinition* parent_object = kernel->get_decomposing_entity(ifc_product)->template as<IfcSchema::IfcObjectDefinition>();
+						if (parent_object) {
+							parent_id = parent_object->data().id();
+						}
+					} catch (const std::exception& e) {
+						Logger::Error(e);
+					} catch (...) {
+						Logger::Error("Failed to find decomposing entity");
+					}
+
+					try {
+						kernel->convert_placement(ifc_product->ObjectPlacement(), trsf);
+					} catch (const std::exception& e) {
+						Logger::Error(e);
+					} catch (...) {
+						Logger::Error("Failed to construct placement");
+					}
+				}
+			} catch (const std::exception& e) {
+				Logger::Error(e);
+			} catch (const Standard_Failure& e) {
+				if (e.GetMessageString() && strlen(e.GetMessageString())) {
+					Logger::Error(e.GetMessageString());
+				} else {
+					Logger::Error("Unknown error returning product");
+				}
+			} catch (...) {
+				Logger::Error("Unknown error returning product");
+			}
+
+			ElementSettings element_settings(settings, unit_magnitude, instance_type);
+
+			Element* ifc_object = new Element(element_settings, id, parent_id, product_name, instance_type, product_guid, "", trsf, ifc_product);
+			return ifc_object;
+			*/
+		}
+
+		IfcUtil::IfcBaseClass* create() {
+			IfcUtil::IfcBaseClass* product = nullptr;
+			try {
+				product = create_shape_model_for_next_entity();
+			} catch (const std::exception& e) {
+				Logger::Error(e);
+			} catch (const Standard_Failure& e) {
+				if (e.GetMessageString() && strlen(e.GetMessageString())) {
+					Logger::Error(e.GetMessageString());
+				} else {
+					Logger::Error("Unknown error creating geometry");
+				}
+			} catch (...) {
+				Logger::Error("Unknown error creating geometry");
+			}
+			return product;
+		}
+	private:
+		void _initialize() {
+			unit_name_ = "METER";
+			unit_magnitude_ = 1.f;
+
+			// @todo
+
+			/*
+            kernel->setValue(ifcopenshell::geometry::Kernel::GV_MAX_FACES_TO_ORIENT, settings.get(settings::SEW_SHELLS) ? std::numeric_limits<double>::infinity() : -1);
+            kernel->setValue(ifcopenshell::geometry::Kernel::GV_DIMENSIONALITY, (settings.get(settings::INCLUDE_CURVES)
+                ? (settings.get(settings::EXCLUDE_SOLIDS_AND_SURFACES) ? -1. : 0.) : +1.));
+			if (settings.get(settings::BUILDING_LOCAL_PLACEMENT)) {
+				if (settings.get(settings::SITE_LOCAL_PLACEMENT)) {
+					Logger::Message(Logger::LOG_WARNING, "building-local-placement takes precedence over site-local-placement");
+				}
+				kernel->set_conversion_placement_rel_to(&IfcSchema::IfcBuilding::Class());
+			} else if (settings.get(settings::SITE_LOCAL_PLACEMENT)) {
+				kernel->set_conversion_placement_rel_to(&IfcSchema::IfcSite::Class());
+			}
+			*/
+		}
+
+		bool owns_ifc_file;
+	public:
+		Iterator(const std::string& geometry_library, const settings& settings, IfcParse::IfcFile* file, const std::vector<ifcopenshell::geometry::filter_t>& filters, int num_threads = 1)
+			: settings_(settings)
+			, ifc_file(file)
+			, filters_(filters)
+			, owns_ifc_file(false)
+			, num_threads_(num_threads)
+			, geometry_library_(geometry_library)
+		{
+			_initialize();
+		}
+
+		Iterator(const settings& settings, IfcParse::IfcFile* file, int num_threads = 1)
+			: settings_(settings)
+			, ifc_file(file)
+			, owns_ifc_file(false)
+			, num_threads_(num_threads)
+			, geometry_library_("opencascade")
+		{
+			_initialize();
+		}
+
+		~Iterator() {
+			if (owns_ifc_file) {
+				delete ifc_file;
+			}
+
+			if (!settings_.get(settings::DISABLE_TRIANGULATION)) {
+				for (auto& p : all_processed_native_elements_) {
+					delete p;
+				}
+			}
+
+			for (auto& p : all_processed_elements_) {
+				delete p;
+			}
+		}
+	};
+}}
+
+#endif

src/ifcgeom/schema_agnostic/IfcGeomRenderStyles.h

@@ -17,35 +17,21 @@
  *                                                                              *
  ********************************************************************************/
 
-#ifndef IFCGEOMMATERIAL_H
-#define IFCGEOMMATERIAL_H
+#ifndef IFCGEOMRENDERSTYLES_H
+#define IFCGEOMRENDERSTYLES_H
 
-#include <string>
+#include "../../ifcgeom/schema_agnostic/ifc_geom_api.h"
+#include "../../ifcgeom/taxonomy.h"
 
-#include "../ifcgeom_schema_agnostic/IfcGeomRenderStyles.h"
+#include <boost/algorithm/string/case_conv.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/optional.hpp>
 
-namespace IfcGeom {	
-
-	class IFC_GEOM_API Material {
-	private:
-		const IfcGeom::SurfaceStyle* style;
-	public:
-		explicit Material(const IfcGeom::SurfaceStyle* style = 0); // TODO default constructor for vector?
-		// 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;
-		const std::string &original_name() const;
-		bool operator==(const Material& other) const;
-	};
+#include <sstream>
 
+namespace IfcGeom {
+	IFC_GEOM_API const ifcopenshell::geometry::taxonomy::style& get_default_style(const std::string& ifc_type);
+	IFC_GEOM_API void set_default_style_file(const std::string& json_file);
 }
 
 #endif

src/ifcgeom/schema_agnostic/IfcGeomRepresentation.cpp

@@ -21,33 +21,36 @@
 #include <BRepTools.hxx>
 #include <BRep_Builder.hxx>
 
+#include <TopoDS.hxx>
 #include <TopoDS_Compound.hxx>
 #include <Geom_Plane.hxx>
 #include <GProp_GProps.hxx>
 #include <BRepGProp.hxx>
 
-#include "../ifcgeom/IfcGeom.h"
-
 #include "IfcGeomRepresentation.h"
+#include "../../ifcgeom/kernels/opencascade/OpenCascadeConversionResult.h"
 
-IfcGeom::Representation::Serialization::Serialization(const BRep& brep)
+ifcopenshell::geometry::Representation::Serialization::Serialization(const BRep& brep)
 	: Representation(brep.settings())
 	, id_(brep.id())
 {
-	TopoDS_Compound compound = brep.as_compound();
-	for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = brep.begin(); it != brep.end(); ++ it) {
-		if (it->hasStyle() && it->Style().Diffuse()) {
-			const IfcGeom::SurfaceStyle::ColorComponent& clr = *it->Style().Diffuse();
-			surface_styles_.push_back(clr.R());
-			surface_styles_.push_back(clr.G());
-			surface_styles_.push_back(clr.B());
+	ifcopenshell::geometry::ConversionResultShape* shape = brep.as_compound();
+	TopoDS_Compound compound = TopoDS::Compound(((OpenCascadeShape*) shape)->shape());
+	delete shape;
+
+	for (ifcopenshell::geometry::ConversionResults::const_iterator it = brep.begin(); it != brep.end(); ++ it) {
+		if (it->hasStyle() && it->Style().diffuse) {
+			auto clr = it->Style().diffuse.get().components;
+			surface_styles_.push_back(clr[0]);
+			surface_styles_.push_back(clr[1]);
+			surface_styles_.push_back(clr[2]);
 		} else {
 			surface_styles_.push_back(-1.);
 			surface_styles_.push_back(-1.);
 			surface_styles_.push_back(-1.);
 		}
-		if (it->hasStyle() && it->Style().Transparency()) {
-			surface_styles_.push_back(1. - *it->Style().Transparency());
+		if (it->hasStyle() && it->Style().transparency) {
+			surface_styles_.push_back(1. - *it->Style().transparency);
 		} else {
 			surface_styles_.push_back(1.);
 		}
@@ -57,7 +60,7 @@ IfcGeom::Representation::Serialization::Serialization(const BRep& brep)
 	brep_data_ = sstream.str();
 }
 
-// todo copied from kernel
+// @todo copied from kernel
 #include <BRepBuilderAPI_Transform.hxx>
 #include <BRepBuilderAPI_GTransform.hxx>
 
@@ -82,15 +85,26 @@ TopoDS_Shape apply_transformation(const TopoDS_Shape& s, const gp_GTrsf& t) {
 	}
 }
 
-TopoDS_Compound IfcGeom::Representation::BRep::as_compound(bool force_meters) const {
+ifcopenshell::geometry::ConversionResultShape* ifcopenshell::geometry::Representation::BRep::as_compound(bool force_meters) const {
 	TopoDS_Compound compound;
 	BRep_Builder builder;
 	builder.MakeCompound(compound);
-	for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = begin(); it != end(); ++it) {
-		const TopoDS_Shape& s = it->Shape();
-		gp_GTrsf trsf = it->Placement();
 
-		if (!force_meters && settings().get(IteratorSettings::CONVERT_BACK_UNITS)) {
+	for (ifcopenshell::geometry::ConversionResults::const_iterator it = begin(); it != end(); ++it) {
+		const TopoDS_Shape& s = *(OpenCascadeShape*) it->Shape();
+		
+		// @todo, check
+		gp_GTrsf trsf;
+		gp_Trsf tr;
+		const auto& m = it->Placement().components;
+		tr.SetValues(
+			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)
+		);
+		trsf = tr;
+
+		if (!force_meters && settings().get(ifcopenshell::geometry::settings::CONVERT_BACK_UNITS)) {
 			gp_Trsf scale;
 			scale.SetScaleFactor(1.0 / settings().unit_magnitude());
 			trsf.PreMultiply(scale);
@@ -99,7 +113,8 @@ TopoDS_Compound IfcGeom::Representation::BRep::as_compound(bool force_meters) co
 		const TopoDS_Shape moved_shape = apply_transformation(s, trsf);
 		builder.Add(compound, moved_shape);
 	}
-	return compound;
+
+	return new OpenCascadeShape(compound);
 }
 
 namespace {
@@ -166,7 +181,7 @@ namespace {
 						const gp_Vec v2 = pt3 - pt2;
 						const gp_Vec v3 = pt1 - pt3;
 						const gp_Vec normal_vector = v1 ^ v2;
-						if (normal_vector.Magnitude() > ALMOST_ZERO) {
+						if (normal_vector.Magnitude() > 1.e-9) {
 							gp_Dir normal = gp_Dir();
 
 							double edge_lengths[3] = { v1.Magnitude(), v2.Magnitude(), v3.Magnitude() };
@@ -186,13 +201,13 @@ namespace {
 	}
 }
 
-bool IfcGeom::Representation::BRep::calculate_surface_area(double& area) const {
+bool ifcopenshell::geometry::Representation::BRep::calculate_surface_area(double& area) const {
 	try {
 		area = 0.;
 
-		for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = begin(); it != end(); ++it) {
+		for (ifcopenshell::geometry::ConversionResults::const_iterator it = begin(); it != end(); ++it) {
 			GProp_GProps prop;
-			BRepGProp::SurfaceProperties(it->Shape(), prop);
+			BRepGProp::SurfaceProperties(*(OpenCascadeShape*)it->Shape(), prop);
 			area += prop.Mass();
 		}
 
@@ -203,14 +218,14 @@ bool IfcGeom::Representation::BRep::calculate_surface_area(double& area) const {
 	}
 }
 
-bool IfcGeom::Representation::BRep::calculate_volume(double& volume) const {
+bool ifcopenshell::geometry::Representation::BRep::calculate_volume(double& volume) const {
 	try {
 		volume = 0.;
 
-		for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = begin(); it != end(); ++it) {
-			if (Kernel::is_manifold(it->Shape())) {
+		for (ifcopenshell::geometry::ConversionResults::const_iterator it = begin(); it != end(); ++it) {
+			if (it->Shape()->is_manifold()) {
 				GProp_GProps prop;
-				BRepGProp::VolumeProperties(it->Shape(), prop);
+				BRepGProp::VolumeProperties(*(OpenCascadeShape*)it->Shape(), prop);
 				volume += prop.Mass();
 			} else {
 				return false;
@@ -224,15 +239,29 @@ bool IfcGeom::Representation::BRep::calculate_volume(double& volume) const {
 	}
 }
 
-bool IfcGeom::Representation::BRep::calculate_projected_surface_area(const gp_Ax3 & ax, double & along_x, double & along_y, double & along_z) const {
+bool ifcopenshell::geometry::Representation::BRep::calculate_projected_surface_area(const ifcopenshell::geometry::taxonomy::matrix4& place, double & along_x, double & along_y, double & along_z) const {
 	try {
+		// @todo check
+		gp_GTrsf trsf;
+		gp_Trsf tr;
+		const auto& m = place.components;
+		tr.SetValues(
+			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)
+		);
+		trsf = tr;
+
+		gp_Mat mat = trsf.Trsf().HVectorialPart();
+		gp_Ax3 ax(trsf.TranslationPart(), mat.Column(3), mat.Column(1));
+
 		along_x = along_y = along_z = 0.;
 
-		for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = begin(); it != end(); ++it) {
+		for (ifcopenshell::geometry::ConversionResults::const_iterator it = begin(); it != end(); ++it) {
 			double x, y, z;
-			surface_area_along_direction(settings().deflection_tolerance(), it->Shape(), ax, x, y, z);
+			surface_area_along_direction(settings().deflection_tolerance(), *(OpenCascadeShape*)it->Shape(), ax, x, y, z);
 
-			if (Kernel::is_manifold(it->Shape())) {
+			if (it->Shape()->is_manifold()) {
 				x /= 2.;
 				y /= 2.;
 				z /= 2.;

src/ifcgeom/schema_agnostic/IfcGeomRepresentation.h

@@ -0,0 +1,235 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCGEOMREPRESENTATION_H
+#define IFCGEOMREPRESENTATION_H
+
+#include "../../ifcgeom/settings.h"
+#include "../../ifcgeom/schema_agnostic/ConversionResult.h"
+
+#include <map>
+
+namespace ifcopenshell { namespace geometry {
+
+	namespace Representation {
+
+		class IFC_GEOM_API Representation {
+			Representation(const Representation&); //N/A
+			Representation& operator =(const Representation&); //N/A
+		protected:
+			const element_settings settings_;
+		public:
+			explicit Representation(const element_settings& settings)
+				: settings_(settings) 
+			{}
+			const element_settings& settings() const { return settings_; }
+			virtual ~Representation() {}
+		};
+
+		class IFC_GEOM_API BRep : public Representation {
+		private:
+			std::string id_;
+			const ifcopenshell::geometry::ConversionResults shapes_;
+			BRep(const BRep& other);
+			BRep& operator=(const BRep& other);
+		public:
+			BRep(const element_settings& settings, const std::string& id, const ifcopenshell::geometry::ConversionResults& shapes)
+				: Representation(settings)
+				, id_(id)
+				, shapes_(shapes)
+			{}
+			virtual ~BRep() {}
+			ifcopenshell::geometry::ConversionResults::const_iterator begin() const { return shapes_.begin(); }
+			ifcopenshell::geometry::ConversionResults::const_iterator end() const { return shapes_.end(); }
+			const ifcopenshell::geometry::ConversionResults& shapes() const { return shapes_; }
+			const std::string& id() const { return id_; }
+			ifcopenshell::geometry::ConversionResultShape* as_compound(bool force_meters = false) const;
+
+			bool calculate_volume(double&) const;
+			bool calculate_surface_area(double&) const;
+			bool calculate_projected_surface_area(const ifcopenshell::geometry::taxonomy::matrix4& ax, double& along_x, double& along_y, double& along_z) const;
+		};
+
+		class IFC_GEOM_API Serialization : public Representation  {
+		private:
+			std::string id_;
+			std::string brep_data_;
+			std::vector<double> surface_styles_;
+		public:
+			const std::string& brep_data() const { return brep_data_; }
+			const std::vector<double>& surface_styles() const { return surface_styles_; }
+			Serialization(const BRep& brep);
+			virtual ~Serialization() {}
+			const std::string& id() const { return id_; }
+		private:
+			Serialization();
+			Serialization(const Serialization&);
+			Serialization& operator=(const Serialization&);
+		};
+
+		class Triangulation : public Representation {
+		private:
+			// A nested pair of floats and a material index to be able to store an XYZ coordinate in a map.
+			// TODO: Make this a std::tuple when compilers add support for that.
+			typedef typename std::pair<double, std::pair<double, double> > Coordinate;
+			typedef typename std::pair<int, Coordinate> VertexKey;
+			typedef std::map<VertexKey, int> VertexKeyMap;
+			typedef std::pair<int, int> Edge;
+
+			std::string id_;
+			std::vector<double> _verts;
+			std::vector<int> _faces;
+			std::vector<int> _edges;
+			std::vector<double> _normals;
+            std::vector<double> uvs_;
+			std::vector<int> _material_ids;
+			std::vector<ifcopenshell::geometry::taxonomy::style> _materials;
+			VertexKeyMap welds;
+
+		public:
+			const std::string& id() const { return id_; }
+			const std::vector<double>& verts() const { return _verts; }
+			const std::vector<int>& faces() const { return _faces; }
+			const std::vector<int>& edges() const { return _edges; }
+			const std::vector<double>& normals() const { return _normals; }
+            const std::vector<double>& uvs() const { return uvs_; }
+			const std::vector<int>& material_ids() const { return _material_ids; }
+			const std::vector<ifcopenshell::geometry::taxonomy::style>& materials() const { return _materials; }
+
+			Triangulation(const BRep& shape_model)
+					: Representation(shape_model.settings())
+					, id_(shape_model.id())
+			{
+				for ( ifcopenshell::geometry::ConversionResults::const_iterator iit = shape_model.begin(); iit != shape_model.end(); ++ iit ) {
+
+					int surface_style_id = -1;
+					if (iit->hasStyle()) {
+						std::vector<ifcopenshell::geometry::taxonomy::style>::const_iterator jt = std::find(_materials.begin(), _materials.end(), iit->Style());
+						if (jt == _materials.end()) {
+							surface_style_id = (int)_materials.size();
+							_materials.push_back(iit->Style());
+						} else {
+							surface_style_id = (int)(jt - _materials.begin());
+						}
+					}
+
+					if (settings().get(ifcopenshell::geometry::settings::APPLY_DEFAULT_MATERIALS) && surface_style_id == -1) {
+						const ifcopenshell::geometry::taxonomy::style& material = IfcGeom::get_default_style(settings().element_type());
+						std::vector<ifcopenshell::geometry::taxonomy::style>::const_iterator mit = std::find(_materials.begin(), _materials.end(), material);
+						if (mit == _materials.end()) {
+							surface_style_id = (int)_materials.size();
+							_materials.push_back(material);
+						} else {
+							surface_style_id = (int)(mit - _materials.begin());
+						}
+					}
+
+					iit->Shape()->Triangulate(settings(), iit->Placement(), this, surface_style_id);
+				}
+			}
+			virtual ~Triangulation() {}
+
+            /// Generates UVs for a single mesh using box projection.
+            /// @todo Very simple impl. Assumes that input vertices and normals match 1:1.
+            static std::vector<double> box_project_uvs(const std::vector<double> &vertices, const std::vector<double> &normals)
+            {
+                std::vector<double> uvs;
+                uvs.resize(vertices.size() / 3 * 2);
+                for (size_t uv_idx = 0, v_idx = 0;
+                uv_idx < uvs.size() && v_idx < vertices.size() && v_idx < normals.size();
+                    uv_idx += 2, v_idx += 3) {
+
+					double n_x = normals[v_idx], n_y = normals[v_idx + 1], n_z = normals[v_idx + 2];
+					double v_x = vertices[v_idx], v_y = vertices[v_idx + 1], v_z = vertices[v_idx + 2];
+
+                    if (std::abs(n_x) > std::abs(n_y) && std::abs(n_x) > std::abs(n_z)) {
+                        uvs[uv_idx] = v_z;
+                        uvs[uv_idx + 1] = v_y;
+                    }
+                    if (std::abs(n_y) > std::abs(n_x) && std::abs(n_y) > std::abs(n_z)) {
+                        uvs[uv_idx] = v_x;
+                        uvs[uv_idx + 1] = v_z;
+                    }
+                    if (std::abs(n_z) > std::abs(n_x) && std::abs(n_z) > std::abs(n_y)) {
+                        uvs[uv_idx] = v_x;
+                        uvs[uv_idx + 1] = v_y;
+                    }
+                }
+
+                return uvs;
+            }
+
+		public:
+
+			// Welds vertices that belong to different faces
+			int addVertex(int material_index, double X, double Y, double Z) {
+                const bool convert = settings().get(ifcopenshell::geometry::settings::CONVERT_BACK_UNITS);
+				X = static_cast<double>(convert ? (X / settings().unit_magnitude()) : X);
+				Y = static_cast<double>(convert ? (Y / settings().unit_magnitude()) : Y);
+				Z = static_cast<double>(convert ? (Z / settings().unit_magnitude()) : Z);
+				int i = (int) _verts.size() / 3;
+				if (settings().get(ifcopenshell::geometry::settings::WELD_VERTICES)) {
+					const VertexKey key = std::make_pair(material_index, std::make_pair(X, std::make_pair(Y, Z)));
+					typename VertexKeyMap::const_iterator it = welds.find(key);
+					if ( it != welds.end() ) return it->second;
+					i = (int) welds.size();
+					welds[key] = i;
+				}
+				_verts.push_back(X);
+				_verts.push_back(Y);
+				_verts.push_back(Z);
+				return i;
+			}
+
+			inline void addEdge(int n1, int n2, std::map<std::pair<int,int>,int>& edgecount, std::vector<std::pair<int,int> >& edges_temp) {
+				const Edge e = Edge( (std::min)(n1,n2),(std::max)(n1,n2) );
+				if ( edgecount.find(e) == edgecount.end() ) edgecount[e] = 1;
+				else edgecount[e] ++;
+				edges_temp.push_back(e);
+			}
+
+			inline void addNormal(double X, double Y, double Z) {
+				_normals.push_back(X);
+				_normals.push_back(Y);
+				_normals.push_back(Z);
+			}
+
+			inline void addFace(int style, int i0, int i1, int i2) {
+				_faces.push_back(i0);
+				_faces.push_back(i1);
+				_faces.push_back(i2);
+
+				_material_ids.push_back(style);
+			}
+
+			inline void registerEdge(int i0, int i1) {
+				_edges.push_back(i0);
+				_edges.push_back(i1);
+			}
+
+		private:
+			Triangulation();
+			Triangulation(const Triangulation&);
+			Triangulation& operator=(const Triangulation&);
+		};
+
+	}
+}}
+
+#endif

src/ifcgeom/schema_agnostic/Serialization.h

@@ -1,5 +1,6 @@
-#include "../ifcgeom/ifc_geom_api.h"
-#include "../ifcparse/IfcBaseClass.h"
+#include "../../ifcparse/IfcBaseClass.h"
+
+#include "../../ifcgeom/schema_agnostic/ifc_geom_api.h"
 
 #include <TopoDS_Shape.hxx>
 

src/ifcgeom/schema_agnostic/SurfaceStyle.cpp

@@ -0,0 +1,122 @@
+#include "../../ifcgeom/schema_agnostic/IfcGeomRenderStyles.h"
+
+#include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
+
+#include <map>
+
+namespace pt = boost::property_tree;
+
+static std::map<std::string, ifcopenshell::geometry::taxonomy::style> default_materials;
+static ifcopenshell::geometry::taxonomy::style default_material;
+static bool default_materials_initialized = false;
+
+void InitDefaultMaterials() {
+	default_materials.insert(std::make_pair("IfcSite", ifcopenshell::geometry::taxonomy::style("IfcSite")));
+	default_materials["IfcSite"].diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.75, 0.8, 0.65));
+
+	default_materials.insert(std::make_pair("IfcSlab", ifcopenshell::geometry::taxonomy::style("IfcSlab")));
+	default_materials["IfcSlab"].diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.4, 0.4, 0.4));
+
+	default_materials.insert(std::make_pair("IfcWallStandardCase", ifcopenshell::geometry::taxonomy::style("IfcWallStandardCase")));
+	default_materials["IfcWallStandardCase"].diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.9, 0.9, 0.9));
+
+	default_materials.insert(std::make_pair("IfcWall", ifcopenshell::geometry::taxonomy::style("IfcWall")));
+	default_materials["IfcWall"].diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.9, 0.9, 0.9));
+
+	default_materials.insert(std::make_pair("IfcWindow", ifcopenshell::geometry::taxonomy::style("IfcWindow")));
+	default_materials["IfcWindow"].diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.75, 0.8, 0.75));
+	default_materials["IfcWindow"].transparency.reset(0.3);
+
+	default_materials.insert(std::make_pair("IfcDoor", ifcopenshell::geometry::taxonomy::style("IfcDoor")));
+	default_materials["IfcDoor"].diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.55, 0.3, 0.15));
+
+	default_materials.insert(std::make_pair("IfcBeam", ifcopenshell::geometry::taxonomy::style("IfcBeam")));
+	default_materials["IfcBeam"].diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.75, 0.7, 0.7));
+
+	default_materials.insert(std::make_pair("IfcRailing", ifcopenshell::geometry::taxonomy::style("IfcRailing")));
+	default_materials["IfcRailing"].diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.65, 0.6, 0.6));
+
+	default_materials.insert(std::make_pair("IfcMember", ifcopenshell::geometry::taxonomy::style("IfcMember")));
+	default_materials["IfcMember"].diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.65, 0.6, 0.6));
+
+	default_materials.insert(std::make_pair("IfcPlate", ifcopenshell::geometry::taxonomy::style("IfcPlate")));
+	default_materials["IfcPlate"].diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.8, 0.8, 0.8));
+
+	default_material = ifcopenshell::geometry::taxonomy::style("DefaultMaterial");
+	default_material.diffuse.reset(ifcopenshell::geometry::taxonomy::colour(0.7, 0.7, 0.7));
+
+	default_materials_initialized = true;
+}
+
+boost::optional<ifcopenshell::geometry::taxonomy::colour> read_colour_component(const boost::optional<pt::ptree&> list) {
+	if (!list) {
+		return boost::none;
+	}
+	double rgb[3];
+	int i = 0;
+	for (pt::ptree::value_type &colour : list.get()) {
+		if (3 <= i) {
+			throw std::runtime_error("rgb array over 3 elements large");
+		}
+		rgb[i] = colour.second.get_value<double>();
+		i++;
+	}
+	if (i != 3) {
+		throw std::runtime_error("rgb array less than 3 elements large (was " + std::to_string(i) + ")");
+	}
+	return ifcopenshell::geometry::taxonomy::colour(rgb[0], rgb[1], rgb[2]);
+}
+
+void IfcGeom::set_default_style_file(const std::string& json_file) {
+	if (!default_materials_initialized) InitDefaultMaterials();
+	default_materials.clear();
+
+	// @todo this will probably need to be updated for UTF-8 paths on Windows
+	pt::ptree root;
+	pt::read_json(json_file, root);
+
+	for (pt::ptree::value_type &material_pair : root) {
+		std::string name = material_pair.first;
+		default_materials.insert(std::make_pair(name, ifcopenshell::geometry::taxonomy::style(name)));
+
+		pt::ptree material = material_pair.second;
+		boost::optional<pt::ptree&> diffuse = material.get_child_optional("diffuse");
+		default_materials[name].diffuse = read_colour_component(diffuse);
+
+		boost::optional<pt::ptree&> specular = material.get_child_optional("specular");
+		default_materials[name].specular = read_colour_component(specular);
+
+		if (material.get_child_optional("specular-roughness")) {
+			default_materials[name].specularity.reset(1.0 / material.get<double>("specular-roughness"));
+		}
+		if (material.get_child_optional("transparency")) {
+			default_materials[name].transparency = material.get<double>("transparency");
+		}
+	}
+
+	// Is "*" present? If yes, remove it and make it the default style.
+	std::map<std::string, ifcopenshell::geometry::taxonomy::style>::const_iterator it = default_materials.find("*");
+	if (it != default_materials.end()) {
+		ifcopenshell::geometry::taxonomy::style star = it->second;
+		default_material.diffuse = star.diffuse;
+		default_material.specular = star.specular;
+		default_material.specularity = star.specularity;
+		default_material.transparency = star.transparency;
+		default_materials.erase(it);
+	}
+}
+
+const ifcopenshell::geometry::taxonomy::style& IfcGeom::get_default_style(const std::string& s) {
+	if (!default_materials_initialized) InitDefaultMaterials();
+	std::map<std::string, ifcopenshell::geometry::taxonomy::style>::const_iterator it = default_materials.find(s);
+	if (it == default_materials.end()) {
+		default_materials.insert(std::make_pair(s, ifcopenshell::geometry::taxonomy::style(s)));
+		default_materials[s].diffuse = default_material.diffuse;
+		default_materials[s].specular = default_material.specular;
+		default_materials[s].specularity = default_material.specularity;
+		default_materials[s].transparency = default_material.transparency;
+		it = default_materials.find(s);
+	}
+	return it->second;
+}

src/ifcgeom/settings.h

@@ -20,13 +20,17 @@
 #ifndef IFCGEOMITERATORSETTINGS_H
 #define IFCGEOMITERATORSETTINGS_H
 
-#include "ifc_geom_api.h"
+// #include "ifc_geom_api.h"
+
+#define IFC_GEOM_API
+
 #include "../ifcparse/IfcException.h"
 #include "../ifcparse/IfcBaseClass.h"
+#include "../ifcparse/IfcLogger.h"
 
-namespace IfcGeom
-{
-    class IFC_GEOM_API IteratorSettings
+namespace ifcopenshell { namespace geometry {
+
+    class IFC_GEOM_API settings
     {
     public:
         /// Enumeration of setting identifiers. These settings define the
@@ -92,7 +96,7 @@ namespace IfcGeom
         /// Used to store logical OR combination of setting flags.
         typedef unsigned SettingField;
 
-        IteratorSettings()
+        settings()
             : settings_(WELD_VERTICES) // OR options that default to true here
             , deflection_tolerance_(1.e-3)
         {
@@ -135,13 +139,13 @@ namespace IfcGeom
         double deflection_tolerance_;
     };
 
-    class IFC_GEOM_API ElementSettings : public IteratorSettings
+    class IFC_GEOM_API element_settings : public settings
     {
     public:
-        ElementSettings(const IteratorSettings& settings,
+		element_settings(const settings& s,
             double unit_magnitude,
             const std::string& element_type)
-            : IteratorSettings(settings)
+            : settings(s)
             , unit_magnitude_(unit_magnitude)
             , element_type_(element_type)
         {
@@ -154,6 +158,7 @@ namespace IfcGeom
         double unit_magnitude_;
         std::string element_type_;
     };
-}
+
+}}
 
 #endif

src/ifcgeom/taxonomy.h

@@ -0,0 +1,291 @@
+#ifndef TAXONOMY_H
+#define TAXONOMY_H
+
+#include "../ifcparse/IfcBaseClass.h"
+
+#include <boost/variant.hpp>
+
+#include <Eigen/Dense>
+
+#include <map>
+#include <string>
+#include <tuple>
+#include <exception>
+#include <cstdalign>
+
+namespace ifcopenshell {
+
+namespace geometry {
+
+namespace taxonomy {
+
+class topology_error : public std::runtime_error {
+public:
+	topology_error() : std::runtime_error("Generic topology error") {}
+	topology_error(const char* const s) : std::runtime_error(s) {}
+};
+
+enum kinds { MATRIX4, POINT3, DIRECTION3, LINE, CIRCLE, ELLIPSE, BSPLINE_CURVE, PLANE, EDGE, LOOP, FACE, SHELL, EXTRUSION, NODE, COLLECTION, BOOLEAN_RESULT, COLOUR, STYLE };
+
+struct item {
+	const IfcUtil::IfcBaseClass* instance;
+    virtual item* clone() const = 0;
+	virtual kinds kind() const = 0;
+	virtual void reverse() { throw taxonomy::topology_error(); }
+
+	item(const IfcUtil::IfcBaseClass* instance = nullptr) : instance(instance) {}
+
+	EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+};
+
+struct matrix4 : public item {
+    enum tag_t {
+        IDENTITY, AFFINE_WO_SCALE, AFFINE_W_UNIFORM_SCALE, AFFINE_W_NONUNIFORM_SCALE, OTHER
+    };
+    tag_t tag;
+	
+	Eigen::Matrix4d components;
+
+	matrix4() : components(Eigen::Matrix4d::Identity()), tag(IDENTITY) {}
+	matrix4(const Eigen::Matrix4d& c) : components(c), tag(OTHER) {}
+	matrix4(const Eigen::Vector3d& o, const Eigen::Vector3d& z, const Eigen::Vector3d& x) : tag(AFFINE_WO_SCALE) {
+		auto X = x.normalized();
+		auto Y = z.cross(x).normalized();
+		auto Z = z.normalized();
+		components << 
+			X(0), Y(0), Z(0), o(0),
+			X(1), Y(1), Z(1), o(1),
+			X(2), Y(2), Z(2), o(2),
+			0, 0, 0, 1.;
+	}
+
+	virtual item* clone() const { return new matrix4(*this); }
+	virtual kinds kind() const { return MATRIX4; }
+};
+
+struct colour : public item {
+	Eigen::Vector3d components;
+
+	virtual item* clone() const { return new colour(*this); }
+	virtual kinds kind() const { return COLOUR; }
+
+	colour() : components(Eigen::Vector3d::Zero()) {}
+	colour(double r, double g, double b) { components << r, g, b; }
+
+	const double& r() const { return components[0]; }
+	const double& g() const { return components[1]; }
+	const double& b() const { return components[2]; }
+};
+
+struct style : public item {
+	// @todo this is not very efficient wrt alignment
+	boost::optional<std::string> name;
+	boost::optional<colour> diffuse;
+	boost::optional<colour> specular;
+	boost::optional<double> specularity, transparency;
+
+	virtual item* clone() const { return new style(*this); }
+	virtual kinds kind() const { return STYLE; }
+
+	// @todo equality implementation based on values?
+	bool operator==(const style& other) const { return instance == other.instance; }
+
+	style() {}
+	style(const std::string& name) : name(name) {}
+};
+
+struct geom_item : public item {
+    style surface_style;
+    matrix4 matrix;
+	boost::optional<bool> orientation;
+
+	geom_item(const IfcUtil::IfcBaseClass* instance = nullptr) : item(instance) {}
+	geom_item(const IfcUtil::IfcBaseClass* instance, matrix4 m) : item(instance), matrix(m) {}
+	geom_item(matrix4 m) : matrix(m) {}
+};
+
+template <size_t N>
+struct cartesian_base : public geom_item {
+	Eigen::Vector3d components;
+
+	cartesian_base() : components(Eigen::Vector3d::Zero()) {}
+	cartesian_base(double x, double y, double z = 0.) { components << x, y, z; }
+};
+
+struct point3 : public cartesian_base<3> {
+    virtual item* clone() const { return new point3(*this); }
+	virtual kinds kind() const { return POINT3; }
+
+	point3(double x = 0., double y = 0., double z = 0.) : cartesian_base(x, y, z) {}
+};
+
+struct direction3 : public cartesian_base<3> {
+	virtual item* clone() const { return new direction3(*this); }
+	virtual kinds kind() const { return DIRECTION3; }
+
+	direction3(double x = 0., double y = 0., double z = 0.) : cartesian_base(x, y, z) {}
+};
+
+struct curve : public geom_item {};
+
+struct line : public curve {
+	virtual item* clone() const { return new line(*this); }
+	virtual kinds kind() const { return LINE; }
+};
+
+struct circle : public curve {
+	double radius;
+
+	virtual item* clone() const { return new circle(*this); }
+	virtual kinds kind() const { return CIRCLE; }
+};
+
+struct ellipse : public circle {
+	double radius2;
+
+	virtual item* clone() const { return new ellipse(*this); }
+	virtual kinds kind() const { return ELLIPSE; }
+};
+
+struct bspline_curve : public curve {
+	virtual item* clone() const { return new bspline_curve(*this); }
+	virtual kinds kind() const { return BSPLINE_CURVE; }
+};
+
+struct trimmed_curve : public curve {
+	boost::variant<point3, double> start, end;
+	// @todo somehow account for the fact that curve in IFC can be trimmed curve, polyline and composite curve as well.
+	item* basis;
+	bool orientation;
+
+	trimmed_curve() : basis(nullptr), orientation(true) {}
+	
+	virtual void reverse() {
+		std::swap(start, end);
+		orientation = !orientation;
+	}
+};
+
+struct edge : public trimmed_curve {
+	// @todo how to express similarity between trimmed_curve and edge?
+	virtual item* clone() const { return new edge(*this); }
+	virtual kinds kind() const { return EDGE; }
+};
+
+struct collection : public geom_item {
+	std::vector<item*> children;
+
+	template <typename T>
+	std::vector<T*> children_as() const {
+		std::vector<T*> ts;
+		ts.reserve(children.size());
+		std::for_each(children.begin(), children.end(), [&ts](item* i){
+			auto v = dynamic_cast<T*>(i);
+			if (v) {
+				ts.push_back(v);
+			}
+		});
+		return ts;
+	}
+
+	virtual item* clone() const { return new collection(*this); }
+	virtual kinds kind() const { return COLLECTION; }
+	virtual void reverse() { 
+		std::reverse(children.begin(), children.end()); 
+		for (auto& child : children) {
+			child->reverse();
+		}
+	}
+};
+
+struct shell : public collection {
+	boost::optional<bool> closed;
+
+	virtual item* clone() const { return new shell(*this); }
+	virtual kinds kind() const { return SHELL; }
+};
+
+struct surface : public geom_item {};
+
+struct plane : public surface {
+	virtual item* clone() const { return new plane(*this); }
+	virtual kinds kind() const { return PLANE; }
+};
+
+struct face : public collection {
+	item* basis;
+
+	virtual item* clone() const { return new face(*this); }
+	virtual kinds kind() const { return FACE; }
+};
+
+struct loop : public collection {
+	boost::optional<bool> external, closed;
+
+	virtual item* clone() const { return new loop(*this); }
+	virtual kinds kind() const { return LOOP; }
+};
+
+struct sweep : public geom_item {
+	face basis;
+
+	sweep(face b) : basis(b) {}
+	sweep(matrix4 m, face b) : geom_item(m), basis(b) {}
+};
+
+struct extrusion : public sweep {
+	direction3 direction;
+	double depth;
+
+	virtual item* clone() const { return new extrusion(*this); }
+	virtual kinds kind() const { return EXTRUSION; }
+
+	extrusion(matrix4 m, face basis, direction3 dir, double d) : sweep(m, basis), direction(dir), depth(d) {}
+};
+
+struct node : public collection {
+	std::map<std::string, geom_item*> representations;
+
+	virtual item* clone() const { return new node(*this); }
+	virtual kinds kind() const { return NODE; }
+};
+
+struct boolean_result : public collection {
+	enum operation_t {
+		UNION, SUBTRACTION, INTERSECTION
+	};
+
+	virtual item* clone() const { return new boolean_result(*this); }
+	virtual kinds kind() const { return BOOLEAN_RESULT; }
+	operation_t operation;
+};
+
+namespace impl {
+	typedef std::tuple<matrix4, point3, direction3, line, circle, ellipse, bspline_curve, edge, plane, loop, face, shell, extrusion, node, collection, boolean_result> KindsTuple;
+	typedef std::tuple<line, circle, ellipse, bspline_curve, loop, edge> CurvesTuple;
+}
+
+struct type_by_kind {
+	template <std::size_t N>
+	using type = typename std::tuple_element<N, impl::KindsTuple>::type;
+
+	static const size_t max = std::tuple_size< impl::KindsTuple>::value;
+};
+
+struct curves {
+	template <std::size_t N>
+	using type = typename std::tuple_element<N, impl::CurvesTuple>::type;
+
+	static const size_t max = std::tuple_size< impl::CurvesTuple>::value;
+};
+
+
+}
+
+
+
+}
+
+}
+
+#endif

src/ifcgeom_schema_agnostic/IfcGeomIterator.h

@@ -1,130 +0,0 @@
-/********************************************************************************
- *                                                                              *
- * This file is part of IfcOpenShell.                                           *
- *                                                                              *
- * IfcOpenShell is free software: you can redistribute it and/or modify         *
- * it under the terms of the Lesser GNU General Public License as published by  *
- * the Free Software Foundation, either version 3.0 of the License, or          *
- * (at your option) any later version.                                          *
- *                                                                              *
- * IfcOpenShell is distributed in the hope that it will be useful,              *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
- * Lesser GNU General Public License for more details.                          *
- *                                                                              *
- * You should have received a copy of the Lesser GNU General Public License     *
- * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
- *                                                                              *
- ********************************************************************************/
-
-/********************************************************************************
- *                                                                              *
- * Geometrical data in an IFC file consists of shapes (IfcShapeRepresentation)  *
- * and instances (SUBTYPE OF IfcBuildingElement e.g. IfcWindow).                *
- *                                                                              *
- * IfcGeom::Representation::Triangulation is a class that represents a          *
- * triangulated IfcShapeRepresentation.                                         *
- *   Triangulation.verts is a 1 dimensional vector of float defining the        *
- *      cartesian coordinates of the vertices of the triangulated shape in the  *
- *      format of [x1,y1,z1,..,xn,yn,zn]                                        *
- *   Triangulation.faces is a 1 dimensional vector of int containing the        *
- *     indices of the triangles referencing positions in Triangulation.verts    *
- *   Triangulation.edges is a 1 dimensional vector of int in {0,1} that dictates*
- *	   the visibility of the edges that span the faces in Triangulation.faces   *
- *                                                                              *
- * IfcGeom::Element represents the actual IfcBuildingElements.                  *
- *   IfcGeomObject.name is the GUID of the element                              *
- *   IfcGeomObject.type is the datatype of the element e.g. IfcWindow           *
- *   IfcGeomObject.mesh is a pointer to an IfcMesh                              *
- *   IfcGeomObject.transformation.matrix is a 4x3 matrix that defines the       *
- *     orientation and translation of the mesh in relation to the world origin  *
- *                                                                              *
- * IfcGeom::Iterator::initialize()                                              *
- *   finds the most suitable representation contexts. Returns true iff          *
- *   at least a single representation will process successfully                 *
- *                                                                              *
- * IfcGeom::Iterator::get()                                                     *
- *   returns a pointer to the current IfcGeom::Element                          *
- *                                                                              * 
- * IfcGeom::Iterator::next()                                                    *
- *   returns true iff a following entity is available for a successive call to  *
- *   IfcGeom::Iterator::get()                                                   *
- *                                                                              *
- * IfcGeom::Iterator::progress()                                                *
- *   returns an int in [0..100] that indicates the overall progress             *
- *                                                                              *
- ********************************************************************************/
-
-#ifndef IFCGEOMITERATOR_H
-#define IFCGEOMITERATOR_H
-
-#include "../ifcgeom_schema_agnostic/IteratorImplementation.h"
-
-// The infamous min & max Win32 #defines can leak here from OCE depending on the build configuration
-#ifdef min
-#undef min
-#endif
-#ifdef max
-#undef max
-#endif
-
-namespace IfcGeom {
-	
-	template <typename P = double, typename PP = P>
-	class Iterator {
-	private:
-		Iterator(const Iterator&); // N/I
-		Iterator& operator=(const Iterator&); // N/I
-
-		IfcParse::IfcFile* file_;
-		IfcGeom::IteratorSettings settings_;
-		std::vector<IfcGeom::filter_t> filters_;
-
-		IteratorImplementation<P, PP>* implementation_;
-
-	public:
-		Iterator(const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file, int num_threads = 1)
-			: file_(file)
-			, settings_(settings)
-		{
-			implementation_ = iterator_implementations<P, PP>().construct(file_->schema()->name(), settings, file, filters_, num_threads);
-		}
-
-		Iterator(const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters, size_t num_threads = 1)
-			: file_(file)
-			, settings_(settings)
-			, filters_(filters)
-		{
-			implementation_ = iterator_implementations<P, PP>().construct(file_->schema()->name(), settings, file, filters_, num_threads);
-		}
-
-		bool initialize() {
-			return implementation_->initialize();
-		}
-
-		int progress() const { return implementation_->progress(); }
-
-		void compute_bounds() { implementation_->compute_bounds(); }
-
-		const gp_XYZ& bounds_min() const { return implementation_->bounds_min(); }
-		const gp_XYZ& bounds_max() const { return implementation_->bounds_max(); }
-
-		const std::string& unit_name() const { return implementation_->getUnitName(); }
-
-		double unit_magnitude() const { return implementation_->getUnitMagnitude(); }
-
-		IfcParse::IfcFile* file() const { return implementation_->file(); }
-
-		IfcUtil::IfcBaseClass* next() const { return implementation_->next(); }
-
-		Element<P, PP>* get() { return implementation_->get(); }
-
-		BRepElement<P, PP>* get_native() { return implementation_->get_native(); }
-
-		const Element<P, PP>* get_object(int id) { return implementation_->get_object(id); }
-
-		IfcUtil::IfcBaseClass* create() { return implementation_->create(); }
-	};
-}
-
-#endif

src/ifcgeom_schema_agnostic/IfcGeomMaterial.cpp

@@ -1,35 +0,0 @@
-/********************************************************************************
- *                                                                              *
- * This file is part of IfcOpenShell.                                           *
- *                                                                              *
- * IfcOpenShell is free software: you can redistribute it and/or modify         *
- * it under the terms of the Lesser GNU General Public License as published by  *
- * the Free Software Foundation, either version 3.0 of the License, or          *
- * (at your option) any later version.                                          *
- *                                                                              *
- * IfcOpenShell is distributed in the hope that it will be useful,              *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
- * Lesser GNU General Public License for more details.                          *
- *                                                                              *
- * You should have received a copy of the Lesser GNU General Public License     *
- * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
- *                                                                              *
- ********************************************************************************/
-
-#include "IfcGeomMaterial.h"
-
-static double black[3] = {0.,0.,0.};
-
-IfcGeom::Material::Material(const IfcGeom::SurfaceStyle* style) : style(style) {}
-bool IfcGeom::Material::hasDiffuse() const { return style->Diffuse() ? true : false; }
-bool IfcGeom::Material::hasSpecular() const { return style->Specular() ? true : false; }
-bool IfcGeom::Material::hasTransparency() const { return style->Transparency() ? true : false; }
-bool IfcGeom::Material::hasSpecularity() const { return style->Specularity() ? true : false; }
-const double* IfcGeom::Material::diffuse() const { if (hasDiffuse()) return &((*style->Diffuse()).R()); else return black; }
-const double* IfcGeom::Material::specular() const { if (hasSpecular()) return &((*style->Specular()).R()); else return black; }
-double IfcGeom::Material::transparency() const { if (hasTransparency()) return *style->Transparency(); else return 0; }
-double IfcGeom::Material::specularity() const { if (hasSpecularity()) return *style->Specularity(); else return 0; }
-const std::string &IfcGeom::Material::name() const { return style->Name(); }
-const std::string &IfcGeom::Material::original_name() const { return style->original_name(); }
-bool IfcGeom::Material::operator==(const IfcGeom::Material& other) const { return style == other.style; }

src/ifcgeom_schema_agnostic/IfcGeomRenderStyles.h

@@ -1,101 +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
-
-#include "../ifcgeom/ifc_geom_api.h"
-
-#include <boost/algorithm/string/case_conv.hpp>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/optional.hpp>
-
-#include <sstream>
-
-namespace IfcGeom {
-	class IFC_GEOM_API SurfaceStyle {
-	public:
-		class ColorComponent {
-		private:
-			double data[3];
-		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;
-        std::string original_name_;
-		boost::optional<int> id;
-		boost::optional<ColorComponent> diffuse, specular;
-		boost::optional<double> transparency;
-		boost::optional<double> specularity;
-	public:
-        SurfaceStyle() : name("surface-style") {}
-		SurfaceStyle(int id) : id(id) {
-			std::stringstream sstr; 
-			sstr << "surface-style-" << id; 
-			this->name = sstr.str(); 
-		}
-        SurfaceStyle(const std::string& name) : name(name), original_name_(name) {}
-        SurfaceStyle(int id, const std::string& name) : original_name_(name), id(id)
-        {
-			std::stringstream sstr; 
-			std::string sanitized = name;
-            boost::to_lower(sanitized);
-            boost::replace_all(sanitized, " ", "-");
-			sstr << "surface-style-" << id << "-" << sanitized;
-			this->name = sstr.str(); 
-		}
-		
-		// Not used at this point. In fact, equality testing in the current
-		// architecture can just as easily be accomplished by comparing the
-		// pointer addresses of the styles, as they are always referenced 
-		// from out of a global map of some sort.
-		bool operator==(const SurfaceStyle& other) {
-			return name == other.name;
-		}
-		
-        /// ID name, e.g. "surface-style-66675-metal---aluminium"
-		const std::string& Name() const { return name; }
-
-        /// Original name, if available, e.g. "Metal - Aluminium"
-        const std::string& original_name() const { return original_name_; }
-
-		const 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; }
-	};
-
-  IFC_GEOM_API const SurfaceStyle* get_default_style(const std::string& ifc_type);
-	IFC_GEOM_API void set_default_style_file(const std::string& json_file);
-}
-
-#endif

src/ifcgeom_schema_agnostic/IteratorImplementation.cpp

@@ -1,47 +0,0 @@
-#include "IteratorImplementation.h"
-
-#include <boost/algorithm/string/case_conv.hpp>
-
-template <typename P, typename PP>
-IteratorFactoryImplementation<P, PP>& iterator_implementations() {
-	static IteratorFactoryImplementation<P, PP> impl;
-	return impl;
-}
-
-template IteratorFactoryImplementation<float, float>& iterator_implementations<float, float>();
-template IteratorFactoryImplementation<float, double>& iterator_implementations<float, double>();
-template IteratorFactoryImplementation<double, double>& iterator_implementations<double, double>();
-
-template <typename P, typename PP>
-extern void init_IteratorImplementation_Ifc2x3(IteratorFactoryImplementation<P, PP>*);
-
-template <typename P, typename PP>
-extern void init_IteratorImplementation_Ifc4(IteratorFactoryImplementation<P, PP>*);
-
-template <typename P, typename PP>
-IteratorFactoryImplementation<P, PP>::IteratorFactoryImplementation() {
-	init_IteratorImplementation_Ifc2x3(this);
-	init_IteratorImplementation_Ifc4(this);
-}
-
-template <typename P, typename PP>
-void IteratorFactoryImplementation<P, PP>::bind(const std::string& schema_name, typename get_factory_type<P, PP>::type fn) {
-	const std::string schema_name_lower = boost::to_lower_copy(schema_name);
-	this->insert(std::make_pair(schema_name_lower, fn));
-}
-
-template <typename P, typename PP>
-IfcGeom::IteratorImplementation<P, PP>* IteratorFactoryImplementation<P, PP>::construct(const std::string& schema_name, const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters, int num_threads) {
-	const std::string schema_name_lower = boost::to_lower_copy(schema_name);
-	typename std::map<std::string, typename get_factory_type<P, PP>::type>::const_iterator it;
-	it = this->find(schema_name_lower);
-	if (it == this->end()) {
-		throw IfcParse::IfcException("No geometry iterator registered for " + schema_name);
-	}
-	return it->second(settings, file, filters, num_threads);
-}
-
-
-template class IteratorFactoryImplementation<float, float>;
-template class IteratorFactoryImplementation<float, double>;
-template class IteratorFactoryImplementation<double, double>;

src/ifcgeom_schema_agnostic/IteratorImplementation.h

@@ -1,81 +0,0 @@
-#ifndef ITERATOR_IMPLEMENTATION_H
-#define ITERATOR_IMPLEMENTATION_H
-
-#include "../ifcgeom_schema_agnostic/IfcGeomFilter.h"
-#include "../ifcparse/IfcFile.h"
-#include "../ifcgeom/IfcGeomIteratorSettings.h"
-
-#include <gp_XYZ.hxx>
-
-#include <boost/function.hpp>
-
-#include <map>
-#include <string>
-
-namespace IfcGeom {
-	template <typename P, typename PP>
-	class IteratorImplementation;
-
-	template <typename P, typename PP>
-	class Element;
-
-	template <typename P, typename PP>
-	class BRepElement;
-}
-
-typedef boost::function4<IfcGeom::IteratorImplementation<float, float>*, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&, int> iterator_float_float_fn;
-typedef boost::function4<IfcGeom::IteratorImplementation<float, double>*, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&, int> iterator_float_double_fn;
-typedef boost::function4<IfcGeom::IteratorImplementation<double, double>*, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&, int> iterator_double_double_fn;
-
-template <typename P, typename PP>
-struct get_factory_type {};
-
-template <>
-struct get_factory_type<float, float> {
-	typedef iterator_float_float_fn type;
-};
-
-template <>
-struct get_factory_type<float, double> {
-	typedef iterator_float_double_fn type;
-};
-
-template <>
-struct get_factory_type<double, double> {
-	typedef iterator_double_double_fn type;
-};
-
-template <typename P, typename PP>
-class IteratorFactoryImplementation : public std::map<std::string, typename get_factory_type<P, PP>::type> {
-public:
-	IteratorFactoryImplementation();
-	void bind(const std::string& schema_name, typename get_factory_type<P, PP>::type fn);
-	IfcGeom::IteratorImplementation<P, PP>* construct(const std::string& schema_name, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&, int);
-};
-
-template <typename P, typename PP>
-IteratorFactoryImplementation<P, PP>& iterator_implementations();
-
-namespace IfcGeom {
-
-	template <typename P, typename PP>
-	class IteratorImplementation {
-	public:
-		virtual bool initialize() = 0;
-		virtual void compute_bounds() = 0;
-		virtual const gp_XYZ& bounds_min() const = 0;
-		virtual const gp_XYZ& bounds_max() const = 0;
-		virtual int progress() const = 0;
-		virtual const std::string& getUnitName() const = 0;
-		virtual double getUnitMagnitude() const = 0;
-		virtual IfcParse::IfcFile* file() const = 0;
-		virtual IfcUtil::IfcBaseClass* next() = 0;
-		virtual Element<P, PP>* get() = 0;
-		virtual BRepElement<P, PP>* get_native() = 0;
-		virtual const Element<P, PP>* get_object(int id) = 0;
-		virtual IfcUtil::IfcBaseClass* create() = 0;
-	};
-
-}
-
-#endif

src/ifcgeom_schema_agnostic/Kernel.cpp

@@ -1,204 +0,0 @@
-#include "Kernel.h"
-
-#include <TopExp.hxx>
-#include <TopTools_ListOfShape.hxx>
-#include <TopTools_IndexedMapOfShape.hxx>
-#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
-
-IfcGeom::Kernel::Kernel(IfcParse::IfcFile* file) {
-	if (file != 0) {
-		if (file->schema() == 0) {
-			throw IfcParse::IfcException("No schema associated with file");
-		}
-
-		const std::string& schema_name = file->schema()->name();
-		implementation_ = impl::kernel_implementations().construct(schema_name, file);
-	}
-}
-
-int IfcGeom::Kernel::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;
-	}
-}
-
-
-int IfcGeom::Kernel::surface_genus(const TopoDS_Shape& s) {
-	int nv = count(s, TopAbs_VERTEX, true);
-	int ne = count(s, TopAbs_EDGE, true);
-	int nf = count(s, TopAbs_FACE, true);
-
-	const int euler = nv - ne + nf;
-	const int genus = (2 - euler) / 2;
-
-	return genus;
-}
-
-IfcGeom::impl::KernelFactoryImplementation& IfcGeom::impl::kernel_implementations() {
-	static KernelFactoryImplementation impl;
-	return impl;
-}
-
-extern void init_KernelImplementation_Ifc2x3(IfcGeom::impl::KernelFactoryImplementation*);
-extern void init_KernelImplementation_Ifc4(IfcGeom::impl::KernelFactoryImplementation*);
-
-IfcGeom::impl::KernelFactoryImplementation::KernelFactoryImplementation() {
-	init_KernelImplementation_Ifc2x3(this);
-	init_KernelImplementation_Ifc4(this);
-}
-
-void IfcGeom::impl::KernelFactoryImplementation::bind(const std::string& schema_name, IfcGeom::impl::kernel_fn fn) {
-	const std::string schema_name_lower = boost::to_lower_copy(schema_name);
-	this->insert(std::make_pair(schema_name_lower, fn));
-}
-
-IfcGeom::Kernel* IfcGeom::impl::KernelFactoryImplementation::construct(const std::string& schema_name, IfcParse::IfcFile* file) {
-	const std::string schema_name_lower = boost::to_lower_copy(schema_name);
-	std::map<std::string, IfcGeom::impl::kernel_fn>::const_iterator it;
-	it = this->find(schema_name_lower);
-	if (it == end()) {
-		throw IfcParse::IfcException("No geometry kernel registered for " + schema_name);
-	}
-	return it->second(file);
-}
-
-#define CREATE_GET_DECOMPOSING_ENTITY(IfcSchema)                                                                 \
-                                                                                                                 \
-IfcSchema::IfcObjectDefinition* get_decomposing_entity_impl(IfcSchema::IfcProduct* product, bool include_openings) {\
-	IfcSchema::IfcObjectDefinition* parent = 0;                                                                  \
-                                                                                                                 \
-	/* In case of an opening element, parent to the RelatingBuildingElement */                                   \
-	if (include_openings && product->declaration().is(IfcSchema::IfcOpeningElement::Class())) {                  \
-		IfcSchema::IfcOpeningElement* opening = (IfcSchema::IfcOpeningElement*)product;                          \
-		IfcSchema::IfcRelVoidsElement::list::ptr voids = opening->VoidsElements();                               \
-		if (voids->size()) {                                                                                     \
-			IfcSchema::IfcRelVoidsElement* ifc_void = *voids->begin();                                           \
-			parent = ifc_void->RelatingBuildingElement();                                                        \
-		}                                                                                                        \
-	} else if (product->declaration().is(IfcSchema::IfcElement::Class())) {                                      \
-		IfcSchema::IfcElement* element = (IfcSchema::IfcElement*)product;                                        \
-		IfcSchema::IfcRelFillsElement::list::ptr fills = element->FillsVoids();                                  \
-		/* In case of a RelatedBuildingElement parent to the opening element */                                  \
-		if (fills->size() && include_openings) {                                                                 \
-			for (IfcSchema::IfcRelFillsElement::list::it it = fills->begin(); it != fills->end(); ++it) {        \
-				IfcSchema::IfcRelFillsElement* fill = *it;                                                       \
-				IfcSchema::IfcObjectDefinition* ifc_objectdef = fill->RelatingOpeningElement();                  \
-				if (product == ifc_objectdef) continue;                                                          \
-				parent = ifc_objectdef;                                                                          \
-			}                                                                                                    \
-		}                                                                                                        \
-		/* Else simply parent to the containing structure */                                                     \
-		if (!parent) {                                                                                           \
-			IfcSchema::IfcRelContainedInSpatialStructure::list::ptr parents = element->ContainedInStructure();   \
-			if (parents->size()) {                                                                               \
-				IfcSchema::IfcRelContainedInSpatialStructure* container = *parents->begin();                     \
-				parent = container->RelatingStructure();                                                         \
-			}                                                                                                    \
-		}                                                                                                        \
-	}                                                                                                            \
-                                                                                                                 \
-	/* Parent decompositions to the RelatingObject */                                                            \
-	if (!parent) {                                                                                               \
-		IfcEntityList::ptr parents = product->data().getInverse((&IfcSchema::IfcRelAggregates::Class()), -1);    \
-		parents->push(product->data().getInverse((&IfcSchema::IfcRelNests::Class()), -1));                       \
-		for (IfcEntityList::it it = parents->begin(); it != parents->end(); ++it) {                              \
-			IfcSchema::IfcRelDecomposes* decompose = (IfcSchema::IfcRelDecomposes*)*it;                          \
-			IfcUtil::IfcBaseEntity* ifc_objectdef;                                                               \
-                 																								 \
-			ifc_objectdef = get_RelatingObject(decompose);                                                       \
-                                                                                                                 \
-			if (product == ifc_objectdef) continue;                                                              \
-			parent = ifc_objectdef->as<IfcSchema::IfcObjectDefinition>();                                        \
-		}                                                                                                        \
-	}                                                                                                            \
-	return parent;                                                                                               \
-}
-
-namespace {
-	IfcUtil::IfcBaseEntity* get_RelatingObject(Ifc4::IfcRelDecomposes* decompose) {
-		Ifc4::IfcRelAggregates* aggr = decompose->as<Ifc4::IfcRelAggregates>();
-		if (aggr != nullptr) {
-			return aggr->RelatingObject();
-		}
-		return nullptr;
-	}
-
-	IfcUtil::IfcBaseEntity* get_RelatingObject(Ifc2x3::IfcRelDecomposes* decompose) {
-		return decompose->RelatingObject();
-	}
-
-	CREATE_GET_DECOMPOSING_ENTITY(Ifc2x3);
-	CREATE_GET_DECOMPOSING_ENTITY(Ifc4);
-}
-
-IfcUtil::IfcBaseEntity* IfcGeom::Kernel::get_decomposing_entity(IfcUtil::IfcBaseEntity* inst, bool include_openings) {
-	if (inst->as<Ifc2x3::IfcProduct>()) {
-		return get_decomposing_entity_impl(inst->as<Ifc2x3::IfcProduct>(), include_openings);
-	} else if (inst->as<Ifc4::IfcProduct>()) {
-		return get_decomposing_entity_impl(inst->as<Ifc4::IfcProduct>(), include_openings);
-	} else if (inst->declaration().name() == "IfcProject") {
-		return nullptr;
-	} else {
-		throw IfcParse::IfcException("Unexpected entity " + inst->declaration().name());
-	}
-}
-
-namespace {
-	template <typename Schema>
-	static std::map<std::string, IfcUtil::IfcBaseEntity*> get_layers_impl(typename Schema::IfcProduct* prod) {
-		std::map<std::string, IfcUtil::IfcBaseEntity*> layers;
-		if (prod->hasRepresentation()) {
-			IfcEntityList::ptr r = IfcParse::traverse(prod->Representation());
-			typename Schema::IfcRepresentation::list::ptr representations = r->as<typename Schema::IfcRepresentation>();
-			for (typename Schema::IfcRepresentation::list::it it = representations->begin(); it != representations->end(); ++it) {
-				typename Schema::IfcPresentationLayerAssignment::list::ptr a = (*it)->LayerAssignments();
-				for (typename Schema::IfcPresentationLayerAssignment::list::it jt = a->begin(); jt != a->end(); ++jt) {
-					layers[(*jt)->Name()] = *jt;
-				}
-			}
-		}
-		return layers;
-	}
-}
-
-std::map<std::string, IfcUtil::IfcBaseEntity*> IfcGeom::Kernel::get_layers(IfcUtil::IfcBaseEntity* inst) {
-	if (inst->as<Ifc2x3::IfcProduct>()) {
-		return get_layers_impl<Ifc2x3>(inst->as<Ifc2x3::IfcProduct>());
-	} else if (inst->as<Ifc4::IfcProduct>()) {
-		return get_layers_impl<Ifc4>(inst->as<Ifc4::IfcProduct>());
-	} else {
-		throw IfcParse::IfcException("Unexpected entity " + inst->declaration().name());
-	}
-}
-
-bool IfcGeom::Kernel::is_manifold(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(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;
-	}
-}

src/ifcgeom_schema_agnostic/Kernel.h

@@ -1,104 +0,0 @@
-#ifndef ITERATOR_KERNEL_H
-#define ITERATOR_KERNEL_H
-
-#include "../ifcparse/IfcFile.h"
-#include "../ifcgeom/IfcGeomIteratorSettings.h"
-#include "../ifcgeom/IfcRepresentationShapeItem.h"
-
-#include "../ifcparse/Ifc2x3.h"
-#include "../ifcparse/Ifc4.h"
-
-#include <boost/function.hpp>
-
-#include <TopExp_Explorer.hxx>
-
-namespace IfcGeom {
-
-	template <typename P, typename PP>
-	class BRepElement;
-
-	class Kernel {
-	private:
-		Kernel* implementation_;
-
-	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
-		};
-
-		Kernel(IfcParse::IfcFile* file_ = 0);
-		
-		virtual ~Kernel() {}
-
-		virtual void setValue(GeomValue var, double value) {
-			implementation_->setValue(var, value);
-		}
-
-		virtual double getValue(GeomValue var) const {
-			return implementation_->getValue(var);
-		}
-
-		virtual BRepElement<double, double>* convert(
-			const IteratorSettings& settings, IfcUtil::IfcBaseClass* representation,
-			IfcUtil::IfcBaseClass* product)
-		{
-			return implementation_->convert(settings, representation, product);
-		}
-
-		virtual IfcRepresentationShapeItems convert(IfcUtil::IfcBaseClass* item) {
-			return implementation_->convert(item);
-		}
-
-		virtual bool convert_placement(IfcUtil::IfcBaseClass* item, gp_Trsf& trsf) {
-			return implementation_->convert_placement(item, trsf);
-		}
-
-		static int count(const TopoDS_Shape&, TopAbs_ShapeEnum, bool unique=false);
-		static int surface_genus(const TopoDS_Shape&);
-
-		static bool is_manifold(const TopoDS_Shape& a);
-		static IfcUtil::IfcBaseEntity* get_decomposing_entity(IfcUtil::IfcBaseEntity*, bool include_openings=true);
-		static std::map<std::string, IfcUtil::IfcBaseEntity*> get_layers(IfcUtil::IfcBaseEntity*);
-	};
-
-	namespace impl {
-		typedef boost::function1<Kernel*, IfcParse::IfcFile*> kernel_fn;
-
-		class KernelFactoryImplementation : public std::map<std::string, kernel_fn> {
-		public:
-			KernelFactoryImplementation();
-			void bind(const std::string& schema_name, kernel_fn);
-			Kernel* construct(const std::string& schema_name, IfcParse::IfcFile*);
-		};
-
-		KernelFactoryImplementation& kernel_implementations();
-	}
-}
-
-#endif

src/ifcgeom_schema_agnostic/SurfaceStyle.cpp

@@ -1,123 +0,0 @@
-#include "../ifcgeom_schema_agnostic/IfcGeomRenderStyles.h"
-
-#include <boost/property_tree/json_parser.hpp>
-#include <boost/property_tree/ptree.hpp>
-
-#include <map>
-
-namespace pt = boost::property_tree;
-
-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;
-}
-
-boost::optional<IfcGeom::SurfaceStyle::ColorComponent> read_colour_component(const boost::optional<pt::ptree&> list) {
-	if (!list) {
-		return boost::none;
-	}
-	double rgb[3];
-	int i = 0;
-	for (pt::ptree::value_type &colour : list.get()) {
-		if (3 <= i) {
-			throw std::runtime_error("rgb array over 3 elements large");
-		}
-		rgb[i] = colour.second.get_value<double>();
-		i++;
-	}
-	if (i != 3) {
-		throw std::runtime_error("rgb array less than 3 elements large (was " + std::to_string(i) + ")");
-	}
-	return IfcGeom::SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]);
-}
-
-void IfcGeom::set_default_style_file(const std::string& json_file) {
-	if (!default_materials_initialized) InitDefaultMaterials();
-	default_materials.clear();
-
-	// @todo this will probably need to be updated for UTF-8 paths on Windows
-	pt::ptree root;
-	pt::read_json(json_file, root);
-
-	for (pt::ptree::value_type &material_pair : root) {
-		std::string name = material_pair.first;
-		default_materials.insert(std::make_pair(name, IfcGeom::SurfaceStyle(name)));
-
-		pt::ptree material = material_pair.second;
-		boost::optional<pt::ptree&> diffuse = material.get_child_optional("diffuse");
-		default_materials[name].Diffuse() = read_colour_component(diffuse);
-
-		boost::optional<pt::ptree&> specular = material.get_child_optional("specular");
-		default_materials[name].Specular() = read_colour_component(specular);
-
-		if (material.get_child_optional("specular-roughness")) {
-			default_materials[name].Specularity().reset(1.0 / material.get<double>("specular-roughness"));
-		}
-		if (material.get_child_optional("transparency")) {
-			default_materials[name].Transparency() = material.get<double>("transparency");
-		}
-	}
-
-	// Is "*" present? If yes, remove it and make it the default style.
-	std::map<std::string, IfcGeom::SurfaceStyle>::const_iterator it = default_materials.find("*");
-	if (it != default_materials.end()) {
-		IfcGeom::SurfaceStyle star = it->second;
-		default_material.Diffuse() = star.Diffuse();
-		default_material.Specular() = star.Specular();
-		default_material.Specularity() = star.Specularity();
-		default_material.Transparency() = star.Transparency();
-		default_materials.erase(it);
-	}
-}
-
-const IfcGeom::SurfaceStyle* IfcGeom::get_default_style(const std::string& s) {
-	if (!default_materials_initialized) InitDefaultMaterials();
-	std::map<std::string, IfcGeom::SurfaceStyle>::const_iterator it = default_materials.find(s);
-	if (it == default_materials.end()) {
-		default_materials.insert(std::make_pair(s, IfcGeom::SurfaceStyle(s)));
-		default_materials[s].Diffuse() = default_material.Diffuse();
-		default_materials[s].Specular() = default_material.Specular();
-		default_materials[s].Specularity() = default_material.Specularity();
-		default_materials[s].Transparency() = default_material.Transparency();
-		it = default_materials.find(s);
-	}
-	const IfcGeom::SurfaceStyle& surface_style = it->second;
-	return &surface_style;
-}

src/ifcgeomserver/IfcGeomServer.cpp

@@ -38,8 +38,8 @@
 #include <fcntl.h>
 #endif
 
-#include "../ifcgeom_schema_agnostic/IfcGeomIterator.h"
-#include "../ifcgeom/IfcGeomElement.h"
+#include "../ifcgeom/schema_agnostic/IfcGeomIterator.h"
+#include "../ifcgeom/schema_agnostic/IfcGeomElement.h"
 #include "../ifcparse/IfcFile.h"
 #include "../ifcparse/IfcLogger.h"
 
@@ -47,14 +47,24 @@
 #include <vld.h>
 #endif
 
+#include "../ifcgeom/kernels/opencascade/OpenCascadeConversionResult.h"
+
 #include <GProp_GProps.hxx>
 #include <BRepGProp.hxx>
 #include <BRepBndLib.hxx>
 #include <Bnd_Box.hxx>
 #include <Geom_Plane.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Compound.hxx>
 
 #include <memory>
 
+#ifdef USE_VOXELS
+#include <voxel/storage.h>
+#include <voxel/traversal.h>
+#include <voxel/processor.h>
+#endif
+
 template <typename T>
 union data_field {
     char buffer[sizeof(T)];
@@ -440,9 +450,9 @@ static const std::array<std::string, 3> XYZ = { "X", "Y", "Z" };
 
 class QuantityWriter_v0 : public EntityExtension {
 private:
-	const IfcGeom::BRepElement<double, double>* elem_;
+	const IfcGeom::NativeElement<double, double>* elem_;
 public:
-	QuantityWriter_v0(const IfcGeom::BRepElement<double, double>* elem) :
+	QuantityWriter_v0(const IfcGeom::NativeElement<double, double>* elem) :
 		elem_(elem) 
 	{
 		put_json(TOTAL_SURFACE_AREA, 0.);
@@ -455,19 +465,20 @@ public:
 
 class QuantityWriter_v1 : public EntityExtension {
 private:
-	const IfcGeom::BRepElement<double, double>* elem_;
+	const IfcGeom::NativeElement<double, double>* elem_;
 public:
-	QuantityWriter_v1(const IfcGeom::BRepElement<double, double>* elem) :
-		elem_(elem) {
+	QuantityWriter_v1(const IfcGeom::NativeElement<double, double>* elem) :
+		elem_(elem)
+	{
 		double a, b, c, largest_face_area = 0.;
 
 		if (elem_->geometry().calculate_surface_area(a)) {
 			put_json(TOTAL_SURFACE_AREA, a);
 		}
 
-		if (elem_->geometry().calculate_volume(a)) {
-			put_json(TOTAL_SHAPE_VOLUME, a);
-		}
+		TopoDS_Compound compound = TopoDS::Compound(((IfcGeom::OpenCascadeShape*) elem_->geometry().as_compound(true))->shape());
+		double bbox_xyz[6];
+		bool has_boundingbox = false;
 
 		if (elem_->calculate_projected_surface_area(a, b, c)) {
 			put_json(SURFACE_AREA_ALONG_X, a);
@@ -478,7 +489,6 @@ public:
 		boost::optional<gp_Dir> largest_face_dir;
 
 		{
-			TopoDS_Compound compound = elem_->geometry().as_compound(true);
 			TopExp_Explorer exp(compound, TopAbs_FACE);
 			for (; exp.More(); exp.Next()) {
 				GProp_GProps prop;
@@ -498,19 +508,50 @@ public:
 			}
 
 			Bnd_Box box;
-			double xyz[6];
 
 			BRepBndLib::AddClose(compound, box);
 
 			if (!box.IsVoid()) {
-				box.Get(xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5]);
+				has_boundingbox = true;
+				box.Get(bbox_xyz[0], bbox_xyz[1], bbox_xyz[2], bbox_xyz[3], bbox_xyz[4], bbox_xyz[5]);
 				for (int i = 0; i < 3; ++i) {
-					const double bsz = xyz[i + 3] - xyz[i];
+					const double bsz = bbox_xyz[i + 3] - bbox_xyz[i];
 					put_json(BOUNDING_BOX_SIZE_ALONG_ + XYZ[i], bsz);
 				}
 			}
 		}
 
+		if (elem_->geometry().calculate_volume(a)) {
+			put_json(TOTAL_SHAPE_VOLUME, a);
+		}
+#ifdef USE_VOXELS
+		// Sometimes geometries are not a topologically valid manifold,
+		// but still (approximately) enclose a volume. In this case
+		// we can voxlize the geometry and fill the interior solid volume.
+		else if (has_boundingbox) {
+			std::array< vec_n<3, double>, 2 > bounds;
+			for (int i = 0; i < 3; ++i) {
+				bounds[0].get(i) = bbox_xyz[i + 0];
+				bounds[1].get(i) = bbox_xyz[i + 3];
+			}
+			progress_writer silent;
+			auto surface = storage_for(bounds, 256U);
+			processor proc(surface, silent);
+			std::vector<std::pair<int, TopoDS_Compound > > geometries = { {1, compound} };
+			proc.process(geometries.begin(), geometries.end(), SURFACE(), output(MERGED()));
+			surface = (regular_voxel_storage*) proc.voxels();
+			double vsize = surface->voxel_size();
+			auto surface_count = surface->count();
+			traversal_voxel_filler_inverse filler;
+			auto volume = filler(surface);
+			auto volume_count = volume->count();
+			delete surface;
+			delete volume;
+			double total_volume = (volume_count + surface_count / 2) * (vsize * vsize * vsize);
+			put_json(TOTAL_SHAPE_VOLUME, total_volume);
+		}
+#endif
+
 		if (largest_face_dir) {
 			put_json(LARGEST_FACE_DIRECTION, *largest_face_dir);
 			put_json(LARGEST_FACE_AREA, largest_face_area);

src/ifcopenshell-python/ifcopenshell/geom/client.py

@@ -0,0 +1,103 @@
+###############################################################################
+#                                                                             #
+# 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/>.        #
+#                                                                             #
+###############################################################################
+
+"""
+Rough draft of a client application for the C++ IfcGeomServer binary
+"""
+
+import os
+import numpy
+import subprocess
+
+from collections import namedtuple
+
+class message_headers(object):
+    HELLO = 0xff00
+    IFC_MODEL = HELLO + 1
+    GET = IFC_MODEL + 1
+    ENTITY = GET + 1
+    MORE = ENTITY + 1
+    NEXT = MORE + 1
+    BYE = NEXT + 1
+    GET_LOG = BYE + 1
+    LOG = GET_LOG + 1
+    DEFLECTION = LOG + 1
+    SETTING = DEFLECTION + 1
+    
+message = namedtuple("message", ("header", "contents"))
+    
+def process(geomserver_exe, ifc_filename):
+        
+    proc = subprocess.Popen([geomserver_exe], stdout=subprocess.PIPE, stdin=subprocess.PIPE)
+    
+    def cast(data, dtype, n=None):
+        arr = numpy.frombuffer(data, dtype=dtype)
+        if n is None: return arr[0]
+        else: return arr
+
+    def read(dtype, n=None):
+        data = proc.stdout.read(dtype().nbytes * (n or 1))
+        return cast(data, dtype, n)
+        
+    def read_message(header_assertion=None):
+        header, size = read(numpy.int32, 2)
+        assert header_assertion is None or header_assertion == header
+        contents = b""
+        if size > 0:
+            contents = proc.stdout.read(size)
+        return message(header, contents)
+        
+    def write(header, contents=None):
+        if contents is None: contents = []
+        proc.stdin.write(numpy.int32(header).tobytes())
+        integers_as_int32 = list(map(lambda s: numpy.int32(s) if isinstance(s, int) else s, contents))
+        to_bytes = list(map(lambda s: s.tobytes() if hasattr(s, 'tobytes') else s, integers_as_int32))
+        total_length = numpy.int32(sum(map(len, to_bytes)))
+        proc.stdin.write(total_length.tobytes())
+        for b in to_bytes:
+            proc.stdin.write(b)
+        proc.stdin.flush()
+        
+    read_message(message_headers.HELLO)
+    
+    # @todo: no need to read the entire file in memory
+    s = open(ifc_filename, "rb").read()
+    
+    write(message_headers.SETTING, [numpy.int32((1 << 4)), numpy.int32(1)]) 
+    write(message_headers.IFC_MODEL, [numpy.int32(len(s)), s, b"\x00" * ((4 - (len(s) % 4)) % 4)])
+        
+    while True:    
+        has_more = cast(read_message(message_headers.MORE).contents, numpy.int32) == 1        
+        if not has_more: break        
+        write(message_headers.GET)        
+        print(read_message(message_headers.ENTITY).contents)        
+        write(message_headers.NEXT)        
+            
+    write(message_headers.BYE)
+    read_message(message_headers.BYE)
+    proc.wait()
+    assert proc.returncode == 0
+
+if __name__ == "__main__":
+    import sys
+    import platform
+    exe_extension = ".exe" if platform.system() == 'Windows' else ""
+    exe = os.environ.get("IFCGEOMSERVER") or ("IfcGeomServer" + exe_extension)
+    for fn in sys.argv[1:]:
+        process(exe, fn)

src/ifcparse/IfcBaseClass.h

@@ -78,6 +78,21 @@ namespace IfcUtil {
 		virtual const IfcParse::entity& declaration() const = 0;
 
 		Argument* get(const std::string& name) const;
+
+		template <typename T>
+		T get_value_or(const std::string& name, const T& if_null) const {
+			auto arg = get(name);
+			if (arg->isNull()) {
+				return if_null;
+			} else {
+				return *arg;
+			}
+		}
+
+		template <typename T>
+		T get_value(const std::string& name) const {
+			return *get(name);
+		}
 	};
 
 	// TODO: Investigate whether these should be template classes instead

src/ifcparse/IfcParse.h

@@ -27,7 +27,7 @@
 #ifndef IFCPARSE_H
 #define IFCPARSE_H
 
-#define IFCOPENSHELL_VERSION "0.6.0b0"
+#define IFCOPENSHELL_VERSION "0.7.0-dev"
 
 #include <string>
 #include <sstream>

src/ifcparse/macros.h

@@ -20,14 +20,14 @@
 #ifndef IFCOPENSHELL_MACROS_H
 #define IFCOPENSHELL_MACROS_H
 
-#define MAKE_TYPE_NAME__(a, b) a ## b
-#define MAKE_TYPE_NAME_(a, b) MAKE_TYPE_NAME__(a, b)
-#define MAKE_TYPE_NAME(t) MAKE_TYPE_NAME_(t, IfcSchema)
+#define POSTFIX_SCHEMA__(a, b) a ## _ ## b
+#define POSTFIX_SCHEMA_(a, b) POSTFIX_SCHEMA__(a, b)
+#define POSTFIX_SCHEMA(t) POSTFIX_SCHEMA_(t, IfcSchema)
 
 #define STRINGIFY_(x) #x
 #define STRINGIFY(x) STRINGIFY_(x)
 
-#define MAKE_INIT_FN__(a, b) init_ ## a ## b
+#define MAKE_INIT_FN__(a, b) init_ ## a ## _ ## b
 #define MAKE_INIT_FN_(a, b) MAKE_INIT_FN__(a, b)
 #define MAKE_INIT_FN(t) MAKE_INIT_FN_(t, IfcSchema)
 

src/ifcwrap/IfcGeomWrapper.i

@@ -38,16 +38,16 @@
 
 %ignore IfcGeom::impl::tree::selector;
 
-%include "../ifcgeom/ifc_geom_api.h"
-%include "../ifcgeom/IfcGeomIteratorSettings.h"
-%include "../ifcgeom/IfcGeomElement.h"
-%include "../ifcgeom_schema_agnostic/IfcGeomMaterial.h"
-%include "../ifcgeom/IfcGeomRepresentation.h"
-%include "../ifcgeom_schema_agnostic/IfcGeomIterator.h"
+%include "../ifcgeom/schema_agnostic/ifc_geom_api.h"
+%include "../ifcgeom/schema_agnostic/IfcGeomIteratorSettings.h"
+%include "../ifcgeom/schema_agnostic/IfcGeomElement.h"
+%include "../ifcgeom/schema_agnostic/IfcGeomMaterial.h"
+%include "../ifcgeom/schema_agnostic/IfcGeomRepresentation.h"
+%include "../ifcgeom/schema_agnostic/IfcGeomIterator.h"
 
 // A Template instantantation should be defined before it is used as a base class. 
 // But frankly I don't care as most methods are subtlely different anyway.
-%include "../ifcgeom/IfcGeomTree.h"
+%include "../ifcgeom/kernels/opencascade/IfcGeomTree.h"
 
 %extend IfcGeom::tree {
 
@@ -277,8 +277,9 @@ struct ShapeRTTI : public boost::static_visitor<PyObject*>
 	template <typename Schema>
 	static boost::variant<IfcGeom::Element<double>*, IfcGeom::Representation::Representation*> helper_fn_create_shape(IfcGeom::IteratorSettings& settings, IfcUtil::IfcBaseClass* instance, IfcUtil::IfcBaseClass* representation = 0) {
 		IfcParse::IfcFile* file = instance->data().file;
-			
-		IfcGeom::Kernel kernel(file);
+
+		// @todo Default to opencascade for now.
+		IfcGeom::Kernel kernel("opencascade", file);
 		kernel.setValue(IfcGeom::Kernel::GV_MAX_FACES_TO_ORIENT, settings.get(IfcGeom::IteratorSettings::SEW_SHELLS) ? std::numeric_limits<double>::infinity() : -1);
 		kernel.setValue(IfcGeom::Kernel::GV_DIMENSIONALITY, (settings.get(IfcGeom::IteratorSettings::INCLUDE_CURVES) ? (settings.get(IfcGeom::IteratorSettings::EXCLUDE_SOLIDS_AND_SURFACES) ? -1. : 0.) : +1.));
 			
@@ -360,7 +361,7 @@ struct ShapeRTTI : public boost::static_visitor<PyObject*>
 				}
 			}
 
-			IfcGeom::BRepElement<double>* brep = kernel.convert(settings, ifc_representation, product);
+			IfcGeom::NativeElement<double>* brep = kernel.convert(settings, ifc_representation, product);
 			if (!brep) {
 				throw IfcParse::IfcException("Failed to process shape");
 			}
@@ -378,7 +379,7 @@ struct ShapeRTTI : public boost::static_visitor<PyObject*>
 		} else {
 			if (!representation) {
 				if (instance->declaration().is(Schema::IfcRepresentationItem::Class()) || instance->declaration().is(Schema::IfcRepresentation::Class())) {
-					IfcGeom::IfcRepresentationShapeItems shapes = kernel.convert(instance);
+					IfcGeom::ConversionResults shapes = kernel.convert(instance);
 
 					IfcGeom::ElementSettings element_settings(settings, kernel.getValue(IfcGeom::Kernel::GV_LENGTH_UNIT), instance->declaration().name());
 					IfcGeom::Representation::BRep brep(element_settings, boost::lexical_cast<std::string>(instance->data().id()), shapes);

src/ifcwrap/IfcPython.i

@@ -70,9 +70,9 @@
 }
 
 %module ifcopenshell_wrapper %{
-	#include "../ifcgeom_schema_agnostic/IfcGeomIterator.h"
-	#include "../ifcgeom_schema_agnostic/Serialization.h"
-	#include "../ifcgeom/IfcGeomTree.h"
+	#include "../ifcgeom/schema_agnostic/IfcGeomIterator.h"
+	#include "../ifcgeom/schema_agnostic/Serialization.h"
+	#include "../ifcgeom/kernels/opencascade/IfcGeomTree.h"
 	
 	#include "../ifcparse/Ifc2x3.h"
 	#include "../ifcparse/Ifc4.h"

src/serializers/ColladaSerializer.cpp

@@ -66,7 +66,7 @@ void ColladaSerializer::ColladaExporter::ColladaGeometries::write(
     const std::string &mesh_id, const std::string &/**<@todo 'default_material_name' unused, remove? */,
     const std::vector<real_t>& positions, const std::vector<real_t>& normals,
     const std::vector<int>& faces, const std::vector<int>& edges,
-    const std::vector<int>& material_ids, const std::vector<IfcGeom::Material>& /**<@todo 'materials' unused, remove? */,
+    const std::vector<int>& material_ids, const std::vector<ifcopenshell::geometry::taxonomy::style>& /**<@todo 'materials' unused, remove? */,
     const std::vector<real_t>& uvs, const std::vector<std::string>& material_references)
 {
 	openMesh(mesh_id);
@@ -179,7 +179,7 @@ void ColladaSerializer::ColladaExporter::ColladaGeometries::close() {
 
 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 IfcGeom::Transformation<real_t>& transformation)
+    const std::vector<std::string>& material_ids, const ifcopenshell::geometry::Transformation& transformation)
 {
 	if (!scene_opened) {
 		openVisualScene(scene_id);
@@ -191,26 +191,26 @@ void ColladaSerializer::ColladaExporter::ColladaScene::add(
 	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.
-
-	IfcGeom::Transformation<real_t>* relative_trsf = 0;
-	const IfcGeom::Transformation<real_t>* transformation_towrite = &transformation;
+	ifcopenshell::geometry::Transformation* relative_trsf = 0;
+	const ifcopenshell::geometry::Transformation* transformation_towrite = &transformation;
 	
 	// If this is not the first parent, get the relative placement
 	if (parentNodes.size() > 0)
 	{
-		relative_trsf = new IfcGeom::Transformation<real_t>(matrixStack.top().multiplied(transformation));
+		auto m4 = ifcopenshell::geometry::taxonomy::matrix4(matrixStack.top().data().components * transformation.data().components);
+		relative_trsf = new ifcopenshell::geometry::Transformation(transformation.settings(), m4);
 		transformation_towrite = relative_trsf;
 	}
 
-	const std::vector<real_t>& posmatrix = transformation_towrite->matrix().data();
+	// @todo verify
+
+	const double* m = transformation_towrite->data().components.data();
 
 	double matrix_array[4][4] = {
-		{ (double)posmatrix[0], (double)posmatrix[3], (double)posmatrix[6], (double)posmatrix[9] },
-		{ (double)posmatrix[1], (double)posmatrix[4], (double)posmatrix[7], (double)posmatrix[10] },
-		{ (double)posmatrix[2], (double)posmatrix[5], (double)posmatrix[8], (double)posmatrix[11] },
-		{ 0, 0, 0, 1 }
+		{ m[0], m[4], m[8], m[12] },
+		{ m[1], m[5], m[9], m[13] },
+		{ m[2], m[6], m[10], m[14] },
+		{ m[3], m[7], m[11], m[15] }
 	};
 	
 	/// @todo: TFK: Rather than applying this offset to all leafs (which might be undesirable) should this offset be applied to a node higher up in the hierarchy?
@@ -236,26 +236,29 @@ void ColladaSerializer::ColladaExporter::ColladaScene::add(
 	node.end();
 }
 
-void ColladaSerializer::ColladaExporter::ColladaScene::addParent(const IfcGeom::Element<real_t>& parent){
+void ColladaSerializer::ColladaExporter::ColladaScene::addParent(const ifcopenshell::geometry::Element& parent){
 	//we open the visual scene tag if it's not.
 	if (!scene_opened) {
 		openVisualScene(scene_id);
 		scene_opened = true;
 	}
 
-	const IfcGeom::Transformation<real_t>& parent_trsf = parent.transformation();
+	const ifcopenshell::geometry::Transformation& parent_trsf = parent.transformation();
 
-	IfcGeom::Transformation<real_t>* relative_trsf = 0;
-	const IfcGeom::Transformation<real_t>* transformation_towrite = &parent_trsf;
+	ifcopenshell::geometry::Transformation* relative_trsf = 0;
+	const ifcopenshell::geometry::Transformation* transformation_towrite = &parent_trsf;
 
 	// If this is not the first parent, get the relative placement
 	if (parentNodes.size() > 0)
 	{
-		relative_trsf = new IfcGeom::Transformation<real_t>(matrixStack.top().multiplied(parent_trsf));
+		auto m4 = ifcopenshell::geometry::taxonomy::matrix4(matrixStack.top().data().components * parent_trsf.data().components);
+		relative_trsf = new ifcopenshell::geometry::Transformation(parent_trsf.settings(), m4);
 		transformation_towrite = relative_trsf;
 	}
 
-	const std::vector<real_t>& parentMatrix = transformation_towrite->matrix().data();
+	// @todo verify
+
+	const double* parentMatrix = transformation_towrite->data().components.data();
 
 	double matrix_array[4][4] = {
 		{ (double)parentMatrix[0], (double)parentMatrix[3], (double)parentMatrix[6], (double)parentMatrix[9] },
@@ -277,7 +280,7 @@ void ColladaSerializer::ColladaExporter::ColladaScene::addParent(const IfcGeom::
 	current_node->addMatrix(matrix_array);
 
 	// Add the node to the parent stack
-	matrixStack.push(parent_trsf.inverted());
+	matrixStack.push(ifcopenshell::geometry::Transformation(parent_trsf.settings(), ifcopenshell::geometry::taxonomy::matrix4(parent_trsf.data().components.inverse())));
 	parentNodes.push(current_node);
 	serializer->parentStackId.push(parent.id());
 }
@@ -311,24 +314,24 @@ void ColladaSerializer::ColladaExporter::ColladaScene::write() {
 }
 
 void ColladaSerializer::ColladaExporter::ColladaMaterials::ColladaEffects::write(
-    const IfcGeom::Material &material, const std::string &material_uri)
+    const ifcopenshell::geometry::taxonomy::style &material, const std::string &material_uri)
 {
     openEffect(material_uri + "-fx");
 	COLLADASW::EffectProfile effect(mSW);
 	effect.setShaderType(COLLADASW::EffectProfile::LAMBERT);
-	if (material.hasDiffuse()) {
-		const double* diffuse = material.diffuse();
+	if (material.diffuse) {
+		auto diffuse = material.diffuse.get().components;
 		effect.setDiffuse(COLLADASW::ColorOrTexture(COLLADASW::Color(diffuse[0],diffuse[1],diffuse[2])));
 	}
-	if (material.hasSpecular()) {
-		const double* specular = material.specular();
+	if (material.specular) {
+		auto specular = material.specular.get().components;
 		effect.setSpecular(COLLADASW::ColorOrTexture(COLLADASW::Color(specular[0],specular[1],specular[2])));
 	}
-	if (material.hasSpecularity()) {
-		effect.setShininess(material.specularity());
+	if (material.specularity) {
+		effect.setShininess(*material.specularity);
 	}
-	if (material.hasTransparency()) {
-		const double transparency = material.transparency();
+	if (material.transparency) {
+		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.
@@ -343,13 +346,14 @@ void ColladaSerializer::ColladaExporter::ColladaMaterials::ColladaEffects::close
 	closeLibrary();
 }
 
-void ColladaSerializer::ColladaExporter::ColladaMaterials::add(const IfcGeom::Material& material) {
+void ColladaSerializer::ColladaExporter::ColladaMaterials::add(const ifcopenshell::geometry::taxonomy::style& material) {
 	if (!contains(material)) {
-		std::string material_name = (serializer->settings().get(SerializerSettings::USE_MATERIAL_NAMES)
-	 		? material.original_name() : material.name());
+		// @todo original_name
+		std::string material_name = *(serializer->settings().get(SerializerSettings::USE_MATERIAL_NAMES)
+	 		? material.name : material.name);
 
 		if (material_name.empty()) {
-			material_name = "missing-material-" + material.name();
+			material_name = "missing-material-" + *material.name;
 		}
 
 		collada_id(material_name);
@@ -360,19 +364,19 @@ void ColladaSerializer::ColladaExporter::ColladaMaterials::add(const IfcGeom::Ma
 	}
 }
 
-std::string ColladaSerializer::ColladaExporter::ColladaMaterials::getMaterialUri(const IfcGeom::Material& material) {
-	std::vector<IfcGeom::Material>::iterator it = std::find(materials.begin(), materials.end(), material);
+std::string ColladaSerializer::ColladaExporter::ColladaMaterials::getMaterialUri(const ifcopenshell::geometry::taxonomy::style& material) {
+	std::vector<ifcopenshell::geometry::taxonomy::style>::iterator it = std::find(materials.begin(), materials.end(), material);
 	ptrdiff_t index = std::distance(materials.begin(), it);
 	return material_uris.at(index);
 }
 
-bool ColladaSerializer::ColladaExporter::ColladaMaterials::contains(const IfcGeom::Material& material) {
+bool ColladaSerializer::ColladaExporter::ColladaMaterials::contains(const ifcopenshell::geometry::taxonomy::style& material) {
 	return std::find(materials.begin(), materials.end(), material) != materials.end();
 }
 
 void ColladaSerializer::ColladaExporter::ColladaMaterials::write() {
 	effects.close();
-    BOOST_FOREACH(const IfcGeom::Material& material, materials) {
+    BOOST_FOREACH(const ifcopenshell::geometry::taxonomy::style& material, materials) {
         std::string material_name = getMaterialUri(material);
 		openMaterial(material_name);
 
@@ -395,9 +399,9 @@ void ColladaSerializer::ColladaExporter::startDocument(const std::string& unit_n
 	asset.add();
 }
 
-void ColladaSerializer::ColladaExporter::write(const IfcGeom::TriangulationElement<real_t>* o)
+void ColladaSerializer::ColladaExporter::write(const ifcopenshell::geometry::TriangulationElement* o)
 {
-	const IfcGeom::Representation::Triangulation<real_t>& mesh = o->geometry();
+	const ifcopenshell::geometry::Representation::Triangulation& mesh = o->geometry();
 	
     std::string name = serializer->object_id(o);
 	collada_id(name);
@@ -406,7 +410,7 @@ void ColladaSerializer::ColladaExporter::write(const IfcGeom::TriangulationEleme
 	collada_id(representation_id);
 
 	std::vector<std::string> material_references;
-	BOOST_FOREACH(const IfcGeom::Material& material, mesh.materials()) {
+	BOOST_FOREACH(const ifcopenshell::geometry::taxonomy::style& material, mesh.materials()) {
 		materials.add(material);
 
 		std::string material_name = materials.getMaterialUri(material);
@@ -456,7 +460,7 @@ std::string ColladaSerializer::differentiateSlabTypes(const IfcUtil::IfcBaseEnti
 	return result;
 }
 
-std::string ColladaSerializer::object_id(const IfcGeom::Element<real_t>* o) /*override*/
+std::string ColladaSerializer::object_id(const ifcopenshell::geometry::Element* o) /*override*/
 {
     if (settings_.get(SerializerSettings::USE_ELEMENT_TYPES)) {
         const std::string slabSuffix = (o->product() && o->product()->declaration().name() == "IfcSlab")
@@ -549,7 +553,7 @@ void ColladaSerializer::writeHeader() {
 	exporter.startDocument(unit_name, unit_magnitude);
 }
 
-void ColladaSerializer::write(const IfcGeom::TriangulationElement<real_t>* o) {
+void ColladaSerializer::write(const ifcopenshell::geometry::TriangulationElement* o) {
     exporter.write(o);
 }
 

src/serializers/ColladaSerializer.h

@@ -41,8 +41,6 @@
 #pragma GCC diagnostic pop
 #endif
 
-#include "../ifcgeom_schema_agnostic/IfcGeomIterator.h"
-
 #include "../serializers/GeometrySerializer.h"
 
 #include <boost/numeric/ublas/matrix.hpp>
@@ -68,14 +66,14 @@ private:
                 , serializer(_serializer)
 			{}
             void addFloatSource(const std::string& mesh_id, const std::string& suffix,
-                const std::vector<real_t>& floats, const char* coords = "XYZ");
+                const std::vector<double>& floats, const char* coords = "XYZ");
             /// @todo pass simply DeferredObject?
             void write(
                 const std::string &mesh_id, const std::string &default_material_name,
-                const std::vector<real_t>& positions, const std::vector<real_t>& normals,
+                const std::vector<double>& positions, const std::vector<double>& normals,
                 const std::vector<int>& faces, const std::vector<int>& edges,
-                const std::vector<int>& material_ids, const std::vector<IfcGeom::Material>& materials,
-                const std::vector<real_t>& uvs, const std::vector<std::string>& material_references);
+                const std::vector<int>& material_ids, const std::vector<ifcopenshell::geometry::taxonomy::style>& materials,
+                const std::vector<double>& uvs, const std::vector<std::string>& material_references);
 			void close();
             ColladaSerializer *serializer;
 		};
@@ -88,7 +86,7 @@ private:
 			const std::string scene_id;
 			bool scene_opened;
 			std::stack<COLLADASW::Node*> parentNodes;
-			std::stack<IfcGeom::Transformation<real_t> > matrixStack;
+			std::stack<ifcopenshell::geometry::Transformation> matrixStack;
 		public:
 			ColladaScene(const std::string& scene_id, COLLADASW::StreamWriter& stream, ColladaSerializer *_serializer)
 				: COLLADASW::LibraryVisualScenes(&stream)
@@ -97,8 +95,8 @@ private:
                 , serializer(_serializer)
 			{}
 			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 IfcGeom::Transformation<real_t>& matrix);
-			void addParent(const IfcGeom::Element<real_t>& parent);
+                const std::vector<std::string>& material_ids, const ifcopenshell::geometry::Transformation& matrix);
+			void addParent(const ifcopenshell::geometry::Element& parent);
 			void closeParent();
 			COLLADASW::Node* GetDirectParent();
 			void write();
@@ -117,11 +115,11 @@ private:
 				explicit ColladaEffects(COLLADASW::StreamWriter& stream)
 					: COLLADASW::LibraryEffects(&stream)
 				{}
-				void write(const IfcGeom::Material &material, const std::string &material_uri);
+				void write(const ifcopenshell::geometry::taxonomy::style &material, const std::string &material_uri);
 				void close();
                 ColladaSerializer *serializer;
 			};
-			std::vector<IfcGeom::Material> materials;
+			std::vector<ifcopenshell::geometry::taxonomy::style> materials;
 			std::vector<std::string> material_uris;
 		public:
 			explicit ColladaMaterials(COLLADASW::StreamWriter& stream, ColladaSerializer *_serializer)
@@ -129,9 +127,9 @@ private:
 				, serializer(_serializer)
 		                , effects(stream)
 			{}
-			void add(const IfcGeom::Material& material);
-			std::string getMaterialUri(const IfcGeom::Material& material);
-			bool contains(const IfcGeom::Material& material);
+			void add(const ifcopenshell::geometry::taxonomy::style& material);
+			std::string getMaterialUri(const ifcopenshell::geometry::taxonomy::style& material);
+			bool contains(const ifcopenshell::geometry::taxonomy::style& material);
 			void write();
             ColladaSerializer *serializer;
             ColladaEffects effects;
@@ -158,21 +156,21 @@ private:
 
 		public:
 			std::string unique_id, representation_id, type;
-			IfcGeom::Transformation<real_t> transformation;
-			std::vector<real_t> vertices;
-			std::vector<real_t> normals;
+			ifcopenshell::geometry::Transformation transformation;
+			std::vector<double> vertices;
+			std::vector<double> normals;
 			std::vector<int> faces;
 			std::vector<int> edges;
 			std::vector<int> material_ids;
-			std::vector<IfcGeom::Material> materials;
+			std::vector<ifcopenshell::geometry::taxonomy::style> materials;
 			std::vector<std::string> material_references;
-            std::vector<real_t> uvs;
-			std::vector<const IfcGeom::Element<real_t>*> parents_;
+            std::vector<double> uvs;
+			std::vector<const ifcopenshell::geometry::Element*> parents_;
 
-			DeferredObject(const std::string& unique_id, const std::string& representation_id, const std::string& type, const IfcGeom::Transformation<real_t>& transformation,
-				const std::vector<real_t>& vertices, const std::vector<real_t>& normals, const std::vector<int>& faces,
-				const std::vector<int>& edges, const std::vector<int>& material_ids, const std::vector<IfcGeom::Material>& materials,
-				const std::vector<std::string>& material_references, const std::vector<real_t>& uvs)
+			DeferredObject(const std::string& unique_id, const std::string& representation_id, const std::string& type, const ifcopenshell::geometry::Transformation& transformation,
+				const std::vector<double>& vertices, const std::vector<double>& normals, const std::vector<int>& faces,
+				const std::vector<int>& edges, const std::vector<int>& material_ids, const std::vector<ifcopenshell::geometry::taxonomy::style>& materials,
+				const std::vector<std::string>& material_references, const std::vector<double>& uvs)
 				: unique_id(unique_id)
 				, representation_id(representation_id)
 				, type(type)
@@ -187,8 +185,8 @@ private:
 				, uvs(uvs)
 			{}
 
-			std::vector<const IfcGeom::Element<real_t>*>& parents() { return parents_; }
-			const std::vector<const IfcGeom::Element<real_t>*>& parents() const { return parents_; }
+			std::vector<const ifcopenshell::geometry::Element*>& parents() { return parents_; }
+			const std::vector<const ifcopenshell::geometry::Element*>& parents() const { return parents_; }
 		};
 		COLLADABU::NativeString filename;
 		COLLADASW::StreamWriter stream;
@@ -211,7 +209,7 @@ private:
 		std::vector<DeferredObject> deferreds;
 		virtual ~ColladaExporter() {}
 		void startDocument(const std::string& unit_name, float unit_magnitude);
-		void write(const IfcGeom::TriangulationElement<real_t>* o);
+		void write(const ifcopenshell::geometry::TriangulationElement* o);
 		void endDocument();
 	};
 	ColladaExporter exporter;
@@ -229,8 +227,8 @@ public:
     }
 	bool ready();
 	void writeHeader();
-	void write(const IfcGeom::TriangulationElement<real_t>* o);
-    void write(const IfcGeom::BRepElement<real_t>* /*o*/) {}
+	void write(const ifcopenshell::geometry::TriangulationElement* o);
+    void write(const ifcopenshell::geometry::NativeElement* /*o*/) {}
 	void finalize();
 	bool isTesselated() const { return true; }
 	void setUnitNameAndMagnitude(const std::string& name, float magnitude) {
@@ -239,7 +237,7 @@ public:
 	}
 	void setFile(IfcParse::IfcFile*) {}
 
-    std::string object_id(const IfcGeom::Element<real_t>* o) /*override*/;
+    std::string object_id(const ifcopenshell::geometry::Element* o) /*override*/;
 
 private:
     static std::string differentiateSlabTypes(const IfcUtil::IfcBaseEntity* slab);

src/serializers/GeometrySerializer.h

@@ -27,29 +27,29 @@ typedef float real_t;
 #endif
 
 #include "../serializers/Serializer.h"
-#include "../ifcgeom_schema_agnostic/IfcGeomIterator.h"
-#include "../ifcgeom/IfcGeomElement.h"
+#include "../ifcgeom/schema_agnostic/IfcGeomElement.h"
+#include "../ifcgeom/settings.h"
 
-class SerializerSettings : public IfcGeom::IteratorSettings
+class SerializerSettings : public ifcopenshell::geometry::settings
 {
 public:
     enum Setting
     {
         /// Use entity names instead of unique IDs for naming elements.
         /// Applicable for OBJ, DAE, and SVG output.
-        USE_ELEMENT_NAMES = 1 << (IfcGeom::IteratorSettings::NUM_SETTINGS + 1),
+        USE_ELEMENT_NAMES = 1 << (ifcopenshell::geometry::settings::NUM_SETTINGS + 1),
         /// Use entity GUIDs instead of unique IDs for naming elements.
         /// Applicable for OBJ, DAE, and SVG output.
-        USE_ELEMENT_GUIDS = 1 << (IfcGeom::IteratorSettings::NUM_SETTINGS + 2),
+        USE_ELEMENT_GUIDS = 1 << (ifcopenshell::geometry::settings::NUM_SETTINGS + 2),
         /// Use material names instead of unique IDs for naming materials.
         /// Applicable for OBJ and DAE output.
-        USE_MATERIAL_NAMES = 1 << (IfcGeom::IteratorSettings::NUM_SETTINGS + 3),
+        USE_MATERIAL_NAMES = 1 << (ifcopenshell::geometry::settings::NUM_SETTINGS + 3),
 		/// Use element types instead of unique IDs for naming elements.
 		/// Applicable for DAE output.
-		USE_ELEMENT_TYPES = 1 << (IfcGeom::IteratorSettings::NUM_SETTINGS + 4),
+		USE_ELEMENT_TYPES = 1 << (ifcopenshell::geometry::settings::NUM_SETTINGS + 4),
 		/// Order the elements using their IfcBuildingStorey parent
 		/// Applicable for DAE output
-		USE_ELEMENT_HIERARCHY = 1 << (IfcGeom::IteratorSettings::NUM_SETTINGS + 5),
+		USE_ELEMENT_HIERARCHY = 1 << (ifcopenshell::geometry::settings::NUM_SETTINGS + 5),
         /// Number of different setting flags.
         NUM_SETTINGS = 5
     };
@@ -76,15 +76,15 @@ public:
 	virtual ~GeometrySerializer() {} 
 
 	virtual bool isTesselated() const = 0;
-	virtual void write(const IfcGeom::TriangulationElement<real_t>* o) = 0;
-	virtual void write(const IfcGeom::BRepElement<real_t>* o) = 0;
+	virtual void write(const ifcopenshell::geometry::TriangulationElement* o) = 0;
+	virtual void write(const ifcopenshell::geometry::NativeElement* o) = 0;
 	virtual void setUnitNameAndMagnitude(const std::string& name, float magnitude) = 0;
 
     const SerializerSettings& settings() const { return settings_; }
     SerializerSettings& settings() { return settings_; }
 
     /// Returns ID for the object depending on the used setting.
-    virtual std::string object_id(const IfcGeom::Element<real_t>* o)
+    virtual std::string object_id(const ifcopenshell::geometry::Element* o)
     {
         if (settings_.get(SerializerSettings::USE_ELEMENT_GUIDS)) return o->guid();
         if (settings_.get(SerializerSettings::USE_ELEMENT_NAMES)) return o->name();

src/serializers/GltfSerializer.h

@@ -43,7 +43,7 @@ public:
 	bool ready();
 	void writeHeader();
 	void write(const IfcGeom::TriangulationElement<real_t>* o);
-	void write(const IfcGeom::BRepElement<real_t>* /*o*/) {}
+	void write(const IfcGeom::NativeElement<real_t>* /*o*/) {}
 	void finalize();
 	bool isTesselated() const { return true; }
 	void setUnitNameAndMagnitude(const std::string& /*name*/, float /*magnitude*/) {}

src/serializers/IgesSerializer.h

@@ -42,8 +42,8 @@ public:
         : OpenCascadeBasedSerializer(out_filename, settings)
 	{}
 	virtual ~IgesSerializer() {}
-	void writeShape(const TopoDS_Shape& shape) {
-		writer.AddShape(shape);
+	void writeShape(const ifcopenshell::geometry::ConversionResultShape* shape) {
+		writer.AddShape(*(ifcopenshell::geometry::OpenCascadeShape*)shape);
 	}
 	void finalize() {
 		writer.Write(out_filename.c_str());

src/serializers/OpenCascadeBasedSerializer.cpp

@@ -36,17 +36,20 @@ bool OpenCascadeBasedSerializer::ready() {
 	return succeeded;
 }
 
-void OpenCascadeBasedSerializer::write(const IfcGeom::BRepElement<real_t>* o) {
-	TopoDS_Shape compound = o->geometry().as_compound();
+void OpenCascadeBasedSerializer::write(const ifcopenshell::geometry::NativeElement* o) {
+	ifcopenshell::geometry::OpenCascadeShape* occt_shape = ((ifcopenshell::geometry::OpenCascadeShape*) o->geometry().as_compound());
+        TopoDS_Shape compound = occt_shape->shape();
+        delete occt_shape;
 
-	if (o->geometry().settings().get(IfcGeom::IteratorSettings::CONVERT_BACK_UNITS)) {
+	if (o->geometry().settings().get(ifcopenshell::geometry::settings::CONVERT_BACK_UNITS)) {
 		gp_Trsf scale;
 		scale.SetScaleFactor(1.0 / o->geometry().settings().unit_magnitude());
 		
 		compound = BRepBuilderAPI_Transform(compound, scale, true).Shape();
 	}
 
-	writeShape(compound);
+	ifcopenshell::geometry::OpenCascadeShape s(compound);
+	writeShape(&s);
 }
 
 #define RATHER_SMALL (1e-3)