File renames, build script and cmake updates

src/ifcgeom/mapping/IfcAdvancedBrep.cpp

@@ -0,0 +1,30 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcAdvancedBrep
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcAdvancedBrep* l, TopoDS_Shape& shape) {
+	return convert(l->Outer(), shape);
+}
+
+#endif

src/ifcgeom/mapping/IfcAnnotationFillArea.cpp

@@ -0,0 +1,56 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <ShapeFix_Shape.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcAnnotationFillArea* l, TopoDS_Shape& face) {
+	TopoDS_Wire outer_boundary;
+	if (!convert_wire(l->OuterBoundary(), outer_boundary)) {
+		return false;
+	}
+
+	util::assert_closed_wire(outer_boundary, getValue(GV_PRECISION));
+
+	BRepBuilderAPI_MakeFace mf(outer_boundary);
+
+	if (l->InnerBoundaries()) {
+		IfcSchema::IfcCurve::list::ptr inner_boundaries = *l->InnerBoundaries();
+
+		for(IfcSchema::IfcCurve::list::it it = inner_boundaries->begin(); it != inner_boundaries->end(); ++it) {
+			TopoDS_Wire hole;
+			if (convert_wire(*it, hole)) {
+				util::assert_closed_wire(hole, getValue(GV_PRECISION));
+				mf.Add(hole);
+			}
+		}
+	}
+
+	ShapeFix_Shape sfs(mf.Face());
+	sfs.Perform();
+	face = sfs.Shape();
+
+	return true;
+}

src/ifcgeom/mapping/IfcArbitraryClosedProfileDef.cpp

@@ -0,0 +1,40 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <TopoDS_Wire.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcArbitraryClosedProfileDef* l, TopoDS_Shape& face) {
+	TopoDS_Wire wire;
+	if (!convert_wire(l->OuterCurve(), wire)) {
+		return false;
+	}
+
+	util::assert_closed_wire(wire, getValue(GV_PRECISION));
+
+	TopoDS_Compound f;
+	bool success = util::convert_wire_to_faces(wire, f, {getValue(GV_NO_WIRE_INTERSECTION_CHECK) < 0., getValue(GV_NO_WIRE_INTERSECTION_TOLERANCE) < 0., 0., getValue(GV_PRECISION)});
+	if (success) {
+		face = f;
+	}
+	return success;
+}

src/ifcgeom/mapping/IfcArbitraryOpenProfileDef.cpp

@@ -0,0 +1,27 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcGeom.h"
+
+#define _USE_MATH_DEFINES
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcArbitraryOpenProfileDef* l, TopoDS_Wire& result) {
+	return convert_wire(l->Curve(), result);
+}

src/ifcgeom/mapping/IfcArbitraryProfileDefWithVoids.cpp

@@ -0,0 +1,56 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <ShapeFix_Shape.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcArbitraryProfileDefWithVoids* l, TopoDS_Shape& face) {
+	TopoDS_Wire profile;
+	if (!convert_wire(l->OuterCurve(), profile)) {
+		return false;
+	}
+
+	util::assert_closed_wire(profile, getValue(GV_PRECISION));
+
+	// @todo this is a discrepancy with IfcArbitraryClosedProfileDef without voids.
+	// wire intersection code is not triggered this way.
+	BRepBuilderAPI_MakeFace mf(profile);
+
+	IfcSchema::IfcCurve::list::ptr voids = l->InnerCurves();
+
+	for(IfcSchema::IfcCurve::list::it it = voids->begin(); it != voids->end(); ++it) {
+		TopoDS_Wire hole;
+		if (convert_wire(*it, hole)) {
+			util::assert_closed_wire(hole, getValue(GV_PRECISION));
+			mf.Add(hole);
+		}
+	}
+
+	ShapeFix_Shape sfs(mf.Face());
+	sfs.Perform();
+	face = sfs.Shape();
+
+	return true;
+}

src/ifcgeom/mapping/IfcAxis1Placement.cpp

@@ -0,0 +1,41 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcAxis1Placement* l, gp_Ax1& ax) {
+	IN_CACHE(IfcAxis1Placement,l,gp_Ax1,ax)
+	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);
+
+	if (!l->Location()->declaration().is("IfcCartesianPoint")) {
+		// only applicable to 4x3 rc2
+		Logger::Error("Not implemented", l->Location());
+		return false;
+	}
+
+	IfcGeom::Kernel::convert((const IfcSchema::IfcCartesianPoint*) l->Location(),o);
+	if ( l->Axis() ) IfcGeom::Kernel::convert(l->Axis(), axis);
+	ax = gp_Ax1(o, axis);
+	CACHE(IfcAxis1Placement,l,ax)
+	return true;
+}

src/ifcgeom/mapping/IfcAxis2Placement2D.cpp

@@ -0,0 +1,54 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Dir2d.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Ax2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcAxis2Placement2D* l, gp_Trsf2d& trsf) {
+	IN_CACHE(IfcAxis2Placement2D,l,gp_Trsf2d,trsf)
+	gp_Pnt P; gp_Dir V (1,0,0);
+
+	if (!l->Location()->declaration().is("IfcCartesianPoint")) {
+		// only applicable to 4x3 rc2
+		Logger::Error("Not implemented", l->Location());
+		return false;
+	}
+
+	IfcGeom::Kernel::convert((const IfcSchema::IfcCartesianPoint*) l->Location(),P);
+	if (l->RefDirection()) {
+		IfcGeom::Kernel::convert(l->RefDirection(), V);
+	}
+
+	gp_Ax2d axis(gp_Pnt2d(P.X(),P.Y()), gp_Dir2d(V.X(),V.Y()));
+	
+	if (!util::axis_equal(axis, gp_Ax2d(), getValue(GV_PRECISION))) {
+		trsf.SetTransformation(axis, gp_Ax2d());
+	}
+
+	CACHE(IfcAxis2Placement2D,l,trsf)
+	return true;
+}

src/ifcgeom/mapping/IfcAxis2Placement3D.cpp

@@ -0,0 +1,76 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Ax3.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcAxis2Placement3D* l, gp_Trsf& trsf) {
+	IN_CACHE(IfcAxis2Placement3D, l, gp_Trsf, trsf)
+
+	gp_Pnt o;
+	gp_Dir axis(0, 0, 1);
+	gp_Dir refDirection;
+
+	if (!l->Location()->declaration().is("IfcCartesianPoint")) {
+		// only applicable to 4x3 rc2
+		Logger::Error("Not implemented", l->Location());
+		return false;
+	}
+
+	IfcGeom::Kernel::convert((const IfcSchema::IfcCartesianPoint*) l->Location(), o);
+	const bool hasAxis = !!l->Axis();
+	const bool hasRef = !!l->RefDirection();
+
+	if (hasAxis != hasRef) {
+		Logger::Warning("Axis and RefDirection should be specified together", l);
+	}
+
+	if (hasAxis) {
+		IfcGeom::Kernel::convert(l->Axis(), axis);
+	}
+
+	if (hasRef) {
+		IfcGeom::Kernel::convert(l->RefDirection(), refDirection);
+	} else {
+		if (!axis.IsParallel(gp::DX(), 1.e-5)) {
+			refDirection = gp::DX();
+		} else {
+			refDirection = gp::DZ();
+		}
+		gp_Vec Xvec = axis.Dot(refDirection) * axis;
+		gp_Vec Xaxis = refDirection.XYZ() - Xvec.XYZ();
+		refDirection = Xaxis;
+	}
+
+	gp_Ax3 ax3(o, axis, refDirection);
+
+	if (!util::axis_equal(ax3, (gp_Ax3) gp::XOY(), getValue(GV_PRECISION))) {
+		trsf.SetTransformation(ax3, gp::XOY());
+	}
+	
+	CACHE(IfcAxis2Placement3D,l,trsf)
+	return true;
+}

src/ifcgeom/mapping/IfcBSplineCurveWithKnots.cpp

@@ -0,0 +1,83 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_Array1OfInteger.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include <Geom_BSplineCurve.hxx>
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcBSplineCurveWithKnots
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcBSplineCurveWithKnots* l, Handle(Geom_Curve)& curve) {
+
+	const bool is_rational = l->declaration().is(IfcSchema::IfcRationalBSplineCurveWithKnots::Class());
+
+	const IfcSchema::IfcCartesianPoint::list::ptr cps = l->ControlPointsList();
+	const std::vector<int> mults = l->KnotMultiplicities();
+	const std::vector<double> knots = l->Knots();
+
+	TColgp_Array1OfPnt      Poles(0,  cps->size() - 1);
+	TColStd_Array1OfReal    Weights(0, cps->size() - 1);
+	TColStd_Array1OfReal    Knots(0, (int)knots.size() - 1);
+	TColStd_Array1OfInteger Mults(0, (int)mults.size() - 1);
+	Standard_Integer        Degree = l->Degree();
+	Standard_Boolean        Periodic = false; 
+	// @tfk: it appears to be wrong to expect a period curve when the curve is closed, see #586
+	// Standard_Boolean     Periodic = l->ClosedCurve();
+	
+	int i;
+
+	if (is_rational) {
+		IfcSchema::IfcRationalBSplineCurveWithKnots* rl = (IfcSchema::IfcRationalBSplineCurveWithKnots*)l;
+		std::vector<double> weights = rl->WeightsData();
+
+		i = 0;
+		for (std::vector<double>::const_iterator it = weights.begin(); it != weights.end(); ++it, ++i) {
+			Weights(i) = *it;
+		}
+	}
+
+	i = 0;
+	for (IfcSchema::IfcCartesianPoint::list::it it = cps->begin(); it != cps->end(); ++it, ++i) {
+		gp_Pnt pnt;
+		if (!convert(*it, pnt)) return false;
+		Poles(i) = pnt;
+	}
+	
+	i = 0;
+	for (std::vector<int>::const_iterator it = mults.begin(); it != mults.end(); ++it, ++i) {
+		Mults(i) = *it;
+	}
+
+	i = 0;
+	for (std::vector<double>::const_iterator it = knots.begin(); it != knots.end(); ++it, ++i) {
+		Knots(i) = *it;
+	}
+	
+	if (is_rational) {
+		curve = new Geom_BSplineCurve(Poles, Weights, Knots, Mults, Degree, Periodic);
+	} else {
+		curve = new Geom_BSplineCurve(Poles, Knots, Mults, Degree, Periodic);
+	}
+	return true;
+}
+#endif

src/ifcgeom/mapping/IfcBSplineSurfaceWithKnots.cpp

@@ -0,0 +1,85 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <gp_Pnt.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_Array1OfInteger.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <Standard_Version.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include <Geom_BSplineSurface.hxx>
+#include <TColgp_Array2OfPnt.hxx>
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcBSplineSurfaceWithKnots
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcBSplineSurfaceWithKnots* l, TopoDS_Shape& face) {
+	boost::shared_ptr< aggregate_of_aggregate_of<IfcSchema::IfcCartesianPoint> > cps = l->ControlPointsList();
+	std::vector<double> uknots = l->UKnots();
+	std::vector<double> vknots = l->VKnots();
+	std::vector<int> umults = l->UMultiplicities();
+	std::vector<int> vmults = l->VMultiplicities();
+
+	TColgp_Array2OfPnt Poles (0, (int)cps->size() - 1, 0, (int)(*cps->begin()).size() - 1);
+	TColStd_Array1OfReal UKnots(0, (int)uknots.size() - 1);
+	TColStd_Array1OfReal VKnots(0, (int)vknots.size() - 1);
+	TColStd_Array1OfInteger UMults(0, (int)umults.size() - 1);
+	TColStd_Array1OfInteger VMults(0, (int)vmults.size() - 1);
+	Standard_Integer UDegree = l->UDegree();
+	Standard_Integer VDegree = l->VDegree();
+
+	int i = 0, j;
+	for (aggregate_of_aggregate_of<IfcSchema::IfcCartesianPoint>::outer_it it = cps->begin(); it != cps->end(); ++it, ++i) {
+		j = 0;
+		for (aggregate_of_aggregate_of<IfcSchema::IfcCartesianPoint>::inner_it jt = (*it).begin(); jt != (*it).end(); ++jt, ++j) {
+			IfcSchema::IfcCartesianPoint* p = *jt;
+			gp_Pnt pnt;
+			if (!convert(p, pnt)) return false;
+			Poles(i, j) = pnt;
+		}
+	}
+	i = 0;
+	for (std::vector<double>::const_iterator it = uknots.begin(); it != uknots.end(); ++it, ++i) {
+		UKnots(i) = *it;
+	}
+	i = 0;
+	for (std::vector<double>::const_iterator it = vknots.begin(); it != vknots.end(); ++it, ++i) {
+		VKnots(i) = *it;
+	}
+	i = 0;
+	for (std::vector<int>::const_iterator it = umults.begin(); it != umults.end(); ++it, ++i) {
+		UMults(i) = *it;
+	}
+	i = 0;
+	for (std::vector<int>::const_iterator it = vmults.begin(); it != vmults.end(); ++it, ++i) {
+		VMults(i) = *it;
+	}
+	Handle_Geom_Surface surf = new Geom_BSplineSurface(Poles, UKnots, VKnots, UMults, VMults, UDegree, VDegree);
+
+#if OCC_VERSION_HEX < 0x60502
+	face = BRepBuilderAPI_MakeFace(surf);
+#else
+	face = BRepBuilderAPI_MakeFace(surf, getValue(GV_PRECISION));
+#endif
+
+	return true;
+}
+
+#endif

src/ifcgeom/mapping/IfcBlock.cpp

@@ -0,0 +1,39 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <BRepPrimAPI_MakeBox.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcBlock* l, TopoDS_Shape& 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);
+
+	BRepPrimAPI_MakeBox builder(dx, dy, dz);
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+
+	// IfcCsgPrimitive3D.Position has unit scale factor
+	shape = builder.Solid().Moved(trsf);
+
+	return true;
+}

src/ifcgeom/mapping/IfcBooleanResult.cpp

@@ -0,0 +1,238 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <TopoDS_Wire.hxx>
+#include <Standard_Version.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+#include "../ifcgeom_schema_agnostic/boolean_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape& shape) {
+
+	TopoDS_Shape s1;
+	IfcRepresentationShapeItems items1;
+	TopoDS_Wire boundary_wire;
+	IfcSchema::IfcBooleanOperand* operand1 = l->FirstOperand();
+	IfcSchema::IfcBooleanOperand* operand2 = l->SecondOperand();
+	bool has_halfspace_operand = false;
+	
+	BOPAlgo_Operation occ_op;
+
+	const IfcSchema::IfcBooleanOperator::Value op = l->Operator();
+	if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_DIFFERENCE) {
+		occ_op = BOPAlgo_CUT;
+	} else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_INTERSECTION) {
+		occ_op = BOPAlgo_COMMON;
+	} else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_UNION) {
+		occ_op = BOPAlgo_FUSE;
+	} else {
+		return false;
+	}
+
+	std::vector<IfcSchema::IfcBooleanOperand*> second_operands;
+	second_operands.push_back(operand2);
+
+	if (occ_op == BOPAlgo_CUT) {
+		int n_half_space_operands = 0;
+		bool process_as_list = true;
+		while (true) {
+			auto res1 = operand1->as<IfcSchema::IfcBooleanResult>();
+			if (res1 && res1->SecondOperand()->as<IfcSchema::IfcHalfSpaceSolid>() && ++n_half_space_operands > 8) {
+				// There is something peculiar about many half space subtraction operands that OCCT does not like.
+				// Often these are used to create a semi-curved arch, as is the case in 693. Supplying all these
+				// operands at once apparently leads to too many edge-edge interference checks.
+				process_as_list = false;
+				break;
+			}
+			if (res1) {
+				if (res1->Operator() == op) {
+					operand1 = res1->FirstOperand();
+					second_operands.push_back(res1->SecondOperand());
+				} else {
+					process_as_list = false;
+					break;
+				}
+			} else {
+				break;
+			}
+		}
+
+		if (!process_as_list) {
+			operand1 = l->FirstOperand();
+			second_operands = { operand2 };
+		}
+	}
+
+	if ( shape_type(operand1) == ST_SHAPELIST ) {
+		if (!(convert_shapes(operand1, items1) && util::flatten_shape_list(items1, s1, true, getValue(GV_PRECISION)))) {
+			return false;
+		}
+	} else if ( shape_type(operand1) == ST_SHAPE ) {
+		if ( ! convert_shape(operand1, s1) ) {
+			return false;
+		}
+		{ TopoDS_Solid temp_solid;
+		s1 = util::ensure_fit_for_subtraction(s1, temp_solid, getValue(GV_PRECISION)); }
+	} else {
+		Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", operand1);
+		return false;
+	}
+
+	if (getValue(GV_DISABLE_BOOLEAN_RESULT) > 0.0) {
+		shape = s1;
+		return true;
+	}
+
+	const double first_operand_volume = util::shape_volume(s1);
+	if (first_operand_volume <= ALMOST_ZERO) {
+		Logger::Message(Logger::LOG_WARNING, "Empty solid for:", l->FirstOperand());
+	}
+
+	TopTools_ListOfShape second_operand_shapes;
+
+	for (auto& op2 : second_operands) {
+		TopoDS_Shape s2;
+
+		bool shape2_processed = false;
+
+		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(op2) == ST_SHAPELIST) {
+				IfcRepresentationShapeItems items2;
+				shape2_processed = convert_shapes(op2, items2) && util::flatten_shape_list(items2, s2, true, getValue(GV_PRECISION));
+			} else if (shape_type(op2) == ST_SHAPE) {
+				shape2_processed = convert_shape(op2, s2);
+				if (shape2_processed) {
+					TopoDS_Solid temp_solid;
+					s2 = util::ensure_fit_for_subtraction(s2, temp_solid, getValue(GV_PRECISION));
+				}
+			} else {
+				Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", op2);
+			}
+		}
+
+		if (is_unbounded_halfspace) {
+			TopoDS_Shape temp;
+			double d;
+			if (util::fit_halfspace(s1, s2, temp, d, getValue(GV_PRECISION))) {
+				if (d < getValue(GV_PRECISION)) {
+					Logger::Message(Logger::LOG_WARNING, "Halfspace subtraction yields unchanged volume:", l);
+					continue;
+				} else {
+					s2 = temp;
+				}
+			}
+		}
+
+		if (!shape2_processed) {
+			Logger::Message(Logger::LOG_ERROR, "Failed to convert SecondOperand:", op2);
+			continue;
+		}
+
+		if (op2->declaration().is(IfcSchema::IfcHalfSpaceSolid::Class())) {
+			const double second_operand_volume = util::shape_volume(s2);
+			if (second_operand_volume <= ALMOST_ZERO) {
+				Logger::Message(Logger::LOG_WARNING, "Empty solid for:", op2);
+			}
+		}
+
+		second_operand_shapes.Append(s2);
+	}
+
+	/*
+	// TK: A little debugging trick to output both operands for visual inspection
+	
+	BRep_Builder builder;
+	TopoDS_Compound compound;
+	builder.MakeCompound(compound);
+	builder.Add(compound, s1);
+	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
+	
+	bool valid_result;
+
+	util::boolean_settings bst;
+	bst.attempt_2d = getValue(GV_BOOLEAN_ATTEMPT_2D) > 0.;
+	bst.debug = getValue(GV_DEBUG_BOOLEAN) > 0.;
+	bst.precision = getValue(GV_PRECISION);
+
+	if (s1.ShapeType() == TopAbs_COMPOUND && TopoDS_Iterator(s1).More() && util::is_nested_compound_of_solid(s1)) {
+		TopoDS_Compound C;
+		BRep_Builder B;
+		B.MakeCompound(C);
+		TopoDS_Iterator it(s1);
+		valid_result = true;
+		for (; it.More(); it.Next()) {
+			TopoDS_Shape part;
+			if (util::boolean_operation(bst, it.Value(), second_operand_shapes, occ_op, part)) {
+				B.Add(C, part);
+			} else {
+				valid_result = false;
+			}
+		}
+		shape = C;
+	} else {
+		valid_result = util::boolean_operation(bst, s1, second_operand_shapes, occ_op, shape);
+	}
+
+#endif
+
+	if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_DIFFERENCE) {
+		// In case of a subtraction, a check on volume is performed.
+		if (valid_result) {
+			const double volume_after_subtraction = util::shape_volume(shape);
+			if ( ALMOST_THE_SAME(first_operand_volume,volume_after_subtraction) )
+				Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",l);
+		} else {
+			Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",l);
+			shape = s1;
+		}
+		// NB: After issuing error the first operand is returned!
+		return true;
+	} else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_UNION && !valid_result) {
+		BRep_Builder B;
+		TopoDS_Compound C;
+		B.MakeCompound(C);
+		B.Add(C, s1);
+		TopTools_ListIteratorOfListOfShape it(second_operand_shapes);
+		for (; it.More(); it.Next()) {
+			B.Add(C, it.Value());
+		}
+		Logger::Message(Logger::LOG_ERROR, "Failed to process union, creating compound:", l);
+		shape = C;
+		return true;
+	} else {
+		return valid_result;
+	}
+	return false;
+}

src/ifcgeom/mapping/IfcBoundingBox.cpp

@@ -0,0 +1,38 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <BRepPrimAPI_MakeBox.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcBoundingBox* l, TopoDS_Shape& shape) {
+	const double dx = l->XDim() * getValue(GV_LENGTH_UNIT);
+	const double dy = l->YDim() * getValue(GV_LENGTH_UNIT);
+	const double dz = l->ZDim() * getValue(GV_LENGTH_UNIT);
+
+	gp_Pnt corner;
+	IfcGeom::Kernel::convert(l->Corner(), corner);
+	BRepPrimAPI_MakeBox builder(corner, dx, dy, dz);
+
+	shape = builder.Solid();
+
+	return true;
+}

src/ifcgeom/mapping/IfcCShapeProfileDef.cpp

@@ -0,0 +1,57 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCShapeProfileDef* l, TopoDS_Shape& 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->InternalFilletRadius();
+	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;
+	}
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	double coords[24] = {-x,-y,x,-y,x,-y+d2,x-d1,-y+d2,x-d1,-y+d1,-x+d1,-y+d1,-x+d1,y-d1,x-d1,y-d1,x-d1,y-d2,x,y-d2,x,y,-x,y};
+	int fillets[8] = {0,1,4,5,6,7,10,11};
+	double radii[8] = {f2,f2,f1,f1,f1,f1,f2,f2};
+	return util::profile_helper(12,coords,doFillet ? 8 : 0,fillets,radii,trsf2d,face);
+}

src/ifcgeom/mapping/IfcCartesianPoint.cpp

@@ -0,0 +1,35 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianPoint* l, gp_Pnt& point) {
+	IN_CACHE(IfcCartesianPoint,l,gp_Pnt,point)
+	std::vector<double> xyz = l->Coordinates();
+	point = gp_Pnt(
+		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
+	);
+	CACHE(IfcCartesianPoint,l,point)
+	return true;
+}

src/ifcgeom/mapping/IfcCartesianTransformationOperator2D.cpp

@@ -0,0 +1,70 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Dir2d.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Ax2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianTransformationOperator2D* l, gp_Trsf2d& trsf) {
+	IN_CACHE(IfcCartesianTransformationOperator2D,l,gp_Trsf2d,trsf)
+
+	gp_Pnt origin;
+	gp_Dir axis1 (1.,0.,0.);
+	gp_Dir axis2 (0.,1.,0.);
+	
+	IfcGeom::Kernel::convert(l->LocalOrigin(),origin);
+	if ( l->Axis1() ) IfcGeom::Kernel::convert(l->Axis1(),axis1);
+	if ( l->Axis2() ) IfcGeom::Kernel::convert(l->Axis2(),axis2);
+	
+	const gp_Pnt2d origin2d(origin.X(), origin.Y());
+	const gp_Dir2d axis12d(axis1.X(), axis1.Y());
+	const gp_Dir2d axis22d(axis2.X(), axis2.Y());
+
+	// A better match to represent the IfcCartesianTransformationOperator2D would
+	// be the gp_Ax22d, but to my knowledge no easy way exists to convert it into
+	// a gp_Trsf2d. Easiest would probably be to simply update the underlying
+	// gp_Mat2d directly.
+	
+	const gp_Ax2d ax2d (origin2d, axis12d);
+	trsf.SetTransformation(ax2d);
+	
+	if ( ax2d.Direction().Rotated(M_PI / 2.).Dot(axis22d) < 0. ) {
+		gp_Trsf2d mirror; mirror.SetMirror(ax2d);
+		trsf.Multiply(mirror);
+	}
+
+	trsf.Invert();
+	if (l->Scale() && !ALMOST_THE_SAME(*l->Scale(), 1.)) {
+		trsf.SetScaleFactor(*l->Scale());
+	}
+
+	if (util::is_identity(trsf, getValue(GV_PRECISION))) {
+		trsf = gp_Trsf2d();
+	}
+
+	CACHE(IfcCartesianTransformationOperator2D,l,trsf)
+	return true;
+}

src/ifcgeom/mapping/IfcCartesianTransformationOperator2DnonUniform.cpp

@@ -0,0 +1,71 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Dir2d.hxx>
+#include <gp_GTrsf2d.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Ax2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianTransformationOperator2DnonUniform* l, gp_GTrsf2d& gtrsf) {
+	IN_CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gp_GTrsf2d,gtrsf)
+
+	gp_Trsf2d trsf;
+	gp_Pnt origin;
+	gp_Dir axis1 (1.,0.,0.);
+	gp_Dir axis2 (0.,1.,0.);
+	
+	IfcGeom::Kernel::convert(l->LocalOrigin(),origin);
+	if ( l->Axis1() ) IfcGeom::Kernel::convert(l->Axis1(),axis1);
+	if ( l->Axis2() ) IfcGeom::Kernel::convert(l->Axis2(),axis2);
+
+	const gp_Pnt2d origin2d(origin.X(), origin.Y());
+	const gp_Dir2d axis12d(axis1.X(), axis1.Y());
+	const gp_Dir2d axis22d(axis2.X(), axis2.Y());
+	
+	const gp_Ax2d ax2d (origin2d, axis12d);
+	trsf.SetTransformation(ax2d);
+	
+	if ( ax2d.Direction().Rotated(M_PI / 2.).Dot(axis22d) < 0. ) {
+		gp_Trsf2d mirror; mirror.SetMirror(ax2d);
+		trsf.Multiply(mirror);
+	}
+
+	trsf.Invert();
+	
+	const double scale1 = l->Scale().get_value_or(1.);
+	const double scale2 = l->Scale2().get_value_or(scale1);
+	gtrsf = gp_GTrsf2d();
+	gtrsf.SetValue(1,1,scale1);
+	gtrsf.SetValue(2,2,scale2);
+	gtrsf.Multiply(trsf);
+
+	if (util::is_identity(gtrsf, getValue(GV_PRECISION))) {
+		gtrsf = gp_GTrsf2d();
+	}
+
+	CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gtrsf)
+	return true;
+}

src/ifcgeom/mapping/IfcCartesianTransformationOperator3D.cpp

@@ -0,0 +1,53 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Ax3.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianTransformationOperator3D* l, gp_Trsf& trsf) {
+	IN_CACHE(IfcCartesianTransformationOperator3D,l,gp_Trsf,trsf)
+	gp_Pnt origin;
+	IfcGeom::Kernel::convert(l->LocalOrigin(),origin);
+	gp_Dir axis1 (1.,0.,0.);
+	gp_Dir axis2 (0.,1.,0.);
+	gp_Dir axis3 (0.,0.,1.);
+	if ( l->Axis1() ) IfcGeom::Kernel::convert(l->Axis1(),axis1);
+	if ( l->Axis2() ) IfcGeom::Kernel::convert(l->Axis2(),axis2);
+	if ( l->Axis3() ) IfcGeom::Kernel::convert(l->Axis3(),axis3);
+	gp_Ax3 ax3 (origin,axis3,axis1);
+	if ( axis2.Dot(ax3.YDirection()) < 0 ) ax3.YReverse();
+	
+	if (!util::axis_equal(ax3, (gp_Ax3) gp::XOY(), getValue(GV_PRECISION))) {
+		trsf.SetTransformation(ax3);
+		trsf.Invert();
+	}
+	
+	if (l->Scale() && !ALMOST_THE_SAME(*l->Scale(), 1.)) {
+		trsf.SetScaleFactor(*l->Scale());
+	}
+
+	CACHE(IfcCartesianTransformationOperator3D,l,trsf)
+	return true;
+}

src/ifcgeom/mapping/IfcCartesianTransformationOperator3DnonUniform.cpp

@@ -0,0 +1,60 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <gp_GTrsf.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Ax3.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCartesianTransformationOperator3DnonUniform* l, gp_GTrsf& gtrsf) {
+	IN_CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gp_GTrsf,gtrsf)
+	gp_Trsf trsf;
+	gp_Pnt origin;
+	IfcGeom::Kernel::convert(l->LocalOrigin(),origin);
+	gp_Dir axis1 (1.,0.,0.);
+	gp_Dir axis2 (0.,1.,0.);
+	gp_Dir axis3 (0.,0.,1.);
+	if ( l->Axis1() ) IfcGeom::Kernel::convert(l->Axis1(),axis1);
+	if ( l->Axis2() ) IfcGeom::Kernel::convert(l->Axis2(),axis2);
+	if ( l->Axis3() ) IfcGeom::Kernel::convert(l->Axis3(),axis3);
+	gp_Ax3 ax3 (origin,axis3,axis1);
+	if ( axis2.Dot(ax3.YDirection()) < 0 ) ax3.YReverse();
+	trsf.SetTransformation(ax3);
+	trsf.Invert();
+	const double scale1 = l->Scale().get_value_or(1.);
+	const double scale2 = l->Scale2().get_value_or(scale1);
+	const double scale3 = l->Scale3().get_value_or(scale1);
+	gtrsf = gp_GTrsf();
+	gtrsf.SetValue(1,1,scale1);
+	gtrsf.SetValue(2,2,scale2);
+	gtrsf.SetValue(3,3,scale3);
+	gtrsf.PreMultiply(trsf);
+
+	if (util::is_identity(gtrsf, getValue(GV_PRECISION))) {
+		gtrsf = gp_GTrsf();
+	}
+
+	CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gtrsf)
+	return true;
+}

src/ifcgeom/mapping/IfcCenterLineProfileDef.cpp

@@ -0,0 +1,84 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Pln.hxx>
+#include <Geom_TrimmedCurve.hxx>
+#include <Geom_OffsetCurve.hxx>
+#include <BRepOffsetAPI_MakeOffset.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRep_Tool.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCenterLineProfileDef* l, TopoDS_Shape& face) {
+	const double d = l->Thickness() * getValue(GV_LENGTH_UNIT) / 2.;
+
+	TopoDS_Wire wire;
+	if (!convert_wire(l->Curve(), wire)) return false;
+
+	// BRepOffsetAPI_MakeOffset insists on creating circular arc
+	// segments for joining the curves that constitute the center
+	// line. This is probably not in accordance with the IFC spec.
+	// Although it does not specify a method to join segments
+	// explicitly, it does dictate 'a constant thickness along the
+	// curve'. Therefore for simple singular wires a quick
+	// alternative is provided that uses a straight join.
+
+	TopExp_Explorer exp(wire, TopAbs_EDGE);
+	TopoDS_Edge edge = TopoDS::Edge(exp.Current());
+	exp.Next();
+
+	if (!exp.More()) {
+		double u1, u2;
+		Handle(Geom_Curve) curve = BRep_Tool::Curve(edge, u1, u2);
+
+		Handle(Geom_TrimmedCurve) trim = new Geom_TrimmedCurve(curve, u1, u2);
+
+		Handle(Geom_OffsetCurve) c1 = new Geom_OffsetCurve(trim,  d, gp::DZ());
+		Handle(Geom_OffsetCurve) c2 = new Geom_OffsetCurve(trim, -d, gp::DZ());
+
+		gp_Pnt c1a, c1b, c2a, c2b;
+		c1->D0(c1->FirstParameter(), c1a);
+		c1->D0(c1->LastParameter(), c1b);
+		c2->D0(c2->FirstParameter(), c2a);
+		c2->D0(c2->LastParameter(), c2b);
+
+		BRepBuilderAPI_MakeWire mw;
+		mw.Add(BRepBuilderAPI_MakeEdge(c1));
+		mw.Add(BRepBuilderAPI_MakeEdge(c1a, c2a));
+		mw.Add(BRepBuilderAPI_MakeEdge(c2));
+		mw.Add(BRepBuilderAPI_MakeEdge(c2b, c1b));
+		
+		face = BRepBuilderAPI_MakeFace(mw.Wire());
+	} else {
+		BRepOffsetAPI_MakeOffset offset(BRepBuilderAPI_MakeFace(gp_Pln(gp::Origin(), gp::DZ())));
+		offset.AddWire(wire);
+		offset.Perform(d);
+		face = BRepBuilderAPI_MakeFace(TopoDS::Wire(offset));
+	}
+	return true;
+}

src/ifcgeom/mapping/IfcCircle.cpp

@@ -0,0 +1,45 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <Geom_Circle.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircle* l, Handle(Geom_Curve)& curve) {
+	const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
+	if ( r < ALMOST_ZERO ) { 
+		Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l);
+		return false;
+	}
+	gp_Trsf trsf;
+	IfcSchema::IfcAxis2Placement* placement = l->Position();
+	if (placement->as<IfcSchema::IfcAxis2Placement3D>()) {
+		IfcGeom::Kernel::convert(placement->as<IfcSchema::IfcAxis2Placement3D>(),trsf);
+	} else {
+		gp_Trsf2d trsf2d;
+		IfcGeom::Kernel::convert(placement->as<IfcSchema::IfcAxis2Placement2D>(),trsf2d);
+		trsf = trsf2d;
+	}
+	gp_Ax2 ax = gp_Ax2().Transformed(trsf);
+	curve = new Geom_Circle(ax, r);
+	return true;
+}

src/ifcgeom/mapping/IfcCircleHollowProfileDef.cpp

@@ -0,0 +1,67 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include <Geom_Circle.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <ShapeFix_Shape.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircleHollowProfileDef* l, TopoDS_Shape& 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;
+	}
+	
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	gp_Ax2 ax = gp_Ax2().Transformed(trsf2d);
+
+	BRepBuilderAPI_MakeWire outer;	
+	Handle(Geom_Circle) outerCircle = new Geom_Circle(ax, r);
+	outer.Add(BRepBuilderAPI_MakeEdge(outerCircle));
+	BRepBuilderAPI_MakeFace mf(outer.Wire(), false);
+
+	BRepBuilderAPI_MakeWire inner;	
+	Handle(Geom_Circle) innerCirlce = new Geom_Circle(ax, r-t);
+	inner.Add(BRepBuilderAPI_MakeEdge(innerCirlce));
+	mf.Add(inner);
+
+	ShapeFix_Shape sfs(mf.Face());
+	sfs.Perform();
+	face = TopoDS::Face(sfs.Shape());	
+	return true;		
+}

src/ifcgeom/mapping/IfcCircleProfileDef.cpp

@@ -0,0 +1,59 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include <Geom_Circle.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircleProfileDef* l, TopoDS_Shape& 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;
+	}
+	
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+	gp_Ax2 ax = gp_Ax2().Transformed(trsf2d);
+
+	
+	Handle(Geom_Circle) circle = new Geom_Circle(ax, r);
+	TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(circle);
+
+	BRepBuilderAPI_MakeWire w;
+	w.Add(edge);
+
+	TopoDS_Face f;
+	bool success = util::convert_wire_to_face(w, f, {false, false, 0., 0.});
+	if (success) face = f;
+	return success;
+}

src/ifcgeom/mapping/IfcCompositeCurve.cpp

@@ -0,0 +1,183 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#include "../ifcgeom_schema_agnostic/wire_builder.h"
+
+#define _USE_MATH_DEFINES
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire& 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
+		TopoDS_Wire wire_radians, wire_degrees;
+        try {
+		    succes_radians = IfcGeom::Kernel::convert(l,wire_radians);
+        } catch (const std::exception& e) {
+			Logger::Notice(e);
+		} catch (const Standard_Failure& e) {
+			if (e.GetMessageString() && strlen(e.GetMessageString())) {
+				Logger::Notice(e.GetMessageString());
+			} else {
+				Logger::Notice("Unknown error using radians");
+			}
+		} catch (...) {
+			Logger::Notice("Unknown error using radians");
+		}
+
+		// Now try degrees
+		setValue(GV_PLANEANGLE_UNIT,0.0174532925199433);
+        try {
+		    succes_degrees = IfcGeom::Kernel::convert(l,wire_degrees);
+        } catch (const std::exception& e) {
+			Logger::Notice(e);
+		} catch (const Standard_Failure& e) {
+			if (e.GetMessageString() && strlen(e.GetMessageString())) {
+				Logger::Notice(e.GetMessageString());
+			} else {
+				Logger::Notice("Unknown error using degrees");
+			}
+		} catch (...) {
+			Logger::Notice("Unknown error using degrees");
+		}
+
+		// 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.Closed() && ! wire_radians.Closed() ) {
+				use_degrees = true;
+			} else if ( wire_radians.Closed() && ! wire_degrees.Closed() ) {
+				use_radians = true;
+			} else {
+				// No heuristic left to prefer the one over the other,
+				// apparently both variants are equally successful.
+				// 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;
+	}
+
+#ifdef SCHEMA_HAS_IfcSegment
+	// 4x3
+	IfcSchema::IfcSegment::list::ptr segments = l->Segments();
+#else
+	IfcSchema::IfcCompositeCurveSegment::list::ptr segments = l->Segments();
+#endif
+
+	TopTools_ListOfShape converted_segments;
+	
+	for (auto it = segments->begin(); it != segments->end(); ++it) {
+
+		if (!(*it)->declaration().is(IfcSchema::IfcCompositeCurveSegment::Class())) {
+			Logger::Error("Not implemented", *it);
+			return false;
+		}
+
+		IfcSchema::IfcCurve* curve = ((IfcSchema::IfcCompositeCurveSegment*)(*it))->ParentCurve();
+
+		// The type of ParentCurve is IfcCurve, but the documentation says:
+		// ParentCurve: The *bounded curve* which defines the geometry of the segment. 
+		// At least let's exclude IfcLine as an infinite linear segment
+		// definitely does not make any sense.
+		TopoDS_Wire segment;
+
+		if (curve->as<IfcSchema::IfcLine>()) {
+			Logger::Notice("Infinite IfcLine used as ParentCurve of segment, treating as a segment", *it);
+			Handle_Geom_Curve handle;
+			convert_curve(curve, handle);
+			double u0 = 0.0;
+			double u1 = curve->as<IfcSchema::IfcLine>()->Dir()->Magnitude() * getValue(GV_LENGTH_UNIT);
+			if (u1 < getValue(GV_PRECISION)) {
+				Logger::Warning("Segment length below tolerance", *it);
+			}
+			BRepBuilderAPI_MakeEdge me(handle, u0, u1);
+			if (me.IsDone()) {
+				BRep_Builder B;
+				B.MakeWire(segment);
+				B.Add(segment, me.Edge());
+			}
+		} else if (!convert_wire(curve, segment)) {
+			const bool failed_on_purpose = curve->as<IfcSchema::IfcPolyline>() && !segment.IsNull();
+			Logger::Message(failed_on_purpose ? Logger::LOG_WARNING : Logger::LOG_ERROR, "Failed to convert curve:", curve);
+			continue;
+		}
+
+		if (!((IfcSchema::IfcCompositeCurveSegment*)(*it))->SameSense()) {
+			segment.Reverse();
+		}
+
+		ShapeFix_ShapeTolerance FTol;
+		FTol.SetTolerance(segment, getValue(GV_PRECISION), TopAbs_WIRE);
+
+		converted_segments.Append(segment);
+
+	}
+
+	if (converted_segments.Extent() == 0) {
+		Logger::Message(Logger::LOG_ERROR, "No segment succesfully converted:", l);
+		return false;
+	}
+
+	BRepBuilderAPI_MakeWire w;
+	TopoDS_Vertex wire_first_vertex, wire_last_vertex, edge_first_vertex, edge_last_vertex;
+
+	TopTools_ListIteratorOfListOfShape it(converted_segments);
+
+	aggregate_of_instance::ptr profile = l->data().getInverse(&IfcSchema::IfcProfileDef::Class(), -1);
+	const bool force_close = profile && profile->size() > 0;
+
+	util::wire_builder bld(getValue(GV_PRECISION), l);
+	util::shape_pair_enumerate(it, bld, force_close);
+	wire = bld.wire();
+
+	return true;
+}

src/ifcgeom/mapping/IfcCompositeProfileDef.cpp

@@ -0,0 +1,53 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <TopoDS_Face.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeProfileDef* l, TopoDS_Shape& face) {
+	// BRepBuilderAPI_MakeFace mf;
+
+	TopoDS_Compound compound;
+	BRep_Builder builder;
+	builder.MakeCompound(compound);
+
+	IfcSchema::IfcProfileDef::list::ptr profiles = l->Profiles();
+	//bool first = true;
+	for (IfcSchema::IfcProfileDef::list::it it = profiles->begin(); it != profiles->end(); ++it) {
+		TopoDS_Face f;
+		if (convert_face(*it, f)) {
+			builder.Add(compound, f);
+			/* TopExp_Explorer exp(f, TopAbs_WIRE);
+			for (; exp.More(); exp.Next()) {
+				const TopoDS_Wire& wire = TopoDS::Wire(exp.Current());
+				if (first) {
+					mf.Init(BRepBuilderAPI_MakeFace(wire));
+				} else {
+					mf.Add(wire);
+				}
+				first = false;
+			} */
+		}
+	}
+
+	face = compound;
+	return !face.IsNull();
+}

src/ifcgeom/mapping/IfcConnectedFaceSet.cpp

@@ -0,0 +1,117 @@
+/********************************************************************************
+ *                                                                              *
+ * 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_schema_agnostic/base_utils.h"
+
+#include "../ifcgeom/IfcGeom.h"
+
+#include <TopoDS.hxx>
+#include <TopoDS_Face.hxx>
+#include <memory>
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Shape& shape) {
+	std::unique_ptr<faceset_helper<>> helper_scope;
+
+	IfcSchema::IfcCartesianPoint::list::ptr points = IfcParse::traverse((IfcUtil::IfcBaseClass*) l)->as<IfcSchema::IfcCartesianPoint>();
+	std::vector<const IfcSchema::IfcCartesianPoint*> points_(points->begin(), points->end());
+
+	IfcSchema::IfcPolyLoop::list::ptr loops = IfcParse::traverse((IfcUtil::IfcBaseClass*)l)->as<IfcSchema::IfcPolyLoop>();
+	std::vector<const IfcSchema::IfcPolyLoop*> loops_(loops->begin(), loops->end());
+
+	helper_scope.reset(new faceset_helper<>(
+		this,
+		points_,
+		loops_,
+		l->declaration().is(IfcSchema::IfcClosedShell::Class())
+		));
+
+	faceset_helper_ = helper_scope.get();
+
+	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;
+		TopoDS_Face face;
+
+		try {
+			success = convert_face(*it, face);
+		} 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 face");
+			}
+		} catch (...) {
+			Logger::Error("Unknown error creating face");
+		}
+
+		if (!success) {
+			Logger::Message(Logger::LOG_WARNING, "Failed to convert face:", (*it));
+			continue;
+		}
+
+		if (face.ShapeType() == TopAbs_COMPOUND) {
+			TopoDS_Iterator face_it(face, false);
+			for (; face_it.More(); face_it.Next()) {
+				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 (util::face_area(triangle) > min_face_area) {
+						face_list.Append(triangle);
+					} else {
+						Logger::Message(Logger::LOG_WARNING, "Degenerate face:", (*it));
+					}
+				}
+			}
+		} else {
+			if (util::face_area(face) > min_face_area) {
+				face_list.Append(face);
+			} else {
+				Logger::Message(Logger::LOG_WARNING, "Degenerate face:", (*it));
+			}
+		}
+	}
+
+	if (face_list.Extent() == 0) {
+		return false;
+	}
+
+	if (face_list.Extent() > getValue(GV_MAX_FACES_TO_ORIENT) || !util::create_solid_from_faces(face_list, shape, getValue(GV_PRECISION))) {
+		TopoDS_Compound compound;
+		BRep_Builder builder;
+		builder.MakeCompound(compound);
+
+		TopTools_ListIteratorOfListOfShape face_iterator;
+		for (face_iterator.Initialize(face_list); face_iterator.More(); face_iterator.Next()) {
+			builder.Add(compound, face_iterator.Value());
+		}
+		shape = compound;
+	}
+
+	return true;
+}

src/ifcgeom/mapping/IfcCraneRailAShapeProfileDef.cpp

@@ -0,0 +1,66 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcCraneRailAShapeProfileDef
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCraneRailAShapeProfileDef* l, TopoDS_Shape& face) {
+	double oh = l->OverallHeight() * getValue(GV_LENGTH_UNIT);
+	double bw2 = l->BaseWidth2() * getValue(GV_LENGTH_UNIT);
+	double hw = l->HeadWidth() * getValue(GV_LENGTH_UNIT);
+	double hd2 = l->HeadDepth2() * getValue(GV_LENGTH_UNIT);
+	double hd3 = l->HeadDepth3() * getValue(GV_LENGTH_UNIT);
+	double wt = l->WebThickness() * getValue(GV_LENGTH_UNIT);
+	double bw4 = l->BaseWidth4() * getValue(GV_LENGTH_UNIT);
+	double bd1 = l->BaseDepth1() * getValue(GV_LENGTH_UNIT);
+	double bd2 = l->BaseDepth2() * getValue(GV_LENGTH_UNIT);
+	double bd3 = l->BaseDepth3() * getValue(GV_LENGTH_UNIT);
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	double coords[28] = {
+		-hw / 2., +oh / 2.,
+		-hw / 2., +oh / 2. - hd3,
+		-wt / 2., +oh / 2. - hd2,
+		-wt / 2., -oh / 2. + bd2,
+		-bw4 / 2., -oh / 2. + bd3,
+		-bw2 / 2., -oh / 2. + bd1,
+		-bw2 / 2., -oh / 2.,
+		+bw2 / 2., -oh / 2.,
+		+bw2 / 2., -oh / 2. + bd1,
+		+bw4 / 2., -oh / 2. + bd3,
+		+wt / 2., -oh / 2. + bd2,
+		+wt / 2., +oh / 2. - hd2,
+		+hw / 2., +oh / 2. - hd3,
+		+hw / 2., +oh / 2.
+	};
+
+	return util::profile_helper(14, coords, 0, 0, 0, trsf2d, face);
+}
+#endif

src/ifcgeom/mapping/IfcCsgSolid.cpp

@@ -0,0 +1,26 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCsgSolid* l, TopoDS_Shape& shape) {
+	return convert_shape(l->TreeRootExpression(), shape);
+}

src/ifcgeom/mapping/IfcCurveBoundedPlane.cpp

@@ -0,0 +1,69 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Pln.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <ShapeFix_Shape.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCurveBoundedPlane* l, TopoDS_Shape& face) {
+	gp_Pln pln;
+	if (!IfcGeom::Kernel::convert(l->BasisSurface(), pln)) {
+		return false;
+	}
+
+	gp_Trsf trsf;
+	trsf.SetTransformation(pln.Position(), gp::XOY());
+	
+	TopoDS_Wire outer;
+	if (!convert_wire(l->OuterBoundary(), outer)) {
+		return false;
+	}
+	
+	BRepBuilderAPI_MakeFace mf(outer);
+
+	if (!mf.IsDone() || mf.Shape().IsNull()) {
+		Logger::Error("Invalid outer boundary:", l->OuterBoundary());
+		return false;
+	}
+	
+	IfcSchema::IfcCurve::list::ptr boundaries = l->InnerBoundaries();
+
+	for (IfcSchema::IfcCurve::list::it it = boundaries->begin(); it != boundaries->end(); ++it) {
+		TopoDS_Wire inner;
+		if (convert_wire(*it, inner)) {
+			mf.Add(inner);
+		}
+	}
+
+	ShapeFix_Shape sfs(mf.Face());
+	sfs.Perform();
+
+	// `trsf` consitutes the placement of the plane and therefore has unit scale factor
+	face = TopoDS::Face(sfs.Shape()).Moved(trsf);
+	
+	return true;
+}

src/ifcgeom/mapping/IfcCylindricalSurface.cpp

@@ -0,0 +1,39 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <Geom_CylindricalSurface.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS_Face.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcCylindricalSurface
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcCylindricalSurface* l, TopoDS_Shape& face) {
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+	
+	// IfcElementarySurface.Position has unit scale factor
+	face = BRepBuilderAPI_MakeFace(new Geom_CylindricalSurface(gp::XOY(), l->Radius() * getValue(GV_LENGTH_UNIT)), getValue(GV_PRECISION)).Face().Moved(trsf);
+	return true;
+}
+
+#endif

src/ifcgeom/mapping/IfcDerivedProfileDef.cpp

@@ -0,0 +1,38 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <TopoDS_Face.hxx>
+#include <BRepBuilderAPI_Transform.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcDerivedProfileDef* l, TopoDS_Shape& face) {
+	TopoDS_Face f;
+	gp_Trsf2d trsf2d;
+	if (convert_face(l->ParentProfile(), f) && IfcGeom::Kernel::convert(l->Operator(), trsf2d)) {
+		gp_Trsf trsf = trsf2d;
+		face = BRepBuilderAPI_Transform(f, trsf).Shape();
+		return true;
+	} else {
+		return false;
+	}
+}

src/ifcgeom/mapping/IfcDirection.cpp

@@ -0,0 +1,35 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Dir.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcDirection* l, gp_Dir& dir) {
+	IN_CACHE(IfcDirection,l,gp_Dir,dir)
+	std::vector<double> xyz = l->DirectionRatios();
+	dir = gp_Dir(
+		xyz.size()     ? xyz[0] : 0.0f,
+		xyz.size() > 1 ? xyz[1] : 0.0f,
+		xyz.size() > 2 ? xyz[2] : 0.0f
+	);
+	CACHE(IfcDirection,l,dir)
+	return true;
+}

src/ifcgeom/mapping/IfcEdge.cpp

@@ -0,0 +1,54 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS_Wire.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define _USE_MATH_DEFINES
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdge* l, TopoDS_Wire& result) {
+	if (!l->EdgeStart()->declaration().is(IfcSchema::IfcVertexPoint::Class()) || !l->EdgeEnd()->declaration().is(IfcSchema::IfcVertexPoint::Class())) {
+		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->declaration().is(IfcSchema::IfcCartesianPoint::Class()) || !pnt2->declaration().is(IfcSchema::IfcCartesianPoint::Class())) {
+		Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l);
+		return false;
+	}
+	
+	gp_Pnt p1, p2;
+	if (!convert(((IfcSchema::IfcCartesianPoint*)pnt1), p1) ||
+		!convert(((IfcSchema::IfcCartesianPoint*)pnt2), p2))
+	{
+		return false;
+	}
+
+	BRepBuilderAPI_MakeWire mw;
+	mw.Add(BRepBuilderAPI_MakeEdge(p1, p2));
+
+	result = mw.Wire();
+	return true;
+}

src/ifcgeom/mapping/IfcEdgeCurve.cpp

@@ -0,0 +1,118 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRep_Tool.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#include "../ifcgeom_schema_agnostic/wire_builder.h"
+
+#define _USE_MATH_DEFINES
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeCurve* l, TopoDS_Wire& result) {
+	IfcSchema::IfcPoint* pnt1 = ((IfcSchema::IfcVertexPoint*) l->EdgeStart())->VertexGeometry();
+	IfcSchema::IfcPoint* pnt2 = ((IfcSchema::IfcVertexPoint*) l->EdgeEnd())->VertexGeometry();
+	if (!pnt1->declaration().is(IfcSchema::IfcCartesianPoint::Class()) || !pnt2->declaration().is(IfcSchema::IfcCartesianPoint::Class())) {
+		Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l);
+		return false;
+	}
+	
+	gp_Pnt p1, p2;
+	if (!IfcGeom::Kernel::convert(((IfcSchema::IfcCartesianPoint*)pnt1), p1) ||
+		!IfcGeom::Kernel::convert(((IfcSchema::IfcCartesianPoint*)pnt2), p2))
+	{
+		return false;
+	}
+	
+	BRepBuilderAPI_MakeWire mw;
+	Handle_Geom_Curve crv;
+
+	// The lack of a clear separation between topological and geometrical entities
+	// is starting to get problematic. If the underlying curve is bounded it is
+	// assumed that a topological wire can be crafted from it. After which an
+	// attempt is made to reconstruct it from the individual curves and the vertices
+	// of the IfcEdgeCurve.
+	const bool is_bounded = l->EdgeGeometry()->declaration().is(IfcSchema::IfcBoundedCurve::Class());
+
+	if (!is_bounded && convert_curve(l->EdgeGeometry(), crv)) {
+		TopoDS_Edge e;
+		if (util::create_edge_over_curve_with_log_messages(crv, getValue(GV_PRECISION), p1, p2, e)) {
+			mw.Add(e);
+			result = mw;
+			return true;
+		} else {
+			return false;
+		}
+	} else if (is_bounded && convert_wire(l->EdgeGeometry(), result)) {
+		if (!l->SameSense()) {
+			result.Reverse();
+		}
+		
+		bool first = true;
+		TopExp_Explorer exp(result, TopAbs_EDGE);
+		
+		while (exp.More()) {
+			const TopoDS_Edge& ed = TopoDS::Edge(exp.Current());
+			Standard_Real u1, u2;
+			Handle(Geom_Curve) ecrv = BRep_Tool::Curve(ed, u1, u2);
+			exp.Next();
+			const bool last = !exp.More();
+
+			gp_Pnt a, b;
+
+			if (first && last) {
+				a = p1;
+				b = p2;				
+			} else if (first) {
+				a = p1;
+				ecrv->D0(u2, b);
+			} else if (last) {
+				ecrv->D0(u1, a);
+				b = p2;
+			} else {
+				BRepBuilderAPI_MakeEdge me(ecrv, u1, u2);
+				if (!me.IsDone()) {
+					return false;
+				}
+				mw.Add(me.Edge());
+				first = false;
+				continue;
+			}
+
+			TopoDS_Edge e;
+			if (util::create_edge_over_curve_with_log_messages(ecrv, getValue(GV_PRECISION), a, b, e)) {
+				mw.Add(e);
+			} else {
+				return false;
+			}
+
+			first = false;
+		}
+		result = mw;
+		return true;
+	} else {
+		return false;
+	}
+}

src/ifcgeom/mapping/IfcEdgeLoop.cpp

@@ -0,0 +1,42 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define _USE_MATH_DEFINES
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeLoop* l, TopoDS_Wire& result) {
+	IfcSchema::IfcOrientedEdge::list::ptr li = l->EdgeList();
+	BRepBuilderAPI_MakeWire mw;
+	for (IfcSchema::IfcOrientedEdge::list::it it = li->begin(); it != li->end(); ++it) {
+		TopoDS_Wire w;
+		if (convert_wire(*it, w)) {
+			mw.Add(TopoDS::Edge(TopoDS_Iterator(w).Value()));
+		}
+	}
+	if (!mw.IsDone()) {
+		return false;
+	}
+	result = mw.Wire();
+	return true;
+}

src/ifcgeom/mapping/IfcEllipse.cpp

@@ -0,0 +1,58 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <Geom_Ellipse.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipse* l, Handle(Geom_Curve)& curve) {
+	double x = l->SemiAxis1() * getValue(GV_LENGTH_UNIT);
+	double y = l->SemiAxis2() * getValue(GV_LENGTH_UNIT);
+	if (x < ALMOST_ZERO || y < ALMOST_ZERO) { 
+		Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l);
+		return false;
+	}
+	// Open Cascade does not allow ellipses of which the minor radius
+	// is greater than the major radius. Hence, in this case, the
+	// ellipse is rotated. Note that special care needs to be taken
+	// when creating a trimmed curve off of an ellipse like this.
+	const bool rotated = y > x;
+	gp_Trsf trsf;
+	
+	IfcSchema::IfcAxis2Placement* placement = l->Position();
+	if (placement->as<IfcSchema::IfcAxis2Placement3D>()) {
+		IfcGeom::Kernel::convert(placement->as<IfcSchema::IfcAxis2Placement3D>(), trsf);
+	} else {
+		gp_Trsf2d trsf2d;
+		IfcGeom::Kernel::convert(placement->as<IfcSchema::IfcAxis2Placement2D>(), trsf2d);
+		trsf = trsf2d;
+	}
+
+	gp_Ax2 ax = gp_Ax2();
+	if (rotated) {
+		ax.Rotate(ax.Axis(), M_PI / 2.);
+		std::swap(x, y);
+	}
+	ax.Transform(trsf);
+	curve = new Geom_Ellipse(ax, x, y);
+	return true;
+}

src/ifcgeom/mapping/IfcEllipseProfileDef.cpp

@@ -0,0 +1,67 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include <Geom_Ellipse.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipseProfileDef* l, TopoDS_Shape& 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;
+	}
+
+	const bool rotated = ry > rx;
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	gp_Ax2 ax = gp_Ax2();
+	if (rotated) {
+		ax.Rotate(ax.Axis(), M_PI / 2.);
+		std::swap(rx, ry);
+	}
+	ax.Transform(trsf2d);
+
+	BRepBuilderAPI_MakeWire w;
+	Handle(Geom_Ellipse) ellipse = new Geom_Ellipse(ax, rx, ry);
+	TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(ellipse);
+	w.Add(edge);
+
+	TopoDS_Face f;
+	bool success = util::convert_wire_to_face(w, f, {false, false, 0., 0.});
+	if (success) face = f;
+	return success;
+}

src/ifcgeom/mapping/IfcExtrudedAreaSolid.cpp

@@ -0,0 +1,107 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Vec.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Trsf.hxx>
+#include <BRepPrimAPI_MakePrism.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+// uncomment if you'd like negative or close to zero extrusion depths to succeed
+// #define PERMISSIVE_EXTRUSION
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolid* l, TopoDS_Shape& 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);
+#ifndef PERMISSIVE_EXTRUSION
+		return false;
+#endif
+	}
+
+	TopoDS_Shape face;
+	if ( !convert_face(l->SweptArea(),face) ) return false;
+
+	gp_Trsf trsf;
+	bool has_position = true;
+#ifdef SCHEMA_IfcSweptAreaSolid_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf);
+	}
+
+#ifdef PERMISSIVE_EXTRUSION
+	if (abs(height) < getValue(GV_PRECISION)) {
+		shape = face;
+
+		if (has_position && !shape.IsNull()) {
+			// IfcSweptAreaSolid.Position (trsf) is an IfcAxis2Placement3D
+			// and therefore has a unit scale factor
+			shape.Move(trsf);
+		}
+
+		return true;
+	}
+#endif
+
+	gp_Dir dir;
+	convert(l->ExtrudedDirection(),dir);
+
+	shape.Nullify();
+
+	/*
+	// @nb This logic was probably flawed always as this does not by itself result in a valid compsolid...
+	if (face.ShapeType() == TopAbs_COMPOUND) {
+		
+		// For compounds (most likely the result of a IfcCompositeProfileDef) 
+		// create a compound solid shape.
+		
+		TopExp_Explorer exp(face, TopAbs_FACE);
+		
+		TopoDS_CompSolid compound;
+		BRep_Builder builder;
+		builder.MakeCompSolid(compound);
+		
+		int num_faces_extruded = 0;
+		for (; exp.More(); exp.Next(), ++num_faces_extruded) {
+			builder.Add(compound, BRepPrimAPI_MakePrism(exp.Current(), height*dir));
+		}
+
+		if (num_faces_extruded) {
+			shape = compound;
+		}
+
+	}
+	*/
+	
+	if (shape.IsNull()) {	
+		shape = BRepPrimAPI_MakePrism(face, height*dir);
+	}
+
+	if (has_position && !shape.IsNull()) {
+		// IfcSweptAreaSolid.Position (trsf) is an IfcAxis2Placement3D
+		// and therefore has a unit scale factor
+		shape.Move(trsf);
+	}
+
+	return !shape.IsNull();
+}

src/ifcgeom/mapping/IfcExtrudedAreaSolidTapered.cpp

@@ -0,0 +1,141 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Trsf.hxx>
+#include <BRepOffsetAPI_MakePipeShell.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#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)) {
+		Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l);
+		return false;
+	}
+
+	TopoDS_Shape face1, face2;
+	if (!convert_face(l->SweptArea(), face1)) return false;
+	if (!convert_face(l->EndSweptArea(), face2)) return false;
+
+	gp_Trsf trsf;
+	bool has_position = true;
+#ifdef SCHEMA_IfcSweptAreaSolid_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf);
+	}
+
+	gp_Dir dir;
+	convert(l->ExtrudedDirection(), dir);
+
+	gp_Trsf end_profile;
+	end_profile.SetTranslation(height * dir);
+
+	TopoDS_Edge spine_edge = BRepBuilderAPI_MakeEdge(gp_Pnt(), gp_Pnt((height * dir).XYZ())).Edge();
+	TopoDS_Wire wire = BRepBuilderAPI_MakeWire(spine_edge).Wire();
+
+	shape.Nullify();
+
+	TopExp_Explorer exp1(face1, TopAbs_WIRE);
+	TopExp_Explorer exp2(face2, TopAbs_WIRE);
+
+	TopoDS_Vertex v1, v2;
+	TopExp::Vertices(wire, v1, v2);
+
+	TopoDS_Shape shell;
+	TopoDS_Compound compound;
+	BRep_Builder compound_builder;
+
+	for (; exp1.More() && exp2.More(); exp1.Next(), exp2.Next()) {
+		const TopoDS_Wire& w1 = TopoDS::Wire(exp1.Current());
+		const TopoDS_Wire& w2 = TopoDS::Wire(exp2.Current());
+
+		BRepOffsetAPI_MakePipeShell builder(wire);
+		builder.Add(w1, v1);
+		builder.Add(w2.Moved(end_profile), v2);
+
+		TopoDS_Shape result = builder.Shape();
+
+		TopTools_ListOfShape li;
+		util::shape_to_face_list(result, li);
+		li.Append(BRepBuilderAPI_MakeFace(w1).Face().Reversed());
+		li.Append(BRepBuilderAPI_MakeFace(w2).Face().Moved(end_profile));
+		
+		util::create_solid_from_faces(li, result, true);
+
+		// @todo ugly hack
+
+		// The reason for this distinction is that at this point of the loop we're not sure anymore
+		// whether this was constructed from an inner or outer bound. So rather than iterating over
+		// wires of `face1` and `face2` we should iterate over the faces and then properly check with
+		// BRepTools::OuterBound().
+		// Currently this distinction happens based on profile type which is not robust and probably
+		// not complete.
+		if (shell.IsNull()) {
+			shell = result;
+		} else if (l->SweptArea()->declaration().is(IfcSchema::IfcCircleHollowProfileDef::Class()) ||
+			l->SweptArea()->declaration().is(IfcSchema::IfcRectangleHollowProfileDef::Class()) ||
+			l->SweptArea()->declaration().is(IfcSchema::IfcArbitraryProfileDefWithVoids::Class()))
+		{
+			// @todo properly check for failure and all.
+			shell = BRepAlgoAPI_Cut(shell, result).Shape();
+		} else {
+			if (compound.IsNull()) {
+				compound_builder.MakeCompound(compound);
+				compound_builder.Add(compound, shell);
+			}
+			compound_builder.Add(compound, result);
+		}
+	}
+
+	if (!compound.IsNull()) {
+		shell = compound;
+	}
+
+	shape = shell;
+
+	if (exp1.More() != exp2.More()) {
+		Logger::Message(Logger::LOG_ERROR, "Inconsistent profiles encountered for:", l);
+	}
+
+	if (has_position && !shape.IsNull()) {
+		// IfcSweptAreaSolid.Position (trsf) is an IfcAxis2Placement3D
+		// and therefore has a unit scale factor
+		shape.Move(trsf);
+	}
+
+	return !shape.IsNull();
+}
+#endif

src/ifcgeom/mapping/IfcFace.cpp

@@ -0,0 +1,337 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Vec.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pln.hxx>
+#include <Geom_Line.hxx>
+#include <Geom_Plane.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopoDS_Iterator.hxx>
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <BRep_Tool.hxx>
+#include <TopTools_DataMapOfShapeInteger.hxx>
+#include <BRepLib_FindSurface.hxx>
+#include <ShapeExtend_MsgRegistrator.hxx>
+#include <Message_Msg.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#include "../ifcgeom_schema_agnostic/face_definition.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& result) {
+	IfcSchema::IfcFaceBound::list::ptr bounds = l->Bounds();
+
+	util::face_definition fd;
+
+	const bool is_face_surface = l->declaration().is(IfcSchema::IfcFaceSurface::Class());
+
+	if (is_face_surface) {
+		IfcSchema::IfcFaceSurface* fs = (IfcSchema::IfcFaceSurface*) l;
+		fs->FaceSurface();
+		// FIXME: Surfaces are interpreted as a TopoDS_Shape
+		TopoDS_Shape surface_shape;
+		if (!convert_shape(fs->FaceSurface(), surface_shape)) return false;
+
+		// FIXME: Assert this obtaines the only face
+		TopExp_Explorer exp(surface_shape, TopAbs_FACE);
+		if (!exp.More()) return false;
+
+		TopoDS_Face surface = TopoDS::Face(exp.Current());
+		fd.surface() = BRep_Tool::Surface(surface);
+	}
+	
+	const int num_bounds = bounds->size();
+	int num_outer_bounds = 0;
+
+	for (IfcSchema::IfcFaceBound::list::it it = bounds->begin(); it != bounds->end(); ++it) {
+		IfcSchema::IfcFaceBound* bound = *it;
+		if (bound->declaration().is(IfcSchema::IfcFaceOuterBound::Class())) num_outer_bounds ++;
+	}
+
+	// The number of outer bounds should be one according to the schema. Also Open Cascade
+	// expects this, but it is not strictly checked. Regardless, if the number is greater,
+	// the face will still be processed as long as there are no holes. A compound of faces
+	// is returned in that case.
+	if (num_bounds > 1 && num_outer_bounds > 1 && num_bounds != num_outer_bounds) {
+		Logger::Message(Logger::LOG_ERROR, "Invalid configuration of boundaries for:", l);
+		return false;
+	}
+
+	if (num_outer_bounds > 1) {
+		Logger::Message(Logger::LOG_WARNING, "Multiple outer boundaries for:", l);
+		fd.all_outer() = true;
+	}
+
+	TopTools_DataMapOfShapeInteger wire_senses;
+	
+	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 =
+				!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;
+
+			TopTools_ListOfShape wires;
+			TopoDS_Wire wire;
+			if (faceset_helper_ && loop->as<IfcSchema::IfcPolyLoop>()) {
+				if (!faceset_helper_->wires(loop->as<IfcSchema::IfcPolyLoop>(), wires)) {
+					Logger::Message(Logger::LOG_WARNING, "Face boundary loop not included", loop);
+					continue;
+				}
+			} else {
+				if (convert_wire(loop, wire)) {
+					wires.Append(wire);
+				} else {
+					Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary loop", loop);
+					return false;
+				}
+			}
+
+			if (wires.Size() > 1) {
+				Logger::Message(Logger::LOG_WARNING, "Face loop definition results in " + std::to_string(wires.Size()) + " loops", loop);
+				if (!is_interior) {
+					fd.all_outer() = true;
+				}
+			}
+
+			for (auto& w : wires) {
+				if (!same_sense) {
+					w.Reverse();
+				}
+
+				wire_senses.Bind(w.Oriented(TopAbs_FORWARD), same_sense ? TopAbs_FORWARD : TopAbs_REVERSED);
+
+				fd.wires().emplace_back(TopoDS::Wire(w));
+			}
+		}
+	}
+
+	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 (util::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 (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;
+					fd.surface() = new Geom_Plane(c1->Position().Location(), n);
+				}
+			} else {
+				gp_Pln pln;
+				if (util::approximate_plane_through_wire(wire, pln, getValue(GV_PRECISION))) {
+					fd.surface() = new Geom_Plane(pln);
+				}
+			}
+		}
+	}	
+
+	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;
+				auto r = util::triangulate_wire({ w }, fl);
+				if (r == util::TRIANGULATE_WIRE_FAIL) {
+					continue;
+				}
+				face_list.Append(fl);
+				if (faceset_helper_ && r == util::TRIANGULATE_WIRE_NON_MANIFOLD) {
+					faceset_helper_->non_manifold() = true;
+				}
+			}
+		} else {
+			auto r = util::triangulate_wire(fd.wires(), face_list);
+			if (r != util::TRIANGULATE_WIRE_FAIL) {
+				if (faceset_helper_ && r == util::TRIANGULATE_WIRE_NON_MANIFOLD) {
+					faceset_helper_->non_manifold() = true;
+				}
+			}
+		}
+	} else if (!fd.all_outer()) {
+		BRepBuilderAPI_MakeFace mf(fd.surface(), fd.outer_wire());
+		TopoDS_Face f = mf.Face();
+
+		if (mf.IsDone()) {
+			if (std::distance(fd.inner_wires().first, fd.inner_wires().second)) {
+				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 {
+				face_list.Append(f);
+			}
+		}		
+	} 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()) {
+				ShapeFix_Shape sfs(it.Value());
+
+				Handle(ShapeExtend_MsgRegistrator) msg;
+				msg = new ShapeExtend_MsgRegistrator;
+				sfs.SetMsgRegistrator(msg);
+
+				sfs.Perform();
+				it.Value() = sfs.Shape();
+				
+				ShapeExtend_DataMapIteratorOfDataMapOfShapeListOfMsg jt(msg->MapShape());
+				for (; jt.More(); jt.Next()) {
+					Message_ListIteratorOfListOfMsg kt(jt.Value());
+					for (; kt.More(); kt.Next()) {
+						char* c = new char[kt.Value().Value().LengthOfCString() + 1];
+						kt.Value().Value().ToUTF8CString(c);
+						Logger::Notice(c, l);
+						delete[] c;
+					}
+				}
+			}			
+		}
+
+		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);
+					}
+				}
+			}
+
+			it.Value() = sfs.Face();
+		}
+
+		for (TopTools_ListIteratorOfListOfShape it(face_list); it.More(); it.Next()) {
+			TopoDS_Face& face = TopoDS::Face(it.Value());
+
+			bool all_reversed = true;
+			TopoDS_Iterator jt(face, false);
+			for (; jt.More(); jt.Next()) {
+				const TopoDS_Wire& w = TopoDS::Wire(jt.Value());
+				if (!wire_senses.IsBound(w.Oriented(TopAbs_FORWARD)) || (w.Orientation() == wire_senses.Find(w.Oriented(TopAbs_FORWARD)))) {
+					all_reversed = false;
+				}
+			}
+
+			if (all_reversed) {
+				face.Reverse();
+			}
+		}
+	}
+
+	if (face_list.Extent() == 0) {
+		return false;
+	}  else 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;
+}

src/ifcgeom/mapping/IfcFaceBasedSurfaceModel.cpp

@@ -0,0 +1,38 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcGeom.h"
+#include <memory>
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcFaceBasedSurfaceModel* l, IfcRepresentationShapeItems& shapes) {
+	bool part_success = false;
+	IfcSchema::IfcConnectedFaceSet::list::ptr facesets = l->FbsmFaces();
+	auto collective_style = get_style(l);
+	for( IfcSchema::IfcConnectedFaceSet::list::it it = facesets->begin(); it != facesets->end(); ++ it ) {
+		TopoDS_Shape s;
+		auto shell_style = get_style(*it);
+		if (convert_shape(*it,s)) {
+			shapes.push_back(IfcRepresentationShapeItem(l->data().id(), s, shell_style ? shell_style : collective_style));
+			part_success |= true;
+		}
+	}
+	return part_success;
+}

src/ifcgeom/mapping/IfcGeometricSet.cpp

@@ -0,0 +1,73 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <TopoDS_Wire.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include <memory>
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcGeometricSet* l, IfcRepresentationShapeItems& shapes) {
+	// @nb the selection is partly duplicated from convert_curves() but it's needed as a
+	// geometric set by it's static class definition does not inform us of the type of elements.
+	// @todo handle this better so that this doesn't log an error.
+	const bool include_curves = getValue(GV_DIMENSIONALITY) != +1;
+	const bool include_solids_and_surfaces = getValue(GV_DIMENSIONALITY) != -1;
+
+	aggregate_of_instance::ptr elements = l->Elements();
+	if ( !elements->size() ) return false;
+	bool part_succes = false;
+	auto parent_style = get_style(l);
+	for (aggregate_of_instance::it it = elements->begin(); it != elements->end(); ++it) {
+		auto element = *it;
+		TopoDS_Shape s;
+		if (shape_type(element) == ST_SHAPELIST) {
+			IfcRepresentationShapeItems items;
+			if (!(convert_shapes(element, items) && util::flatten_shape_list(items, s, false, getValue(GV_PRECISION)))) {
+				continue;
+			}
+		} else if (shape_type(element) == ST_SHAPE && include_solids_and_surfaces) {
+			if (!convert_shape(element, s)) {
+				continue;
+			}
+		} else if ((shape_type(element) == ST_WIRE || shape_type(element) == ST_CURVE) && include_curves) {
+			TopoDS_Wire w;
+			if (!convert_wire(element, w)) {
+				continue;
+			}
+			s = w;
+		} else {
+			continue;
+		}
+
+		part_succes = true;
+		decltype(parent_style) style = 0;
+		if (element->declaration().is(IfcSchema::IfcPoint::Class())) {
+			style = get_style((IfcSchema::IfcPoint*) element);
+		}
+		else if (element->declaration().is(IfcSchema::IfcCurve::Class())) {
+			style = get_style((IfcSchema::IfcCurve*) element);
+		}
+		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));
+	}
+	return part_succes;
+}

src/ifcgeom/mapping/IfcHalfSpaceSolid.cpp

@@ -0,0 +1,42 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Ax1.hxx>
+#include <gp_Pln.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS_Face.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcHalfSpaceSolid* l, TopoDS_Shape& shape) {
+	IfcSchema::IfcSurface* surface = l->BaseSurface();
+	if ( ! surface->declaration().is(IfcSchema::IfcPlane::Class()) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface);
+		return false;
+	}
+	gp_Pln pln;
+	IfcGeom::Kernel::convert((IfcSchema::IfcPlane*)surface,pln);
+	const gp_Pnt pnt = pln.Location().Translated( l->AgreementFlag() ? -pln.Axis().Direction() : pln.Axis().Direction());
+	shape = BRepPrimAPI_MakeHalfSpace(BRepBuilderAPI_MakeFace(pln),pnt).Solid();
+	return true;
+}

src/ifcgeom/mapping/IfcIShapeProfileDef.cpp

@@ -0,0 +1,72 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcIShapeProfileDef* l, TopoDS_Shape& 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->FilletRadius();
+	double f1 = 0.;
+	if ( doFillet1 ) {
+		f1 = *l->FilletRadius() * getValue(GV_LENGTH_UNIT);
+	}
+
+	bool doFillet2 = doFillet1;
+	double x2 = x1, dy2 = dy1, f2 = f1;
+
+	// @todo in IFC4 a IfcAsymmetricIShapeProfileDef is not a subtype anymore of IfcIShapeProfileDef!
+	if (l->declaration().is(IfcSchema::IfcAsymmetricIShapeProfileDef::Class())) {
+		IfcSchema::IfcAsymmetricIShapeProfileDef* assym = (IfcSchema::IfcAsymmetricIShapeProfileDef*) l;
+		x2 = assym->TopFlangeWidth() / 2. * getValue(GV_LENGTH_UNIT);
+		doFillet2 = !!assym->TopFlangeFilletRadius();
+		if (doFillet2) {
+			f2 = *assym->TopFlangeFilletRadius() * getValue(GV_LENGTH_UNIT);
+		}
+		if (assym->TopFlangeThickness()) {
+			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;
+	}
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	double coords[24] = {-x1,-y, x1,-y, x1,-y+dy1, d1,-y+dy1, d1,y-dy2, x2,y-dy2, x2,y, -x2,y, -x2,y-dy2, -d1,y-dy2, -d1,-y+dy1, -x1,-y+dy1};
+	int fillets[4] = {3,4,9,10};
+	double radii[4] = {f1,f2,f2,f1};
+	return util::profile_helper(12,coords,(doFillet1||doFillet2) ? 4 : 0,fillets,radii,trsf2d,face);
+}

src/ifcgeom/mapping/IfcIndexedPolyCurve.cpp

@@ -0,0 +1,124 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <GC_MakeCircle.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS_Wire.hxx>
+#include <BRep_Tool.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define _USE_MATH_DEFINES
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcIndexedPolyCurve
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcIndexedPolyCurve* l, TopoDS_Wire& result) {
+	
+	IfcSchema::IfcCartesianPointList* point_list = l->Points();
+	std::vector< std::vector<double> > coordinates;
+	if (point_list->as<IfcSchema::IfcCartesianPointList2D>()) {
+		coordinates = point_list->as<IfcSchema::IfcCartesianPointList2D>()->CoordList();
+	} else if (point_list->as<IfcSchema::IfcCartesianPointList3D>()) {
+		coordinates = point_list->as<IfcSchema::IfcCartesianPointList3D>()->CoordList();
+	}
+
+	std::vector<gp_Pnt> 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;
+		points.push_back(gp_Pnt(
+			coords.size() < 1 ? 0. : coords[0] * getValue(GV_LENGTH_UNIT),
+			coords.size() < 2 ? 0. : coords[1] * getValue(GV_LENGTH_UNIT),
+			coords.size() < 3 ? 0. : coords[2] * getValue(GV_LENGTH_UNIT)));
+	}
+
+	int max_index = (int) points.size();
+
+	BRepBuilderAPI_MakeWire w;
+
+	// ignored, just for capturing the curve parameters on the null check
+	double u, v;
+
+	if(l->Segments()) {
+		aggregate_of_instance::ptr segments = *l->Segments();
+		for (aggregate_of_instance::it it = segments->begin(); it != segments->end(); ++it) {
+			IfcUtil::IfcBaseClass* segment = *it;
+			if (segment->declaration().is(IfcSchema::IfcLineIndex::Class())) {
+				IfcSchema::IfcLineIndex* line = (IfcSchema::IfcLineIndex*) segment;
+				std::vector<int> indices = *line;
+				gp_Pnt previous;
+				for (std::vector<int>::const_iterator jt = indices.begin(); jt != indices.end(); ++jt) {
+					if (*jt < 1 || *jt > max_index) {
+						throw IfcParse::IfcException("IfcIndexedPolyCurve index out of bounds for index " + boost::lexical_cast<std::string>(*jt));
+					}
+					const gp_Pnt& current = points[*jt - 1];
+					if (jt != indices.begin()) {
+						BRepBuilderAPI_MakeEdge me(previous, current);
+						if (me.IsDone() && !BRep_Tool::Curve(me.Edge(), u, v).IsNull()) {
+							w.Add(me.Edge());
+						} else {
+							Logger::Warning("Ignoring segment on", l);
+						}
+					}
+					previous = current;
+				}
+			} else if (segment->declaration().is(IfcSchema::IfcArcIndex::Class())) {
+				IfcSchema::IfcArcIndex* arc = (IfcSchema::IfcArcIndex*) segment;
+				std::vector<int> indices = *arc;
+				if (indices.size() != 3) {
+					throw IfcParse::IfcException("Invalid IfcArcIndex encountered");
+				}
+				for (int i = 0; i < 3; ++i) {
+					const int& idx = indices[i];
+					if (idx < 1 || idx > max_index) {
+						throw IfcParse::IfcException("IfcIndexedPolyCurve index out of bounds for index " + boost::lexical_cast<std::string>(idx));
+					}
+				}
+				const gp_Pnt& a = points[indices[0] - 1];
+				const gp_Pnt& b = points[indices[1] - 1];
+				const gp_Pnt& c = points[indices[2] - 1];
+				Handle(Geom_Circle) circ = GC_MakeCircle(a, b, c).Value();
+				BRepBuilderAPI_MakeEdge me(circ, a, c);
+				if (me.IsDone() && !BRep_Tool::Curve(me.Edge(), u, v).IsNull()) {
+					w.Add(me.Edge());
+				} else {
+					Logger::Warning("Ignoring segment on", l);
+				}
+			} else {
+				throw IfcParse::IfcException("Unexpected IfcIndexedPolyCurve segment of type " + segment->declaration().name());
+			}
+		}
+	} else if (points.begin() < points.end()) {
+        std::vector<gp_Pnt>::const_iterator previous = points.begin();
+        for (std::vector<gp_Pnt>::const_iterator current = previous+1; current < points.end(); ++current){
+			BRepBuilderAPI_MakeEdge me(*previous, *current);
+			if (me.IsDone() && !BRep_Tool::Curve(me.Edge(), u, v).IsNull()) {
+				w.Add(me.Edge());
+				previous = current;
+			}
+        }
+    }
+
+	result = w.Wire();
+	return true;
+}
+
+#endif

src/ifcgeom/mapping/IfcLShapeProfileDef.cpp

@@ -0,0 +1,99 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcLShapeProfileDef* l, TopoDS_Shape& face) {
+	const bool hasSlope = !!l->LegSlope();
+	const bool doEdgeFillet = !!l->EdgeRadius();
+	const bool doFillet = !!l->FilletRadius();
+
+	const double y = l->Depth() / 2.0f * getValue(GV_LENGTH_UNIT);
+	const double x = l->Width().get_value_or(l->Depth()) / 2.0f * getValue(GV_LENGTH_UNIT);
+	const double d = l->Thickness() * getValue(GV_LENGTH_UNIT);
+	const double slope = l->LegSlope().get_value_or(0.) * getValue(GV_PLANEANGLE_UNIT);
+	
+	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;
+	}
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	double coords[12] = {-x,-y, x,-y, x,-y+d-dy1, xx, xy, -x+d-dx1,y, -x,y};
+	int fillets[3] = {2,3,4};
+	double radii[3] = {f2,f1,f2};
+	return util::profile_helper(6,coords,doFillet ? 3 : 0,fillets,radii,trsf2d,face);
+}

src/ifcgeom/mapping/IfcLine.cpp

@@ -0,0 +1,34 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <Geom_Line.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcLine* l, Handle(Geom_Curve)& curve) {
+	gp_Pnt pnt;gp_Vec vec;
+	convert(l->Pnt(),pnt);
+	convert(l->Dir(),vec);	
+	// See note at IfcGeomWires.cpp:237
+	curve = new Geom_Line(pnt,vec);
+	return true;
+}

src/ifcgeom/mapping/IfcManifoldSolidBrep.cpp

@@ -0,0 +1,55 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <BRepAlgoAPI_Cut.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include <memory>
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, IfcRepresentationShapeItems& shape) {
+	TopoDS_Shape s;
+	auto collective_style = get_style(l);
+	if (convert_shape(l->Outer(),s) ) {
+		auto indiv_style = get_style(l->Outer());
+
+		IfcSchema::IfcClosedShell::list::ptr voids(new IfcSchema::IfcClosedShell::list);
+		if (l->declaration().is(IfcSchema::IfcFacetedBrepWithVoids::Class())) {
+			voids = l->as<IfcSchema::IfcFacetedBrepWithVoids>()->Voids();
+		}
+#ifdef SCHEMA_HAS_IfcAdvancedBrepWithVoids
+		if (l->declaration().is(IfcSchema::IfcAdvancedBrepWithVoids::Class())) {
+			voids = l->as<IfcSchema::IfcAdvancedBrepWithVoids>()->Voids();
+		}
+#endif
+
+		for (IfcSchema::IfcClosedShell::list::it it = voids->begin(); it != voids->end(); ++it) {
+			TopoDS_Shape s2;
+			/// @todo No extensive shapefixing since shells should be disjoint.
+			/// @todo Awaiting generalized boolean ops module with appropriate checking
+			if (convert_shape(l->Outer(), s2)) {
+				s = BRepAlgoAPI_Cut(s, s2).Shape();
+			}
+		}
+
+		shape.push_back(IfcRepresentationShapeItem(l->data().id(), s, indiv_style ? indiv_style : collective_style));
+		return true;
+	}
+	return false;
+}

src/ifcgeom/mapping/IfcMappedItem.cpp

@@ -0,0 +1,72 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_GTrsf.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, IfcRepresentationShapeItems& shapes) {
+	gp_GTrsf gtrsf;
+	IfcSchema::IfcCartesianTransformationOperator* transform = l->MappingTarget();
+	if ( transform->declaration().is(IfcSchema::IfcCartesianTransformationOperator3DnonUniform::Class()) ) {
+		IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator3DnonUniform*)transform,gtrsf);
+	} else if ( transform->declaration().is(IfcSchema::IfcCartesianTransformationOperator2DnonUniform::Class()) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported MappingTarget:", transform);
+		return false;
+	} else if ( transform->declaration().is(IfcSchema::IfcCartesianTransformationOperator3D::Class()) ) {
+		gp_Trsf trsf;
+		IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator3D*)transform,trsf);
+		gtrsf = trsf;
+	} else if ( transform->declaration().is(IfcSchema::IfcCartesianTransformationOperator2D::Class()) ) {
+		gp_Trsf2d trsf_2d;
+		IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator2D*)transform,trsf_2d);
+		gtrsf = (gp_Trsf) trsf_2d;
+	}
+	IfcSchema::IfcRepresentationMap* map = l->MappingSource();
+	IfcSchema::IfcAxis2Placement* placement = map->MappingOrigin();
+	gp_Trsf trsf;
+	if (placement->declaration().is(IfcSchema::IfcAxis2Placement3D::Class())) {
+		IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
+	} else {
+		gp_Trsf2d trsf_2d;
+		IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf_2d);
+		trsf = trsf_2d;
+	}
+	gtrsf.Multiply(trsf);
+
+	auto 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 ) {
+		shapes[i].prepend(gtrsf);
+
+		// 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;
+}

src/ifcgeom/mapping/IfcObjectPlacement.cpp

@@ -0,0 +1,75 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+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()) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l);
+		return false; 		
+	}
+	IfcSchema::IfcLocalPlacement* current = (IfcSchema::IfcLocalPlacement*)l;
+	for (;;) {
+
+		gp_Trsf trsf2;
+		IfcSchema::IfcAxis2Placement* relplacement = current->RelativePlacement();
+		if (relplacement->as<IfcSchema::IfcAxis2Placement3D>()) {
+			IfcGeom::Kernel::convert(relplacement->as<IfcSchema::IfcAxis2Placement3D>(),trsf2);
+			trsf.PreMultiply(trsf2);
+		}
+
+		if (current->PlacementRelTo()) {
+			IfcSchema::IfcObjectPlacement* parent = current->PlacementRelTo();
+
+			bool parent_placement_ignored = false;
+			if (placement_rel_to_type_ || placement_rel_to_instance_) {
+				IfcSchema::IfcProduct::list::ptr parent_places = parent->PlacesObject();
+				for (auto iter = parent_places->begin(); iter != parent_places->end(); ++iter) {
+					if ((placement_rel_to_type_ && (*iter)->declaration().is(*placement_rel_to_type_)) ||
+						(placement_rel_to_instance_ && (*iter)->as<IfcUtil::IfcBaseEntity>() == placement_rel_to_instance_)) {
+						parent_placement_ignored = true;
+					}
+				}
+			}
+
+			if (parent_placement_ignored) {
+				// The parent placement of the current is a placement for a type that is
+				// being ignored (Site or Building) or it is the host element of an opening.
+				break;
+			} else if (parent->declaration().is(IfcSchema::IfcLocalPlacement::Class())) {
+				// Keep processing parent placements
+				current = current->PlacementRelTo()->as<IfcSchema::IfcLocalPlacement>();
+			} else {
+				// This is the root placement (typically Site).
+				break;
+			}
+		} else {
+			break;
+		}
+	}
+
+	trsf.PreMultiply(offset_and_rotation);
+	
+	CACHE(IfcObjectPlacement,l,trsf)
+	return true;
+}

src/ifcgeom/mapping/IfcOrientedEdge.cpp

@@ -0,0 +1,35 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <TopoDS_Wire.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define _USE_MATH_DEFINES
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcOrientedEdge* l, TopoDS_Wire& result) {
+	if (convert_wire(l->EdgeElement(), result)) {
+		if (!l->Orientation()) {
+			result.Reverse();
+		}
+		return true;
+	} else {
+		return false;
+	}
+}

src/ifcgeom/mapping/IfcPlane.cpp

@@ -0,0 +1,64 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Pln.hxx>
+#include <Geom_Plane.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <Standard_Version.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcPlane* l, TopoDS_Shape& face) {
+	gp_Pln pln;
+	convert(l, pln);
+	Handle_Geom_Surface surf = new Geom_Plane(pln);
+#if OCC_VERSION_HEX < 0x60502
+	face = BRepBuilderAPI_MakeFace(surf);
+#else
+	face = BRepBuilderAPI_MakeFace(surf, getValue(GV_PRECISION));
+#endif
+	return true;
+}
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcPlane* pln, gp_Pln& plane) {
+	IN_CACHE(IfcPlane,pln,gp_Pln,plane)
+	IfcSchema::IfcAxis2Placement3D* l = pln->Position();
+	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
+
+	if (!l->Location()->declaration().is("IfcCartesianPoint")) {
+		// only applicable to 4x3 rc2
+		Logger::Error("Not implemented", l->Location());
+		return false;
+	}
+
+	IfcGeom::Kernel::convert((const IfcSchema::IfcCartesianPoint*) l->Location(),o);
+	bool hasRef = !!l->RefDirection();
+	if ( l->Axis() ) IfcGeom::Kernel::convert(l->Axis(),axis);
+	if ( hasRef ) IfcGeom::Kernel::convert(l->RefDirection(),refDirection);
+	gp_Ax3 ax3;
+	if ( hasRef ) ax3 = gp_Ax3(o,axis,refDirection);
+	else ax3 = gp_Ax3(o,axis);
+	plane = gp_Pln(ax3);
+	CACHE(IfcPlane,pln,plane)
+	return true;
+}

src/ifcgeom/mapping/IfcPolyLoop.cpp

@@ -0,0 +1,79 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+
+#include <gp_Pnt.hxx>
+#include <BRepBuilderAPI_MakePolygon.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopTools_ListOfShape.hxx>
+
+#define _USE_MATH_DEFINES
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyLoop* l, TopoDS_Wire& result) {
+	IfcSchema::IfcCartesianPoint::list::ptr points = l->Polygon();
+
+	// Parse and store the points in a sequence
+	TColgp_SequenceOfPnt polygon;
+	for(IfcSchema::IfcCartesianPoint::list::it it = points->begin(); it != points->end(); ++ it) {
+		gp_Pnt pnt;
+		IfcGeom::Kernel::convert(*it, pnt);
+		polygon.Append(pnt);
+	}
+
+	// A loop should consist of at least three vertices
+	int original_count = polygon.Length();
+	if (original_count < 3) {
+		Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l);
+		return false;
+	}
+
+	// Remove points that are too close to one another
+	const double eps = getValue(GV_PRECISION) * 10;
+	util::remove_duplicate_points_from_loop(polygon, true, eps);
+
+	int count = polygon.Length();
+	if (original_count - count != 0) {
+		std::stringstream ss; ss << (original_count - count) << " edges removed for:"; 
+		Logger::Message(Logger::LOG_WARNING, ss.str(), l);
+	}
+
+	if (count < 3) {
+		Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l);
+		return false;
+	}
+
+	BRepBuilderAPI_MakePolygon w;
+	for (int i = 1; i <= polygon.Length(); ++i) {
+		w.Add(polygon.Value(i));
+	}
+	w.Close();
+
+	result = w.Wire();
+
+	TopTools_ListOfShape results;
+	if (getValue(GV_NO_WIRE_INTERSECTION_CHECK) < 0. && util::wire_intersections(result, results, {getValue(GV_NO_WIRE_INTERSECTION_CHECK) < 0., getValue(GV_NO_WIRE_INTERSECTION_TOLERANCE) < 0., 0., getValue(GV_PRECISION)})) {
+		Logger::Error("Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected", l);
+		util::select_largest(results, result);
+	}
+
+	return true;
+}

src/ifcgeom/mapping/IfcPolygonalBoundedHalfSpace.cpp

@@ -0,0 +1,63 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Vec.hxx>
+#include <gp_Trsf.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS_Wire.hxx>
+#include <BRepPrimAPI_MakePrism.hxx>
+#include <BRepAlgoAPI_Common.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolygonalBoundedHalfSpace* l, TopoDS_Shape& shape) {
+	TopoDS_Shape halfspace;
+	if ( ! IfcGeom::Kernel::convert((IfcSchema::IfcHalfSpaceSolid*)l,halfspace) ) return false;	
+	
+	TopoDS_Wire wire;
+	if ( ! convert_wire(l->PolygonalBoundary(),wire) || ! wire.Closed() ) return false;
+	
+	gp_Trsf trsf;
+	if ( ! convert(l->Position(),trsf) ) return false;
+
+	TColgp_SequenceOfPnt points;
+	if (util::wire_to_sequence_of_point(wire, points)) {
+		// Boolean subtractions not very robust for narrow operands, 
+		// increase minimal point spacing to eliminate such shapes.
+		const double t = getValue(GV_PRECISION) * 10.;
+		util::remove_duplicate_points_from_loop(points, wire.Closed() != 0, t); // Note: wire always closed, as per if statement above
+		util::remove_collinear_points_from_loop(points, wire.Closed() != 0, t);
+		if (points.Length() < 3) {
+			Logger::Message(Logger::LOG_ERROR, "Not enough points retained from:", l->PolygonalBoundary());
+			return false;
+		}
+		util::sequence_of_point_to_wire(points, wire, wire.Closed() != 0);
+	}
+
+	TopoDS_Shape prism = BRepPrimAPI_MakePrism(BRepBuilderAPI_MakeFace(wire),gp_Vec(0,0,200));
+	gp_Trsf down; down.SetTranslation(gp_Vec(0,0,-100.0));
+	
+	// `trsf` and `down` both have a unit scale factor
+	prism.Move(trsf*down);	
+	
+	shape = BRepAlgoAPI_Common(halfspace,prism);
+	return true;
+}

src/ifcgeom/mapping/IfcPolygonalFaceSet.cpp

@@ -0,0 +1,146 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcPolygonalFaceSet
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolygonalFaceSet* pfs, TopoDS_Shape& shape) {
+	IfcSchema::IfcCartesianPointList3D* point_list = pfs->Coordinates();
+	auto coord_list = point_list->CoordList();
+	auto polygonal_faces = pfs->Faces();
+
+	std::vector<std::vector<int>> indices;
+	indices.reserve(polygonal_faces->size() * 2);
+
+	std::vector<std::vector<int>> loop_grouping;
+	loop_grouping.reserve(polygonal_faces->size());
+	
+	for (auto& f : *polygonal_faces) {
+		loop_grouping.emplace_back();
+		loop_grouping.back().push_back((int) indices.size());
+		indices.push_back(f->CoordIndex());
+		if (f->as<IfcSchema::IfcIndexedPolygonalFaceWithVoids>()) {
+			auto inner_coordinates = f->as<IfcSchema::IfcIndexedPolygonalFaceWithVoids>()->InnerCoordIndices();
+			for (auto& x : inner_coordinates) {
+				loop_grouping.back().push_back((int) indices.size());
+				indices.push_back(x);
+			}
+		}
+	}
+
+	faceset_helper<
+		std::vector<double>,
+		std::vector<int>
+	> helper(this, coord_list, indices, pfs->Closed().get_value_or(false));
+
+	TopTools_ListOfShape faces;
+
+	for (auto& f : loop_grouping) {
+		bool not_planar = false;
+		
+		TopoDS_Wire w;
+		if (!helper.wire(indices[f[0]], w)) {
+			continue;
+		}
+
+		TopoDS_Face face;
+		std::vector<TopoDS_Wire> ws = { w };
+
+		// @todo triangulate
+		BRepBuilderAPI_MakeFace mf(w);
+		if (mf.Error() == BRepBuilderAPI_NotPlanar) {
+			not_planar = true;
+		} else if (mf.IsDone()) {
+			face = mf.Face();
+		} else {
+			// todo log
+			continue;
+		}
+
+		if (f.size() > 1) {
+
+			if (not_planar) {
+				for (auto it = f.begin() + 1; it != f.end(); ++it) {
+					TopoDS_Wire w2;
+					if (helper.wire(indices[*it], w2)) {
+						ws.push_back(w2);
+					}
+				}
+			} else {
+				BRepBuilderAPI_MakeFace mf2(face);
+				for (auto it = f.begin() + 1; it != f.end(); ++it) {
+					TopoDS_Wire w2;
+					if (helper.wire(indices[*it], w2)) {
+						mf2.Add(w2);
+						ws.push_back(w2);
+					}
+
+				}
+				
+				if (mf2.Error() == BRepBuilderAPI_NotPlanar) {
+					not_planar = true;
+				} else if (mf2.IsDone()) {
+					face = mf2.Face();
+				}
+			}	
+			
+		}
+
+		if (not_planar) {
+			TopTools_ListOfShape fs;
+			if (util::triangulate_wire(ws, fs)) {
+				Logger::Warning("Triangulated face boundary:", pfs);
+				TopTools_ListIteratorOfListOfShape it(fs);
+				for (; it.More(); it.Next()) {
+					const TopoDS_Face& tri = TopoDS::Face(it.Value());
+					if (util::face_area(tri) > getValue(GV_MINIMAL_FACE_AREA)) {
+						faces.Append(tri);
+					}
+				}
+			}
+		} else {
+			faces.Append(face);
+		}
+	}
+
+	if (faces.Extent() > getValue(GV_MAX_FACES_TO_ORIENT) || !util::create_solid_from_faces(faces, shape, getValue(GV_PRECISION))) {
+		TopoDS_Compound compound;
+		BRep_Builder builder;
+		builder.MakeCompound(compound);
+
+		TopTools_ListIteratorOfListOfShape face_iterator;
+		for (face_iterator.Initialize(faces); face_iterator.More(); face_iterator.Next()) {
+			builder.Add(compound, face_iterator.Value());
+		}
+		shape = compound;
+	}
+
+	return true;
+}
+
+#endif

src/ifcgeom/mapping/IfcPolyline.cpp

@@ -0,0 +1,69 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <BRepBuilderAPI_MakePolygon.hxx>
+#include <TopoDS_Wire.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+
+#define _USE_MATH_DEFINES
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyline* l, TopoDS_Wire& result) {
+	IfcSchema::IfcCartesianPoint::list::ptr points = l->Points();
+
+	// Parse and store the points in a sequence
+	TColgp_SequenceOfPnt polygon;
+	for(IfcSchema::IfcCartesianPoint::list::it it = points->begin(); it != points->end(); ++ it) {
+		gp_Pnt pnt;
+		IfcGeom::Kernel::convert(*it, pnt);
+		polygon.Append(pnt);
+	}
+
+	// @todo the strict tolerance should also govern these arbitrary precision increases
+	const double eps = getValue(GV_PRECISION) * 10;
+	const bool closed_by_proximity = polygon.Length() >= 3 && polygon.First().Distance(polygon.Last()) < eps;
+	if (closed_by_proximity) {
+		// tfk: note 1-based
+		polygon.Remove(polygon.Length());
+	}
+
+	// Remove points that are too close to one another
+	util::remove_duplicate_points_from_loop(polygon, closed_by_proximity, eps);
+
+	if (polygon.Length() < 2) {
+		// We somehow need to signal we fail this curve on purpose not to trigger an error.
+		BRep_Builder B;
+		B.MakeWire(result);
+		return false;
+	}
+	
+	BRepBuilderAPI_MakePolygon w;
+	for (int i = 1; i <= polygon.Length(); ++i) {
+		w.Add(polygon.Value(i));
+	}
+
+	if (closed_by_proximity) {
+		w.Close();
+	}
+
+	result = w.Wire();
+	return true;
+}

src/ifcgeom/mapping/IfcRectangleHollowProfileDef.cpp

@@ -0,0 +1,84 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopExp_Explorer.hxx>
+#include <ShapeFix_Shape.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangleHollowProfileDef* l, TopoDS_Shape& 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->OuterFilletRadius();
+	const bool fr2 = !!l->InnerFilletRadius();
+
+	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;
+	}
+
+	TopoDS_Face f1;
+	TopoDS_Face f2;
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	double coords1[8] = {-x  ,-y,   x  ,-y,   x,  y,   -x,  y  };
+	double coords2[8] = {-x+d,-y+d, x-d,-y+d, x-d,y-d, -x+d,y-d};
+	double radii1[4] = {r1,r1,r1,r1};
+	double radii2[4] = {r2,r2,r2,r2};
+	int fillets[4] = {0,1,2,3};
+
+	bool s1 = util::profile_helper(4,coords1,fr1 ? 4 : 0,fillets,radii1,trsf2d,f1);
+	bool s2 = util::profile_helper(4,coords2,fr2 ? 4 : 0,fillets,radii2,trsf2d,f2);
+
+	if (!s1 || !s2) return false;
+
+	TopExp_Explorer exp1(f1, TopAbs_WIRE);
+	TopExp_Explorer exp2(f2, TopAbs_WIRE);
+
+	TopoDS_Wire w1 = TopoDS::Wire(exp1.Current());	
+	TopoDS_Wire w2 = TopoDS::Wire(exp2.Current());
+
+	BRepBuilderAPI_MakeFace mf(w1, false);
+	mf.Add(w2);
+
+	ShapeFix_Shape sfs(mf.Face());
+	sfs.Perform();
+	face = TopoDS::Face(sfs.Shape());	
+	return true;
+}

src/ifcgeom/mapping/IfcRectangleProfileDef.cpp

@@ -0,0 +1,46 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangleProfileDef* l, TopoDS_Shape& 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;
+	}
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+	
+	double coords[8] = {-x,-y,x,-y,x,y,-x,y};
+	return util::profile_helper(4,coords,0,0,0,trsf2d,face);
+}

src/ifcgeom/mapping/IfcRectangularPyramid.cpp

@@ -0,0 +1,48 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <BRepPrimAPI_MakeWedge.hxx>
+#include <BRepBuilderAPI_Transform.hxx>
+#include <Standard_Version.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangularPyramid* l, TopoDS_Shape& 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);
+	
+	BRepPrimAPI_MakeWedge builder(dx, dz, dy, dx / 2., dy / 2., dx / 2., dy / 2.);
+	
+	gp_Trsf trsf1, trsf2;
+	trsf2.SetValues(
+		1, 0, 0, 0,
+		0, 0, 1, 0,
+		0, 1, 0, 0
+#if OCC_VERSION_HEX < 0x60800
+		, Precision::Angular(), Precision::Confusion()
+#endif			
+	);
+	
+	IfcGeom::Kernel::convert(l->Position(), trsf1);
+	shape = BRepBuilderAPI_Transform(builder.Solid(), trsf1 * trsf2);
+	return true;
+}

src/ifcgeom/mapping/IfcRectangularTrimmedSurface.cpp

@@ -0,0 +1,40 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pln.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS_Face.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangularTrimmedSurface* l, TopoDS_Shape& face) {
+	if (!l->BasisSurface()->declaration().is(IfcSchema::IfcPlane::Class())) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported BasisSurface:", l->BasisSurface());
+		return false;
+	}
+	gp_Pln pln;
+	IfcGeom::Kernel::convert((IfcSchema::IfcPlane*) l->BasisSurface(), pln);
+
+	BRepBuilderAPI_MakeFace mf(pln, l->U1(), l->U2(), l->V1(), l->V2());
+
+	face = mf.Face();
+
+	return true;
+}

src/ifcgeom/mapping/IfcRepresentation.cpp

@@ -0,0 +1,49 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRepresentation* l, IfcRepresentationShapeItems& 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 {
+				TopoDS_Shape s;
+				if (convert_shape(representation_item, s)) {
+					if (s.ShapeType() == TopAbs_COMPOUND && TopoDS_Iterator(s).More() && TopoDS_Iterator(s).Value().ShapeType() == TopAbs_SOLID) {
+						TopoDS_Iterator topo_it(s);
+						for (; topo_it.More(); topo_it.Next()) {
+							shapes.push_back(IfcRepresentationShapeItem(representation_item->data().id(), topo_it.Value(), get_style(representation_item)));
+						}
+					} else {
+						shapes.push_back(IfcRepresentationShapeItem(representation_item->data().id(), s, get_style(representation_item)));
+					}
+					part_succes |= true;
+				}
+			}
+		}
+	}
+	return part_succes;
+}

src/ifcgeom/mapping/IfcRevolvedAreaSolid.cpp

@@ -0,0 +1,101 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Ax1.hxx>
+#include <TopoDS.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRepPrimAPI_MakeRevol.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRevolvedAreaSolid* l, TopoDS_Shape& shape) {
+	const double ang = l->Angle() * getValue(GV_PLANEANGLE_UNIT);
+
+	TopoDS_Shape face;
+	if ( ! convert_face(l->SweptArea(),face) ) return false;
+
+	gp_Ax1 ax1;
+	IfcGeom::Kernel::convert(l->Axis(), ax1);
+
+	gp_Trsf trsf;
+	bool has_position = true;
+#ifdef SCHEMA_IfcSweptAreaSolid_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf);
+	}
+
+
+	{
+		// https://github.com/IfcOpenShell/IfcOpenShell/issues/1030
+		// Check whether Axis does not intersect SweptArea
+
+		double min_dot = +std::numeric_limits<double>::infinity();
+		double max_dot = -std::numeric_limits<double>::infinity();
+
+		gp_Ax2 ax(ax1.Location(), gp::DZ(), ax1.Direction());
+
+		TopExp_Explorer exp(face, TopAbs_EDGE);
+		for (; exp.More(); exp.Next()) {
+			BRepAdaptor_Curve crv(TopoDS::Edge(exp.Current()));
+			GCPnts_QuasiUniformDeflection tessellater(crv, getValue(GV_PRECISION));
+
+			int n = tessellater.NbPoints();
+			for (int i = 1; i <= n; ++i) {
+				double d = ax.YDirection().XYZ().Dot(tessellater.Value(i).XYZ());
+				if (d < min_dot) {
+					min_dot = d;
+				}
+				if (d > max_dot) {
+					max_dot = d;
+				}
+			}
+		}
+
+		bool intersecting;
+		if (std::abs(min_dot) > std::abs(max_dot)) {
+			intersecting = max_dot > + getValue(GV_PRECISION);
+		} else {
+			intersecting = min_dot < - getValue(GV_PRECISION);
+		}
+
+		if (intersecting) {
+			Logger::Warning("Warning Axis and SweptArea intersecting", l);
+		}
+	}
+
+	if (ang >= M_PI * 2. - ALMOST_ZERO) {
+		shape = BRepPrimAPI_MakeRevol(face, ax1);
+	} else {
+		shape = BRepPrimAPI_MakeRevol(face, ax1, ang);
+	}
+
+	if (has_position) {
+		// IfcSweptAreaSolid.Position (trsf) is an IfcAxis2Placement3D
+		// and therefore has a unit scale factor
+		shape.Move(trsf);
+	}
+
+	return !shape.IsNull();
+}

src/ifcgeom/mapping/IfcRightCircularCone.cpp

@@ -0,0 +1,38 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <BRepPrimAPI_MakeCone.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRightCircularCone* l, TopoDS_Shape& shape) {
+	const double r = l->BottomRadius() * getValue(GV_LENGTH_UNIT);
+	const double h = l->Height() * getValue(GV_LENGTH_UNIT);
+
+	BRepPrimAPI_MakeCone builder(r, 0., h);
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+
+	// IfcCsgPrimitive3D.Position has unit scale factor
+	shape = builder.Solid().Moved(trsf);
+
+	return true;
+}

src/ifcgeom/mapping/IfcRightCircularCylinder.cpp

@@ -0,0 +1,38 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <BRepPrimAPI_MakeCylinder.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRightCircularCylinder* l, TopoDS_Shape& shape) {
+	const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
+	const double h = l->Height() * getValue(GV_LENGTH_UNIT);
+
+	BRepPrimAPI_MakeCylinder builder(r, h);
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+	
+	// IfcCsgPrimitive3D.Position has unit scale factor
+	shape = builder.Solid().Moved(trsf);
+
+	return true;
+}

src/ifcgeom/mapping/IfcRoundedRectangleProfileDef.cpp

@@ -0,0 +1,49 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcRoundedRectangleProfileDef* l, TopoDS_Shape& 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;
+	}
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	double coords[8] = {-x,-y, x,-y, x,y, -x,y};
+	int fillets[4] = {0,1,2,3};
+	double radii[4] = {r,r,r,r};
+	return util::profile_helper(4,coords,4,fillets,radii,trsf2d,face);
+}

src/ifcgeom/mapping/IfcShellBasedSurfaceModel.cpp

@@ -0,0 +1,39 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcGeom.h"
+#include <memory>
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, IfcRepresentationShapeItems& shapes) {
+	aggregate_of_instance::ptr shells = l->SbsmBoundary();
+	auto collective_style = get_style(l);
+	for( aggregate_of_instance::it it = shells->begin(); it != shells->end(); ++ it ) {
+		TopoDS_Shape s;
+		decltype(collective_style) shell_style;
+		if ((*it)->declaration().is(IfcSchema::IfcRepresentationItem::Class())) {
+			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));
+		}
+	}
+	return true;
+}

src/ifcgeom/mapping/IfcSphere.cpp

@@ -0,0 +1,37 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <BRepPrimAPI_MakeSphere.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSphere* l, TopoDS_Shape& shape) {
+	const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
+	
+	BRepPrimAPI_MakeSphere builder(r);
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(),trsf);
+	
+	// IfcCsgPrimitive3D.Position has unit scale factor
+	shape = builder.Solid().Moved(trsf);
+
+	return true;
+}

src/ifcgeom/mapping/IfcSphericalSurface.cpp

@@ -0,0 +1,38 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS_Face.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcSphericalSurface
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSphericalSurface* l, TopoDS_Shape& face) {
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(), trsf);
+
+	// IfcElementarySurface.Position has unit scale factor
+	face = BRepBuilderAPI_MakeFace(new Geom_SphericalSurface(gp::XOY(), l->Radius() * getValue(GV_LENGTH_UNIT)), getValue(GV_PRECISION)).Face().Moved(trsf);
+	return true;
+}
+
+#endif

src/ifcgeom/mapping/IfcSubedge.cpp

@@ -0,0 +1,48 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRep_Tool.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define _USE_MATH_DEFINES
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSubedge* l, TopoDS_Wire& result) {
+	TopoDS_Wire temp;
+	if (convert_wire(l->ParentEdge(), result) && convert((IfcSchema::IfcEdge*) l, temp)) {
+		TopExp_Explorer exp(result, TopAbs_EDGE);
+		TopoDS_Edge edge = TopoDS::Edge(exp.Current());
+		Standard_Real u1, u2;
+		Handle(Geom_Curve) crv = BRep_Tool::Curve(edge, u1, u2);
+		TopoDS_Vertex v1, v2;
+		TopExp::Vertices(temp, v1, v2);
+		BRepBuilderAPI_MakeWire mw;
+		mw.Add(BRepBuilderAPI_MakeEdge(crv, v1, v2));
+		result = mw.Wire();
+		return true;
+	} else {
+		return false;
+	}
+}

src/ifcgeom/mapping/IfcSurfaceCurve.cpp

@@ -0,0 +1,29 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcSurfaceCurve
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceCurve* sc, Handle(Geom_Curve)& curve) {
+	// @todo take into account PCurves.
+	return convert_curve(sc->Curve3D(), curve);
+}
+#endif

src/ifcgeom/mapping/IfcSurfaceCurveSweptAreaSolid.cpp

@@ -0,0 +1,157 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Ax1.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Pln.hxx>
+#include <BRepOffsetAPI_MakePipeShell.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRepBuilderAPI_Transform.hxx>
+#include <ShapeFix_Edge.hxx>
+#include <ShapeAnalysis_Surface.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceCurveSweptAreaSolid* l, TopoDS_Shape& shape) {
+	gp_Trsf directrix;
+	TopoDS_Shape face;
+	TopoDS_Face surface_face;
+	TopoDS_Wire wire, section;
+
+	const bool is_plane = l->ReferenceSurface()->declaration().is(IfcSchema::IfcPlane::Class());
+
+	if (!is_plane) {
+		TopoDS_Shape surface_shell;
+		if (!convert_shape(l->ReferenceSurface(), surface_shell)) {
+			Logger::Error("Failed to convert reference surface", l);
+			return false;
+		}
+		if (util::count(surface_shell, TopAbs_FACE) != 1) {
+			Logger::Error("Non-continuous reference surface", l);
+			return false;
+		}
+		surface_face = TopoDS::Face(TopExp_Explorer(surface_shell, TopAbs_FACE).Current());
+	}
+	
+	gp_Trsf trsf;
+	bool has_position = true;
+#ifdef SCHEMA_IfcSweptAreaSolid_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf);
+	}
+
+	if (!convert_face(l->SweptArea(), face) || 
+		!convert_wire(l->Directrix(), wire)    ) {
+		return false;
+	}
+
+	gp_Pln pln;
+	gp_Pnt directrix_origin;
+	gp_Vec directrix_tangent;
+	bool directrix_on_plane = is_plane;
+
+	if (is_plane) {
+		IfcGeom::Kernel::convert((IfcSchema::IfcPlane*) l->ReferenceSurface(), pln);
+
+		// As per Informal propositions 2: The Directrix shall lie on the ReferenceSurface.
+		// This is not always the case with the test files in the repository. I am not sure
+		// how to deal with this and whether my interpretation of the propositions is
+		// correct. However, if it has been asserted that the vertices of the directrix do
+		// not conform to the ReferenceSurface, the ReferenceSurface is ignored.
+		{
+			for (TopExp_Explorer exp(wire, TopAbs_VERTEX); exp.More(); exp.Next()) {
+				if (pln.Distance(BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()))) > ALMOST_ZERO) {
+					directrix_on_plane = false;
+					Logger::Message(Logger::LOG_WARNING, "The Directrix does not lie on the ReferenceSurface", l);
+					break;
+				}
+			}
+		}
+	}
+
+	{
+		TopExp_Explorer exp(wire, TopAbs_EDGE);
+		TopoDS_Edge edge = TopoDS::Edge(exp.Current());
+		double u0, u1;
+		Handle(Geom_Curve) crv = BRep_Tool::Curve(edge, u0, u1);
+		crv->D1(u0, directrix_origin, directrix_tangent);
+	}
+
+	if (is_plane && pln.Axis().Direction().IsNormal(directrix_tangent, Precision::Approximation()) && directrix_on_plane) {
+		directrix.SetTransformation(gp_Ax3(directrix_origin, directrix_tangent, pln.Axis().Direction()), gp::XOY());
+	} else if (!is_plane) {
+		ShapeAnalysis_Surface sas(BRep_Tool::Surface(surface_face));
+		auto pnt2d = sas.ValueOfUV(directrix_origin, getValue(GV_PRECISION) * 10.);
+		BRepGProp_Face prop(surface_face);
+		gp_Pnt _;
+		gp_Vec surface_normal;
+		prop.Normal(pnt2d.X(), pnt2d.Y(), _, surface_normal);
+		directrix.SetTransformation(gp_Ax3(directrix_origin, directrix_tangent, surface_normal), gp::XOY());
+	} else {
+		directrix.SetTransformation(gp_Ax3(directrix_origin, directrix_tangent), gp::XOY());
+	}
+	face = BRepBuilderAPI_Transform(face, directrix);
+
+	if (!is_plane) {
+		TopExp_Explorer exp(wire, TopAbs_EDGE);
+		for (; exp.More(); exp.Next()) {
+			ShapeFix_Edge sfe;
+			sfe.FixAddPCurve(TopoDS::Edge(exp.Current()), surface_face, false, getValue(GV_PRECISION));
+		}
+	}
+
+	// NB: Note that StartParam and EndParam param are ignored and the assumption is
+	// made that the parametric range over which to be swept matches the IfcCurve in
+	// its entirety.
+	BRepOffsetAPI_MakePipeShell builder(wire);
+
+	{ TopExp_Explorer exp(face, TopAbs_WIRE);
+	section = TopoDS::Wire(exp.Current()); }
+
+	builder.Add(section);
+	builder.SetTransitionMode(BRepBuilderAPI_RightCorner);
+	if (directrix_on_plane) {
+		builder.SetMode(pln.Axis().Direction());
+	} else if (!is_plane) {
+		builder.SetMode(surface_face);
+	}
+	builder.Build();
+	builder.MakeSolid();
+	shape = builder.Shape();
+
+	if (has_position) {
+		// IfcSweptAreaSolid.Position (trsf) is an IfcAxis2Placement3D
+		// and therefore has a unit scale factor
+		shape.Move(trsf);
+	}
+
+	return true;
+}

src/ifcgeom/mapping/IfcSurfaceOfLinearExtrusion.cpp

@@ -0,0 +1,63 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Vec.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Trsf.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRepPrimAPI_MakePrism.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceOfLinearExtrusion* l, TopoDS_Shape& shape) {
+	TopoDS_Wire wire;
+	if ( !convert_wire(l->SweptCurve(), wire) ) {
+		TopoDS_Face face;
+		if ( !convert_face(l->SweptCurve(),face) ) return false;
+		TopExp_Explorer exp(face, TopAbs_WIRE);
+		wire = TopoDS::Wire(exp.Current());
+	}
+	const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
+	
+	gp_Trsf trsf;
+	bool has_position = true;
+#ifdef SCHEMA_IfcSweptSurface_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf);
+	}
+
+	gp_Dir dir;
+	convert(l->ExtrudedDirection(),dir);
+
+	shape = BRepPrimAPI_MakePrism(wire, height*dir);
+	
+	if (has_position) {
+		// IfcSweptSurface.Position (trsf) is an IfcAxis2Placement3D
+		// and therefore has a unit scale factor
+		shape.Move(trsf);
+	}
+	
+	return !shape.IsNull();
+}

src/ifcgeom/mapping/IfcSurfaceOfRevolution.cpp

@@ -0,0 +1,61 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <gp_Ax1.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRepPrimAPI_MakeRevol.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceOfRevolution* l, TopoDS_Shape& shape) {
+	TopoDS_Wire wire;
+	if ( !convert_wire(l->SweptCurve(), wire) ) {
+		TopoDS_Face face;
+		if ( !convert_face(l->SweptCurve(),face) ) return false;
+		TopExp_Explorer exp(face, TopAbs_WIRE);
+		wire = TopoDS::Wire(exp.Current());
+	}
+
+	gp_Ax1 ax1;
+	IfcGeom::Kernel::convert(l->AxisPosition(), ax1);
+
+	gp_Trsf trsf;
+	bool has_position = true;
+#ifdef SCHEMA_IfcSweptSurface_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf);
+	}
+	
+	shape = BRepPrimAPI_MakeRevol(wire, ax1);
+
+	if (has_position) {
+		// IfcSweptSurface.Position (trsf) is an IfcAxis2Placement3D
+		// and therefore has a unit scale factor
+		shape.Move(trsf);
+	}
+
+	return !shape.IsNull();
+}

src/ifcgeom/mapping/IfcSweptDiskSolid.cpp

@@ -0,0 +1,286 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <Geom_Circle.hxx>
+#include <Geom_Ellipse.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+#include <ShapeFix_Shape.hxx>
+#include <BRepCheck_Analyzer.hxx>
+#include <Geom_Line.hxx>
+#include <Geom_Plane.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepFilletAPI_MakeFillet2d.hxx>
+
+#include "../ifcgeom/IfcGeom.h"
+
+#include "../ifcgeom_schema_agnostic/sweep_utils.h"
+#include "../ifcgeom_schema_agnostic/wire_utils.h"
+#include "../ifcgeom_schema_agnostic/face_definition.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+namespace {
+	std::string format_edge(const TopoDS_Edge& e) {
+		std::ostringstream oss;
+		double _, __;
+		TopoDS_Vertex v0, v1;
+
+		auto crv = BRep_Tool::Curve(e, _, __);
+		auto nm = crv->DynamicType()->Name();
+		TopExp::Vertices(e, v0, v1, true);
+
+		auto p0 = BRep_Tool::Pnt(v0);
+		auto p1 = BRep_Tool::Pnt(v1);
+
+		oss << "Edge" << std::endl << std::setprecision(2)
+			<< " (" << p0.X() << " " << p0.Y() << " " << p0.Z() << ")" << std::endl
+			<< " (" << p1.X() << " " << p1.Y() << " " << p1.Z() << ")" << std::endl
+			<< nm << std::endl;
+
+		return oss.str();
+	}
+}
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcSweptDiskSolid* l, TopoDS_Shape& shape) {
+	TopoDS_Wire wire, section1, section2;
+
+	bool hasInnerRadius = !!l->InnerRadius();
+
+	if (!convert_wire(l->Directrix(), wire)) {
+		return false;
+	}
+	
+	// Start- EndParam became optional in IFC4
+#ifdef SCHEMA_IfcSweptDiskSolid_StartParam_IS_OPTIONAL
+	auto sp = l->StartParam();
+	auto ep = l->EndParam();
+#else
+	boost::optional<double> sp, ep;
+	sp = l->StartParam();
+	ep = l->EndParam();
+#endif
+
+	if (util::count(wire, TopAbs_EDGE) == 1 && sp && ep) {
+		TopoDS_Vertex v0, v1;
+		TopExp::Vertices(wire, v0, v1);
+		if (v0.IsSame(v1)) {
+			TopExp_Explorer exp(wire, TopAbs_EDGE);
+			auto& e = TopoDS::Edge(exp.Current());
+			double a, b;
+			auto crv = BRep_Tool::Curve(e, a, b);
+			if ((crv->DynamicType() == STANDARD_TYPE(Geom_Circle)) ||
+				(crv->DynamicType() == STANDARD_TYPE(Geom_Ellipse))) 
+			{
+				BRepBuilderAPI_MakeEdge me(crv, *sp, *ep);
+				if (me.IsDone()) {
+					auto e2 = me.Edge();
+					BRep_Builder B;
+					wire.Nullify();
+					B.MakeWire(wire);
+					B.Add(wire, e2);
+				}
+			}
+		}
+	}
+
+	double fillet = 0.;
+
+#ifdef SCHEMA_HAS_IfcSweptDiskSolidPolygonal
+	if (l->as<IfcSchema::IfcSweptDiskSolidPolygonal>()) {
+		auto fr = l->as<IfcSchema::IfcSweptDiskSolidPolygonal>()->FilletRadius();
+		if (fr) {
+			fillet = *fr;
+		}
+	}
+#endif
+
+	if (fillet > getValue(GV_PRECISION)) {
+
+		if (util::is_polyhedron(wire)) {
+			BRep_Builder BB;
+			TopoDS_Vertex V;
+			std::vector<TopoDS_Edge> sorted_edges;
+			util::sort_edges(wire, sorted_edges);
+
+			if (sorted_edges.size() >= 2) {
+				size_t i = 0, j = 1;
+
+				// If the wire is closed we need to cycle from end back to begin
+				while (j < (sorted_edges.size() + (wire.Closed() ? 1 : 0))) {
+					const TopoDS_Edge& a = sorted_edges[i];
+					const TopoDS_Edge& b = sorted_edges[j % sorted_edges.size()];
+
+					/*
+					std::wcout << "INPUT:" << std::endl;
+					std::wcout << "a " << format_edge(a).c_str() << std::endl;
+					std::wcout << "b " << format_edge(b).c_str() << std::endl;
+					*/
+
+					// @todo this code is duplicated with code from IfcFace, refactor
+					// Help Open Cascade by finding the plane more efficiently
+					// We have already asserted the wire is a polyhedron and edges are linear
+					double _, __;
+					Handle(Geom_Line) c1 = Handle(Geom_Line)::DownCast(BRep_Tool::Curve(a, _, __));
+					Handle(Geom_Line) c2 = Handle(Geom_Line)::DownCast(BRep_Tool::Curve(b, _, __));
+
+					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;
+						gp_Pln plane(c1->Position().Location(), n);
+						auto face = BRepBuilderAPI_MakeFace(plane).Face();
+
+						{
+							TopoDS_Wire w;
+							BB.MakeWire(w);
+							BB.Add(w, a);
+							BB.Add(w, b);
+							BB.Add(face, w);
+						}
+						TopExp::CommonVertex(a, b, V);
+
+						BRepFilletAPI_MakeFillet2d mf2d(face);
+						mf2d.AddFillet(V, fillet);
+						mf2d.Build();
+
+						if (mf2d.IsDone()) {
+
+							auto new_wire = TopoDS::Wire(TopoDS_Iterator(mf2d.Shape()).Value());
+							std::vector<TopoDS_Edge> new_sorted_edges;
+							util::sort_edges(new_wire, new_sorted_edges);
+
+							//  B               C      B2            C
+							// 	o───────────────o      o─────────────o
+							// 	│                     /
+							// 	│                 B1 o
+							// 	│                    │
+							// 	│                    │
+							// 	o                    o
+							// 	A                    A
+
+							if (new_sorted_edges.size() == 3) {
+								// Delete AB
+								sorted_edges.erase(sorted_edges.begin() + i);
+								// Delete BC
+								sorted_edges.erase(sorted_edges.begin() + i);
+
+								/*
+								std::wcout << "OUTPUT:" << std::endl;
+								for (auto& e : new_sorted_edges) {
+									std::wcout << " " << format_edge(e).c_str() << std::endl;
+								}
+								*/
+
+								// Insert AB1 B1B2 B2C
+								sorted_edges.insert(sorted_edges.begin() + i, new_sorted_edges.begin(), new_sorted_edges.end());
+
+								// Number of edges increased, so an additional increment
+								i += 1;
+								j += 1;
+							} else {
+								Logger::Error("Unexpected amount of fillet edges generated");
+							}					
+						} else {
+							Logger::Error("Unable to build fillet, probably edge too short");
+						}
+					} else {
+						Logger::Error("Colinear edges, not applying fillet");
+					}
+					i++;
+					j++;
+				}
+			} else {
+				Logger::Error("Not enough edges for applying fillet");
+			}
+
+			TopoDS_Wire new_wire;
+			BB.MakeWire(new_wire);
+
+			for (size_t i = 0; i < sorted_edges.size(); ++i) {
+				const auto& e = sorted_edges[i];
+				BB.Add(new_wire, e);
+			}
+
+			wire = new_wire;
+		} else {
+			Logger::Error("Directrix is not polyhedral, ignoring FilletRadius");
+		}
+	}
+
+	// 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.
+	
+	util::process_sweep(wire, l->Radius() * getValue(GV_LENGTH_UNIT), shape);
+
+	if (shape.IsNull()) {
+		return false;
+	}
+
+	double r2 = 0.;
+
+	if (hasInnerRadius) {
+		// Subtraction of pipes with small radii is unstable.
+		r2 = *l->InnerRadius() * getValue(GV_LENGTH_UNIT);
+	}
+
+	if (r2 > getValue(GV_PRECISION) * 10.) {
+		TopoDS_Shape inner;
+		util::process_sweep(wire, r2, inner);
+
+		bool is_valid = false;
+
+		// Boolean op on the compound of separately processed sweeps
+		// is not attempted.
+		// @todo iterate over compound subshapes and process boolean
+		// separately.
+		// @todo don't process as boolean op at all, since we know
+		// only the start and end faces intersect and we know they
+		// are co-planar and we know they are circles.
+		if (shape.ShapeType() != TopAbs_COMPOUND) {
+			BRepAlgoAPI_Cut brep_cut(shape, inner);
+			if (brep_cut.IsDone()) {
+				TopoDS_Shape result = brep_cut;
+
+				ShapeFix_Shape fix(result);
+				fix.Perform();
+				result = fix.Shape();
+
+				is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
+				if (is_valid) {
+					shape = result;
+				}
+			}
+		}
+
+		if (!is_valid) {
+			Logger::Message(Logger::LOG_WARNING, "Failed to subtract inner radius void for:", l);
+		}
+	}
+
+	return true;
+}

src/ifcgeom/mapping/IfcTShapeProfileDef.cpp

@@ -0,0 +1,113 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcTShapeProfileDef* l, TopoDS_Shape& face) {
+	const bool doFlangeEdgeFillet = !!l->FlangeEdgeRadius();
+	const bool doWebEdgeFillet = !!l->WebEdgeRadius();
+	const bool doFillet = !!l->FilletRadius();
+	const bool hasFlangeSlope = !!l->FlangeSlope();
+	const bool hasWebSlope = !!l->WebSlope();
+
+	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;
+	}
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	double coords[16] = {d1/2.-dx2,-y, xx,xy, x,y-d2+dy2, x,y, -x,y, -x,y-d2+dy2, -xx,xy, -d1/2.+dx2,-y};
+	int fillets[6] = {0,1,2,5,6,7};
+	double radii[6] = {f2,f1,f3,f3,f1,f2};
+	return util::profile_helper(8, coords, (doFillet || doWebEdgeFillet || doFlangeEdgeFillet) ? 6 : 0, fillets, radii, trsf2d, face);
+}

src/ifcgeom/mapping/IfcToroidalSurface.cpp

@@ -0,0 +1,39 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS_Face.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include <Geom_ToroidalSurface.hxx>
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcToroidalSurface
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcToroidalSurface* l, TopoDS_Shape& face) {
+	gp_Trsf trsf;
+	IfcGeom::Kernel::convert(l->Position(), trsf);
+
+	// IfcElementarySurface.Position has unit scale factor
+	face = BRepBuilderAPI_MakeFace(new Geom_ToroidalSurface(gp::XOY(), l->MajorRadius() * getValue(GV_LENGTH_UNIT), l->MinorRadius() * getValue(GV_LENGTH_UNIT)), getValue(GV_PRECISION)).Face().Moved(trsf);
+	return true;
+}
+
+#endif

src/ifcgeom/mapping/IfcTrapeziumProfileDef.cpp

@@ -0,0 +1,58 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrapeziumProfileDef* l, TopoDS_Shape& face) {
+	const double x1 = l->BottomXDim() / 2. * 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.  * getValue(GV_LENGTH_UNIT);
+
+	// See: https://forums.buildingsmart.org/t/how-are-the-sides-of-ifctrapeziumprofiledefs-bounding-box-calculated-in-most-implementations/2945/8
+	// The trapezium x center should not be midway of BottomXDim but rather at the center of the overall bounding box.
+	const double x_offset = ((std::min(dx, 0.) + std::max(w + dx, x1 * 2.)) / 2.) - x1;
+
+	if ( x1 < ALMOST_ZERO || w < ALMOST_ZERO || y < ALMOST_ZERO ) {
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
+		return false;
+	}
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	double coords[8] = {
+		-x1 - x_offset, -y,
+		+x1 - x_offset, -y,
+		-x1 + dx + w - x_offset, y,
+		-x1 + dx - x_offset,y
+	};
+	return util::profile_helper(4,coords,0,0,0,trsf2d,face);
+}

src/ifcgeom/mapping/IfcTriangulatedFaceSet.cpp

@@ -0,0 +1,67 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <BRepBuilderAPI_MakeFace.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/base_utils.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+#ifdef SCHEMA_HAS_IfcTriangulatedFaceSet
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS_Shape& shape) {
+	IfcSchema::IfcCartesianPointList3D* point_list = l->Coordinates();
+	auto coord_list = point_list->CoordList();
+	std::vector<std::vector<int>> indices = l->CoordIndex();
+
+	faceset_helper<
+		std::vector<double>,
+		std::vector<int>
+	> helper(this, coord_list, indices, l->Closed().get_value_or(false));
+
+	TopTools_ListOfShape faces;
+
+	for (auto it = indices.begin(); it != indices.end(); ++it) {
+		TopoDS_Wire w;
+		if (helper.wire(*it, w)) {
+			BRepBuilderAPI_MakeFace mf(w);
+			if (mf.IsDone()) {
+				faces.Append(mf.Face());
+			}
+		}
+	}
+	
+	if (faces.Extent() > getValue(GV_MAX_FACES_TO_ORIENT) || !util::create_solid_from_faces(faces, shape, getValue(GV_PRECISION))) {
+		TopoDS_Compound compound;
+		BRep_Builder builder;
+		builder.MakeCompound(compound);
+
+		TopTools_ListIteratorOfListOfShape face_iterator;
+		for (face_iterator.Initialize(faces); face_iterator.More(); face_iterator.Next()) {
+			builder.Add(compound, face_iterator.Value());
+		}
+		shape = compound;
+	}
+	
+	return true;
+}
+
+#endif

src/ifcgeom/mapping/IfcTrimmedCurve.cpp

@@ -0,0 +1,252 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <cmath>
+#include <gp_Pnt.hxx>
+#include <Geom_Circle.hxx>
+#include <Geom_Ellipse.hxx>
+#include <BRepBuilderAPI_MakeVertex.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopExp.hxx>
+#include <BRep_Tool.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <BRepAdaptor_CompCurve.hxx>
+#include <Standard_Version.hxx>
+
+#if OCC_VERSION_HEX < 0x70600
+#include <BRepAdaptor_HCompCurve.hxx>
+#endif
+
+#include <Approx_Curve3d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#include "../ifcgeom_schema_agnostic/wire_builder.h"
+
+#define _USE_MATH_DEFINES
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire& wire) {
+	IfcSchema::IfcCurve* basis_curve = l->BasisCurve();
+	bool isConic = basis_curve->declaration().is(IfcSchema::IfcConic::Class());
+	double parameterFactor = isConic ? getValue(GV_PLANEANGLE_UNIT) : getValue(GV_LENGTH_UNIT);
+	
+	Handle(Geom_Curve) curve;
+	if (shape_type(basis_curve) == ST_CURVE) {
+		if (!convert_curve(basis_curve, curve)) return false;
+	} else if (shape_type(basis_curve) == ST_WIRE) {
+		Logger::Warning("Approximating BasisCurve due to possible discontinuities", l);
+		TopoDS_Wire w;
+		if (!convert_wire(basis_curve, w)) return false;
+#if OCC_VERSION_HEX < 0x70600
+		BRepAdaptor_CompCurve cc(w, true);
+		Handle(Adaptor3d_HCurve) hcc = Handle(Adaptor3d_HCurve)(new BRepAdaptor_HCompCurve(cc));
+#else
+		auto hcc = new BRepAdaptor_CompCurve(w, true);
+#endif
+		// @todo, arbitrary numbers here, note they cannot be too high as contiguous memory is allocated based on them.
+		Approx_Curve3d approx(hcc, getValue(GV_PRECISION), GeomAbs_C0, 10, 10);
+		curve = approx.Curve();
+	} else {
+		Logger::Error("Unknown BasisCurve", l);
+		return false;
+	}
+	
+	bool trim_cartesian = l->MasterRepresentation() != IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER;
+	aggregate_of_instance::ptr trims1 = l->Trim1();
+	aggregate_of_instance::ptr trims2 = l->Trim2();
+	
+	unsigned sense_agreement = l->SenseAgreement() ? 0 : 1;
+	double flts[2];
+	gp_Pnt pnts[2];
+	bool has_flts[2] = {false,false};
+	bool has_pnts[2] = {false,false};
+	
+	TopoDS_Edge e;
+
+	for ( aggregate_of_instance::it it = trims1->begin(); it != trims1->end(); it ++ ) {
+		IfcUtil::IfcBaseClass* i = *it;
+		if ( i->declaration().is(IfcSchema::IfcCartesianPoint::Class()) ) {
+			IfcGeom::Kernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[sense_agreement] );
+			has_pnts[sense_agreement] = true;
+		} else if ( i->declaration().is(IfcSchema::IfcParameterValue::Class()) ) {
+			const double value = *((IfcSchema::IfcParameterValue*)i);
+			flts[sense_agreement] = value * parameterFactor;
+			has_flts[sense_agreement] = true;
+		}
+	}
+
+	for ( aggregate_of_instance::it it = trims2->begin(); it != trims2->end(); it ++ ) {
+		IfcUtil::IfcBaseClass* i = *it;
+		if ( i->declaration().is(IfcSchema::IfcCartesianPoint::Class()) ) {
+			IfcGeom::Kernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[1-sense_agreement] );
+			has_pnts[1-sense_agreement] = true;
+		} else if ( i->declaration().is(IfcSchema::IfcParameterValue::Class()) ) {
+			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 ) {
+		if ( pnts[0].Distance(pnts[1]) < 2 * getValue(GV_PRECISION) ) {
+			Logger::Message(Logger::LOG_WARNING,"Skipping segment with length below tolerance level:",l);
+			return false;
+		}
+		ShapeFix_ShapeTolerance FTol;
+		TopoDS_Vertex v1 = BRepBuilderAPI_MakeVertex(pnts[0]);
+		TopoDS_Vertex v2 = BRepBuilderAPI_MakeVertex(pnts[1]);
+		FTol.SetTolerance(v1, getValue(GV_PRECISION), TopAbs_VERTEX);
+		FTol.SetTolerance(v2, getValue(GV_PRECISION), TopAbs_VERTEX);
+		BRepBuilderAPI_MakeEdge me (curve,v1,v2);
+		if (!me.IsDone()) {
+			BRepBuilderAPI_EdgeError err = me.Error();
+			if ( err == BRepBuilderAPI_PointProjectionFailed ) {
+				Logger::Message(Logger::LOG_WARNING,"Point projection failed for:",l);
+				trim_cartesian_failed = true;
+			}
+		} else {
+			e = me.Edge();
+			// BRepBuilderAPI_MakeEdge swaps v1 and v2 if the parameter value of v2 is 
+			// smaller than that of v1. In that case the edge has to be reversed so that
+			// the vertex order is consistent with Trim1 and Trim2. Otherwise the
+			// IfcOpenShell wire builder will create intermediate edges automatically.
+			// The alternative would be to reverse the underlying curve instead.
+			if (!TopExp::FirstVertex(e, true).IsSame(v1)) {
+				e.Reverse();
+			}
+		}
+	}
+
+	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->declaration().is(IfcSchema::IfcLine::Class()) ) {
+			IfcSchema::IfcLine* line = static_cast<IfcSchema::IfcLine*>(basis_curve);
+			const double magnitude = line->Dir()->Magnitude();
+			flts[0] *= magnitude; flts[1] *= magnitude;
+		}
+		if ( basis_curve->declaration().is(IfcSchema::IfcEllipse::Class()) ) {
+			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);
+			const bool rotated = y > x;
+			if (rotated) {
+				flts[0] -= M_PI / 2.;
+				flts[1] -= M_PI / 2.;
+			}
+		}
+
+		double radius = 1.0;
+		if (curve->DynamicType() == STANDARD_TYPE(Geom_Circle)) {
+			auto circle_curve = Handle_Geom_Circle::DownCast(curve);
+			radius = circle_curve->Radius();
+		} else if (curve->DynamicType() == STANDARD_TYPE(Geom_Ellipse)) {
+			auto circle_curve = Handle_Geom_Ellipse::DownCast(curve);
+			radius = (circle_curve->MajorRadius() + circle_curve->MinorRadius()) / 2.;
+		}
+
+		// Fix from @sanderboer to compare using model tolerance, see #744
+		// Made dependent on radius, see #928
+
+		// A good critereon for determining whether to take full curve
+		// or trimmed segment would be whether there are other curve segments or this
+		// is the only one.
+		boost::optional<size_t> num_segments;
+		auto segment = l->data().getInverse(&IfcSchema::IfcCompositeCurveSegment::Class(), -1);
+		if (segment->size() == 1) {
+			auto comp = (*segment->begin())->data().getInverse(&IfcSchema::IfcCompositeCurve::Class(), -1);
+			if (comp->size() == 1) {
+				num_segments = (*comp->begin())->as<IfcSchema::IfcCompositeCurve>()->Segments()->size();
+			}
+		}
+
+		// @todo is 100. not too much? Check with the original issue.
+		const double precision_markup = getValue(IfcGeom::Kernel::GV_PRECISION_FACTOR) == 1. ? 1. : 100.;
+
+		if (isConic && ALMOST_THE_SAME(fmod(flts[1]-flts[0],M_PI*2.), 0., precision_markup * getValue(GV_PRECISION) / (2 * M_PI * radius))) {
+			e = BRepBuilderAPI_MakeEdge(curve).Edge();
+		} else {
+			BRepBuilderAPI_MakeEdge me (curve,flts[0],flts[1]);
+			e = me.Edge();
+		}
+
+		if (num_segments && *num_segments > 1) {
+			TopoDS_Vertex v0, v1;
+			TopExp::Vertices(e, v0, v1);
+			if (v0.IsSame(v1)) {
+				Logger::Warning("Skipping degenerate segment", l);
+				return false;
+			}
+		}
+
+	} else if ( trim_cartesian_failed && (has_pnts[0] && has_pnts[1]) ) {
+		e = BRepBuilderAPI_MakeEdge(pnts[0], pnts[1]).Edge();
+	}
+
+	if (e.IsNull()) {
+		return false;
+	}
+
+	if (isConic) {
+		// Tiny circle segnments can cause issues later on, for example
+		// when the comp curve is used as the sweeping directrix.
+		double a, b;
+		Handle(Geom_Curve) crv = BRep_Tool::Curve(e, a, b);
+		double radius = -1.;
+		if (crv->DynamicType() == STANDARD_TYPE(Geom_Circle)) {
+			radius = Handle(Geom_Circle)::DownCast(crv)->Radius();
+		} else if (crv->DynamicType() == STANDARD_TYPE(Geom_Ellipse)) {
+			// The formula in deflection_for_approximating_circle() is for circles, but probably good enough
+			radius = Handle(Geom_Ellipse)::DownCast(crv)->MajorRadius();
+		}
+		if (radius > 0. && util::deflection_for_approximating_circle(radius, b - a) < 100 * getValue(GV_PRECISION) && std::abs(b-a) < M_PI/4.) {
+			TopoDS_Vertex v0, v1;
+			TopExp::Vertices(e, v0, v1);
+			e = TopoDS::Edge(BRepBuilderAPI_MakeEdge(v0, v1).Edge().Oriented(e.Orientation()));
+			Logger::Warning("Subsituted edge with linear approximation", l);
+		}
+	}
+
+	BRepBuilderAPI_MakeWire w;
+	w.Add(e);
+
+	if (w.IsDone()) {
+		wire = w.Wire();
+
+		// When SenseAgreement == .F. the vertices above have been reversed to
+		// comply with the direction of conical curves. The ordering of the
+		// vertices then still needs to be reversed in order to have begin and
+		// end vertex consistent with IFC.
+		if (sense_agreement != 0) { // .F.
+			wire.Reverse();
+		}
+
+		return true;
+	} else {
+		return false;
+	}
+}

src/ifcgeom/mapping/IfcUShapeProfileDef.cpp

@@ -0,0 +1,72 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcUShapeProfileDef* l, TopoDS_Shape& face) {
+	const bool doEdgeFillet = !!l->EdgeRadius();
+	const bool doFillet = !!l->FilletRadius();
+	const bool hasSlope = !!l->FlangeSlope();
+
+	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 = l->FlangeSlope().get_value_or(0.) * getValue(GV_PLANEANGLE_UNIT);
+	
+	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;
+	}
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	double coords[16] = {-x,-y, x,-y, x,-y+d2-dy2, -x+d1,-y+d2+dy1, -x+d1,y-d2-dy1, x,y-d2+dy2, x,y, -x,y};
+	int fillets[4] = {2,3,4,5};
+	double radii[4] = {f2,f1,f1,f2};
+	return util::profile_helper(8, coords, (doFillet || doEdgeFillet) ? 4 : 0, fillets, radii, trsf2d, face);
+}

src/ifcgeom/mapping/IfcVector.cpp

@@ -0,0 +1,33 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Vec.hxx>
+#include <gp_Dir.hxx>
+#include "../ifcgeom/IfcGeom.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcVector* l, gp_Vec& v) {
+	IN_CACHE(IfcVector,l,gp_Vec,v)
+	gp_Dir d;
+	IfcGeom::Kernel::convert(l->Orientation(),d);
+	v = l->Magnitude() * getValue(GV_LENGTH_UNIT) * d;
+	CACHE(IfcVector,l,v)
+	return true;
+}

src/ifcgeom/mapping/IfcZShapeProfileDef.cpp

@@ -0,0 +1,63 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <gp_Trsf2d.hxx>
+#include "../ifcgeom/IfcGeom.h"
+#include "../ifcgeom_schema_agnostic/profile_helper.h"
+
+#define Kernel MAKE_TYPE_NAME(Kernel)
+
+bool IfcGeom::Kernel::convert(const IfcSchema::IfcZShapeProfileDef* l, TopoDS_Shape& 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->FilletRadius();
+	bool doEdgeFillet = !!l->EdgeRadius();
+	
+	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;
+	}
+
+	gp_Trsf2d trsf2d;
+	bool has_position = true;
+#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
+	has_position = l->Position() != nullptr;
+#endif
+	if (has_position) {
+		IfcGeom::Kernel::convert(l->Position(), trsf2d);
+	}
+
+	double coords[16] = {-dx,-y, x,-y, x,-y+dy, dx,-y+dy, dx,y, -x,y, -x,y-dy, -dx,y-dy};
+	int fillets[4] = {2,3,6,7};
+	double radii[4] = {f2,f1,f2,f1};
+	return util::profile_helper(8,coords,(doFillet || doEdgeFillet) ? 4 : 0,fillets,radii,trsf2d,face);
+}

src/ifcgeom/mapping/Kernel.cpp

@@ -0,0 +1,222 @@
+#include "Kernel.h"
+
+#include <TopExp.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <TopoDS_Edge.hxx>
+
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/preprocessor/seq/for_each.hpp>
+
+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);
+	}
+}
+
+IfcGeom::impl::KernelFactoryImplementation& IfcGeom::impl::kernel_implementations() {
+	static KernelFactoryImplementation impl;
+	return impl;
+}
+
+// Declares the schema-based external kernel initialization routines:
+// - extern void init_KernelImplementation_Ifc2x3(IfcGeom::impl::KernelFactoryImplementation*);
+// - ...
+#define EXTERNAL_DEFS(r, data, elem) \
+	extern void BOOST_PP_CAT(init_KernelImplementation_Ifc, elem)(IfcGeom::impl::KernelFactoryImplementation*);
+
+// Declares the schema-based external iterator initialization routines:
+// - init_IteratorImplementation_Ifc2x3(this);
+// - ...
+#define CALL_DEFS(r, data, elem) \
+	BOOST_PP_CAT(init_KernelImplementation_Ifc, elem)(this);
+
+BOOST_PP_SEQ_FOR_EACH(EXTERNAL_DEFS, , SCHEMA_SEQ)
+
+IfcGeom::impl::KernelFactoryImplementation::KernelFactoryImplementation() {
+	BOOST_PP_SEQ_FOR_EACH(CALL_DEFS, , SCHEMA_SEQ)
+}
+
+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) {                                                                                               \
+		aggregate_of_instance::ptr parents = product->data().getInverse((&IfcSchema::IfcRelAggregates::Class()), -1);    \
+		parents->push(product->data().getInverse((&IfcSchema::IfcRelNests::Class()), -1));                       \
+		for (aggregate_of_instance::it it = parents->begin(); it != parents->end(); ++it) {                      \
+			IfcSchema::IfcRelDecomposes* decompose = (*it)->as<IfcSchema::IfcRelDecomposes>();                   \
+			IfcUtil::IfcBaseEntity* ifc_objectdef;                                                               \
+                 																								 \
+			ifc_objectdef = get_RelatingObject(decompose);                                                       \
+                                                                                                                 \
+			if (!ifc_objectdef || product == ifc_objectdef) continue;                                            \
+			parent = ifc_objectdef->as<IfcSchema::IfcObjectDefinition>();                                        \
+		}                                                                                                        \
+	}                                                                                                            \
+	return parent;                                                                                               \
+}
+
+#define GET_RELATINGOBJECT_IFC4_VARIANT(IfcSchema)                                    \
+                                                                                      \
+IfcUtil::IfcBaseEntity* get_RelatingObject(IfcSchema::IfcRelDecomposes* decompose) {  \
+    IfcSchema::IfcRelAggregates* aggr = decompose->as<IfcSchema::IfcRelAggregates>(); \
+    if (aggr != nullptr) {                                                            \
+        return aggr->RelatingObject();                                                \
+    }                                                                                 \
+    IfcSchema::IfcRelNests* nest = decompose->as<IfcSchema::IfcRelNests>();           \
+    if (nest != nullptr) {                                                            \
+        return nest->RelatingObject();                                                \
+    }                                                                                 \
+    return nullptr;                                                                   \
+}
+
+namespace {
+
+#ifdef HAS_SCHEMA_2x3
+	IfcUtil::IfcBaseEntity* get_RelatingObject(Ifc2x3::IfcRelDecomposes* decompose) {
+		return decompose->RelatingObject();
+	}
+	CREATE_GET_DECOMPOSING_ENTITY(Ifc2x3);
+#endif
+
+#ifdef HAS_SCHEMA_4
+	GET_RELATINGOBJECT_IFC4_VARIANT(Ifc4);
+	CREATE_GET_DECOMPOSING_ENTITY(Ifc4);
+#endif
+
+#ifdef HAS_SCHEMA_4x1
+	GET_RELATINGOBJECT_IFC4_VARIANT(Ifc4x1);
+	CREATE_GET_DECOMPOSING_ENTITY(Ifc4x1);
+#endif
+
+#ifdef HAS_SCHEMA_4x2
+	GET_RELATINGOBJECT_IFC4_VARIANT(Ifc4x2);
+	CREATE_GET_DECOMPOSING_ENTITY(Ifc4x2);
+#endif
+
+#ifdef HAS_SCHEMA_4x3_rc1
+	GET_RELATINGOBJECT_IFC4_VARIANT(Ifc4x3_rc1);
+	CREATE_GET_DECOMPOSING_ENTITY(Ifc4x3_rc1);
+#endif
+
+#ifdef HAS_SCHEMA_4x3_rc2
+	GET_RELATINGOBJECT_IFC4_VARIANT(Ifc4x3_rc2);
+	CREATE_GET_DECOMPOSING_ENTITY(Ifc4x3_rc2);
+#endif
+	
+#ifdef HAS_SCHEMA_4x3_rc3
+	GET_RELATINGOBJECT_IFC4_VARIANT(Ifc4x3_rc3);
+	CREATE_GET_DECOMPOSING_ENTITY(Ifc4x3_rc3);
+#endif
+
+#ifdef HAS_SCHEMA_4x3_rc4
+	GET_RELATINGOBJECT_IFC4_VARIANT(Ifc4x3_rc4);
+	CREATE_GET_DECOMPOSING_ENTITY(Ifc4x3_rc4);
+#endif
+
+#ifdef HAS_SCHEMA_4x3
+	GET_RELATINGOBJECT_IFC4_VARIANT(Ifc4x3);
+	CREATE_GET_DECOMPOSING_ENTITY(Ifc4x3);
+#endif
+}
+
+// Declares the schema-based IfcProduct check:
+// - if (inst->as<Ifc2x3::IfcProduct>()) { ... }
+// - ...
+#define IFCPROCUCT_CHECK(r, data, elem) \
+	if (inst->as<BOOST_PP_CAT(Ifc, elem)::IfcProduct>()) { return get_decomposing_entity_impl(inst->as<BOOST_PP_CAT(Ifc, elem)::IfcProduct>(), include_openings); }
+
+#define GET_LAYERS(r, data, elem) \
+	if (inst->as<BOOST_PP_CAT(Ifc, elem)::IfcProduct>()) { return get_layers_impl<BOOST_PP_CAT(Ifc, elem)>(inst->as<BOOST_PP_CAT(Ifc, elem)::IfcProduct>()); }
+
+
+IfcUtil::IfcBaseEntity* IfcGeom::Kernel::get_decomposing_entity(IfcUtil::IfcBaseEntity* inst, bool include_openings) {
+	BOOST_PP_SEQ_FOR_EACH(IFCPROCUCT_CHECK, , SCHEMA_SEQ)
+
+	if (inst->declaration().name() == "IfcProject") {
+		return nullptr;
+	}
+
+	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->Representation()) {
+			aggregate_of_instance::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) {
+	BOOST_PP_SEQ_FOR_EACH(GET_LAYERS, , SCHEMA_SEQ)
+
+	throw IfcParse::IfcException("Unexpected entity " + inst->declaration().name());
+}