Option to select Kernel from IfcConvert

cmake/CMakeLists.txt

@@ -554,6 +554,18 @@ ENDIF()
 
 if (BUILD_IFCGEOM)
 
+foreach(kernel opencascade cgal)
+string(TOUPPER ${kernel} KERNEL_UPPER)
+file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/schema_agnostic/${kernel}/*.h)
+file(GLOB IFCGEOM_CPP_FILES ../src/ifcgeom/schema_agnostic/${kernel}/*.cpp)
+set(IFCGEOM_FILES ${IFCGEOM_CPP_FILES} ${IFCGEOM_H_FILES})
+
+add_library(IfcGeom_${kernel} ${IFCGEOM_FILES})
+set_target_properties(IfcGeom_${kernel} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS")
+target_link_libraries(IfcGeom_${kernel} IfcParse ${${KERNEL_UPPER}_LIBRARIES})
+list(APPEND IfcGeom_libraries IfcGeom_${kernel})
+endforeach()
+
 foreach(schema 2x3 4)
 
 file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/kernel_agnostic/*.h)
@@ -566,15 +578,13 @@ target_link_libraries(IfcGeom_ifc${schema} IfcParse)
 list(APPEND IfcGeom_libraries IfcGeom_ifc${schema})
 
 foreach(kernel opencascade cgal)
-string(TOUPPER ${kernel} KERNEL_UPPER)
-
 file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/kernels/${kernel}/*.h)
 file(GLOB IFCGEOM_CPP_FILES ../src/ifcgeom/kernels/${kernel}/*.cpp)
 set(IFCGEOM_FILES ${IFCGEOM_CPP_FILES} ${IFCGEOM_H_FILES})
 
 add_library(IfcGeom_${kernel}_ifc${schema} ${IFCGEOM_FILES})
 set_target_properties(IfcGeom_${kernel}_ifc${schema} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIfcSchema=Ifc${schema} -DUSE_IFC${schema}")
-target_link_libraries(IfcGeom_${kernel}_ifc${schema} IfcGeom_ifc${schema} ${${KERNEL_UPPER}_LIBRARIES})
+target_link_libraries(IfcGeom_${kernel}_ifc${schema} IfcGeom_${kernel} IfcGeom_ifc${schema})
 list(APPEND IfcGeom_libraries IfcGeom_${kernel}_ifc${schema})
 endforeach()
 

src/ifcconvert/IfcConvert.cpp

@@ -652,7 +652,7 @@ int main(int argc, char** argv)
         return EXIT_FAILURE;
     }
 
-    IfcGeom::Iterator<real_t> context_iterator(settings, ifc_file, filter_funcs);
+    IfcGeom::Iterator<real_t> context_iterator(settings, ifc_file, filter_funcs, "cgal");
     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.

src/ifcgeom/kernel_agnostic/IfcGeomIteratorImplementation.cpp

@@ -1,5 +1,5 @@
 #include "IfcGeomIteratorImplementation.h"
-#include "../../../ifcgeom/schema_agnostic/IteratorImplementation.h"
+#include "../../ifcgeom/schema_agnostic/IteratorImplementation.h"
 
 namespace IfcGeom {
 	template class MAKE_TYPE_NAME(IteratorImplementation_)<float, float>;
@@ -14,8 +14,8 @@ namespace IfcGeom {
 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) const {
+		IfcGeom::IteratorImplementation<P, PP>* operator()(const std::string& geometry_engine, const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters) const {
-			return new IfcGeom::MAKE_TYPE_NAME(IteratorImplementation_)<P, PP>(settings, file, filters);
+			return new IfcGeom::MAKE_TYPE_NAME(IteratorImplementation_)<P, PP>(geometry_engine, settings, file, filters);
 		}
 	};
 }

src/ifcgeom/kernel_agnostic/IfcGeomIteratorImplementation.h

@@ -73,16 +73,18 @@
 #include <gp_Trsf.hxx>
 #include <gp_Trsf2d.hxx>
 
-#include "../../../ifcparse/IfcFile.h"
+#include "../../ifcparse/IfcFile.h"
 
-#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
+#include "../../ifcgeom/kernels/opencascade/IfcGeom.h"
-#include "../../../ifcgeom/schema_agnostic/IfcGeomElement.h"
+#include "../../ifcgeom/schema_agnostic/IfcGeomElement.h"
-#include "../../../ifcgeom/schema_agnostic/IfcGeomMaterial.h"
+#include "../../ifcgeom/schema_agnostic/IfcGeomMaterial.h"
-#include "../../../ifcgeom/schema_agnostic/IfcGeomIteratorSettings.h"
+#include "../../ifcgeom/schema_agnostic/IfcGeomIteratorSettings.h"
-#include "../../../ifcgeom/schema_agnostic/ConversionResult.h"
+#include "../../ifcgeom/schema_agnostic/ConversionResult.h"
 
-#include "../../../ifcgeom/schema_agnostic/IfcGeomFilter.h"
+#include "../../ifcgeom/schema_agnostic/IfcGeomFilter.h"
-#include "../../../ifcgeom/schema_agnostic/IteratorImplementation.h"
+#include "../../ifcgeom/schema_agnostic/IteratorImplementation.h"
+
+#include "../../ifcgeom/schema_agnostic/Kernel.h"
 
 // The infamous min & max Win32 #defines can leak here from OCE depending on the build configuration
 #ifdef min
@@ -101,7 +103,7 @@ namespace IfcGeom {
 		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;
+		MAKE_TYPE_NAME(Kernel)* kernel;
 		IteratorSettings settings;
 
 		IfcParse::IfcFile* ifc_file;
@@ -141,29 +143,12 @@ namespace IfcGeom {
             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");
@@ -185,9 +170,6 @@ namespace IfcGeom {
 				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);
 
@@ -237,15 +219,7 @@ namespace IfcGeom {
 				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());
@@ -254,21 +228,6 @@ namespace IfcGeom {
 				// 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>();
@@ -310,7 +269,7 @@ namespace IfcGeom {
                     bool success = false;
 
                     try {
-                        success = kernel.convert(product->ObjectPlacement(), trsf);
+                        success = kernel->convert(product->ObjectPlacement(), trsf);
                     } catch (const std::exception& e) {
                         Logger::Error(e);
                     } catch (...) {
@@ -357,7 +316,7 @@ namespace IfcGeom {
 			// 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();
+				kernel->purge_cache();
 			}
 			ifcproducts.reset();
 			++ representation_iterator;
@@ -378,7 +337,7 @@ namespace IfcGeom {
 			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()) {
+				if (!settings.get(IteratorSettings::DISABLE_OPENING_SUBTRACTIONS) && kernel->find_openings(product)->size()) {
 					return false;
 				}
 
@@ -396,7 +355,7 @@ namespace IfcGeom {
 				}
 
 				// 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));
+				associated_single_materials.insert(kernel->get_single_material_association(product));
                 if (associated_single_materials.size() > 1) return false;
 			}
 
@@ -416,7 +375,7 @@ namespace IfcGeom {
 				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);
+					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;
@@ -450,7 +409,7 @@ namespace IfcGeom {
 
 					// 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);
+                    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);
@@ -476,9 +435,9 @@ namespace IfcGeom {
 
 				NativeElement<P, PP>* element;
 				if (ifcproduct_iterator == ifcproducts->begin() || !geometry_reuse_ok_for_current_representation_) {
-					element = kernel.create_brep_for_representation_and_product<P, PP>(settings, representation, product);
+					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);
+					element = kernel->create_brep_for_processed_representation(settings, representation, product, current_shape_model);
 				}
 
 				Logger::SetProduct(boost::none);
@@ -614,7 +573,7 @@ namespace IfcGeom {
 					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>();
+						IfcSchema::IfcObjectDefinition* parent_object = kernel->get_decomposing_entity(ifc_product)->template as<IfcSchema::IfcObjectDefinition>();
 						if (parent_object) {
 							parent_id = parent_object->data().id();
 						}
@@ -625,7 +584,7 @@ namespace IfcGeom {
 					}
 
 					try {
-						kernel.convert(ifc_product->ObjectPlacement(), trsf);
+						kernel->convert(ifc_product->ObjectPlacement(), trsf);
 					} catch (const std::exception& e) {
 						Logger::Error(e);
 					} catch (...) {
@@ -706,26 +665,28 @@ namespace IfcGeom {
 			unit_name = "METER";
 			unit_magnitude = 1.f;
 
-            kernel.setValue(IfcGeom::Kernel::GV_DIMENSIONALITY, (settings.get(IteratorSettings::INCLUDE_CURVES)
+            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());
+				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());
+				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)
+		MAKE_TYPE_NAME(IteratorImplementation_)(const std::string& geometry_library, const IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters)
 			: settings(settings)
 			, ifc_file(file)
 			, filters_(filters)
 			, owns_ifc_file(false)
 		{
+			kernel = (MAKE_TYPE_NAME(Kernel)*) impl::kernel_implementations().construct(file->schema()->name(), geometry_library, file);
+			// kernel = new Kernel(geometry_library, file);
 			_initialize();
 		}
 

src/ifcgeom/kernels/cgal/CgalConversionFunctions.cpp

@@ -1,5 +1,5 @@
 #include "CgalKernel.h"
-#include "CgalConversionResult.h"
+#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
 
 #define CgalKernel MAKE_TYPE_NAME(CgalKernel)
 

src/ifcgeom/kernels/cgal/CgalEntityMapping.cpp

@@ -18,7 +18,6 @@
 ********************************************************************************/
 
 #include "CgalKernel.h"
-#include "CgalConversionResult.h"
 
 #define CgalKernel MAKE_TYPE_NAME(CgalKernel)
 

src/ifcgeom/kernels/cgal/CgalKernel.cpp

@@ -18,7 +18,6 @@
 ********************************************************************************/
 
 #include "CgalKernel.h"
-#include "CgalConversionResult.h"
 
 namespace {
 	struct MAKE_TYPE_NAME(factory_t) {
@@ -208,3 +207,27 @@ template IFC_GEOM_API IfcGeom::NativeElement<float, double>* IfcGeom::CgalKernel
 	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product, IfcGeom::NativeElement<float, double>* brep);
 template IFC_GEOM_API IfcGeom::NativeElement<double, double>* IfcGeom::CgalKernel::create_brep_for_processed_representation<double, double>(
 	const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product, IfcGeom::NativeElement<double, double>* brep);
+
+
+void IfcGeom::CgalKernel::setValue(GeomValue var, double value) {
+	switch (var) {
+	case GV_DEFLECTION_TOLERANCE:
+		deflection_tolerance = value;
+		break;
+	case GV_DIMENSIONALITY:
+		dimensionality = value;
+		break;
+	default:
+		throw std::runtime_error("Not implemented for this kernel");
+	}
+}
+
+double IfcGeom::CgalKernel::getValue(GeomValue var) const {
+	switch (var) {
+	case GV_DEFLECTION_TOLERANCE:
+		return deflection_tolerance;
+	case GV_DIMENSIONALITY:
+		return dimensionality;
+	}
+	throw std::runtime_error("Not implemented for this kernel");
+}

src/ifcgeom/kernels/cgal/CgalKernel.h

@@ -38,6 +38,7 @@ if ( it != cache.T.end() ) { e = it->second; return true; }
 #include "../../../ifcparse/macros.h"
 #include "../../../ifcgeom/schema_agnostic/Kernel.h"
 #include "../../../ifcgeom/schema_agnostic/IfcGeomElement.h"
+#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
 
 // @todo create separate shapetype enum?
 #include "../../../ifcgeom/kernels/opencascade/IfcGeomShapeType.h"
@@ -46,13 +47,6 @@ if ( it != cache.T.end() ) { e = it->second; return true; }
 #include INCLUDE_SCHEMA(IfcSchema)
 #undef INCLUDE_SCHEMA
 
-typedef void* cgal_shape_t;
-typedef void* cgal_face_t;
-typedef void* cgal_wire_t;
-typedef void* cgal_curve_t;
-typedef void* cgal_placement_t;
-typedef void* cgal_point_t;
-
 namespace IfcGeom {
 
 	class IFC_GEOM_API CgalCache {
@@ -78,6 +72,9 @@ namespace IfcGeom {
 		bool convert_curve(const IfcUtil::IfcBaseClass* L, cgal_curve_t& result);
 		bool convert_face(const IfcUtil::IfcBaseClass* L, cgal_face_t& result);
 
+		virtual void setValue(GeomValue var, double value);
+		virtual double getValue(GeomValue var) const;
+
 		// bool convert_openings(const IfcSchema::IfcProduct* entity, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const ConversionResults& entity_shapes, const gp_Trsf& entity_trsf, ConversionResults& cut_shapes);
 
 		void purge_cache() {
@@ -102,6 +99,9 @@ namespace IfcGeom {
 
 #include "CgalEntityMappingDeclaration.h"
 
+	private:
+		double deflection_tolerance;
+		double dimensionality;
 	};
 
 }

src/ifcgeom/kernels/opencascade/IfcGeom.h

@@ -58,7 +58,7 @@ inline static bool ALMOST_THE_SAME(const T& a, const T& b, double tolerance=ALMO
 #include "../../../ifcgeom/kernels/opencascade/IfcGeomShapeType.h"
 
 #include "../../../ifcgeom/schema_agnostic/Kernel.h"
-#include "OpenCascadeConversionResult.h"
+#include "../../../ifcgeom/schema_agnostic/opencascade/OpenCascadeConversionResult.h"
 
 #include "../../../ifcgeom/schema_agnostic/ifc_geom_api.h"
 

src/ifcgeom/schema_agnostic/IfcGeomIterator.h

@@ -83,19 +83,19 @@ namespace IfcGeom {
 		IteratorImplementation<P, PP>* implementation_;
 
 	public:
-		Iterator(const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file)
+		Iterator(const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file, const std::string& geometry_library="opencascade")
 			: file_(file)
 			, settings_(settings)
 		{
-			implementation_ = iterator_implementations<P, PP>().construct(file_->schema()->name(), settings, file, filters_);
+			implementation_ = iterator_implementations<P, PP>().construct(file_->schema()->name(), geometry_library, settings, file, filters_);
 		}
 
-		Iterator(const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters)
+		Iterator(const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters, const std::string& geometry_library = "opencascade")
 			: file_(file)
 			, settings_(settings)
 			, filters_(filters)
 		{
-			implementation_ = iterator_implementations<P, PP>().construct(file_->schema()->name(), settings, file, filters_);
+			implementation_ = iterator_implementations<P, PP>().construct(file_->schema()->name(), geometry_library, settings, file, filters_);
 		}
 
 		bool initialize() {

src/ifcgeom/schema_agnostic/IfcGeomRepresentation.cpp

@@ -27,7 +27,7 @@
 #include <BRepGProp.hxx>
 
 #include "IfcGeomRepresentation.h"
-#include "../../ifcgeom/kernels/opencascade/OpenCascadeConversionResult.h"
+#include "../../ifcgeom/schema_agnostic/opencascade/OpenCascadeConversionResult.h"
 #include "../../ifcgeom/schema_agnostic/Kernel.h"
 
 IfcGeom::Representation::Serialization::Serialization(const BRep& brep)

src/ifcgeom/schema_agnostic/IteratorImplementation.cpp

@@ -31,14 +31,14 @@ void IteratorFactoryImplementation<P, PP>::bind(const std::string& schema_name,
 }
 
 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) {
+IfcGeom::IteratorImplementation<P, PP>* IteratorFactoryImplementation<P, PP>::construct(const std::string& schema_name, const std::string& geometry_library, const IfcGeom::IteratorSettings& settings, IfcParse::IfcFile* file, const std::vector<IfcGeom::filter_t>& filters) {
 	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);
+	return it->second(geometry_library, settings, file, filters);
 }
 
 

src/ifcgeom/schema_agnostic/IteratorImplementation.h

@@ -23,9 +23,9 @@ namespace IfcGeom {
 	class NativeElement;
 }
 
-typedef boost::function3<IfcGeom::IteratorImplementation<float, float>*, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&> iterator_float_float_fn;
+typedef boost::function4<IfcGeom::IteratorImplementation<float, float>*, const std::string&, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&> iterator_float_float_fn;
-typedef boost::function3<IfcGeom::IteratorImplementation<float, double>*, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&> iterator_float_double_fn;
+typedef boost::function4<IfcGeom::IteratorImplementation<float, double>*, const std::string&, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&> iterator_float_double_fn;
-typedef boost::function3<IfcGeom::IteratorImplementation<double, double>*, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&> iterator_double_double_fn;
+typedef boost::function4<IfcGeom::IteratorImplementation<double, double>*, const std::string&, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&> iterator_double_double_fn;
 
 template <typename P, typename PP>
 struct get_factory_type {};
@@ -50,7 +50,7 @@ class IteratorFactoryImplementation : public std::map<std::string, typename get_
 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>&);
+	IfcGeom::IteratorImplementation<P, PP>* construct(const std::string& schema_name, const std::string& geometry_library, const IfcGeom::IteratorSettings&, IfcParse::IfcFile*, const std::vector<IfcGeom::filter_t>&);
 };
 
 template <typename P, typename PP>

src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.cpp

@@ -1,4 +1,3 @@
-#include "CgalKernel.h"
 #include "CgalConversionResult.h"
 
 template <typename Precision>

src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.h

@@ -20,6 +20,13 @@
 #ifndef CGALCONVERSIONRESULT_H
 #define CGALCONVERSIONRESULT_H
 
+typedef void* cgal_shape_t;
+typedef void* cgal_face_t;
+typedef void* cgal_wire_t;
+typedef void* cgal_curve_t;
+typedef void* cgal_placement_t;
+typedef void* cgal_point_t;
+
 #include "../../../ifcgeom/schema_agnostic/ConversionResult.h"
 
 namespace IfcGeom {

src/ifcgeom/schema_agnostic/opencascade/OpenCascadeConversionResult.cpp

@@ -3,8 +3,6 @@
 #include "../../../ifcparse/IfcLogger.h"
 #include "../../../ifcgeom/schema_agnostic/IfcGeomRepresentation.h"
 
-#include "IfcGeom.h"
-
 #include <TopoDS.hxx>
 
 #include <map>
@@ -198,5 +196,6 @@ void IfcGeom::OpenCascadeShape::Triangulate(const IfcGeom::IteratorSettings & se
 }
 
 int IfcGeom::OpenCascadeShape::surface_genus() const {
-	return IfcGeom::Kernel::surface_genus(shape_);
+	throw std::runtime_error("Not implemented");
+	// return IfcGeom::Kernel::surface_genus(shape_);
 }

src/serializers/OpenCascadeBasedSerializer.h

@@ -21,7 +21,7 @@
 #define OPENCASCADEBASEDSERIALIZER_H
 
 #include "../ifcgeom/schema_agnostic/IfcGeomIterator.h"
-#include "../ifcgeom/kernels/opencascade/OpenCascadeConversionResult.h"
+#include "../ifcgeom/schema_agnostic/opencascade/OpenCascadeConversionResult.h"
 #include "../serializers/GeometrySerializer.h"
 
 class OpenCascadeBasedSerializer : public GeometrySerializer {