Merge remote-tracking branch 'origin/v0.6.0' into v0.7.0

src/ifcgeom/kernel_agnostic/AbstractKernel.cpp

@@ -13,9 +13,6 @@ void IfcGeom::AbstractKernel::setValue(GeomValue var, double value) {
 	case GV_DEFLECTION_TOLERANCE:
 		deflection_tolerance = value;
 		break;
-	case GV_WIRE_CREATION_TOLERANCE:
-		wire_creation_tolerance = value;
-		break;
 	case GV_POINT_EQUALITY_TOLERANCE:
 		point_equality_tolerance = value;
 		break;
@@ -40,8 +37,6 @@ double IfcGeom::AbstractKernel::getValue(GeomValue var) const {
 	switch (var) {
 	case GV_DEFLECTION_TOLERANCE:
 		return deflection_tolerance;
-	case GV_WIRE_CREATION_TOLERANCE:
-		return wire_creation_tolerance;
 	case GV_MINIMAL_FACE_AREA:
 		// Considering a right-angled triangle, this about the smallest
 		// area you can obtain without the vertices being confused.
@@ -178,7 +173,7 @@ namespace {
 
 	template <typename T>
 	std::pair<IfcSchema::IfcSurfaceStyle*, T*> _get_surface_style(const IfcSchema::IfcStyledItem* si) {
-#ifdef USE_IFC4
+#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())) {

src/ifcgeom/kernel_agnostic/AbstractKernel.h

@@ -9,6 +9,9 @@
 #define INCLUDE_SCHEMA(x) STRINGIFY(../../ifcparse/x.h)
 #include INCLUDE_SCHEMA(IfcSchema)
 #undef INCLUDE_SCHEMA
+#define INCLUDE_SCHEMA(x) STRINGIFY(../../ifcparse/x-definitions.h)
+#include INCLUDE_SCHEMA(IfcSchema)
+#undef INCLUDE_SCHEMA
 
 namespace IfcGeom {
 

src/ifcgeom/kernel_agnostic/IfcGeomIteratorImplementation.h

@@ -409,8 +409,8 @@ namespace IfcGeom {
 					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);
+                        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) {
@@ -663,6 +663,7 @@ namespace IfcGeom {
 			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)) {

src/ifcgeom/kernels/opencascade/IfcGeom.h

@@ -84,6 +84,9 @@ if ( it != cache.T.end() ) { e = it->second; return true; }
 #define INCLUDE_SCHEMA(x) STRINGIFY(../../../ifcparse/x.h)
 #include INCLUDE_SCHEMA(IfcSchema)
 #undef INCLUDE_SCHEMA
+#define INCLUDE_SCHEMA(x) STRINGIFY(../../../ifcparse/x-definitions.h)
+#include INCLUDE_SCHEMA(IfcSchema)
+#undef INCLUDE_SCHEMA
 
 namespace IfcGeom {
 	class IFC_GEOM_API geometry_exception : public std::exception {
@@ -123,6 +126,7 @@ private:
 	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_;
@@ -177,6 +181,9 @@ private:
 		}
 
 		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;
@@ -232,8 +239,7 @@ public:
 
 	MAKE_TYPE_NAME(Kernel)& operator=(const MAKE_TYPE_NAME(Kernel)& other) {
 		setValue(GV_DEFLECTION_TOLERANCE,     other.getValue(GV_DEFLECTION_TOLERANCE));
-		setValue(GV_WIRE_CREATION_TOLERANCE,  other.getValue(GV_WIRE_CREATION_TOLERANCE));
-		setValue(GV_POINT_EQUALITY_TOLERANCE, other.getValue(GV_POINT_EQUALITY_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));
@@ -302,7 +308,8 @@ public:
 	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&);
-	bool triangulate_wire(const TopoDS_Wire&, TopTools_ListOfShape&);
+	/// 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);
 
@@ -321,6 +328,55 @@ public:
 	
 	std::pair<std::string, double> initializeUnits(IfcSchema::IfcUnitAssignment*);
 
+	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

src/ifcgeom/kernels/opencascade/IfcGeomCurves.cpp

@@ -77,12 +77,12 @@
 
 #include <TopLoc_Location.hxx>
 
-#ifdef USE_IFC4
+#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
+
+#ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
 #include <Geom_BSplineCurve.hxx>
 #endif
 
-#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
-
 #define Kernel MAKE_TYPE_NAME(Kernel)
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircle* l, Handle(Geom_Curve)& curve) {
@@ -143,7 +143,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcLine* l, Handle(Geom_Curve)& c
 	return true;
 }
 
-#ifdef USE_IFC4
+#ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcBSplineCurveWithKnots* l, Handle(Geom_Curve)& curve) {
 
 	const bool is_rational = l->declaration().is(IfcSchema::IfcRationalBSplineCurveWithKnots::Class());

src/ifcgeom/kernels/opencascade/IfcGeomFaces.cpp

@@ -97,39 +97,80 @@
 
 #include <BRepLib_FindSurface.hxx>
 
-#ifdef USE_IFC4
+#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
+
+#ifdef SCHEMA_HAS_IfcBSplineSurfaceWithKnots
 #include <Geom_BSplineSurface.hxx>
 #include <TColgp_Array2OfPnt.hxx>
 #include <TColStd_Array1OfReal.hxx>
 #include <TColStd_Array1OfInteger.hxx>
 #endif
 
-#include "../../../ifcgeom/kernels/opencascade/IfcGeom.h"
-
 #define Kernel MAKE_TYPE_NAME(Kernel)
 
 namespace {
-        int count_occt(const TopoDS_Shape& s, TopAbs_ShapeEnum t) {
-                IfcGeom::OpenCascadeShape Ss(s);
-                return IfcGeom::Kernel::count(&Ss, (int) t);
-        }
+	/* Returns whether wire conforms to a polyhedron, i.e. only edges with linear curves*/
+	bool is_polyhedron(const TopoDS_Wire& wire) {
+		double a, b;
+		TopLoc_Location l;
 
-        int is_manifold_occt(const TopoDS_Shape& s) {
-                IfcGeom::OpenCascadeShape Ss(s);
-                return IfcGeom::Kernel::is_manifold(&Ss);
-        }
-}
+		TopoDS_Iterator it(wire, false, false);
+		for (; it.More(); it.Next()) {
+			auto crv = BRep_Tool::Curve(TopoDS::Edge(it.Value()), l, a, b);
+			if (!crv || crv->DynamicType() != STANDARD_TYPE(Geom_Line)) {
+				return false;
+			}
+		}
 
-
-bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
-	IfcSchema::IfcFaceBound::list::ptr bounds = l->Bounds();
-
-	// Fail on this early as it can cause issues later on
-	if (bounds->size() == 0) {
-		return false;
+		return true;
 	}
 
-	Handle(Geom_Surface) face_surface;
+	/* A temporary structure to store the intermediate data for the face conversion */
+	class face_definition {
+	private:
+		Handle(Geom_Surface) surface_;
+		std::vector<TopoDS_Wire> wires_;
+		bool all_outer_;
+	public:
+		face_definition() : surface_(), all_outer_(false) {}
+
+		typedef std::vector<TopoDS_Wire>::const_iterator wire_it;
+		
+		bool& all_outer() {
+			return all_outer_;
+		}
+
+		bool all_outer() const {
+			return all_outer_;
+		}
+
+		Handle(Geom_Surface)& surface() {
+			return surface_;
+		}
+
+		const Handle(Geom_Surface)& surface() const {
+			return surface_;
+		}
+
+		std::vector<TopoDS_Wire>& wires() {
+			return wires_;
+		}
+
+		const TopoDS_Wire& outer_wire() const {
+			return wires_.front();
+		}
+
+		std::pair<wire_it, wire_it> inner_wires() const {
+			return { wires_.begin() + 1, wires_.end() };
+		}
+	};
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& result) {
+	IfcSchema::IfcFaceBound::list::ptr bounds = l->Bounds();
+
+	face_definition fd;
+
 	const bool is_face_surface = l->declaration().is(IfcSchema::IfcFaceSurface::Class());
 
 	if (is_face_surface) {
@@ -144,7 +185,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 		if (!exp.More()) return false;
 
 		TopoDS_Face surface = TopoDS::Face(exp.Current());
-		face_surface = BRep_Tool::Surface(surface);
+		fd.surface() = BRep_Tool::Surface(surface);
 	}
 	
 	const int num_bounds = bounds->size();
@@ -164,247 +205,188 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 		return false;
 	}
 
-	TopoDS_Compound compound;
-	BRep_Builder builder;
 	if (num_outer_bounds > 1) {
-		builder.MakeCompound(compound);
+		Logger::Message(Logger::LOG_WARNING, "Multiple outer boundaries for:", l);
+		fd.all_outer() = true;
 	}
 
 	TopTools_DataMapOfShapeInteger wire_senses;
 	
-	// The builder is initialized on the heap because of the various different moments
-	// of initialization depending on the configuration of surfaces and boundaries.
-	BRepBuilderAPI_MakeFace* mf = 0;
-	
-	bool success = false;
-	int processed = 0;
-
 	for (int process_interior = 0; process_interior <= 1; ++process_interior) {
 		for (IfcSchema::IfcFaceBound::list::it it = bounds->begin(); it != bounds->end(); ++it) {
 			IfcSchema::IfcFaceBound* bound = *it;
 			IfcSchema::IfcLoop* loop = bound->Bound();
-		
+
 			bool same_sense = bound->Orientation();
-			const bool is_interior = 
+			const bool is_interior =
 				!bound->declaration().is(IfcSchema::IfcFaceOuterBound::Class()) &&
 				(num_bounds > 1) &&
 				(num_outer_bounds < num_bounds);
 
 			// The exterior face boundary is processed first
 			if (is_interior == !process_interior) continue;
-		
+
 			TopoDS_Wire wire;
 			if (faceset_helper_ && loop->as<IfcSchema::IfcPolyLoop>()) {
 				if (!faceset_helper_->wire(loop->as<IfcSchema::IfcPolyLoop>(), wire)) {
 					Logger::Message(Logger::LOG_WARNING, "Face boundary loop not included", loop);
-					delete mf;
-					return false;
+					continue;
 				}
 			} else if (!convert_wire(loop, wire)) {
 				Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary loop", loop);
-				delete mf;
 				return false;
 			}
-			
-			// The approach below does not result in a significant speed-up
-			if (loop->as<IfcSchema::IfcPolyLoop>() && processed == 0 && face_surface.IsNull()) {
-				TopExp_Explorer exp(wire, TopAbs_EDGE);
-				int count = 0;
-				TopoDS_Edge edges[2];
-				for (; exp.More(); exp.Next(), count++) {
-					if (count < 2) {
-						edges[count] = TopoDS::Edge(exp.Current());
-					}
-				}
-				
-				if (count == 3) {
-					// Help Open Cascade by finding the plane more efficiently
-					double _, __;
-					Handle(Geom_Line) c1 = Handle(Geom_Line)::DownCast(BRep_Tool::Curve(edges[0], _, __));
-					Handle(Geom_Line) c2 = Handle(Geom_Line)::DownCast(BRep_Tool::Curve(edges[1], _, __));
 
-					const gp_Vec ab = c1->Position().Direction();
-					const gp_Vec ac = c2->Position().Direction();					
-					const gp_Vec cross = ab.Crossed(ac);
-
-					if (cross.SquareMagnitude() > ALMOST_ZERO) {
-						const gp_Dir n = cross;
-						face_surface = new Geom_Plane(c1->Position().Location(), n);
-					}
-				} else {
-					gp_Pln pln;
-					if (approximate_plane_through_wire(wire, pln)) {
-						face_surface = new Geom_Plane(pln);
-					}
-				}
-			}
-		
 			if (!same_sense) {
 				wire.Reverse();
 			}
 
 			wire_senses.Bind(wire.Oriented(TopAbs_FORWARD), same_sense ? TopAbs_FORWARD : TopAbs_REVERSED);
-			
-			bool flattened_wire = false;
 
-			if (!mf) {
-			process_wire:
+			fd.wires().emplace_back(wire);
+		}
+	}
 
-				if (face_surface.IsNull()) {
-					gp_Pln pln;
-					if (count_occt(wire, TopAbs_EDGE) > 128 && approximate_plane_through_wire(wire, pln)) {
-						// tfk: optimization find the underlying surface ourselves since it's going
-						// to be planar in IFC if no explicit surface is given. Should we always do this?
-						// @todo is this still relevant considering the code above
-						mf = new BRepBuilderAPI_MakeFace(pln, wire, true);
-					} else {
-						BRepLib_FindSurface fs(wire, getValue(GV_PRECISION), true, true);
-						if (fs.Found()) {
-							mf = new BRepBuilderAPI_MakeFace(fs.Surface(), wire);
-							ShapeFix_ShapeTolerance ftol;
-							ftol.SetTolerance(wire, fs.ToleranceReached(), TopAbs_WIRE);
-						}
-					}
-				} else {
-					/// @todo check necessity of false here
-					mf = new BRepBuilderAPI_MakeFace(face_surface, wire, false);
+	if (fd.wires().empty()) {
+		Logger::Warning("Face with no boundaries", l);
+		return false;
+	}
+
+	if (fd.surface().IsNull()) {
+		// Use the first wire to find a plane manually for polygonal wires
+		const TopoDS_Wire& wire = fd.wires().front();
+		if (is_polyhedron(wire)) {
+			TopExp_Explorer exp(wire, TopAbs_EDGE);
+			int count = 0;
+			TopoDS_Edge edges[2];
+			for (; exp.More(); exp.Next(), count++) {
+				if (count < 2) {
+					edges[count] = TopoDS::Edge(exp.Current());
 				}
+			}
 
-				if (mf && mf->IsDone()) {
-					TopoDS_Face outer_face_bound = mf->Face();
+			if (count == 3) {
+				// Help Open Cascade by finding the plane more efficiently
+				double _, __;
+				Handle(Geom_Line) c1 = Handle(Geom_Line)::DownCast(BRep_Tool::Curve(edges[0], _, __));
+				Handle(Geom_Line) c2 = Handle(Geom_Line)::DownCast(BRep_Tool::Curve(edges[1], _, __));
 
-					// In case of (non-planar) face surface, p-curves need to be computed.
-					// For planar faces, Open Cascade generates p-curves on the fly.
-					if (!face_surface.IsNull() && face_surface->DynamicType() != STANDARD_TYPE(Geom_Plane)) {
-						TopExp_Explorer exp(outer_face_bound, TopAbs_EDGE);
-						for (; exp.More(); exp.Next()) {
-							const TopoDS_Edge& edge = TopoDS::Edge(exp.Current());
-							ShapeFix_Edge fix_edge;
-							fix_edge.FixAddPCurve(edge, outer_face_bound, false, getValue(GV_PRECISION));
-						}
-					}
-					
-					if (BRepCheck_Face(outer_face_bound).OrientationOfWires() == BRepCheck_BadOrientationOfSubshape) {
-						wire.Reverse();
-						same_sense = !same_sense;
-						delete mf;
-						if (face_surface.IsNull()) {
-							mf = new BRepBuilderAPI_MakeFace(wire);
-						} else {
-							mf = new BRepBuilderAPI_MakeFace(face_surface, wire); 
-						}
-						ShapeFix_Face fix(mf->Face());
-						fix.FixOrientation();
-						outer_face_bound = fix.Face();
-					}
+				const gp_Vec ab = c1->Position().Direction();
+				const gp_Vec ac = c2->Position().Direction();
+				const gp_Vec cross = ab.Crossed(ac);
 
-					if (num_outer_bounds > 1) {
-						builder.Add(compound, outer_face_bound);
-						delete mf; mf = 0;
-					} else if (num_bounds > 1) {
-						// Reinitialize the builder to the outer face 
-						// bound in order to add holes more robustly.
-						delete mf;
-						// TODO: What about the face_surface?
-						mf = new BRepBuilderAPI_MakeFace(outer_face_bound);
-					} else {
-						face = outer_face_bound;
-						success = true;
-					}
-				} else {
-					// if mf == nullptr, it means we failed to find a surface earlier using BRepLib_FindSurface
-					const bool non_planar = mf == nullptr || mf->Error() == BRepBuilderAPI_NotPlanar;
-					delete mf;
-
-					if (non_planar && bounds->size() == 1 && face_surface.IsNull()) {
-						Logger::Message(Logger::LOG_WARNING, "Triangulating face boundary", bound);
-
-						// When creating a solid, flatting the boundary only postpones the issue to
-						// creating a topological manifold out of the individual faces.
-						TopTools_ListOfShape face_list;
-						triangulate_wire(wire, face_list);
-
-						TopoDS_Compound triangulation_compound;
-						BRep_Builder triangulation_builder;
-						triangulation_builder.MakeCompound(triangulation_compound);
-
-						TopTools_ListIteratorOfListOfShape face_iterator;
-						for (face_iterator.Initialize(face_list); face_iterator.More(); face_iterator.Next()) {
-							triangulation_builder.Add(triangulation_compound, face_iterator.Value());
-						}
-
-						face = triangulation_compound;
-
-						return true;
-					}
-
-					if (!non_planar || flattened_wire || !flatten_wire(wire)) {
-						Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary", bound);
-						return false;
-					} else {
-						Logger::Message(Logger::LOG_ERROR, "Flattening face boundary", bound);
-						flattened_wire = true;
-						goto process_wire;
-					}
+				if (cross.SquareMagnitude() > ALMOST_ZERO) {
+					const gp_Dir n = cross;
+					fd.surface() = new Geom_Plane(c1->Position().Location(), n);
 				}
-
 			} else {
-				mf->Add(wire);
+				gp_Pln pln;
+				if (approximate_plane_through_wire(wire, pln)) {
+					fd.surface() = new Geom_Plane(pln);
+				}
+			}
+		}
+	}	
 
-				// Same as above:
-				// In case of (non-planar) face surface, p-curves need to be computed.
-				if (BRep_Tool::Surface(mf->Face())->DynamicType() != STANDARD_TYPE(Geom_Plane)) {
-					TopExp_Explorer exp(wire, TopAbs_EDGE);
-					for (; exp.More(); exp.Next()) {
-						const TopoDS_Edge& edge = TopoDS::Edge(exp.Current());
+	if (fd.surface().IsNull()) {
+		// BRepLib_FindSurface is used in case no surface is found or provided
+		
+		const TopoDS_Wire& wire = fd.wires().front();
+
+		BRepLib_FindSurface fs(wire, getValue(GV_PRECISION), true, true);
+		if (fs.Found()) {
+			fd.surface() = fs.Surface();
+			ShapeFix_ShapeTolerance ftol;
+			ftol.SetTolerance(wire, fs.ToleranceReached(), TopAbs_WIRE);
+		}
+	}
+
+	TopTools_ListOfShape face_list;
+
+	if (fd.surface().IsNull()) {
+		// The set of wires is triangulated in case no surface can be found
+		Logger::Message(Logger::LOG_WARNING, "Triangulating face boundaries for face", l);
+
+		if (fd.all_outer()) {
+			for (const auto& w : fd.wires()) {
+				TopTools_ListOfShape fl;
+				triangulate_wire({ w }, fl);
+				face_list.Append(fl);
+			}
+		} else {
+			triangulate_wire(fd.wires(), face_list);			
+		}
+	} else if (!fd.all_outer()) {
+		BRepBuilderAPI_MakeFace mf(fd.surface(), fd.outer_wire());
+
+		if (mf.IsDone()) {
+			// Is this necessary
+			TopoDS_Face f = mf.Face();
+			mf.Init(f);
+
+			for (auto it = fd.inner_wires().first; it != fd.inner_wires().second; ++it) {
+				mf.Add(*it);
+			}
+
+			face_list.Append(mf.Face());
+		}		
+	} else {
+		for (const auto& w : fd.wires()) {
+			BRepBuilderAPI_MakeFace mf(fd.surface(), w);
+			if (mf.IsDone()) {
+				face_list.Append(mf.Face());
+			}
+		}
+	}
+
+	if (!fd.surface().IsNull()) {
+		// Some fixes for orientation and p-curves. If we have no surface, it
+		// means the face has been triangulated in which case none of these
+		// fixes are necessary.
+		
+		if (fd.surface()->DynamicType() != STANDARD_TYPE(Geom_Plane)) {
+			// In case of (non-planar) face surface, p-curves need to be computed.
+			// For planar faces, Open Cascade generates p-curves on the fly.
+
+			for (TopTools_ListIteratorOfListOfShape it(face_list); it.More(); it.Next()) {
+				// Small chance there are multiple faces
+				const TopoDS_Face& face = TopoDS::Face(it.Value());
+				for (TopExp_Explorer exp2(face, TopAbs_EDGE); exp2.More(); exp2.Next()) {
+					const TopoDS_Edge& edge = TopoDS::Edge(exp2.Current());
 						ShapeFix_Edge fix_edge;
-						fix_edge.FixAddPCurve(edge, mf->Face(), false, getValue(GV_PRECISION));
+						fix_edge.FixAddPCurve(edge, face, false, getValue(GV_PRECISION));
+				}
+			}
+		}
+
+		for (TopTools_ListIteratorOfListOfShape it(face_list); it.More(); it.Next()) {
+			const TopoDS_Face& face = TopoDS::Face(it.Value());
+			
+			ShapeFix_Face sfs(TopoDS::Face(face));
+			TopTools_DataMapOfShapeListOfShape wire_map;
+			sfs.FixOrientation(wire_map);
+
+			TopoDS_Iterator jt(face, false);
+			for (; jt.More(); jt.Next()) {
+				const TopoDS_Wire& w = TopoDS::Wire(jt.Value());
+				// tfk: @todo if wire_map contains w, I would assume wire_senses also contains w,
+				// this is not the case in github issue #405.
+				if (wire_map.IsBound(w) && wire_senses.IsBound(w)) {
+					const TopTools_ListOfShape& shapes = wire_map.Find(w);
+					TopTools_ListIteratorOfListOfShape kt(shapes);
+					for (; kt.More(); kt.Next()) {
+						// Apparently the wire got reversed, so register it with opposite orientation in the map
+						wire_senses.Bind(kt.Value(), wire_senses.Find(w) == TopAbs_FORWARD ? TopAbs_REVERSED : TopAbs_FORWARD);
 					}
 				}
 			}
-			processed ++;
+
+			it.Value() = sfs.Face();
 		}
-	}
 
-	if (!success) {
-		success = processed == num_bounds;
-		if (success) {
-			if (num_outer_bounds > 1) {
-				face = compound;
-			} else {
-				success = success && mf->IsDone();
-				if (success) {
-					face = mf->Face();
-				}
+		for (TopTools_ListIteratorOfListOfShape it(face_list); it.More(); it.Next()) {
+			TopoDS_Face& face = TopoDS::Face(it.Value());
 
-				ShapeFix_Face sfs(TopoDS::Face(face));
-				TopTools_DataMapOfShapeListOfShape wire_map;
-				sfs.FixOrientation(wire_map);
-				
-				TopoDS_Iterator jt(face, false);
-				for (; jt.More(); jt.Next()) {
-					const TopoDS_Wire& w = TopoDS::Wire(jt.Value());
-					// tfk: @todo if wire_map contains w, I would assume wire_senses also contains w,
-					// this is not the case in github issue #405.
-					if (wire_map.IsBound(w) && wire_senses.IsBound(w)) {
-						const TopTools_ListOfShape& shapes = wire_map.Find(w);
-						TopTools_ListIteratorOfListOfShape it(shapes);
-						for (; it.More(); it.Next()) {
-							// Apparently the wire got reversed, so register it with opposite orientation in the map
-							wire_senses.Bind(it.Value(), wire_senses.Find(w) == TopAbs_FORWARD ? TopAbs_REVERSED : TopAbs_FORWARD);
-						}
-					}
-				}
-				
-				face = TopoDS::Face(sfs.Face());				
-			}
-		}
-	}
-
-	if (success) {
-		// If the wires are reversed the face needs to be reversed as well in order
-		// to maintain the counter-clock-wise ordering of the bounding wire's vertices.
-		if (num_bounds == 1 || true) {
 			bool all_reversed = true;
 			TopoDS_Iterator jt(face, false);
 			for (; jt.More(); jt.Next()) {
@@ -420,8 +402,20 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 		}
 	}
 
-	delete mf;
-	return success;
+	if (face_list.Extent() > 1) {
+		TopoDS_Compound compound;
+		BRep_Builder builder;
+		builder.MakeCompound(compound);
+		for (TopTools_ListIteratorOfListOfShape it(face_list); it.More(); it.Next()) {
+			TopoDS_Face& face = TopoDS::Face(it.Value());
+			builder.Add(compound, face);
+		}
+		result = compound;
+	} else {
+		result = face_list.First();
+	}
+
+	return true;
 }
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcArbitraryClosedProfileDef* l, TopoDS_Shape& face) {
@@ -478,7 +472,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangleProfileDef* l, TopoDS
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -501,7 +495,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRoundedRectangleProfileDef* l,
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -535,7 +529,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangleHollowProfileDef* l,
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -581,7 +575,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrapeziumProfileDef* l, TopoDS
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -626,7 +620,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcIShapeProfileDef* l, TopoDS_Sh
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -665,7 +659,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcZShapeProfileDef* l, TopoDS_Sh
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -698,7 +692,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCShapeProfileDef* l, TopoDS_Sh
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -773,7 +767,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcLShapeProfileDef* l, TopoDS_Sh
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -821,7 +815,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcUShapeProfileDef* l, TopoDS_Sh
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -910,7 +904,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTShapeProfileDef* l, TopoDS_Sh
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -932,7 +926,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircleProfileDef* l, TopoDS_Sh
 	
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -964,7 +958,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircleHollowProfileDef* l, Top
 	
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -1002,7 +996,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipseProfileDef* l, TopoDS_S
 
 	gp_Trsf2d trsf2d;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -1130,7 +1124,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPlane* l, TopoDS_Shape& face)
 	return true;
 }
 
-#ifdef USE_IFC4
+#ifdef SCHEMA_HAS_IfcBSplineSurfaceWithKnots
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcBSplineSurfaceWithKnots* l, TopoDS_Shape& face) {
 	boost::shared_ptr< IfcTemplatedEntityListList<IfcSchema::IfcCartesianPoint> > cps = l->ControlPointsList();

src/ifcgeom/kernels/opencascade/IfcGeomFunctions.cpp

@@ -374,7 +374,7 @@ namespace {
 
 		IfcGeom::impl::tree<int> tree;
 
-		// Add edges to tree
+		// Add faces to tree
 		for (int i = 1; i <= faces.Extent(); ++i) {
 			if (BRep_Tool::Surface(TopoDS::Face(faces(i)))->DynamicType() == STANDARD_TYPE(Geom_Plane)) {
 				tree.add(i, faces(i));
@@ -395,9 +395,9 @@ namespace {
 			BRepBndLib::AddClose(f, b);
 			b.Enlarge(max_search);
 
-			std::vector<int> edge_idxs = tree.select_box(b, false);
-			std::vector<int>::const_iterator it = edge_idxs.begin();
-			for (; it != edge_idxs.end(); ++it) {
+			std::vector<int> face_idxs = tree.select_box(b, false);
+			std::vector<int>::const_iterator it = face_idxs.begin();
+			for (; it != face_idxs.end(); ++it) {
 				if (*it == j) {
 					continue;
 				}
@@ -419,6 +419,8 @@ namespace {
 						double u = d.Dot(p1->Position().XDirection());
 						double v = d.Dot(p1->Position().YDirection());
 
+						// nb: TopAbs_ON is explicitly not considered to prevent matching adjacent faces
+						// with similar orientations.
 						if (cls.Perform(gp_Pnt2d(u, v)) == TopAbs_IN) {
 							gp_Pnt test2;
 							p1->D0(u, v, test2);
@@ -458,16 +460,15 @@ namespace {
 		}
 	}
 
-#ifdef UNIFY_OPERANDS
-	TopoDS_Shape unify(const TopoDS_Shape& s) {
+	TopoDS_Shape unify(const TopoDS_Shape& s, double tolerance) {
+		tolerance = (std::min)(min_edge_length(s) / 2., tolerance);
 		ShapeUpgrade_UnifySameDomain usd(s);
-		usd.SetLinearTolerance(Precision::Confusion() * 10.);
-		usd.SetAngularTolerance(Precision::Angular() * 10.);
+		usd.SetSafeInputMode(true);
+		usd.SetLinearTolerance(tolerance);
+		usd.SetAngularTolerance(1.e-3);
 		usd.Build();
 		return usd.Shape();
 	}
-#endif
-
 }
 
 namespace {
@@ -1438,7 +1439,7 @@ bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std
 		gp_Trsf extrusion_position;
 
 		bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcSweptAreaSolid_Position_IS_OPTIONAL
 		has_position = extrusion->hasPosition();
 #endif
 		if (has_position) {
@@ -1486,6 +1487,8 @@ bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std
 	}
 
 	if (positive) {
+		std::reverse(thicknesses.begin(), thicknesses.end());
+		std::reverse(styles.begin(), styles.end());
 		std::reverse(surfaces.begin(), surfaces.end());
 	}
 
@@ -2532,7 +2535,7 @@ bool IfcGeom::Kernel::flatten_wire(TopoDS_Wire& wire) {
 	return true;
 }
 
-bool IfcGeom::Kernel::triangulate_wire(const TopoDS_Wire& wire, TopTools_ListOfShape& faces) {
+bool IfcGeom::Kernel::triangulate_wire(const std::vector<TopoDS_Wire>& wires, TopTools_ListOfShape& faces) {
 	// This is a bit of a precarious approach, but seems to work for the 
 	// versions of OCCT tested for. OCCT has a Delaunay triangulation function 
 	// BRepMesh_Delaun, but it is notoriously hard to interpret the results 
@@ -2549,52 +2552,70 @@ bool IfcGeom::Kernel::triangulate_wire(const TopoDS_Wire& wire, TopTools_ListOfS
 	typedef std::pair<double, double> uv_node;
 
 	gp_Pln pln;
-	if (!approximate_plane_through_wire(wire, pln, std::numeric_limits<double>::infinity())) {
+	if (!approximate_plane_through_wire(wires.front(), pln, std::numeric_limits<double>::infinity())) {
 		return false;
 	}
 
 	const gp_XYZ& udir = pln.Position().XDirection().XYZ();
 	const gp_XYZ& vdir = pln.Position().YDirection().XYZ();
 	const gp_XYZ& pnt = pln.Position().Location().XYZ();
-	
-	BRepTools_WireExplorer exp(wire);
-	BRepBuilderAPI_MakePolygon mp;
+
 	std::map<uv_node, TopoDS_Vertex> mapping;
 	std::map<std::pair<uv_node, uv_node>, TopoDS_Edge> existing_edges, new_edges;
 
-	// Add UV coordinates to a newly created polygon
-	for (; exp.More(); exp.Next()) {
-		// Project onto plane
-		const TopoDS_Vertex& V = exp.CurrentVertex();
-		gp_Pnt p = BRep_Tool::Pnt(V);
-		double u = (p.XYZ() - pnt).Dot(udir);
-		double v = (p.XYZ() - pnt).Dot(vdir);
-		mp.Add(gp_Pnt(u, v, 0.));
+	std::unique_ptr<BRepBuilderAPI_MakeFace> mf;
 
-		mapping.insert(std::make_pair(std::make_pair(u, v), V));
+	for (auto it = wires.begin(); it != wires.end(); ++it) {
+		const TopoDS_Wire& wire = *it;
+		BRepTools_WireExplorer exp(wire);
+		BRepBuilderAPI_MakePolygon mp;
 
-		// Store existing edges in a map so that triangles can
-		// actually reference the preexisting edges.
-		const TopoDS_Edge& e = exp.Current();
-		TopoDS_Vertex V0, V1;
-		TopExp::Vertices(e, V0, V1, true);
-		gp_Pnt p0 = BRep_Tool::Pnt(V0);
-		gp_Pnt p1 = BRep_Tool::Pnt(V1);
-		double u0 = (p0.XYZ() - pnt).Dot(udir);
-		double v0 = (p0.XYZ() - pnt).Dot(vdir);
-		double u1 = (p1.XYZ() - pnt).Dot(udir);
-		double v1 = (p1.XYZ() - pnt).Dot(vdir);
-		uv_node uv0 = std::make_pair(u0, v0);
-		uv_node uv1 = std::make_pair(u1, v1);
-		existing_edges.insert(std::make_pair(std::make_pair(uv0, uv1), e));
-		existing_edges.insert(std::make_pair(std::make_pair(uv1, uv0), TopoDS::Edge(e.Reversed())));
+		// Add UV coordinates to a newly created polygon
+		for (; exp.More(); exp.Next()) {
+			// Project onto plane
+			const TopoDS_Vertex& V = exp.CurrentVertex();
+			gp_Pnt p = BRep_Tool::Pnt(V);
+			double u = (p.XYZ() - pnt).Dot(udir);
+			double v = (p.XYZ() - pnt).Dot(vdir);
+			mp.Add(gp_Pnt(u, v, 0.));
+
+			mapping.insert(std::make_pair(std::make_pair(u, v), V));
+
+			// Store existing edges in a map so that triangles can
+			// actually reference the preexisting edges.
+			const TopoDS_Edge& e = exp.Current();
+			TopoDS_Vertex V0, V1;
+			TopExp::Vertices(e, V0, V1, true);
+			gp_Pnt p0 = BRep_Tool::Pnt(V0);
+			gp_Pnt p1 = BRep_Tool::Pnt(V1);
+			double u0 = (p0.XYZ() - pnt).Dot(udir);
+			double v0 = (p0.XYZ() - pnt).Dot(vdir);
+			double u1 = (p1.XYZ() - pnt).Dot(udir);
+			double v1 = (p1.XYZ() - pnt).Dot(vdir);
+			uv_node uv0 = std::make_pair(u0, v0);
+			uv_node uv1 = std::make_pair(u1, v1);
+			existing_edges.insert(std::make_pair(std::make_pair(uv0, uv1), e));
+			existing_edges.insert(std::make_pair(std::make_pair(uv1, uv0), TopoDS::Edge(e.Reversed())));
+		}
+
+		// Not closed by default
+		mp.Close();
+
+		if (mf) {
+			if (it - 1 == wires.begin()) {
+				// @todo is this necessary?
+				TopoDS_Face f = mf->Face();
+				mf->Init(f);
+			} 
+			mf->Add(mp.Wire());
+		} else {
+			mf.reset(new BRepBuilderAPI_MakeFace(mp.Wire()));
+		}
 	}
 
-	// Not closed by default
-	mp.Close();
+	const TopoDS_Face& face = mf->Face();
 
-	// Create a new face from the {u,v,0} wire and mesh the face
-	TopoDS_Face face = BRepBuilderAPI_MakeFace(mp.Wire());
+	// Create a triangular mesh from the face
 	BRepMesh_IncrementalMesh(face, Precision::Confusion());
 
 	int n123[3]; 
@@ -2655,13 +2676,13 @@ bool IfcGeom::Kernel::triangulate_wire(const TopoDS_Wire& wire, TopTools_ListOfS
 				}
 			}
 
-			BRepBuilderAPI_MakeFace mf(mp2.Wire());
-			if (mf.IsDone()) {
-				TopoDS_Face triangle_face = mf.Face();
+			BRepBuilderAPI_MakeFace mft(mp2.Wire());
+			if (mft.IsDone()) {
+				TopoDS_Face triangle_face = mft.Face();
 				TopoDS_Iterator jt(triangle_face, false);
 				for (; jt.More(); jt.Next()) {
 					const TopoDS_Wire& w = TopoDS::Wire(jt.Value());
-					if (w.Orientation() != wire.Orientation()) {
+					if (w.Orientation() != wires.front().Orientation()) {
 						triangle_face.Reverse();
 					}
 				}
@@ -2674,7 +2695,9 @@ bool IfcGeom::Kernel::triangulate_wire(const TopoDS_Wire& wire, TopTools_ListOfS
 	}
 
 	TopTools_IndexedDataMapOfShapeListOfShape mape, mapn;
-	TopExp::MapShapesAndAncestors(wire, TopAbs_EDGE, TopAbs_WIRE, mape);
+	for (auto& wire : wires) {
+		TopExp::MapShapesAndAncestors(wire, TopAbs_EDGE, TopAbs_WIRE, mape);
+	}
 	TopTools_ListIteratorOfListOfShape it(faces);
 	for (; it.More(); it.Next()) {
 		TopExp::MapShapesAndAncestors(it.Value(), TopAbs_EDGE, TopAbs_WIRE, mapn);
@@ -3162,20 +3185,21 @@ bool IfcGeom::Kernel::boolean_operation(const TopoDS_Shape& a, const TopoDS_Shap
 
 bool IfcGeom::Kernel::boolean_operation(const TopoDS_Shape& a_, const TopTools_ListOfShape& b__, BOPAlgo_Operation op, TopoDS_Shape& result, double fuzziness) {
 	
-#ifdef UNIFY_OPERANDS
-	TopoDS_Shape a = unify(a_);
+	if (fuzziness < 0.) {
+		fuzziness = getValue(GV_PRECISION) / 10.;
+	}
+
+	// @todo, it does seem a bit odd, we first triangulate non-planar faces
+	// to later unify them again. Can we make this a bit more intelligent?
+	TopoDS_Shape a = unify(a_, fuzziness);
 	TopTools_ListOfShape b_;
 	{
 		TopTools_ListIteratorOfListOfShape it(b__);
 		for (; it.More(); it.Next()) {
-			b_.Append(unify(it.Value()));
+			b_.Append(unify(it.Value(), fuzziness));
 		}
 	}
-#else
-	const TopoDS_Shape& a = a_;
-	const TopTools_ListOfShape& b_ = b__;
-#endif
-		
+
 	bool success = false;
 	BRepAlgoAPI_BooleanOperation* builder;
 	TopTools_ListOfShape B, b;
@@ -3197,15 +3221,11 @@ bool IfcGeom::Kernel::boolean_operation(const TopoDS_Shape& a_, const TopTools_L
 		return true;
 	}
 
-	if (fuzziness < 0.) {
-		fuzziness = getValue(GV_PRECISION);
-	}
-
 	// Find a sensible value for the fuzziness, based on precision
 	// and limited by edge lengths and vertex-edge distances.
-	const double len_a = min_edge_length(a);
-	double min_length_orig = (std::min)(len_a, min_vertex_edge_distance(a, getValue(GV_PRECISION), len_a));
-	TopTools_ListIteratorOfListOfShape it(b);
+	const double len_a = min_edge_length(a_);
+	double min_length_orig = (std::min)(len_a, min_vertex_edge_distance(a_, getValue(GV_PRECISION), len_a));
+	TopTools_ListIteratorOfListOfShape it(b__);
 	for (; it.More(); it.Next()) {
 		double d = min_edge_length(it.Value());
 		if (d < min_length_orig) {
@@ -3217,7 +3237,7 @@ bool IfcGeom::Kernel::boolean_operation(const TopoDS_Shape& a_, const TopTools_L
 		}
 	}
 
-	const double fuzz = (std::min)(min_length_orig / 10., fuzziness);
+	const double fuzz = (std::min)(min_length_orig / 3., fuzziness);
 
 	TopTools_ListOfShape s1s;
 	s1s.Append(copy_operand(a));
@@ -3255,13 +3275,13 @@ bool IfcGeom::Kernel::boolean_operation(const TopoDS_Shape& a_, const TopTools_L
 				// output is not trusted and the operation is attempted with a higher fuzziness.
 				int reason = 0;
 				double v;
-				if ((v = min_edge_length(r)) < fuzziness * 10.) {
+				if ((v = min_edge_length(r)) < fuzziness * 3.) {
 					reason = 0;
 					success = false;
-				} else if ((v = min_vertex_edge_distance(r, getValue(GV_PRECISION), fuzziness * 10.)) < fuzziness * 10.) {
+				} else if ((v = min_vertex_edge_distance(r, getValue(GV_PRECISION), fuzziness * 3.)) < fuzziness * 3.) {
 					reason = 1;
 					success = false;
-				} else if ((v = min_face_face_distance(r, fuzziness * 10.)) < fuzziness * 10.) {
+				} else if ((v = min_face_face_distance(r, fuzziness * 3.)) < fuzziness * 3.) {
 					reason = 2;
 					success = false;
 				}
@@ -3401,19 +3421,36 @@ IfcGeom::Kernel::faceset_helper::faceset_helper(Kernel* kernel, const IfcSchema:
 		}
 	}
 
+	// @todo, there a tiny possibility that the duplicate faces are triggered
+	// for an internal boundary, that is also present as an external boundary.
+	// This will result in non-manifold configuration then, but this is deemed
+	// such as corner-case that it is not considered.
 	IfcSchema::IfcPolyLoop::list::ptr loops = IfcParse::traverse((IfcUtil::IfcBaseClass*)l)->as<IfcSchema::IfcPolyLoop>();
 
-	size_t loops_removed = 0, non_manifold = 0;
+	size_t loops_removed = 0, non_manifold = 0, duplicate_faces = 0;
+
+	typedef std::array<int, 2> edge_t;
+	typedef std::set<edge_t> edge_set_t;
+	std::set<edge_set_t> edge_sets;
 
 	for (auto& loop : *loops) {
 		auto ps = loop->Polygon();
 
 		std::vector<std::pair<int, int> > segments;
+		edge_set_t segment_set;
 
-		loop_(ps, [&segments](int C, int D, bool) {
+		loop_(ps, [&segments, &segment_set](int C, int D, bool) {
+			segment_set.insert({{ C, D }});
 			segments.push_back({ C, D });
 		});
 
+		if (edge_sets.find(segment_set) != edge_sets.end()) {
+			duplicate_faces++;
+			duplicates_.insert(loop);
+			continue;
+		}
+		edge_sets.insert(segment_set);
+
 		if (segments.size() >= 3) {
 			for (auto& p : segments) {
 				edge_use[p] ++;
@@ -3434,7 +3471,7 @@ IfcGeom::Kernel::faceset_helper::faceset_helper(Kernel* kernel, const IfcSchema:
 	}
 
 	if (loops_removed || (non_manifold && l->declaration().is(IfcSchema::IfcClosedShell::Class()))) {
-		Logger::Warning(boost::lexical_cast<std::string>(loops_removed) + " loops removed and " + boost::lexical_cast<std::string>(non_manifold) + " non-manifold edges for:", l);
+		Logger::Warning(boost::lexical_cast<std::string>(duplicate_faces) + " duplicate faces removed, " + boost::lexical_cast<std::string>(loops_removed) + " loops removed and " + boost::lexical_cast<std::string>(non_manifold) + " non-manifold edges for:", l);
 	}
 }
 
@@ -3544,4 +3581,6 @@ bool IfcGeom::Kernel::validate_quantities(const IfcSchema::IfcProduct* product,
 			}
 		}
 	}
+
+	return true;
 }

src/ifcgeom/kernels/opencascade/IfcGeomShapes.cpp

@@ -119,7 +119,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolid* l, TopoDS_S
 
 	gp_Trsf trsf;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcSweptAreaSolid_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -166,7 +166,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolid* l, TopoDS_S
 	return !shape.IsNull();
 }
 
-#ifdef USE_IFC4
+#ifdef SCHEMA_HAS_IfcExtrudedAreaSolidTapered
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered* l, TopoDS_Shape& shape) {
 	const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
 	if (height < getValue(GV_PRECISION)) {
@@ -180,7 +180,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered* l, T
 
 	gp_Trsf trsf;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcSweptAreaSolid_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -280,7 +280,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceOfLinearExtrusion* l, T
 	
 	gp_Trsf trsf;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcSweptSurface_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -315,7 +315,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceOfRevolution* l, TopoDS
 
 	gp_Trsf trsf;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcSweptSurface_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -344,7 +344,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRevolvedAreaSolid* l, TopoDS_S
 
 	gp_Trsf trsf;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcSweptAreaSolid_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -376,7 +376,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, Conversi
 		if (l->declaration().is(IfcSchema::IfcFacetedBrepWithVoids::Class())) {
 			voids = l->as<IfcSchema::IfcFacetedBrepWithVoids>()->Voids();
 		}
-#ifdef USE_IFC4
+#ifdef SCHEMA_HAS_IfcAdvancedBrepWithVoids
 		if (l->declaration().is(IfcSchema::IfcAdvancedBrepWithVoids::Class())) {
 			voids = l->as<IfcSchema::IfcAdvancedBrepWithVoids>()->Voids();
 		}
@@ -478,7 +478,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, Con
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape& shape) {
 
 	TopoDS_Shape s1, s2;
-	ConversionResults items1, items2;
+	ConversionResults items1;
 	TopoDS_Wire boundary_wire;
 	IfcSchema::IfcBooleanOperand* operand1 = l->FirstOperand();
 	IfcSchema::IfcBooleanOperand* operand2 = l->SecondOperand();
@@ -545,24 +545,27 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape
 
 	TopTools_ListOfShape second_operand_shapes;
 
-	for (auto& operand2 : second_operands) {
+	for (auto& op2 : second_operands) {
+		TopoDS_Shape s2;
+
 		bool shape2_processed = false;
 
-		bool is_halfspace = operand2->declaration().is(IfcSchema::IfcHalfSpaceSolid::Class());
-		bool is_unbounded_halfspace = is_halfspace && !operand2->declaration().is(IfcSchema::IfcPolygonalBoundedHalfSpace::Class());
+		bool is_halfspace = op2->declaration().is(IfcSchema::IfcHalfSpaceSolid::Class());
+		bool is_unbounded_halfspace = is_halfspace && !op2->declaration().is(IfcSchema::IfcPolygonalBoundedHalfSpace::Class());
 		has_halfspace_operand |= is_halfspace;
 
 		{
-			if (shape_type(operand2) == ST_SHAPELIST) {
-				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);
+			if (shape_type(op2) == ST_SHAPELIST) {
+				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);
 				if (shape2_processed) {
 					TopoDS_Solid temp_solid;
 					s2 = ensure_fit_for_subtraction(s2, temp_solid);
 				}
 			} else {
-				Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", operand2);
+				Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", op2);
 			}
 		}
 
@@ -580,14 +583,14 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape
 		}
 
 		if (!shape2_processed) {
-			Logger::Message(Logger::LOG_ERROR, "Failed to convert SecondOperand:", operand2);
+			Logger::Message(Logger::LOG_ERROR, "Failed to convert SecondOperand:", op2);
 			continue;
 		}
 
-		if (operand2->declaration().is(IfcSchema::IfcHalfSpaceSolid::Class())) {
+		if (op2->declaration().is(IfcSchema::IfcHalfSpaceSolid::Class())) {
 			const double second_operand_volume = shape_volume(s2);
 			if (second_operand_volume <= ALMOST_ZERO) {
-				Logger::Message(Logger::LOG_WARNING, "Empty solid for:", operand2);
+				Logger::Message(Logger::LOG_WARNING, "Empty solid for:", op2);
 			}
 		}
 
@@ -601,16 +604,18 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape
 	TopoDS_Compound compound;
 	builder.MakeCompound(compound);
 	builder.Add(compound, s1);
-	builder.Add(compound, s2);
+	for (const auto& s2 : second_operand_shapes) {
+		builder.Add(compound, s2);
+	}
 	shape = compound;
 	return true;
 	*/	
 
 #if OCC_VERSION_HEX < 0x60900
+	// @todo: this currently does not compile anymore, do we still need this?
 	bool valid_result = boolean_operation(s1, s2, occ_op, shape);
 #else
-	const double fuzz = has_halfspace_operand ? getValue(GV_PRECISION) * 10. : -1.;
-	bool valid_result = boolean_operation(s1, second_operand_shapes, occ_op, shape, fuzz);
+	bool valid_result = boolean_operation(s1, second_operand_shapes, occ_op, shape);
 #endif
 
 	if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_DIFFERENCE) {
@@ -637,6 +642,10 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh
 
 	IfcSchema::IfcFace::list::ptr faces = l->CfsFaces();
 
+	double min_face_area = faceset_helper_
+		? (faceset_helper_->epsilon() * faceset_helper_->epsilon() / 20.)
+		: getValue(GV_MINIMAL_FACE_AREA);
+
 	TopTools_ListOfShape face_list;
 	for (IfcSchema::IfcFace::list::it it = faces->begin(); it != faces->end(); ++it) {
 		bool success = false;
@@ -667,18 +676,18 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh
 				if (face_it.Value().ShapeType() == TopAbs_FACE) {
 					// This should really be the case. This is not asserted.
 					const TopoDS_Face& triangle = TopoDS::Face(face_it.Value());
-					if (face_area(triangle) > getValue(GV_MINIMAL_FACE_AREA)) {
+					if (face_area(triangle) > min_face_area) {
 						face_list.Append(triangle);
 					} else {
-						Logger::Message(Logger::LOG_WARNING, "Invalid face:", (*it));
+						Logger::Message(Logger::LOG_WARNING, "Degenerate face:", (*it));
 					}
 				}
 			}
 		} else {
-			if (face_area(face) > getValue(GV_MINIMAL_FACE_AREA)) {
+			if (face_area(face) > min_face_area) {
 				face_list.Append(face);
 			} else {
-				Logger::Message(Logger::LOG_WARNING, "Invalid face:", (*it));
+				Logger::Message(Logger::LOG_WARNING, "Degenerate face:", (*it));
 			}
 		}
 	}
@@ -687,7 +696,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh
 		return false;
 	}
 
-	if (!create_solid_from_faces(face_list, shape)) {
+	if (face_list.Extent() > getValue(GV_MAX_FACES_TO_ORIENT) || !create_solid_from_faces(face_list, shape)) {
 		TopoDS_Compound compound;
 		BRep_Builder builder;
 		builder.MakeCompound(compound);
@@ -942,7 +951,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceCurveSweptAreaSolid* l,
 	
 	gp_Trsf trsf;
 	bool has_position = true;
-#ifdef USE_IFC4
+#ifdef SCHEMA_IfcSweptAreaSolid_Position_IS_OPTIONAL
 	has_position = l->hasPosition();
 #endif
 	if (has_position) {
@@ -1100,20 +1109,15 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSweptDiskSolid* l, TopoDS_Shap
 		}
 	}
 
-	const bool is_continuous = wire_is_c1_continuous(wire, 1.e-3);
+	// This is not used anymore, BRepBuilderAPI_RightCorner is always used now.
+	// const bool is_continuous = wire_is_c1_continuous(wire, 1.e-3);
 
 	// NB: Note that StartParam and EndParam param are ignored and the assumption is
 	// made that the parametric range over which to be swept matches the IfcCurve in
 	// its entirety.
-	// NB2: Contrary to IfcSurfaceCurveSweptAreaSolid the transition mode has been
-	// set to create round corners as this has proven to work better with the types
-	// of directrices encountered, which do not necessarily conform to a surface.
 	{ BRepOffsetAPI_MakePipeShell builder(wire);
 	builder.Add(section1);
-	if (!is_continuous) {
-		// Only perform round corners on wires that are not c1 continuous
-		builder.SetTransitionMode(BRepBuilderAPI_RoundCorner);
-	}
+	builder.SetTransitionMode(BRepBuilderAPI_RightCorner);
 	builder.Build();
 	builder.MakeSolid();
 	shape = builder.Shape(); }
@@ -1121,9 +1125,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSweptDiskSolid* l, TopoDS_Shap
 	if (hasInnerRadius) {
 		BRepOffsetAPI_MakePipeShell builder(wire);
 		builder.Add(section2);
-		if (!is_continuous) {
-			builder.SetTransitionMode(BRepBuilderAPI_RoundCorner);
-		}
+		builder.SetTransitionMode(BRepBuilderAPI_RightCorner);
 		builder.Build();
 		builder.MakeSolid();
 		TopoDS_Shape inner = builder.Shape();
@@ -1151,7 +1153,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSweptDiskSolid* l, TopoDS_Shap
 	return true;
 }
 
-#ifdef USE_IFC4
+#ifdef SCHEMA_HAS_IfcCylindricalSurface
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcCylindricalSurface* l, TopoDS_Shape& face) {
 	gp_Trsf trsf;
@@ -1166,10 +1168,18 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCylindricalSurface* l, TopoDS_
 	return true;
 }
 
+#endif
+
+#ifdef SCHEMA_HAS_IfcAdvancedBrep
+
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcAdvancedBrep* l, TopoDS_Shape& shape) {
 	return convert(l->Outer(), shape);
 }
 
+#endif
+
+#ifdef SCHEMA_HAS_IfcTriangulatedFaceSet
+
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS_Shape& shape) {
 	IfcSchema::IfcCartesianPointList3D* point_list = l->Coordinates();
 	const std::vector< std::vector<double> > coordinates = point_list->CoordList();
@@ -1230,18 +1240,18 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS
 	bool valid_shell = false;
 
 	// @todo Do this more efficiently by creating proper half-edge pairs.
-	BRepOffsetAPI_Sewing builder;
-	builder.SetTolerance(getValue(GV_POINT_EQUALITY_TOLERANCE));
-	builder.SetMaxTolerance(getValue(GV_POINT_EQUALITY_TOLERANCE));
-	builder.SetMinTolerance(getValue(GV_POINT_EQUALITY_TOLERANCE));
+	BRepOffsetAPI_Sewing sewing_builder;
+	sewing_builder.SetTolerance(getValue(GV_POINT_EQUALITY_TOLERANCE));
+	sewing_builder.SetMaxTolerance(getValue(GV_POINT_EQUALITY_TOLERANCE));
+	sewing_builder.SetMinTolerance(getValue(GV_POINT_EQUALITY_TOLERANCE));
 		
 	for (std::vector<TopoDS_Face>::const_iterator it = faces.begin(); it != faces.end(); ++it) {
-		builder.Add(*it);
+		sewing_builder.Add(*it);
 	}
 
 	try {
-		builder.Perform();
-		shape = builder.SewedShape();
+		sewing_builder.Perform();
+		shape = sewing_builder.SewedShape();
 		valid_shell = BRepCheck_Analyzer(shape).IsValid();
 	} catch(...) {}
 

src/ifcgeom/kernels/opencascade/IfcGeomTree.h

@@ -269,6 +269,7 @@ namespace IfcGeom {
 			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);
 
 			IfcGeom::Iterator<double> it(settings_, &f);
 

src/ifcgeom/kernels/opencascade/IfcGeomWires.cpp

@@ -849,7 +849,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSubedge* l, TopoDS_Wire& resul
 	}
 }
 
-#ifdef USE_IFC4
+#ifdef SCHEMA_HAS_IfcIndexedPolyCurve
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcIndexedPolyCurve* l, TopoDS_Wire& result) {
 	

src/ifcgeom/kernels/opencascade/IfcRegister.h

@@ -52,12 +52,20 @@ SHAPES(IfcMappedItem);
 SHAPES(IfcManifoldSolidBrep);
 SHAPES(IfcGeometricSet);
 
-#ifdef USE_IFC4
+#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);
@@ -114,14 +122,14 @@ WIRE(IfcPolyLoop);
 WIRE(IfcCompositeCurve);
 WIRE(IfcTrimmedCurve);
 WIRE(IfcArbitraryOpenProfileDef);
-#ifdef USE_IFC4
+#ifdef SCHEMA_HAS_IfcIndexedPolyCurve
 WIRE(IfcIndexedPolyCurve)
 #endif
 
 CURVE(IfcCircle);
 CURVE(IfcEllipse);
 CURVE(IfcLine);
-#ifdef USE_IFC4
+#ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
 // IfcRationalBSplineCurveWithKnots included
 CURVE(IfcBSplineCurveWithKnots);
 #endif

src/ifcgeom/schema_agnostic/IfcGeomElement.h

@@ -24,6 +24,7 @@
 #include <algorithm>
 
 #include "../../ifcparse/IfcGlobalId.h"
+#include "../../ifcparse/Argument.h"
 
 #include "../../ifcgeom/schema_agnostic/IfcGeomRepresentation.h"
 #include "../../ifcgeom/schema_agnostic/IfcGeomIteratorSettings.h"

src/ifcgeom/schema_agnostic/Kernel.cpp

@@ -167,6 +167,8 @@ IfcUtil::IfcBaseEntity* IfcGeom::Kernel::get_decomposing_entity(IfcUtil::IfcBase
 		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());
 	}

src/ifcgeom/schema_agnostic/Kernel.h

@@ -22,15 +22,15 @@ namespace IfcGeom {
 			// Specifies the deflection of the mesher
 			// Default: 0.001m / 1mm
 			GV_DEFLECTION_TOLERANCE,
-			// Specifies the tolerance of the wire builder, most notably for trimmed curves
-			// Default: 0.0001m / 0.1mm
-			GV_WIRE_CREATION_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
-			// Default: 0.00001m / 0.01mm
+			// 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