diff --git a/.gitattributes b/.gitattributes
index 7664152c72..720b232cbb 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -30,6 +30,7 @@
 *.gitkeep
 *.h text
 *.html text
+*.i text
 *.ifc text
 *.json text
 *.md text
@@ -43,7 +44,6 @@
 # files not normalized ATM
 # bnf
 # blend
-# i
 # ico
 # mo
 # mpass
diff --git a/src/ifcwrap/IfcGeomWrapper.i b/src/ifcwrap/IfcGeomWrapper.i
index 5935c48718..4c6e131e03 100644
--- a/src/ifcwrap/IfcGeomWrapper.i
+++ b/src/ifcwrap/IfcGeomWrapper.i
@@ -1,1418 +1,1418 @@
-/********************************************************************************
- *                                                                              *
- * 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/>.         *
- *                                                                              *
- ********************************************************************************/
-
-%rename("buffer") stream_or_filename;
-
-%ignore stream_or_filename::stream;
-%ignore boost::hash_value;
-%ignore IfcGeom::BRepElement::geometry_pointer;
-%ignore IfcGeom::TriangulationElement::geometry_pointer;
-
-// This is only used for RGB colours, hence the size of 3
-%typemap(out) const double* {
-	$result = PyTuple_New(3);
-	for (int i = 0; i < 3; ++i) {
-		PyTuple_SetItem($result, i, PyFloat_FromDouble($1[i]));
-	}
-}
-
-%typemap(out) Eigen::Matrix4d {
-	$result = PyTuple_New(4);
-	for (int i = 0; i < 4; ++i) {
-		auto row = PyTuple_New(4);
-		for (int j = 0; j < 4; ++j) {
-			PyTuple_SetItem(row, j, PyFloat_FromDouble($1(i, j)));
-		}
-		PyTuple_SetItem($result, i, row);
-	}
-}
-
-// SWIG does not support bool references in a meaningful way, so the
-// ifcopenshell::geometry::Settings functions degrade to return a read only value
-%typemap(out) double& {
-	$result = SWIG_From_double(*$1);
-}
-%typemap(out) bool& {
-	$result = PyBool_FromLong(static_cast<long>(*$1));
-}
-
-%typemap(out) IfcGeom::OpaqueNumber {
-	$result = SWIG_NewPointerObj(SWIG_as_voidptr(new IfcGeom::OpaqueNumber($1)), SWIGTYPE_p_IfcGeom__OpaqueNumber, SWIG_POINTER_OWN);
-}
-
-%typemap(in) const IfcGeom::OpaqueNumber& (IfcGeom::OpaqueNumber temp) {
-	void* argp = nullptr;
-	int res = SWIG_ConvertPtr($input, &argp, SWIGTYPE_p_IfcGeom__OpaqueNumber, 0);
-	if (!SWIG_IsOK(res) || !argp) {
-		SWIG_exception_fail(SWIG_ArgError(res), "Expected IfcGeom::OpaqueNumber");
-	}
-	temp = *reinterpret_cast<IfcGeom::OpaqueNumber*>(argp);
-	$1 = &temp;
-}
-
-// Using RTTI return a more specialized type of Element
-// Note that these elements are not to be owned by SWIG/Python as they will be freed automatically upon the next iteration
-// except for the IfcGeom::Element instances which are returned by Iterator::getObject() calls
-%typemap(out) IfcGeom::Element* {
-	IfcGeom::SerializedElement* serialized_elem = dynamic_cast<IfcGeom::SerializedElement*>($1);
-	IfcGeom::TriangulationElement* triangulation_elem = dynamic_cast<IfcGeom::TriangulationElement*>($1);
-	IfcGeom::BRepElement* brep_elem = dynamic_cast<IfcGeom::BRepElement*>($1);
-	if (triangulation_elem) {
-		$result = SWIG_NewPointerObj(SWIG_as_voidptr(triangulation_elem), SWIGTYPE_p_IfcGeom__TriangulationElement, 0);
-	} else if (serialized_elem) {
-		$result = SWIG_NewPointerObj(SWIG_as_voidptr(serialized_elem), SWIGTYPE_p_IfcGeom__SerializedElement, 0);
-	} else if (brep_elem) {
-		$result = SWIG_NewPointerObj(SWIG_as_voidptr(brep_elem), SWIGTYPE_p_IfcGeom__BRepElement, 0);
-	} else {
-		$result = SWIG_NewPointerObj(SWIG_as_voidptr($1), SWIGTYPE_p_IfcGeom__Element, SWIG_POINTER_OWN);
-	}
-}
-
-%newobject IfcGeom::Representation::BRep::item;
-%newobject IfcGeom::Representation::BRep::as_compound;
-
-%newobject IfcGeom::ConversionResultShape::halfspaces;
-%newobject IfcGeom::ConversionResultShape::box;
-%newobject IfcGeom::ConversionResultShape::solid;
-%newobject IfcGeom::ConversionResultShape::add;
-%newobject IfcGeom::ConversionResultShape::subtract;
-%newobject IfcGeom::ConversionResultShape::intersect;
-%newobject IfcGeom::ConversionResultShape::concat;
-%newobject IfcGeom::ConversionResultShape::moved;
-%newobject IfcGeom::ConversionResultShape::wrap_in_compound;
-
-
-%newobject nary_union;
-
-
-%inline %{
-template <typename T>
-std::pair<char const*, size_t> vector_to_buffer(const T& t) {
-    using V = typename std::remove_reference<decltype(t)>::type;
-    return { reinterpret_cast<const char*>(t.data()), t.size() * sizeof(typename V::value_type) };
-}
-%}
-
-%ignore ifcopenshell::geometry::taxonomy::item::print;
-
-%typemap(out) std::variant<boost::blank, ifcopenshell::geometry::taxonomy::point3::ptr, double> {
-	if ($1.index() == 0) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	} else if ($1.index() == 1) {
-		return SWIG_NewPointerObj(SWIG_as_voidptr(new std::shared_ptr<ifcopenshell::geometry::taxonomy::point3>(std::get<ifcopenshell::geometry::taxonomy::point3::ptr>($1))), SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__point3_t, 0 | SWIG_POINTER_OWN);
-	} else {
-		return PyFloat_FromDouble(std::get<double>($1));
-	}
-}
-
-%typemap(out) std::optional<bool> {
-    if ($1) {
-        $result = PyBool_FromLong(*$1 ? 1 : 0);
-    } else {
-        Py_INCREF(Py_None);
-        $result = Py_None;
-    }
-}
-
-%typemap(in) ifcopenshell::geometry::taxonomy::item::ptr {
-	// @this is really annoying, but apparently inheritance
-	// is lost in swig in the shared_ptr type hiearchy
-	using namespace ifcopenshell::geometry::taxonomy;
-	if (!$1) $1 = try_upcast<boolean_result>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__boolean_result_t);
-	if (!$1) $1 = try_upcast<bspline_curve>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__bspline_curve_t);
-	if (!$1) $1 = try_upcast<bspline_surface>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__bspline_surface_t);
-	if (!$1) $1 = try_upcast<circle>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__circle_t);
-	if (!$1) $1 = try_upcast<collection>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__collection_t);
-	if (!$1) $1 = try_upcast<colour>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__colour_t);
-	if (!$1) $1 = try_upcast<cylinder>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__cylinder_t);
-	if (!$1) $1 = try_upcast<direction3>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__direction3_t);
-	if (!$1) $1 = try_upcast<edge>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__edge_t);
-	if (!$1) $1 = try_upcast<ellipse>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__ellipse_t);
-	if (!$1) $1 = try_upcast<extrusion>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__extrusion_t);
-	if (!$1) $1 = try_upcast<face>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__face_t);
-	if (!$1) $1 = try_upcast<line>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__line_t);
-	if (!$1) $1 = try_upcast<loft>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__loft_t);
-	if (!$1) $1 = try_upcast<loop>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__loop_t);
-	if (!$1) $1 = try_upcast<matrix4>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__matrix4_t);
-	if (!$1) $1 = try_upcast<node>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__node_t);
-	if (!$1) $1 = try_upcast<offset_curve>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__offset_curve_t);
-	if (!$1) $1 = try_upcast<function_item>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__function_item_t);
-	if (!$1) $1 = try_upcast<functor_item>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__functor_item_t);
-	if (!$1) $1 = try_upcast<piecewise_function>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__piecewise_function_t);
-	if (!$1) $1 = try_upcast<gradient_function>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__gradient_function_t);
-	if (!$1) $1 = try_upcast<cant_function>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__cant_function_t);
-	if (!$1) $1 = try_upcast<offset_function>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__offset_function_t);
-	if (!$1) $1 = try_upcast<plane>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__plane_t);
-	if (!$1) $1 = try_upcast<point3>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__point3_t);
-	if (!$1) $1 = try_upcast<revolve>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__revolve_t);
-	if (!$1) $1 = try_upcast<shell>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__shell_t);
-	if (!$1) $1 = try_upcast<solid>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__solid_t);
-	if (!$1) $1 = try_upcast<sphere>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__sphere_t);
-	if (!$1) $1 = try_upcast<torus>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__torus_t);
-	if (!$1) $1 = try_upcast<style>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__style_t);
-	if (!$1) $1 = try_upcast<sweep_along_curve>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__sweep_along_curve_t);
-}
-
-%inline %{
-std::string taxonomy_item_repr(ifcopenshell::geometry::taxonomy::item::ptr i) {
-	std::ostringstream oss;
-	i->print(oss);
-	std::string result = oss.str();
-
-	// Strip new line at the end of the printed result.
-	// result is probably always ends with \n but just to be safe.
-	if (!result.empty() && result.back() == '\n') {
-		result.pop_back();
-	}
-	return result;  
-}
-%}
-
-%{
-
-
-namespace {
-    // Helper function to create a Python tuple from an Eigen matrix/vector
-    template <typename T>
-    PyObject* eigen_to_python_tuple(const Eigen::MatrixBase<T>& mat) {
-        constexpr auto rows = T::RowsAtCompileTime;
-        constexpr auto cols = T::ColsAtCompileTime;
-
-        if constexpr (rows == 1 || cols == 1) {
-            // Eigen::Vector (1D array)
-            PyObject* tuple = PyTuple_New(rows * cols);
-            for (int i = 0; i < mat.size(); ++i) {
-                PyTuple_SetItem(tuple, i, PyFloat_FromDouble(mat(i)));
-            }
-            return tuple;
-        } else {
-            // Eigen::Matrix (2D array)
-            PyObject* tuple = PyTuple_New(rows);
-            for (int i = 0; i < rows; ++i) {
-                PyObject* row = PyTuple_New(cols);
-                for (int j = 0; j < cols; ++j) {
-                    PyTuple_SetItem(row, j, PyFloat_FromDouble(mat(i, j)));
-                }
-                PyTuple_SetItem(tuple, i, row);
-            }
-            return tuple;
-        }
-    }
-}
-
-%}
-
-%shared_ptr(ifcopenshell::geometry::taxonomy::boolean_result);
-%shared_ptr(ifcopenshell::geometry::taxonomy::item);
-%shared_ptr(ifcopenshell::geometry::taxonomy::implicit_item);
-%shared_ptr(ifcopenshell::geometry::taxonomy::function_item);
-%shared_ptr(ifcopenshell::geometry::taxonomy::functor_item);
-%shared_ptr(ifcopenshell::geometry::taxonomy::piecewise_function);
-%shared_ptr(ifcopenshell::geometry::taxonomy::gradient_function);
-%shared_ptr(ifcopenshell::geometry::taxonomy::cant_function);
-%shared_ptr(ifcopenshell::geometry::taxonomy::offset_function);
-%shared_ptr(ifcopenshell::geometry::taxonomy::less_functor);
-%shared_ptr(ifcopenshell::geometry::taxonomy::eigen_base);
-%shared_ptr(ifcopenshell::geometry::taxonomy::matrix4);
-%shared_ptr(ifcopenshell::geometry::taxonomy::colour);
-%shared_ptr(ifcopenshell::geometry::taxonomy::style);
-%shared_ptr(ifcopenshell::geometry::taxonomy::geom_item);
-%shared_ptr(ifcopenshell::geometry::taxonomy::cartesian_base);
-%shared_ptr(ifcopenshell::geometry::taxonomy::point3);
-%shared_ptr(ifcopenshell::geometry::taxonomy::direction3);
-%shared_ptr(ifcopenshell::geometry::taxonomy::curve);
-%shared_ptr(ifcopenshell::geometry::taxonomy::line);
-%shared_ptr(ifcopenshell::geometry::taxonomy::circle);
-%shared_ptr(ifcopenshell::geometry::taxonomy::ellipse);
-%shared_ptr(ifcopenshell::geometry::taxonomy::bspline_curve);
-%shared_ptr(ifcopenshell::geometry::taxonomy::offset_curve);
-%shared_ptr(ifcopenshell::geometry::taxonomy::trimmed_curve);
-%shared_ptr(ifcopenshell::geometry::taxonomy::edge);
-%shared_ptr(ifcopenshell::geometry::taxonomy::collection_base);
-%shared_ptr(ifcopenshell::geometry::taxonomy::collection);
-%shared_ptr(ifcopenshell::geometry::taxonomy::loop);
-%shared_ptr(ifcopenshell::geometry::taxonomy::face);
-%shared_ptr(ifcopenshell::geometry::taxonomy::shell);
-%shared_ptr(ifcopenshell::geometry::taxonomy::solid);
-%shared_ptr(ifcopenshell::geometry::taxonomy::loft);
-%shared_ptr(ifcopenshell::geometry::taxonomy::surface);
-%shared_ptr(ifcopenshell::geometry::taxonomy::plane);
-%shared_ptr(ifcopenshell::geometry::taxonomy::cylinder);
-%shared_ptr(ifcopenshell::geometry::taxonomy::sphere);
-%shared_ptr(ifcopenshell::geometry::taxonomy::torus);
-%shared_ptr(ifcopenshell::geometry::taxonomy::bspline_surface);
-%shared_ptr(ifcopenshell::geometry::taxonomy::sweep);
-%shared_ptr(ifcopenshell::geometry::taxonomy::extrusion);
-%shared_ptr(ifcopenshell::geometry::taxonomy::revolve);
-%shared_ptr(ifcopenshell::geometry::taxonomy::sweep_along_curve);
-%shared_ptr(ifcopenshell::geometry::taxonomy::node);
-
-%include "../ifcgeom/ifc_geom_api.h"
-%include "../ifcgeom/ConversionResult.h"
-%include "../ifcgeom/ConversionSettings.h"
-
-// Keep the owning element alive while its geometry is referenced (#1124).
-%define GEOMETRY_WITH_BACKREF(cls)
-%feature("shadow") cls::geometry %{
-	@property
-	def geometry(self):
-		result = $action(self)
-		result._parent = self
-		return result
-%}
-%enddef
-
-GEOMETRY_WITH_BACKREF(IfcGeom::TriangulationElement)
-GEOMETRY_WITH_BACKREF(IfcGeom::SerializedElement)
-GEOMETRY_WITH_BACKREF(IfcGeom::BRepElement)
-
-%include "../ifcgeom/IfcGeomElement.h"
-%include "../ifcgeom/IfcGeomRepresentation.h"
-%include "../ifcgeom/Iterator.h"
-%include "../ifcgeom/GeometrySerializer.h"
-%include "../ifcgeom/taxonomy.h"
-%include "../ifcgeom/function_item_evaluator.h"
-
-%{
-#include "../serializers/geometry_serializer_plugin.h"
-
-class PythonPluginGeometrySerializer : public GeometrySerializer {
-public:
-	PythonPluginGeometrySerializer(
-		const std::string& extension,
-		const std::string& output_filename,
-		const std::string& output_temp_filename,
-		ifcopenshell::geometry::Settings& geometry_settings,
-		const ifcopenshell::geometry::SerializerSettings& serializer_settings
-	)
-		: GeometrySerializer(geometry_settings, serializer_settings)
-	{
-		ifcopenshell::serializers::geometry_serializer_context context{
-			output_filename,
-			output_temp_filename.empty() ? output_filename : output_temp_filename,
-			geometry_settings,
-			serializer_settings
-		};
-
-		initialize_serializer(extension, context);
-	}
-
-	PythonPluginGeometrySerializer(
-		const std::string& extension,
-		const stream_or_filename& output_filename,
-		const stream_or_filename& output_temp_filename,
-		ifcopenshell::geometry::Settings& geometry_settings,
-		const ifcopenshell::geometry::SerializerSettings& serializer_settings
-	)
-		: GeometrySerializer(geometry_settings, serializer_settings)
-	{
-		const auto output_filename_string = output_filename.filename().value_or("");
-		const auto output_temp_filename_string = output_temp_filename.filename().value_or(output_filename_string);
-		ifcopenshell::serializers::geometry_serializer_context context{
-			output_filename_string,
-			output_temp_filename_string,
-			geometry_settings,
-			serializer_settings,
-			&output_filename,
-			&output_temp_filename
-		};
-
-		initialize_serializer(extension, context);
-	}
-
-private:
-	void initialize_serializer(
-		const std::string& extension,
-		ifcopenshell::serializers::geometry_serializer_context& context
-	) {
-		auto& registry = ifcopenshell::serializers::geometry_serializer_registry_instance();
-		registry.configure(extension, context);
-		geometry_settings_ = context.geometry_settings;
-		serializer_ = registry.create(extension, context);
-	}
-
-public:
-
-	bool ready() override {
-		return serializer_->ready();
-	}
-
-	bool is_streaming() const override {
-		return serializer_->is_streaming();
-	}
-
-	void writeHeader() override {
-		serializer_->writeHeader();
-	}
-
-	void finalize() override {
-		serializer_->finalize();
-	}
-
-	void setFile(ifcopenshell::file& file) override {
-		serializer_->setFile(file);
-	}
-
-	bool isTesselated() const override {
-		return serializer_->isTesselated();
-	}
-
-	void write(const IfcGeom::TriangulationElement* element) override {
-		serializer_->write(element);
-	}
-
-	void write(const IfcGeom::BRepElement* element) override {
-		serializer_->write(element);
-	}
-
-	void setUnitNameAndMagnitude(const std::string& name, float magnitude) override {
-		serializer_->setUnitNameAndMagnitude(name, magnitude);
-	}
-
-	IfcGeom::Element* read(
-		ifcopenshell::file& file,
-		const std::string& guid,
-		const std::string& representation_id,
-		read_type rt = READ_BREP
-	) override {
-		return serializer_->read(file, guid, representation_id, rt);
-	}
-
-	std::string object_id(const IfcGeom::Element* element) override {
-		return serializer_->object_id(element);
-	}
-
-private:
-	boost::shared_ptr<GeometrySerializer> serializer_;
-};
-%}
-
-%extend GeometrySerializer {
-	bool ready() {
-		return $self->ready();
-	}
-
-	bool is_streaming() const {
-		return $self->is_streaming();
-	}
-
-	void writeHeader() {
-		$self->writeHeader();
-	}
-
-	void finalize() {
-		$self->finalize();
-	}
-
-	void setFile(ifcopenshell::file& file) {
-		$self->setFile(file);
-	}
-}
-
-%extend ifcopenshell::geometry::taxonomy::style {
-	size_t instance_id() const {
-		if (!self->instance) {
-			return 0;
-		}
-		return self->instance.id();
-	}
-}
-
-
-%define assign_component_acccess(item_name)
-
-%extend ifcopenshell::geometry::taxonomy::item_name {
-	PyObject* components_() const {
-		return eigen_to_python_tuple(self->ccomponents());
-	}
-
-	%pythoncode %{
-		components = property(components_)
-	%}
-};
-
-%enddef
-
-assign_component_acccess(point3);
-assign_component_acccess(direction3);
-assign_component_acccess(matrix4);
-assign_component_acccess(colour);
-
-%define assign_children_access(item_name, children_type)
-
-%extend ifcopenshell::geometry::taxonomy::item_name {
-	// swig does not accept auto here as the return type
-	const std::vector<ifcopenshell::geometry::taxonomy::children_type::ptr>& children_() const {
-		return $self->children;
-	}
-
-	const ifcopenshell::geometry::taxonomy::children_type::ptr& __getitem__(int index) const {
-		if (index < 0 || index >= $self->children.size()) {
-			throw std::runtime_error("Index " + std::to_string(index) + " is out of bounds for an array of length " + std::to_string($self->children.size()));
-		}
-		return $self->children[index];
-	}
-
-	%pythoncode %{
-		children = property(children_)
-		def __iter__(self):
-			return iter(self.children)
-	%}
-};
-
-%enddef
-
-assign_children_access(collection, geom_item);
-assign_children_access(loop, edge);
-assign_children_access(face, loop);
-assign_children_access(shell, face);
-assign_children_access(solid, shell);
-assign_children_access(loft, geom_item);
-assign_children_access(boolean_result, geom_item);
-
-%define assign_matrix_access(item_name)
-
-%extend ifcopenshell::geometry::taxonomy::item_name {
-	// swig does not accept auto here as the return type
-	const ifcopenshell::geometry::taxonomy::matrix4::ptr& matrix_() const {
-		return $self->matrix;
-	}
-
-	%pythoncode %{
-		matrix = property(matrix_)
-	%}
-};
-
-%enddef
-
-assign_matrix_access(line);
-assign_matrix_access(circle);
-assign_matrix_access(ellipse);
-assign_matrix_access(collection);
-assign_matrix_access(solid);
-assign_matrix_access(face);
-assign_matrix_access(plane);
-assign_matrix_access(cylinder);
-assign_matrix_access(sphere);
-assign_matrix_access(torus);
-assign_matrix_access(extrusion);
-assign_matrix_access(revolve);
-
-%extend ifcopenshell::geometry::Settings {
-	void set_(const std::string& name, bool val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, int val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, ifcopenshell::geometry::settings::IteratorOutputOptions val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, ifcopenshell::geometry::settings::FunctionStepMethod val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, ifcopenshell::geometry::settings::OutputDimensionalityTypes val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, double val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, const std::string& val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, const std::set<int>& val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, const std::vector<double>& val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, const std::vector<std::string>& val) {
-		// Python sequences cannot distinguish std::vector<std::string> from std::set<std::string>.
-		if ($self->get_type(name) == "std::set<std::string>") {
-			return $self->set(name, std::set<std::string>(val.begin(), val.end()));
-		}
-		return $self->set(name, val);
-	}
-	ifcopenshell::geometry::Settings::value_variant_t get_(const std::string& name) {
-		return $self->get(name);
-	}
-	std::vector<std::string> setting_names() {
-		return $self->setting_names();
-	}
-	std::string get_type(const std::string& name) {
-		return $self->get_type(name);
-	}
-}
-
-%extend ifcopenshell::geometry::SerializerSettings {
-	void set_(const std::string& name, bool val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, int val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, double val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, const std::string& val) {
-		return $self->set(name, val);
-	}
-	void set_(const std::string& name, const std::set<int>& val) {
-		return $self->set(name, val);
-	}
-	ifcopenshell::geometry::SerializerSettings::value_variant_t get_(const std::string& name) {
-		return $self->get(name);
-	}
-	std::vector<std::string> setting_names() {
-		return $self->setting_names();
-	}
-	std::string get_type(const std::string& name) {
-		return $self->get_type(name);
-	}
-}
-
-%template(ray_intersection_results) std::vector<IfcGeom::ray_intersection_result>;
-
-%template(clashes) std::vector<IfcGeom::clash>;
-
-%ignore IfcGeom::tree::uint8_to_b64;
-
-%include "../ifcgeom/tree.h"
-
-%extend IfcGeom::tree {
-
-	std::vector<express::Base> select_box(const express::Base& e, bool completely_within = false, double extend=-1.e-5) const {
-		if (!e.declaration().is("IfcProduct")) {
-			throw ifcopenshell::exception("Instance should be an IfcProduct");
-		}
-		return cast_vector<express::Base>($self->select_box(e.as<express::Entity>(), completely_within, extend));
-	}
-
-	std::vector<express::Base> select_box(const std::vector<double>& p) const {
-		if (p.size() != 3) {
-			throw ifcopenshell::exception("Point should be a sequence of 3 floats");
-		}
-		IfcGeom::tree_point point = {{ p[0], p[1], p[2] }};
-		return cast_vector<express::Base>($self->select_box(point));
-	}
-
-	std::vector<express::Base> select_box(const std::vector<std::vector<double>>& b, bool completely_within = false) const {
-		if (b.size() != 2 || b[0].size() != 3 || b[1].size() != 3) {
-			throw ifcopenshell::exception("Bounding box should be a sequence of 2 x 3 floats");
-		}
-		IfcGeom::tree_box box = {{
-			{ b[0][0], b[0][1], b[0][2] },
-			{ b[1][0], b[1][1], b[1][2] }
-		}};
-		return cast_vector<express::Base>($self->select_box(box, completely_within));
-	}
-
-	std::vector<express::Base> select(const express::Base& e, bool completely_within = false, double extend = 0.0) const {
-		if (!e.declaration().is("IfcProduct")) {
-			throw ifcopenshell::exception("Instance should be an IfcProduct");
-		}
-		return cast_vector<express::Base>($self->select(e.as<express::Entity>(), completely_within, extend));
-	}
-
-	std::vector<express::Base> select(const std::vector<double>& p, double extend=0.0) const {
-		if (p.size() != 3) {
-			throw ifcopenshell::exception("Point should be a sequence of 3 floats");
-		}
-		IfcGeom::tree_point point = {{ p[0], p[1], p[2] }};
-		return cast_vector<express::Base>($self->select(point, extend));
-	}
-
-	std::vector<express::Base> select(const IfcGeom::Element* elem, bool completely_within = false, double extend = -1.e-5) const {
-		return cast_vector<express::Base>($self->select(elem, completely_within, extend));
-	}
-
-	std::vector<IfcGeom::ray_intersection_result> select_ray(const std::vector<double>& p0, const std::vector<double>& d, double length = 1000.) const {
-		if (p0.size() != 3 || d.size() != 3) {
-			throw ifcopenshell::exception("Origin and direction should be sequences of 3 floats");
-		}
-		IfcGeom::tree_point origin = {{ p0[0], p0[1], p0[2] }};
-		IfcGeom::tree_point direction = {{ d[0], d[1], d[2] }};
-		return $self->select_ray(origin, direction, length);
-	}
-
-}
-
-// A visitor
-%{
-struct ShapeRTTI : public boost::static_visitor<PyObject*>
-{
-    PyObject* operator()(IfcGeom::Element* elem) const {
-		IfcGeom::SerializedElement* serialized_elem = dynamic_cast<IfcGeom::SerializedElement*>(elem);
-		IfcGeom::TriangulationElement* triangulation_elem = dynamic_cast<IfcGeom::TriangulationElement*>(elem);
-		IfcGeom::BRepElement* brep_elem = dynamic_cast<IfcGeom::BRepElement*>(elem);
-		if (triangulation_elem) {
-			return SWIG_NewPointerObj(SWIG_as_voidptr(triangulation_elem), SWIGTYPE_p_IfcGeom__TriangulationElement, SWIG_POINTER_OWN);
-		} else if (serialized_elem) {
-			return SWIG_NewPointerObj(SWIG_as_voidptr(serialized_elem), SWIGTYPE_p_IfcGeom__SerializedElement, SWIG_POINTER_OWN);
-		} else if (brep_elem) {
-			return SWIG_NewPointerObj(SWIG_as_voidptr(brep_elem), SWIGTYPE_p_IfcGeom__BRepElement, SWIG_POINTER_OWN);
-		} else {
-			return SWIG_Py_Void();
-		}
-	}
-    PyObject* operator()(IfcGeom::Representation::Representation* representation) const {
-		IfcGeom::Representation::Serialization* serialized_representation = dynamic_cast<IfcGeom::Representation::Serialization*>(representation);
-		IfcGeom::Representation::Triangulation* triangulated_representation = dynamic_cast<IfcGeom::Representation::Triangulation*>(representation);
-		IfcGeom::Representation::BRep* brep_representation = dynamic_cast<IfcGeom::Representation::BRep*>(representation);
-		if (serialized_representation) {
-			return SWIG_NewPointerObj(SWIG_as_voidptr(serialized_representation), SWIGTYPE_p_IfcGeom__Representation__Serialization, SWIG_POINTER_OWN);
-		} else if (triangulated_representation) {
-			return SWIG_NewPointerObj(SWIG_as_voidptr(triangulated_representation), SWIGTYPE_p_IfcGeom__Representation__Triangulation, SWIG_POINTER_OWN);
-		} else if (brep_representation) {
-			return SWIG_NewPointerObj(SWIG_as_voidptr(brep_representation), SWIGTYPE_p_IfcGeom__Representation__BRep, SWIG_POINTER_OWN);
-		} else {
-			return SWIG_Py_Void();
-		}
-	}
-	PyObject* operator()(IfcGeom::Transformation* transformation) const {
-		return SWIG_NewPointerObj(SWIG_as_voidptr(transformation), SWIGTYPE_p_IfcGeom__Transformation, SWIG_POINTER_OWN);
-	}
-};
-%}
-
-// Note that these elements ARE to be owned by SWIG/Python
-%typemap(out) std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*> {
-	// See which type is set and return appropriate
-	$result = std::visit(ShapeRTTI(), (std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*>) $1);
-}
-
-%newobject construct_iterator;
-%newobject construct_iterator_with_include_exclude;
-%newobject construct_iterator_with_include_exclude_globalid;
-%newobject construct_iterator_with_include_exclude_id;
-%newobject create_geometry_serializer;
-
-// I couldn't get the vector<string> typemap to be applied when %extending Iterator constructor.
-// anyway it does not matter as SWIG generates C code without actual constructors
-%inline %{
-	GeometrySerializer* create_geometry_serializer(
-		const std::string& extension,
-		const std::string& output_filename,
-		const std::string& output_temp_filename,
-		ifcopenshell::geometry::Settings& geometry_settings,
-		const ifcopenshell::geometry::SerializerSettings& serializer_settings
-	) {
-		return new PythonPluginGeometrySerializer(
-			extension,
-			output_filename,
-			output_temp_filename,
-			geometry_settings,
-			serializer_settings
-		);
-	}
-
-	GeometrySerializer* create_geometry_serializer(
-		const std::string& extension,
-		const stream_or_filename& output_filename,
-		const stream_or_filename& output_temp_filename,
-		ifcopenshell::geometry::Settings& geometry_settings,
-		const ifcopenshell::geometry::SerializerSettings& serializer_settings
-	) {
-		return new PythonPluginGeometrySerializer(
-			extension,
-			output_filename,
-			output_temp_filename,
-			geometry_settings,
-			serializer_settings
-		);
-	}
-
-	// I couldn't get the vector<string> typemap to be applied when %extending Iterator constructor.
-	// anyway it does not matter as SWIG generates C code without actual constructors
-	IfcGeom::Iterator* construct_iterator(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, ifcopenshell::file* file, int num_threads, logger* logger = nullptr) {
-		::logger& logger_ = logger_or_root(logger);
-		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings), settings, file, num_threads, logger_);
-	}
-
-	IfcGeom::Iterator* construct_iterator_with_include_exclude(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, ifcopenshell::file* file, std::vector<std::string> elems, bool include, int num_threads, logger* logger = nullptr) {
-		::logger& logger_ = logger_or_root(logger);
-		std::set<std::string> elems_set(elems.begin(), elems.end());
-		IfcGeom::entity_filter ef{ include, false, elems_set };
-		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings), settings, file, {ef}, num_threads, logger_);
-	}
-
-	IfcGeom::Iterator* construct_iterator_with_include_exclude_globalid(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, ifcopenshell::file* file, std::vector<std::string> elems, bool include, int num_threads, logger* logger = nullptr) {
-		::logger& logger_ = logger_or_root(logger);
-		std::set<std::string> elems_set(elems.begin(), elems.end());
-		IfcGeom::attribute_filter af;
-		af.attribute_name = "GlobalId";
-		af.populate(elems_set);
-		af.include = include;
-		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings), settings, file, {af}, num_threads, logger_);
-	}
-
-	IfcGeom::Iterator* construct_iterator_with_include_exclude_id(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, ifcopenshell::file* file, std::vector<int> elems, bool include, int num_threads, logger* logger = nullptr) {
-		::logger& logger_ = logger_or_root(logger);
-		std::set<int> elems_set(elems.begin(), elems.end());
-		IfcGeom::instance_id_filter af(include, false, elems_set);
-		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings), settings, file, {af}, num_threads, logger_);
-	}
-%}
-
-%extend IfcGeom::Representation::Triangulation {
-
-	std::pair<const char*, size_t> faces_buffer() const {
-		return vector_to_buffer(self->faces());
-	}
-
-	std::pair<const char*, size_t> edges_buffer() const {
-		return vector_to_buffer(self->edges());
-	}
-
-	std::pair<const char*, size_t> material_ids_buffer() const {
-		return vector_to_buffer(self->material_ids());
-	}
-
-	std::pair<const char*, size_t> item_ids_buffer() const {
-		return vector_to_buffer(self->item_ids());
-	}
-
-	std::pair<const char*, size_t> edges_item_ids_buffer() const {
-		return vector_to_buffer(self->edges_item_ids());
-	}
-
-	std::pair<const char*, size_t> verts_buffer() const {
-		return vector_to_buffer(self->verts());
-	}
-
-	std::pair<const char*, size_t> normals_buffer() const {
-		return vector_to_buffer(self->normals());
-	}
-
-    PyObject* colors_buffer() const {
-        std::vector<double> clrs;
-        clrs.reserve(self->materials().size() * 4);
-        for (auto& mptr : self->materials()) {
-			auto& m = *mptr;
-            if (m.diffuse) {
-                clrs.push_back(m.diffuse.ccomponents()[0]);
-                clrs.push_back(m.diffuse.ccomponents()[1]);
-                clrs.push_back(m.diffuse.ccomponents()[2]);
-            } else {
-                clrs.push_back(0.);
-                clrs.push_back(0.);
-                clrs.push_back(0.);
-            }
-            if (m.has_transparency()) {
-                clrs.push_back(1. - m.transparency);
-            } else {
-                clrs.push_back(1.);
-            }
-        }
-        auto p = vector_to_buffer(clrs);
-        return PyBytes_FromStringAndSize(p.first, p.second);
-    }
-
-    %pythoncode %{
-        # Hide the getters with read-only property implementations
-        faces_tri = property(faces)
-        polyhedral_faces_without_holes = property(polyhedral_faces_without_holes)
-        polyhedral_faces_with_holes = property(polyhedral_faces_with_holes)
-        def get_faces(self):
-            if self.faces_tri: 
-                return self.faces_tri
-            elif self.polyhedral_faces_without_holes:
-                return self.polyhedral_faces_without_holes
-            else:
-                return self.polyhedral_faces_with_holes
-        faces = property(get_faces)
-        edges = property(edges)
-        material_ids = property(material_ids)
-        materials = property(materials)
-        verts = property(verts)
-        normals = property(normals)
-        item_ids = property(item_ids)
-        uvs = property(uvs)
-        edges_item_ids = property(edges_item_ids)
-
-        faces_buffer = property(faces_buffer)
-        edges_buffer = property(edges_buffer)
-        material_ids_buffer = property(material_ids_buffer)
-        item_ids_buffer = property(item_ids_buffer)
-        edges_item_ids_buffer = property(edges_item_ids_buffer)
-        verts_buffer = property(verts_buffer)
-        normals_buffer = property(normals_buffer)
-        colors_buffer = property(colors_buffer)
-    %}
-};
-
-%extend IfcGeom::Representation::Representation {
-	%pythoncode %{
-        # Hide the getters with read-only property implementations
-        id = property(id)
-	%}
-};
-
-%extend IfcGeom::Representation::Serialization {
-	%pythoncode %{
-        # Hide the getters with read-only property implementations
-        brep_data = property(brep_data)
-        surface_styles = property(surface_styles)
-        surface_style_ids = property(surface_style_ids)
-	%}
-};
-
-%extend IfcGeom::Element {
-    std::pair<const char*, size_t> transformation_buffer() const {
-        // @todo check whether needs to be transposed
-        const double* data = self->transformation().data()->ccomponents().data();
-        return { reinterpret_cast<const char*>(data), 16 * sizeof(double) };
-    }
-
-    const express::Base product_() const {
-        return $self->product();
-    }
-
-    %pythoncode %{
-        # Hide the getters with read-only property implementations
-        id = property(id)
-        parent_id = property(parent_id)
-        name = property(name)
-        type = property(type)
-        guid = property(guid)
-        context = property(context)
-        unique_id = property(unique_id)
-        transformation = property(transformation)
-        product = property(product_)
-
-        transformation_buffer = property(transformation_buffer)
-    %}
-};
-
-%extend IfcGeom::TriangulationElement {
-};
-
-%extend IfcGeom::SerializedElement {
-};
-
-%extend IfcGeom::BRepElement {
-    double calc_volume_() const {
-        double v;
-        if ($self->geometry().calculate_volume(v)) {
-            return v;
-        } else {
-            return std::numeric_limits<double>::quiet_NaN();
-        }
-    }
-
-    double calc_surface_area_() const {
-        double v;
-        if ($self->geometry().calculate_surface_area(v)) {
-            return v;
-        } else {
-            return std::numeric_limits<double>::quiet_NaN();
-        }
-    }
-
-    %pythoncode %{
-        volume = property(calc_volume_)
-        surface_area = property(calc_surface_area_)
-    %}
-};
-
-/*
-%extend IfcGeom::Material {
-	%pythoncode %{
-        # Hide the getters with read-only property implementations
-        has_diffuse = property(hasDiffuse)
-        has_specular = property(hasSpecular)
-        has_transparency = property(hasTransparency)
-        has_specularity = property(hasSpecularity)
-        diffuse = property(diffuse)
-        specular = property(specular)
-        transparency = property(transparency)
-        specularity = property(specularity)
-        name = property(name)
-	%}
-};
-*/
-
-%extend IfcGeom::Transformation {
-	PyObject* matrix_() const {
-		auto result = PyTuple_New(16);
-		for (int i = 0; i < 16; ++i) {
-			PyTuple_SET_ITEM(result, i, PyFloat_FromDouble(self->data()->ccomponents().data()[i]));
-		}
-		return result;
-	}
-	%pythoncode %{
-        # Hide the getters with read-only property implementations
-        matrix = property(matrix_)
-	%}
-};
-
-%extend IfcGeom::Matrix {
-	%pythoncode %{
-        # Hide the getters with read-only property implementations
-        data = property(data)
-	%}
-};
-
-%{
-	template <typename T>
-	std::string to_locale_invariant_string(const T& t) {
-		std::ostringstream oss;
-		oss.imbue(std::locale::classic());
-		oss << t;
-		return oss.str();
-	}
-
-	static std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*> helper_fn_create_shape(logger& logger, const std::string& geometry_library, ifcopenshell::geometry::Settings& st, const express::Base& instance, const express::Base& representation = express::Base()) {
-		ifcopenshell::file* file = instance.file();
-
-		ifcopenshell::geometry::Converter kernel(ifcopenshell::geometry::kernels::construct(file, geometry_library, st), file, st, logger);
-		if (instance.declaration().is("IfcProduct")) {
-			if (representation && !representation.declaration().is("IfcRepresentation")) {
-				throw ifcopenshell::exception("Supplied representation not of type IfcRepresentation");
-			}
-
-			auto selected_representation = representation ? representation : kernel.mapping()->representation_of(instance);
-			if (!selected_representation) {
-				throw ifcopenshell::exception("No suitable IfcRepresentation found");
-			}
-
-			IfcGeom::BRepElement* brep = kernel.create_brep_for_representation_and_product(selected_representation, instance);
-			if (!brep) {
-				std::ostringstream oss_repr, oss_product;
-				selected_representation.to_string(oss_repr);
-				instance.to_string(oss_product);
-				throw ifcopenshell::exception("Failed to process shape. Product: " + oss_product.str() + ", representation: " + oss_repr.str());
-			}
-			if (st.get<ifcopenshell::geometry::settings::IteratorOutput>().get() == ifcopenshell::geometry::settings::SERIALIZED) {
-				IfcGeom::SerializedElement* serialization = new IfcGeom::SerializedElement(*brep);
-				delete brep;
-				return serialization;
-			} else if (st.get<ifcopenshell::geometry::settings::IteratorOutput>().get() == ifcopenshell::geometry::settings::TRIANGULATED) {
-				IfcGeom::TriangulationElement* triangulation = new IfcGeom::TriangulationElement(*brep);
-				delete brep;
-				return triangulation;
-			} else {
-				return brep;
-			}
-		} else if (instance.declaration().is("IfcPlacement") || instance.declaration().is("IfcObjectPlacement")) {
-			auto item = ifcopenshell::geometry::taxonomy::cast<ifcopenshell::geometry::taxonomy::matrix4>(kernel.mapping()->map(instance));
-			if (item == nullptr) {
-				throw ifcopenshell::exception("Failed to convert placement");
-			}
-			/*
-            if (st.get<ifcopenshell::geometry::settings::ConvertBackUnits>().get()) {
-                // we pass the settings to the Transformation object, but access the data just offloads to the
-                // generic cartesian_base<Matrix4> so there's no time to apply the settings to the translation part.
-                item = ifcopenshell::geometry::taxonomy::matrix4::ptr(item->clone_());
-                item->components().col(3).head<3>() /= kernel.settings().get<ifcopenshell::geometry::settings::LengthUnit>().get();
-			}
-			*/
-			return new IfcGeom::Transformation(kernel.settings(), item);
-		} else {
-			if (!representation) {
-				if (instance.declaration().is("IfcRepresentationItem") ||
-					instance.declaration().is("IfcRepresentation") ||
-					// https://github.com/IfcOpenShell/IfcOpenShell/issues/1649
-					instance.declaration().is("IfcProfileDef")
-				) {
-					IfcGeom::ConversionResults shapes;
-					try {
-						shapes = kernel.convert(instance);
-					} catch (...) {
-						std::ostringstream oss;
-						instance.to_string(oss);
-						throw ifcopenshell::exception("Failed to process shape. Instance: " + oss.str());
-					}
-
-					IfcGeom::Representation::BRep brep(kernel.settings(), instance.declaration().name(), to_locale_invariant_string(instance.id()), shapes);
-					try {
-						if (st.get<ifcopenshell::geometry::settings::IteratorOutput>().get() == ifcopenshell::geometry::settings::SERIALIZED) {
-							return new IfcGeom::Representation::Serialization(brep);
-						} else if (st.get<ifcopenshell::geometry::settings::IteratorOutput>().get() == ifcopenshell::geometry::settings::TRIANGULATED) {
-							return new IfcGeom::Representation::Triangulation(brep);
-						}
-					} catch (...) {
-						throw ifcopenshell::exception("error during shape serialization");
-					}
-				}
-			} else {
-				throw ifcopenshell::exception("Invalid additional representation specified");
-			}
-		}
-		return std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*>();
-	}
-%}
-
-%typemap(out) ifcopenshell::geometry::taxonomy::item::ptr {
-	$result = item_to_pyobject($1);
-}
-
-%{
-template <typename T>
-ifcopenshell::geometry::taxonomy::item::ptr try_upcast(PyObject* obj0, swig_type_info* info) {
-    typename T::ptr *arg1 = 0 ;
-    void *argp1 ;
-    typename T::ptr tempshared1 ;
-
-    int newmem = 0;
-    auto res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, info,  0 , &newmem);
-    if (SWIG_IsOK(res1)) {
-        if (newmem & SWIG_CAST_NEW_MEMORY) {
-            if (argp1) tempshared1 = *reinterpret_cast< typename T::ptr * >(argp1);
-            delete reinterpret_cast< typename T::ptr * >(argp1);
-            arg1 = &tempshared1;
-        } else {
-            arg1 = (argp1) ? reinterpret_cast< typename T::ptr * >(argp1) : &tempshared1;
-        }
-        return std::static_pointer_cast<ifcopenshell::geometry::taxonomy::item>(*arg1);
-    }
-    return nullptr;
-}
-%}
-
-%inline %{
-	ifcopenshell::geometry::taxonomy::item::ptr map_shape(ifcopenshell::geometry::Settings& settings, const express::Base& instance) {
-        std::unique_ptr<ifcopenshell::geometry::abstract_mapping> mapping(ifcopenshell::geometry::impl::mapping_implementations().construct(instance.file(), settings));
-		return mapping->map(instance);
-	}
-%}
-
-%inline %{
-	static std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*> create_shape(ifcopenshell::geometry::Settings& settings, const express::Base& instance, const express::Base& representation, const char* const geometry_library="opencascade", logger* logger = nullptr) {
-		return helper_fn_create_shape(logger_or_root(logger), geometry_library, settings, instance, representation);
-	}
-
-	// Manual definition of overload without representation argument
-	static std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*> create_shape(ifcopenshell::geometry::Settings& settings, const express::Base& instance, const char* const geometry_library="opencascade", logger* logger = nullptr) {
-		return create_shape(settings, instance, express::Base(), geometry_library, logger);
-	}
-%}
-
-// @todo bring back serialization OCCT -> IFC by means of opencascade_geometry_ifc_writer_registry
-
-%template(OpaqueCoordinate_3) IfcGeom::OpaqueCoordinate<3>;
-%template(OpaqueCoordinate_4) IfcGeom::OpaqueCoordinate<4>;
-
-%newobject create_epeck;
-
-%inline %{
-	IfcGeom::OpaqueNumber* create_epeck(int i) {
-		return new IfcGeom::OpaqueNumber(i);
-	}
-	IfcGeom::OpaqueNumber* create_epeck(double d) {
-		return new IfcGeom::OpaqueNumber(d);
-	}
-	IfcGeom::OpaqueNumber* create_epeck(const std::string& s) {
-		return new IfcGeom::OpaqueNumber(std::stod(s));
-	}
-%}
-
-%inline %{
-	IfcGeom::ConversionResultShape* nary_union(PyObject* sequence) {
-		IfcGeom::ConversionResultShape* result = nullptr;
-		std::string backend_id;
-		auto identity = ifcopenshell::geometry::taxonomy::make<ifcopenshell::geometry::taxonomy::matrix4>();
-		for(Py_ssize_t i = 0; i < PySequence_Size(sequence); ++i) {
-			PyObject* element = PySequence_GetItem(sequence, i);
-			void* argp1 = nullptr;
-			auto res1 = SWIG_ConvertPtr(element, &argp1, SWIGTYPE_p_IfcGeom__ConversionResultShape, 0);
-			if (SWIG_IsOK(res1)) {
-				auto arg1 = reinterpret_cast<IfcGeom::ConversionResultShape*>(argp1);
-				auto element_backend_id = std::string(arg1->backend_id());
-				if (backend_id.empty()) {
-					backend_id = element_backend_id;
-					result = arg1->moved(identity);
-				} else {
-					if (element_backend_id != backend_id) {
-						delete result;
-						throw ifcopenshell::exception("nary_union requires shapes from the same geometry backend");
-					}
-					auto next = result->add(arg1);
-					if (!next) {
-						delete result;
-						throw ifcopenshell::exception("nary_union failed for backend " + backend_id);
-					}
-					delete result;
-					result = next;
-				}
-			}
-		}
-		if (!result) {
-			throw ifcopenshell::exception("nary_union requires at least one shape");
-		}
-		return result;
-	}
-%}
-
-%extend IfcGeom::ConversionResultShape {
-	std::string serialize_obj() {
-		ifcopenshell::geometry::Settings settings;
-		std::unique_ptr<IfcGeom::Representation::Triangulation> triangulation($self->Triangulate(settings));
-		std::ostringstream result;
-
-		for (auto it = triangulation->verts().begin(); it != triangulation->verts().end();) {
-			result << "v " << *(it++) << " " << *(it++) << " " << *(it++) << "\n";
-		}
-		for (auto it = triangulation->normals().begin(); it != triangulation->normals().end();) {
-			result << "vn " << *(it++) << " " << *(it++) << " " << *(it++) << "\n";
-		}
-
-		const bool has_normals = !triangulation->normals().empty();
-		for (auto it = triangulation->faces().begin(); it != triangulation->faces().end();) {
-			const auto v1 = *(it++) + 1;
-			const auto v2 = *(it++) + 1;
-			const auto v3 = *(it++) + 1;
-			if (has_normals) {
-				result << "f "
-					<< v1 << "//" << v1 << " "
-					<< v2 << "//" << v2 << " "
-					<< v3 << "//" << v3 << "\n";
-			} else {
-				result << "f " << v1 << " " << v2 << " " << v3 << "\n";
-			}
-		}
-
-		return result.str();
-	}
-
-	void convex_tag(bool b) {
-		(void)b;
-		throw ifcopenshell::exception("convex_tag is not available through the generic conversion result interface");
-	}
-
-	std::string serialize() {
-		std::string result;
-		ifcopenshell::geometry::taxonomy::matrix4 iden;
-		$self->Serialize(iden, result);
-		return result;
-	}
-
-	ConversionResultShape* solid_mt() {
-		IfcGeom::ConversionResultShape* r;
-		Py_BEGIN_ALLOW_THREADS;
-		r = $self->solid();
-		Py_END_ALLOW_THREADS;
-		return r;
-	}
-}
-
-#ifdef IFOPSH_WITH_CGAL
-
-%ignore hlr_writer;
-%ignore hlr_calc;
-%ignore occt_join;
-%ignore prefiltered_hlr;
-%ignore svgfill::svg_to_line_segments;
-%ignore svgfill::line_segments_to_polygons;
-%ignore svgfill::svg_to_polygons;
-%ignore svgfill::arrange_polygons;
-%ignore svgfill::abstract_arrangement;
-%ignore svgfill::context::delete_same_facet_edge_pairs;
-
-%template(svg_line_segments) std::vector<std::array<svgfill::point_2, 2>>;
-%template(svg_groups_of_line_segments) std::vector<std::vector<std::array<svgfill::point_2, 2>>>;
-%template(svg_point) std::array<double, 2>;
-%template(line_segment) std::array<svgfill::point_2, 2>;
-%template(svg_polygons) std::vector<svgfill::polygon_2>;
-%template(svg_groups_of_polygons) std::vector<std::vector<svgfill::polygon_2>>;
-%template(svg_loop) std::vector<std::array<double, 2>>;
-%template(svg_loops) std::vector<std::vector<std::array<double, 2>>>;
-
-%extend IfcGeom::OpaqueCoordinate {
-	%pythoncode %{
-		__len__ = size
-		def __iter__(self):
-			yield from (self.get(i) for i in range(len(self)))
-	%}
-}
-
-%extend IfcGeom::OpaqueNumber {
-	%pythoncode %{
-		__abs__ = abs
-	%}
-}
-
-%template(OpaqueCoordinate_3) IfcGeom::OpaqueCoordinate<3>;
-%template(OpaqueCoordinate_4) IfcGeom::OpaqueCoordinate<4>;
-
-#if 0
-%inline %{
-	IfcGeom::OpaqueNumber create_epeck(int i) {
-		return ifcopenshell::geometry::NumberEpeck(i);
-	}
-	IfcGeom::OpaqueNumber create_epeck(double d) {
-		return ifcopenshell::geometry::NumberEpeck(d);
-	}
-	IfcGeom::OpaqueNumber create_epeck(const std::string& s) {
-		return ifcopenshell::geometry::NumberEpeck(typename CGAL::Epeck::FT::ET(s));
-	}
-%}
-
-%inline %{
-	IfcGeom::ConversionResultShape* nary_union(PyObject* sequence) {
-		std::vector<const CGAL::Nef_polyhedron_3<CGAL::Epeck>*> nefs;
-		for(Py_ssize_t i = 0; i < PySequence_Size(sequence); ++i) {
-			PyObject* element = PySequence_GetItem(sequence, i);
-			void* argp1 = nullptr;
-			auto res1 = SWIG_ConvertPtr(element, &argp1, SWIGTYPE_p_IfcGeom__ConversionResultShape, 0);
-			if (SWIG_IsOK(res1)) {
-				auto arg1 = reinterpret_cast<IfcGeom::ConversionResultShape*>(argp1);
-				auto cgs = dynamic_cast<ifcopenshell::geometry::CgalShape*>(arg1);
-				if (cgs) {
-					nefs.push_back(&cgs->nef());
-				}
-			}
-		}
-		ifcopenshell::geometry::CgalShape* shp;
-		Py_BEGIN_ALLOW_THREADS;
-		CGAL::Nef_nary_union_3< CGAL::Nef_polyhedron_3<CGAL::Epeck> > accum;
-		for (auto& n : nefs) {
-			accum.add_polyhedron(*n);
-		}
-		shp = new ifcopenshell::geometry::CgalShape(accum.get_union());
-		Py_END_ALLOW_THREADS;
-		return shp;
-	}
-%}
-#endif
-
-%extend IfcGeom::ConversionResultShape {
-	std::string serialize_obj() {
-		std::ostringstream result;
-		auto cgs = dynamic_cast<ifcopenshell::geometry::CgalShape*>($self);
-		if (cgs) {
-			write_to_obj(cgs->nef(), result, std::numeric_limits<size_t>::max());
-		}		
-		return result.str();
-	}
-
-	void convex_tag(bool b) {
-		auto cgs = dynamic_cast<ifcopenshell::geometry::CgalShape*>($self);
-		if (cgs) {
-			cgs->convex_tag() = b;
-		}		
-	}
-
-	std::string serialize() {
-		std::string result;
-		ifcopenshell::geometry::taxonomy::matrix4 iden;
-		$self->Serialize(iden, result);
-		return result;
-	}
-
-	ConversionResultShape* solid_mt() {
-		IfcGeom::ConversionResultShape* r;
-		Py_BEGIN_ALLOW_THREADS;
-		r = $self->solid();
-		Py_END_ALLOW_THREADS;
-		return r;
-	}
-}
-
-%naturalvar svgfill::polygon_2::boundary;
-%naturalvar svgfill::polygon_2::inner_boundaries;
-%naturalvar svgfill::polygon_2::point_inside;
-
-%include "../svgfill/src/svgfill.h"
-
-%inline %{
-	std::vector<std::vector<svgfill::line_segment_2>> svg_to_line_segments(const std::string& data, const std::optional<std::string>& class_name) {
-		std::vector<std::vector<svgfill::line_segment_2>> r;
-		if (svgfill::svg_to_line_segments(data, class_name, r)) {
-			return r;
-		} else {
-			throw std::runtime_error("Failed to read SVG");
-		}
-	}
-
-	std::vector<std::vector<svgfill::polygon_2>> line_segments_to_polygons(svgfill::solver s, double eps, const std::vector<std::vector<svgfill::line_segment_2>>& segments) {
-		std::vector<std::vector<svgfill::polygon_2>> r;
-		if (svgfill::line_segments_to_polygons(s, eps, segments, r)) {
-			return r;
-		} else {
-			throw std::runtime_error("Failed process line segments");
-		}
-	}
-
-	std::vector<svgfill::polygon_2> svg_to_polygons(const std::string& data, const std::optional<std::string>& class_name) {
-		std::vector<svgfill::polygon_2> r;
-		if (svgfill::svg_to_polygons(data, class_name, r)) {
-			return r;
-		} else {
-			throw std::runtime_error("Failed to read SVG");
-		}	
-	}
-
-	std::vector<svgfill::polygon_2> arrange_polygons(svgfill::arrange_polygon_settings settings, const std::vector<svgfill::polygon_2>& polygons, logger* logger = nullptr) {
-		std::vector<svgfill::polygon_2> r;
-		if (svgfill::arrange_polygons(settings, polygons, r, logger_or_root(logger))) {
-			return r;
-		} else {
-			throw std::runtime_error("Failed to arrange polygons");
-		}
-	}
-%}
-
-%define assign_repr(item_name)
-
-%extend item_name {
-	%pythoncode %{
-		__repr__ = taxonomy_item_repr
-	%}
-};
-
-%enddef
-
-assign_repr(ifcopenshell::geometry::taxonomy::boolean_result)
-assign_repr(ifcopenshell::geometry::taxonomy::bspline_curve)
-assign_repr(ifcopenshell::geometry::taxonomy::bspline_surface)
-assign_repr(ifcopenshell::geometry::taxonomy::circle)
-assign_repr(ifcopenshell::geometry::taxonomy::collection)
-assign_repr(ifcopenshell::geometry::taxonomy::colour)
-assign_repr(ifcopenshell::geometry::taxonomy::cylinder)
-assign_repr(ifcopenshell::geometry::taxonomy::direction3)
-assign_repr(ifcopenshell::geometry::taxonomy::edge)
-assign_repr(ifcopenshell::geometry::taxonomy::ellipse)
-assign_repr(ifcopenshell::geometry::taxonomy::extrusion)
-assign_repr(ifcopenshell::geometry::taxonomy::face)
-assign_repr(ifcopenshell::geometry::taxonomy::line)
-assign_repr(ifcopenshell::geometry::taxonomy::loft)
-assign_repr(ifcopenshell::geometry::taxonomy::loop)
-assign_repr(ifcopenshell::geometry::taxonomy::matrix4)
-assign_repr(ifcopenshell::geometry::taxonomy::node)
-assign_repr(ifcopenshell::geometry::taxonomy::offset_curve)
-assign_repr(ifcopenshell::geometry::taxonomy::function_item)
-assign_repr(ifcopenshell::geometry::taxonomy::functor_item)
-assign_repr(ifcopenshell::geometry::taxonomy::piecewise_function)
-assign_repr(ifcopenshell::geometry::taxonomy::gradient_function)
-assign_repr(ifcopenshell::geometry::taxonomy::cant_function)
-assign_repr(ifcopenshell::geometry::taxonomy::offset_function)
-assign_repr(ifcopenshell::geometry::taxonomy::plane)
-assign_repr(ifcopenshell::geometry::taxonomy::point3)
-assign_repr(ifcopenshell::geometry::taxonomy::revolve)
-assign_repr(ifcopenshell::geometry::taxonomy::shell)
-assign_repr(ifcopenshell::geometry::taxonomy::solid)
-assign_repr(ifcopenshell::geometry::taxonomy::sphere)
-assign_repr(ifcopenshell::geometry::taxonomy::torus)
-assign_repr(ifcopenshell::geometry::taxonomy::style)
-assign_repr(ifcopenshell::geometry::taxonomy::sweep_along_curve)
-
-
-#endif
+/********************************************************************************
+ *                                                                              *
+ * 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/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+%rename("buffer") stream_or_filename;
+
+%ignore stream_or_filename::stream;
+%ignore boost::hash_value;
+%ignore IfcGeom::BRepElement::geometry_pointer;
+%ignore IfcGeom::TriangulationElement::geometry_pointer;
+
+// This is only used for RGB colours, hence the size of 3
+%typemap(out) const double* {
+	$result = PyTuple_New(3);
+	for (int i = 0; i < 3; ++i) {
+		PyTuple_SetItem($result, i, PyFloat_FromDouble($1[i]));
+	}
+}
+
+%typemap(out) Eigen::Matrix4d {
+	$result = PyTuple_New(4);
+	for (int i = 0; i < 4; ++i) {
+		auto row = PyTuple_New(4);
+		for (int j = 0; j < 4; ++j) {
+			PyTuple_SetItem(row, j, PyFloat_FromDouble($1(i, j)));
+		}
+		PyTuple_SetItem($result, i, row);
+	}
+}
+
+// SWIG does not support bool references in a meaningful way, so the
+// ifcopenshell::geometry::Settings functions degrade to return a read only value
+%typemap(out) double& {
+	$result = SWIG_From_double(*$1);
+}
+%typemap(out) bool& {
+	$result = PyBool_FromLong(static_cast<long>(*$1));
+}
+
+%typemap(out) IfcGeom::OpaqueNumber {
+	$result = SWIG_NewPointerObj(SWIG_as_voidptr(new IfcGeom::OpaqueNumber($1)), SWIGTYPE_p_IfcGeom__OpaqueNumber, SWIG_POINTER_OWN);
+}
+
+%typemap(in) const IfcGeom::OpaqueNumber& (IfcGeom::OpaqueNumber temp) {
+	void* argp = nullptr;
+	int res = SWIG_ConvertPtr($input, &argp, SWIGTYPE_p_IfcGeom__OpaqueNumber, 0);
+	if (!SWIG_IsOK(res) || !argp) {
+		SWIG_exception_fail(SWIG_ArgError(res), "Expected IfcGeom::OpaqueNumber");
+	}
+	temp = *reinterpret_cast<IfcGeom::OpaqueNumber*>(argp);
+	$1 = &temp;
+}
+
+// Using RTTI return a more specialized type of Element
+// Note that these elements are not to be owned by SWIG/Python as they will be freed automatically upon the next iteration
+// except for the IfcGeom::Element instances which are returned by Iterator::getObject() calls
+%typemap(out) IfcGeom::Element* {
+	IfcGeom::SerializedElement* serialized_elem = dynamic_cast<IfcGeom::SerializedElement*>($1);
+	IfcGeom::TriangulationElement* triangulation_elem = dynamic_cast<IfcGeom::TriangulationElement*>($1);
+	IfcGeom::BRepElement* brep_elem = dynamic_cast<IfcGeom::BRepElement*>($1);
+	if (triangulation_elem) {
+		$result = SWIG_NewPointerObj(SWIG_as_voidptr(triangulation_elem), SWIGTYPE_p_IfcGeom__TriangulationElement, 0);
+	} else if (serialized_elem) {
+		$result = SWIG_NewPointerObj(SWIG_as_voidptr(serialized_elem), SWIGTYPE_p_IfcGeom__SerializedElement, 0);
+	} else if (brep_elem) {
+		$result = SWIG_NewPointerObj(SWIG_as_voidptr(brep_elem), SWIGTYPE_p_IfcGeom__BRepElement, 0);
+	} else {
+		$result = SWIG_NewPointerObj(SWIG_as_voidptr($1), SWIGTYPE_p_IfcGeom__Element, SWIG_POINTER_OWN);
+	}
+}
+
+%newobject IfcGeom::Representation::BRep::item;
+%newobject IfcGeom::Representation::BRep::as_compound;
+
+%newobject IfcGeom::ConversionResultShape::halfspaces;
+%newobject IfcGeom::ConversionResultShape::box;
+%newobject IfcGeom::ConversionResultShape::solid;
+%newobject IfcGeom::ConversionResultShape::add;
+%newobject IfcGeom::ConversionResultShape::subtract;
+%newobject IfcGeom::ConversionResultShape::intersect;
+%newobject IfcGeom::ConversionResultShape::concat;
+%newobject IfcGeom::ConversionResultShape::moved;
+%newobject IfcGeom::ConversionResultShape::wrap_in_compound;
+
+
+%newobject nary_union;
+
+
+%inline %{
+template <typename T>
+std::pair<char const*, size_t> vector_to_buffer(const T& t) {
+    using V = typename std::remove_reference<decltype(t)>::type;
+    return { reinterpret_cast<const char*>(t.data()), t.size() * sizeof(typename V::value_type) };
+}
+%}
+
+%ignore ifcopenshell::geometry::taxonomy::item::print;
+
+%typemap(out) std::variant<boost::blank, ifcopenshell::geometry::taxonomy::point3::ptr, double> {
+	if ($1.index() == 0) {
+		Py_INCREF(Py_None);
+		return Py_None;
+	} else if ($1.index() == 1) {
+		return SWIG_NewPointerObj(SWIG_as_voidptr(new std::shared_ptr<ifcopenshell::geometry::taxonomy::point3>(std::get<ifcopenshell::geometry::taxonomy::point3::ptr>($1))), SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__point3_t, 0 | SWIG_POINTER_OWN);
+	} else {
+		return PyFloat_FromDouble(std::get<double>($1));
+	}
+}
+
+%typemap(out) std::optional<bool> {
+    if ($1) {
+        $result = PyBool_FromLong(*$1 ? 1 : 0);
+    } else {
+        Py_INCREF(Py_None);
+        $result = Py_None;
+    }
+}
+
+%typemap(in) ifcopenshell::geometry::taxonomy::item::ptr {
+	// @this is really annoying, but apparently inheritance
+	// is lost in swig in the shared_ptr type hiearchy
+	using namespace ifcopenshell::geometry::taxonomy;
+	if (!$1) $1 = try_upcast<boolean_result>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__boolean_result_t);
+	if (!$1) $1 = try_upcast<bspline_curve>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__bspline_curve_t);
+	if (!$1) $1 = try_upcast<bspline_surface>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__bspline_surface_t);
+	if (!$1) $1 = try_upcast<circle>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__circle_t);
+	if (!$1) $1 = try_upcast<collection>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__collection_t);
+	if (!$1) $1 = try_upcast<colour>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__colour_t);
+	if (!$1) $1 = try_upcast<cylinder>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__cylinder_t);
+	if (!$1) $1 = try_upcast<direction3>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__direction3_t);
+	if (!$1) $1 = try_upcast<edge>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__edge_t);
+	if (!$1) $1 = try_upcast<ellipse>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__ellipse_t);
+	if (!$1) $1 = try_upcast<extrusion>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__extrusion_t);
+	if (!$1) $1 = try_upcast<face>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__face_t);
+	if (!$1) $1 = try_upcast<line>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__line_t);
+	if (!$1) $1 = try_upcast<loft>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__loft_t);
+	if (!$1) $1 = try_upcast<loop>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__loop_t);
+	if (!$1) $1 = try_upcast<matrix4>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__matrix4_t);
+	if (!$1) $1 = try_upcast<node>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__node_t);
+	if (!$1) $1 = try_upcast<offset_curve>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__offset_curve_t);
+	if (!$1) $1 = try_upcast<function_item>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__function_item_t);
+	if (!$1) $1 = try_upcast<functor_item>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__functor_item_t);
+	if (!$1) $1 = try_upcast<piecewise_function>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__piecewise_function_t);
+	if (!$1) $1 = try_upcast<gradient_function>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__gradient_function_t);
+	if (!$1) $1 = try_upcast<cant_function>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__cant_function_t);
+	if (!$1) $1 = try_upcast<offset_function>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__offset_function_t);
+	if (!$1) $1 = try_upcast<plane>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__plane_t);
+	if (!$1) $1 = try_upcast<point3>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__point3_t);
+	if (!$1) $1 = try_upcast<revolve>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__revolve_t);
+	if (!$1) $1 = try_upcast<shell>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__shell_t);
+	if (!$1) $1 = try_upcast<solid>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__solid_t);
+	if (!$1) $1 = try_upcast<sphere>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__sphere_t);
+	if (!$1) $1 = try_upcast<torus>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__torus_t);
+	if (!$1) $1 = try_upcast<style>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__style_t);
+	if (!$1) $1 = try_upcast<sweep_along_curve>($input, SWIGTYPE_p_std__shared_ptrT_ifcopenshell__geometry__taxonomy__sweep_along_curve_t);
+}
+
+%inline %{
+std::string taxonomy_item_repr(ifcopenshell::geometry::taxonomy::item::ptr i) {
+	std::ostringstream oss;
+	i->print(oss);
+	std::string result = oss.str();
+
+	// Strip new line at the end of the printed result.
+	// result is probably always ends with \n but just to be safe.
+	if (!result.empty() && result.back() == '\n') {
+		result.pop_back();
+	}
+	return result;  
+}
+%}
+
+%{
+
+
+namespace {
+    // Helper function to create a Python tuple from an Eigen matrix/vector
+    template <typename T>
+    PyObject* eigen_to_python_tuple(const Eigen::MatrixBase<T>& mat) {
+        constexpr auto rows = T::RowsAtCompileTime;
+        constexpr auto cols = T::ColsAtCompileTime;
+
+        if constexpr (rows == 1 || cols == 1) {
+            // Eigen::Vector (1D array)
+            PyObject* tuple = PyTuple_New(rows * cols);
+            for (int i = 0; i < mat.size(); ++i) {
+                PyTuple_SetItem(tuple, i, PyFloat_FromDouble(mat(i)));
+            }
+            return tuple;
+        } else {
+            // Eigen::Matrix (2D array)
+            PyObject* tuple = PyTuple_New(rows);
+            for (int i = 0; i < rows; ++i) {
+                PyObject* row = PyTuple_New(cols);
+                for (int j = 0; j < cols; ++j) {
+                    PyTuple_SetItem(row, j, PyFloat_FromDouble(mat(i, j)));
+                }
+                PyTuple_SetItem(tuple, i, row);
+            }
+            return tuple;
+        }
+    }
+}
+
+%}
+
+%shared_ptr(ifcopenshell::geometry::taxonomy::boolean_result);
+%shared_ptr(ifcopenshell::geometry::taxonomy::item);
+%shared_ptr(ifcopenshell::geometry::taxonomy::implicit_item);
+%shared_ptr(ifcopenshell::geometry::taxonomy::function_item);
+%shared_ptr(ifcopenshell::geometry::taxonomy::functor_item);
+%shared_ptr(ifcopenshell::geometry::taxonomy::piecewise_function);
+%shared_ptr(ifcopenshell::geometry::taxonomy::gradient_function);
+%shared_ptr(ifcopenshell::geometry::taxonomy::cant_function);
+%shared_ptr(ifcopenshell::geometry::taxonomy::offset_function);
+%shared_ptr(ifcopenshell::geometry::taxonomy::less_functor);
+%shared_ptr(ifcopenshell::geometry::taxonomy::eigen_base);
+%shared_ptr(ifcopenshell::geometry::taxonomy::matrix4);
+%shared_ptr(ifcopenshell::geometry::taxonomy::colour);
+%shared_ptr(ifcopenshell::geometry::taxonomy::style);
+%shared_ptr(ifcopenshell::geometry::taxonomy::geom_item);
+%shared_ptr(ifcopenshell::geometry::taxonomy::cartesian_base);
+%shared_ptr(ifcopenshell::geometry::taxonomy::point3);
+%shared_ptr(ifcopenshell::geometry::taxonomy::direction3);
+%shared_ptr(ifcopenshell::geometry::taxonomy::curve);
+%shared_ptr(ifcopenshell::geometry::taxonomy::line);
+%shared_ptr(ifcopenshell::geometry::taxonomy::circle);
+%shared_ptr(ifcopenshell::geometry::taxonomy::ellipse);
+%shared_ptr(ifcopenshell::geometry::taxonomy::bspline_curve);
+%shared_ptr(ifcopenshell::geometry::taxonomy::offset_curve);
+%shared_ptr(ifcopenshell::geometry::taxonomy::trimmed_curve);
+%shared_ptr(ifcopenshell::geometry::taxonomy::edge);
+%shared_ptr(ifcopenshell::geometry::taxonomy::collection_base);
+%shared_ptr(ifcopenshell::geometry::taxonomy::collection);
+%shared_ptr(ifcopenshell::geometry::taxonomy::loop);
+%shared_ptr(ifcopenshell::geometry::taxonomy::face);
+%shared_ptr(ifcopenshell::geometry::taxonomy::shell);
+%shared_ptr(ifcopenshell::geometry::taxonomy::solid);
+%shared_ptr(ifcopenshell::geometry::taxonomy::loft);
+%shared_ptr(ifcopenshell::geometry::taxonomy::surface);
+%shared_ptr(ifcopenshell::geometry::taxonomy::plane);
+%shared_ptr(ifcopenshell::geometry::taxonomy::cylinder);
+%shared_ptr(ifcopenshell::geometry::taxonomy::sphere);
+%shared_ptr(ifcopenshell::geometry::taxonomy::torus);
+%shared_ptr(ifcopenshell::geometry::taxonomy::bspline_surface);
+%shared_ptr(ifcopenshell::geometry::taxonomy::sweep);
+%shared_ptr(ifcopenshell::geometry::taxonomy::extrusion);
+%shared_ptr(ifcopenshell::geometry::taxonomy::revolve);
+%shared_ptr(ifcopenshell::geometry::taxonomy::sweep_along_curve);
+%shared_ptr(ifcopenshell::geometry::taxonomy::node);
+
+%include "../ifcgeom/ifc_geom_api.h"
+%include "../ifcgeom/ConversionResult.h"
+%include "../ifcgeom/ConversionSettings.h"
+
+// Keep the owning element alive while its geometry is referenced (#1124).
+%define GEOMETRY_WITH_BACKREF(cls)
+%feature("shadow") cls::geometry %{
+	@property
+	def geometry(self):
+		result = $action(self)
+		result._parent = self
+		return result
+%}
+%enddef
+
+GEOMETRY_WITH_BACKREF(IfcGeom::TriangulationElement)
+GEOMETRY_WITH_BACKREF(IfcGeom::SerializedElement)
+GEOMETRY_WITH_BACKREF(IfcGeom::BRepElement)
+
+%include "../ifcgeom/IfcGeomElement.h"
+%include "../ifcgeom/IfcGeomRepresentation.h"
+%include "../ifcgeom/Iterator.h"
+%include "../ifcgeom/GeometrySerializer.h"
+%include "../ifcgeom/taxonomy.h"
+%include "../ifcgeom/function_item_evaluator.h"
+
+%{
+#include "../serializers/geometry_serializer_plugin.h"
+
+class PythonPluginGeometrySerializer : public GeometrySerializer {
+public:
+	PythonPluginGeometrySerializer(
+		const std::string& extension,
+		const std::string& output_filename,
+		const std::string& output_temp_filename,
+		ifcopenshell::geometry::Settings& geometry_settings,
+		const ifcopenshell::geometry::SerializerSettings& serializer_settings
+	)
+		: GeometrySerializer(geometry_settings, serializer_settings)
+	{
+		ifcopenshell::serializers::geometry_serializer_context context{
+			output_filename,
+			output_temp_filename.empty() ? output_filename : output_temp_filename,
+			geometry_settings,
+			serializer_settings
+		};
+
+		initialize_serializer(extension, context);
+	}
+
+	PythonPluginGeometrySerializer(
+		const std::string& extension,
+		const stream_or_filename& output_filename,
+		const stream_or_filename& output_temp_filename,
+		ifcopenshell::geometry::Settings& geometry_settings,
+		const ifcopenshell::geometry::SerializerSettings& serializer_settings
+	)
+		: GeometrySerializer(geometry_settings, serializer_settings)
+	{
+		const auto output_filename_string = output_filename.filename().value_or("");
+		const auto output_temp_filename_string = output_temp_filename.filename().value_or(output_filename_string);
+		ifcopenshell::serializers::geometry_serializer_context context{
+			output_filename_string,
+			output_temp_filename_string,
+			geometry_settings,
+			serializer_settings,
+			&output_filename,
+			&output_temp_filename
+		};
+
+		initialize_serializer(extension, context);
+	}
+
+private:
+	void initialize_serializer(
+		const std::string& extension,
+		ifcopenshell::serializers::geometry_serializer_context& context
+	) {
+		auto& registry = ifcopenshell::serializers::geometry_serializer_registry_instance();
+		registry.configure(extension, context);
+		geometry_settings_ = context.geometry_settings;
+		serializer_ = registry.create(extension, context);
+	}
+
+public:
+
+	bool ready() override {
+		return serializer_->ready();
+	}
+
+	bool is_streaming() const override {
+		return serializer_->is_streaming();
+	}
+
+	void writeHeader() override {
+		serializer_->writeHeader();
+	}
+
+	void finalize() override {
+		serializer_->finalize();
+	}
+
+	void setFile(ifcopenshell::file& file) override {
+		serializer_->setFile(file);
+	}
+
+	bool isTesselated() const override {
+		return serializer_->isTesselated();
+	}
+
+	void write(const IfcGeom::TriangulationElement* element) override {
+		serializer_->write(element);
+	}
+
+	void write(const IfcGeom::BRepElement* element) override {
+		serializer_->write(element);
+	}
+
+	void setUnitNameAndMagnitude(const std::string& name, float magnitude) override {
+		serializer_->setUnitNameAndMagnitude(name, magnitude);
+	}
+
+	IfcGeom::Element* read(
+		ifcopenshell::file& file,
+		const std::string& guid,
+		const std::string& representation_id,
+		read_type rt = READ_BREP
+	) override {
+		return serializer_->read(file, guid, representation_id, rt);
+	}
+
+	std::string object_id(const IfcGeom::Element* element) override {
+		return serializer_->object_id(element);
+	}
+
+private:
+	boost::shared_ptr<GeometrySerializer> serializer_;
+};
+%}
+
+%extend GeometrySerializer {
+	bool ready() {
+		return $self->ready();
+	}
+
+	bool is_streaming() const {
+		return $self->is_streaming();
+	}
+
+	void writeHeader() {
+		$self->writeHeader();
+	}
+
+	void finalize() {
+		$self->finalize();
+	}
+
+	void setFile(ifcopenshell::file& file) {
+		$self->setFile(file);
+	}
+}
+
+%extend ifcopenshell::geometry::taxonomy::style {
+	size_t instance_id() const {
+		if (!self->instance) {
+			return 0;
+		}
+		return self->instance.id();
+	}
+}
+
+
+%define assign_component_acccess(item_name)
+
+%extend ifcopenshell::geometry::taxonomy::item_name {
+	PyObject* components_() const {
+		return eigen_to_python_tuple(self->ccomponents());
+	}
+
+	%pythoncode %{
+		components = property(components_)
+	%}
+};
+
+%enddef
+
+assign_component_acccess(point3);
+assign_component_acccess(direction3);
+assign_component_acccess(matrix4);
+assign_component_acccess(colour);
+
+%define assign_children_access(item_name, children_type)
+
+%extend ifcopenshell::geometry::taxonomy::item_name {
+	// swig does not accept auto here as the return type
+	const std::vector<ifcopenshell::geometry::taxonomy::children_type::ptr>& children_() const {
+		return $self->children;
+	}
+
+	const ifcopenshell::geometry::taxonomy::children_type::ptr& __getitem__(int index) const {
+		if (index < 0 || index >= $self->children.size()) {
+			throw std::runtime_error("Index " + std::to_string(index) + " is out of bounds for an array of length " + std::to_string($self->children.size()));
+		}
+		return $self->children[index];
+	}
+
+	%pythoncode %{
+		children = property(children_)
+		def __iter__(self):
+			return iter(self.children)
+	%}
+};
+
+%enddef
+
+assign_children_access(collection, geom_item);
+assign_children_access(loop, edge);
+assign_children_access(face, loop);
+assign_children_access(shell, face);
+assign_children_access(solid, shell);
+assign_children_access(loft, geom_item);
+assign_children_access(boolean_result, geom_item);
+
+%define assign_matrix_access(item_name)
+
+%extend ifcopenshell::geometry::taxonomy::item_name {
+	// swig does not accept auto here as the return type
+	const ifcopenshell::geometry::taxonomy::matrix4::ptr& matrix_() const {
+		return $self->matrix;
+	}
+
+	%pythoncode %{
+		matrix = property(matrix_)
+	%}
+};
+
+%enddef
+
+assign_matrix_access(line);
+assign_matrix_access(circle);
+assign_matrix_access(ellipse);
+assign_matrix_access(collection);
+assign_matrix_access(solid);
+assign_matrix_access(face);
+assign_matrix_access(plane);
+assign_matrix_access(cylinder);
+assign_matrix_access(sphere);
+assign_matrix_access(torus);
+assign_matrix_access(extrusion);
+assign_matrix_access(revolve);
+
+%extend ifcopenshell::geometry::Settings {
+	void set_(const std::string& name, bool val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, int val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, ifcopenshell::geometry::settings::IteratorOutputOptions val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, ifcopenshell::geometry::settings::FunctionStepMethod val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, ifcopenshell::geometry::settings::OutputDimensionalityTypes val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, double val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, const std::string& val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, const std::set<int>& val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, const std::vector<double>& val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, const std::vector<std::string>& val) {
+		// Python sequences cannot distinguish std::vector<std::string> from std::set<std::string>.
+		if ($self->get_type(name) == "std::set<std::string>") {
+			return $self->set(name, std::set<std::string>(val.begin(), val.end()));
+		}
+		return $self->set(name, val);
+	}
+	ifcopenshell::geometry::Settings::value_variant_t get_(const std::string& name) {
+		return $self->get(name);
+	}
+	std::vector<std::string> setting_names() {
+		return $self->setting_names();
+	}
+	std::string get_type(const std::string& name) {
+		return $self->get_type(name);
+	}
+}
+
+%extend ifcopenshell::geometry::SerializerSettings {
+	void set_(const std::string& name, bool val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, int val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, double val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, const std::string& val) {
+		return $self->set(name, val);
+	}
+	void set_(const std::string& name, const std::set<int>& val) {
+		return $self->set(name, val);
+	}
+	ifcopenshell::geometry::SerializerSettings::value_variant_t get_(const std::string& name) {
+		return $self->get(name);
+	}
+	std::vector<std::string> setting_names() {
+		return $self->setting_names();
+	}
+	std::string get_type(const std::string& name) {
+		return $self->get_type(name);
+	}
+}
+
+%template(ray_intersection_results) std::vector<IfcGeom::ray_intersection_result>;
+
+%template(clashes) std::vector<IfcGeom::clash>;
+
+%ignore IfcGeom::tree::uint8_to_b64;
+
+%include "../ifcgeom/tree.h"
+
+%extend IfcGeom::tree {
+
+	std::vector<express::Base> select_box(const express::Base& e, bool completely_within = false, double extend=-1.e-5) const {
+		if (!e.declaration().is("IfcProduct")) {
+			throw ifcopenshell::exception("Instance should be an IfcProduct");
+		}
+		return cast_vector<express::Base>($self->select_box(e.as<express::Entity>(), completely_within, extend));
+	}
+
+	std::vector<express::Base> select_box(const std::vector<double>& p) const {
+		if (p.size() != 3) {
+			throw ifcopenshell::exception("Point should be a sequence of 3 floats");
+		}
+		IfcGeom::tree_point point = {{ p[0], p[1], p[2] }};
+		return cast_vector<express::Base>($self->select_box(point));
+	}
+
+	std::vector<express::Base> select_box(const std::vector<std::vector<double>>& b, bool completely_within = false) const {
+		if (b.size() != 2 || b[0].size() != 3 || b[1].size() != 3) {
+			throw ifcopenshell::exception("Bounding box should be a sequence of 2 x 3 floats");
+		}
+		IfcGeom::tree_box box = {{
+			{ b[0][0], b[0][1], b[0][2] },
+			{ b[1][0], b[1][1], b[1][2] }
+		}};
+		return cast_vector<express::Base>($self->select_box(box, completely_within));
+	}
+
+	std::vector<express::Base> select(const express::Base& e, bool completely_within = false, double extend = 0.0) const {
+		if (!e.declaration().is("IfcProduct")) {
+			throw ifcopenshell::exception("Instance should be an IfcProduct");
+		}
+		return cast_vector<express::Base>($self->select(e.as<express::Entity>(), completely_within, extend));
+	}
+
+	std::vector<express::Base> select(const std::vector<double>& p, double extend=0.0) const {
+		if (p.size() != 3) {
+			throw ifcopenshell::exception("Point should be a sequence of 3 floats");
+		}
+		IfcGeom::tree_point point = {{ p[0], p[1], p[2] }};
+		return cast_vector<express::Base>($self->select(point, extend));
+	}
+
+	std::vector<express::Base> select(const IfcGeom::Element* elem, bool completely_within = false, double extend = -1.e-5) const {
+		return cast_vector<express::Base>($self->select(elem, completely_within, extend));
+	}
+
+	std::vector<IfcGeom::ray_intersection_result> select_ray(const std::vector<double>& p0, const std::vector<double>& d, double length = 1000.) const {
+		if (p0.size() != 3 || d.size() != 3) {
+			throw ifcopenshell::exception("Origin and direction should be sequences of 3 floats");
+		}
+		IfcGeom::tree_point origin = {{ p0[0], p0[1], p0[2] }};
+		IfcGeom::tree_point direction = {{ d[0], d[1], d[2] }};
+		return $self->select_ray(origin, direction, length);
+	}
+
+}
+
+// A visitor
+%{
+struct ShapeRTTI : public boost::static_visitor<PyObject*>
+{
+    PyObject* operator()(IfcGeom::Element* elem) const {
+		IfcGeom::SerializedElement* serialized_elem = dynamic_cast<IfcGeom::SerializedElement*>(elem);
+		IfcGeom::TriangulationElement* triangulation_elem = dynamic_cast<IfcGeom::TriangulationElement*>(elem);
+		IfcGeom::BRepElement* brep_elem = dynamic_cast<IfcGeom::BRepElement*>(elem);
+		if (triangulation_elem) {
+			return SWIG_NewPointerObj(SWIG_as_voidptr(triangulation_elem), SWIGTYPE_p_IfcGeom__TriangulationElement, SWIG_POINTER_OWN);
+		} else if (serialized_elem) {
+			return SWIG_NewPointerObj(SWIG_as_voidptr(serialized_elem), SWIGTYPE_p_IfcGeom__SerializedElement, SWIG_POINTER_OWN);
+		} else if (brep_elem) {
+			return SWIG_NewPointerObj(SWIG_as_voidptr(brep_elem), SWIGTYPE_p_IfcGeom__BRepElement, SWIG_POINTER_OWN);
+		} else {
+			return SWIG_Py_Void();
+		}
+	}
+    PyObject* operator()(IfcGeom::Representation::Representation* representation) const {
+		IfcGeom::Representation::Serialization* serialized_representation = dynamic_cast<IfcGeom::Representation::Serialization*>(representation);
+		IfcGeom::Representation::Triangulation* triangulated_representation = dynamic_cast<IfcGeom::Representation::Triangulation*>(representation);
+		IfcGeom::Representation::BRep* brep_representation = dynamic_cast<IfcGeom::Representation::BRep*>(representation);
+		if (serialized_representation) {
+			return SWIG_NewPointerObj(SWIG_as_voidptr(serialized_representation), SWIGTYPE_p_IfcGeom__Representation__Serialization, SWIG_POINTER_OWN);
+		} else if (triangulated_representation) {
+			return SWIG_NewPointerObj(SWIG_as_voidptr(triangulated_representation), SWIGTYPE_p_IfcGeom__Representation__Triangulation, SWIG_POINTER_OWN);
+		} else if (brep_representation) {
+			return SWIG_NewPointerObj(SWIG_as_voidptr(brep_representation), SWIGTYPE_p_IfcGeom__Representation__BRep, SWIG_POINTER_OWN);
+		} else {
+			return SWIG_Py_Void();
+		}
+	}
+	PyObject* operator()(IfcGeom::Transformation* transformation) const {
+		return SWIG_NewPointerObj(SWIG_as_voidptr(transformation), SWIGTYPE_p_IfcGeom__Transformation, SWIG_POINTER_OWN);
+	}
+};
+%}
+
+// Note that these elements ARE to be owned by SWIG/Python
+%typemap(out) std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*> {
+	// See which type is set and return appropriate
+	$result = std::visit(ShapeRTTI(), (std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*>) $1);
+}
+
+%newobject construct_iterator;
+%newobject construct_iterator_with_include_exclude;
+%newobject construct_iterator_with_include_exclude_globalid;
+%newobject construct_iterator_with_include_exclude_id;
+%newobject create_geometry_serializer;
+
+// I couldn't get the vector<string> typemap to be applied when %extending Iterator constructor.
+// anyway it does not matter as SWIG generates C code without actual constructors
+%inline %{
+	GeometrySerializer* create_geometry_serializer(
+		const std::string& extension,
+		const std::string& output_filename,
+		const std::string& output_temp_filename,
+		ifcopenshell::geometry::Settings& geometry_settings,
+		const ifcopenshell::geometry::SerializerSettings& serializer_settings
+	) {
+		return new PythonPluginGeometrySerializer(
+			extension,
+			output_filename,
+			output_temp_filename,
+			geometry_settings,
+			serializer_settings
+		);
+	}
+
+	GeometrySerializer* create_geometry_serializer(
+		const std::string& extension,
+		const stream_or_filename& output_filename,
+		const stream_or_filename& output_temp_filename,
+		ifcopenshell::geometry::Settings& geometry_settings,
+		const ifcopenshell::geometry::SerializerSettings& serializer_settings
+	) {
+		return new PythonPluginGeometrySerializer(
+			extension,
+			output_filename,
+			output_temp_filename,
+			geometry_settings,
+			serializer_settings
+		);
+	}
+
+	// I couldn't get the vector<string> typemap to be applied when %extending Iterator constructor.
+	// anyway it does not matter as SWIG generates C code without actual constructors
+	IfcGeom::Iterator* construct_iterator(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, ifcopenshell::file* file, int num_threads, logger* logger = nullptr) {
+		::logger& logger_ = logger_or_root(logger);
+		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings), settings, file, num_threads, logger_);
+	}
+
+	IfcGeom::Iterator* construct_iterator_with_include_exclude(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, ifcopenshell::file* file, std::vector<std::string> elems, bool include, int num_threads, logger* logger = nullptr) {
+		::logger& logger_ = logger_or_root(logger);
+		std::set<std::string> elems_set(elems.begin(), elems.end());
+		IfcGeom::entity_filter ef{ include, false, elems_set };
+		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings), settings, file, {ef}, num_threads, logger_);
+	}
+
+	IfcGeom::Iterator* construct_iterator_with_include_exclude_globalid(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, ifcopenshell::file* file, std::vector<std::string> elems, bool include, int num_threads, logger* logger = nullptr) {
+		::logger& logger_ = logger_or_root(logger);
+		std::set<std::string> elems_set(elems.begin(), elems.end());
+		IfcGeom::attribute_filter af;
+		af.attribute_name = "GlobalId";
+		af.populate(elems_set);
+		af.include = include;
+		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings), settings, file, {af}, num_threads, logger_);
+	}
+
+	IfcGeom::Iterator* construct_iterator_with_include_exclude_id(const std::string& geometry_library, ifcopenshell::geometry::Settings settings, ifcopenshell::file* file, std::vector<int> elems, bool include, int num_threads, logger* logger = nullptr) {
+		::logger& logger_ = logger_or_root(logger);
+		std::set<int> elems_set(elems.begin(), elems.end());
+		IfcGeom::instance_id_filter af(include, false, elems_set);
+		return new IfcGeom::Iterator(ifcopenshell::geometry::kernels::construct(file, geometry_library, settings), settings, file, {af}, num_threads, logger_);
+	}
+%}
+
+%extend IfcGeom::Representation::Triangulation {
+
+	std::pair<const char*, size_t> faces_buffer() const {
+		return vector_to_buffer(self->faces());
+	}
+
+	std::pair<const char*, size_t> edges_buffer() const {
+		return vector_to_buffer(self->edges());
+	}
+
+	std::pair<const char*, size_t> material_ids_buffer() const {
+		return vector_to_buffer(self->material_ids());
+	}
+
+	std::pair<const char*, size_t> item_ids_buffer() const {
+		return vector_to_buffer(self->item_ids());
+	}
+
+	std::pair<const char*, size_t> edges_item_ids_buffer() const {
+		return vector_to_buffer(self->edges_item_ids());
+	}
+
+	std::pair<const char*, size_t> verts_buffer() const {
+		return vector_to_buffer(self->verts());
+	}
+
+	std::pair<const char*, size_t> normals_buffer() const {
+		return vector_to_buffer(self->normals());
+	}
+
+    PyObject* colors_buffer() const {
+        std::vector<double> clrs;
+        clrs.reserve(self->materials().size() * 4);
+        for (auto& mptr : self->materials()) {
+			auto& m = *mptr;
+            if (m.diffuse) {
+                clrs.push_back(m.diffuse.ccomponents()[0]);
+                clrs.push_back(m.diffuse.ccomponents()[1]);
+                clrs.push_back(m.diffuse.ccomponents()[2]);
+            } else {
+                clrs.push_back(0.);
+                clrs.push_back(0.);
+                clrs.push_back(0.);
+            }
+            if (m.has_transparency()) {
+                clrs.push_back(1. - m.transparency);
+            } else {
+                clrs.push_back(1.);
+            }
+        }
+        auto p = vector_to_buffer(clrs);
+        return PyBytes_FromStringAndSize(p.first, p.second);
+    }
+
+    %pythoncode %{
+        # Hide the getters with read-only property implementations
+        faces_tri = property(faces)
+        polyhedral_faces_without_holes = property(polyhedral_faces_without_holes)
+        polyhedral_faces_with_holes = property(polyhedral_faces_with_holes)
+        def get_faces(self):
+            if self.faces_tri: 
+                return self.faces_tri
+            elif self.polyhedral_faces_without_holes:
+                return self.polyhedral_faces_without_holes
+            else:
+                return self.polyhedral_faces_with_holes
+        faces = property(get_faces)
+        edges = property(edges)
+        material_ids = property(material_ids)
+        materials = property(materials)
+        verts = property(verts)
+        normals = property(normals)
+        item_ids = property(item_ids)
+        uvs = property(uvs)
+        edges_item_ids = property(edges_item_ids)
+
+        faces_buffer = property(faces_buffer)
+        edges_buffer = property(edges_buffer)
+        material_ids_buffer = property(material_ids_buffer)
+        item_ids_buffer = property(item_ids_buffer)
+        edges_item_ids_buffer = property(edges_item_ids_buffer)
+        verts_buffer = property(verts_buffer)
+        normals_buffer = property(normals_buffer)
+        colors_buffer = property(colors_buffer)
+    %}
+};
+
+%extend IfcGeom::Representation::Representation {
+	%pythoncode %{
+        # Hide the getters with read-only property implementations
+        id = property(id)
+	%}
+};
+
+%extend IfcGeom::Representation::Serialization {
+	%pythoncode %{
+        # Hide the getters with read-only property implementations
+        brep_data = property(brep_data)
+        surface_styles = property(surface_styles)
+        surface_style_ids = property(surface_style_ids)
+	%}
+};
+
+%extend IfcGeom::Element {
+    std::pair<const char*, size_t> transformation_buffer() const {
+        // @todo check whether needs to be transposed
+        const double* data = self->transformation().data()->ccomponents().data();
+        return { reinterpret_cast<const char*>(data), 16 * sizeof(double) };
+    }
+
+    const express::Base product_() const {
+        return $self->product();
+    }
+
+    %pythoncode %{
+        # Hide the getters with read-only property implementations
+        id = property(id)
+        parent_id = property(parent_id)
+        name = property(name)
+        type = property(type)
+        guid = property(guid)
+        context = property(context)
+        unique_id = property(unique_id)
+        transformation = property(transformation)
+        product = property(product_)
+
+        transformation_buffer = property(transformation_buffer)
+    %}
+};
+
+%extend IfcGeom::TriangulationElement {
+};
+
+%extend IfcGeom::SerializedElement {
+};
+
+%extend IfcGeom::BRepElement {
+    double calc_volume_() const {
+        double v;
+        if ($self->geometry().calculate_volume(v)) {
+            return v;
+        } else {
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+    }
+
+    double calc_surface_area_() const {
+        double v;
+        if ($self->geometry().calculate_surface_area(v)) {
+            return v;
+        } else {
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+    }
+
+    %pythoncode %{
+        volume = property(calc_volume_)
+        surface_area = property(calc_surface_area_)
+    %}
+};
+
+/*
+%extend IfcGeom::Material {
+	%pythoncode %{
+        # Hide the getters with read-only property implementations
+        has_diffuse = property(hasDiffuse)
+        has_specular = property(hasSpecular)
+        has_transparency = property(hasTransparency)
+        has_specularity = property(hasSpecularity)
+        diffuse = property(diffuse)
+        specular = property(specular)
+        transparency = property(transparency)
+        specularity = property(specularity)
+        name = property(name)
+	%}
+};
+*/
+
+%extend IfcGeom::Transformation {
+	PyObject* matrix_() const {
+		auto result = PyTuple_New(16);
+		for (int i = 0; i < 16; ++i) {
+			PyTuple_SET_ITEM(result, i, PyFloat_FromDouble(self->data()->ccomponents().data()[i]));
+		}
+		return result;
+	}
+	%pythoncode %{
+        # Hide the getters with read-only property implementations
+        matrix = property(matrix_)
+	%}
+};
+
+%extend IfcGeom::Matrix {
+	%pythoncode %{
+        # Hide the getters with read-only property implementations
+        data = property(data)
+	%}
+};
+
+%{
+	template <typename T>
+	std::string to_locale_invariant_string(const T& t) {
+		std::ostringstream oss;
+		oss.imbue(std::locale::classic());
+		oss << t;
+		return oss.str();
+	}
+
+	static std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*> helper_fn_create_shape(logger& logger, const std::string& geometry_library, ifcopenshell::geometry::Settings& st, const express::Base& instance, const express::Base& representation = express::Base()) {
+		ifcopenshell::file* file = instance.file();
+
+		ifcopenshell::geometry::Converter kernel(ifcopenshell::geometry::kernels::construct(file, geometry_library, st), file, st, logger);
+		if (instance.declaration().is("IfcProduct")) {
+			if (representation && !representation.declaration().is("IfcRepresentation")) {
+				throw ifcopenshell::exception("Supplied representation not of type IfcRepresentation");
+			}
+
+			auto selected_representation = representation ? representation : kernel.mapping()->representation_of(instance);
+			if (!selected_representation) {
+				throw ifcopenshell::exception("No suitable IfcRepresentation found");
+			}
+
+			IfcGeom::BRepElement* brep = kernel.create_brep_for_representation_and_product(selected_representation, instance);
+			if (!brep) {
+				std::ostringstream oss_repr, oss_product;
+				selected_representation.to_string(oss_repr);
+				instance.to_string(oss_product);
+				throw ifcopenshell::exception("Failed to process shape. Product: " + oss_product.str() + ", representation: " + oss_repr.str());
+			}
+			if (st.get<ifcopenshell::geometry::settings::IteratorOutput>().get() == ifcopenshell::geometry::settings::SERIALIZED) {
+				IfcGeom::SerializedElement* serialization = new IfcGeom::SerializedElement(*brep);
+				delete brep;
+				return serialization;
+			} else if (st.get<ifcopenshell::geometry::settings::IteratorOutput>().get() == ifcopenshell::geometry::settings::TRIANGULATED) {
+				IfcGeom::TriangulationElement* triangulation = new IfcGeom::TriangulationElement(*brep);
+				delete brep;
+				return triangulation;
+			} else {
+				return brep;
+			}
+		} else if (instance.declaration().is("IfcPlacement") || instance.declaration().is("IfcObjectPlacement")) {
+			auto item = ifcopenshell::geometry::taxonomy::cast<ifcopenshell::geometry::taxonomy::matrix4>(kernel.mapping()->map(instance));
+			if (item == nullptr) {
+				throw ifcopenshell::exception("Failed to convert placement");
+			}
+			/*
+            if (st.get<ifcopenshell::geometry::settings::ConvertBackUnits>().get()) {
+                // we pass the settings to the Transformation object, but access the data just offloads to the
+                // generic cartesian_base<Matrix4> so there's no time to apply the settings to the translation part.
+                item = ifcopenshell::geometry::taxonomy::matrix4::ptr(item->clone_());
+                item->components().col(3).head<3>() /= kernel.settings().get<ifcopenshell::geometry::settings::LengthUnit>().get();
+			}
+			*/
+			return new IfcGeom::Transformation(kernel.settings(), item);
+		} else {
+			if (!representation) {
+				if (instance.declaration().is("IfcRepresentationItem") ||
+					instance.declaration().is("IfcRepresentation") ||
+					// https://github.com/IfcOpenShell/IfcOpenShell/issues/1649
+					instance.declaration().is("IfcProfileDef")
+				) {
+					IfcGeom::ConversionResults shapes;
+					try {
+						shapes = kernel.convert(instance);
+					} catch (...) {
+						std::ostringstream oss;
+						instance.to_string(oss);
+						throw ifcopenshell::exception("Failed to process shape. Instance: " + oss.str());
+					}
+
+					IfcGeom::Representation::BRep brep(kernel.settings(), instance.declaration().name(), to_locale_invariant_string(instance.id()), shapes);
+					try {
+						if (st.get<ifcopenshell::geometry::settings::IteratorOutput>().get() == ifcopenshell::geometry::settings::SERIALIZED) {
+							return new IfcGeom::Representation::Serialization(brep);
+						} else if (st.get<ifcopenshell::geometry::settings::IteratorOutput>().get() == ifcopenshell::geometry::settings::TRIANGULATED) {
+							return new IfcGeom::Representation::Triangulation(brep);
+						}
+					} catch (...) {
+						throw ifcopenshell::exception("error during shape serialization");
+					}
+				}
+			} else {
+				throw ifcopenshell::exception("Invalid additional representation specified");
+			}
+		}
+		return std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*>();
+	}
+%}
+
+%typemap(out) ifcopenshell::geometry::taxonomy::item::ptr {
+	$result = item_to_pyobject($1);
+}
+
+%{
+template <typename T>
+ifcopenshell::geometry::taxonomy::item::ptr try_upcast(PyObject* obj0, swig_type_info* info) {
+    typename T::ptr *arg1 = 0 ;
+    void *argp1 ;
+    typename T::ptr tempshared1 ;
+
+    int newmem = 0;
+    auto res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, info,  0 , &newmem);
+    if (SWIG_IsOK(res1)) {
+        if (newmem & SWIG_CAST_NEW_MEMORY) {
+            if (argp1) tempshared1 = *reinterpret_cast< typename T::ptr * >(argp1);
+            delete reinterpret_cast< typename T::ptr * >(argp1);
+            arg1 = &tempshared1;
+        } else {
+            arg1 = (argp1) ? reinterpret_cast< typename T::ptr * >(argp1) : &tempshared1;
+        }
+        return std::static_pointer_cast<ifcopenshell::geometry::taxonomy::item>(*arg1);
+    }
+    return nullptr;
+}
+%}
+
+%inline %{
+	ifcopenshell::geometry::taxonomy::item::ptr map_shape(ifcopenshell::geometry::Settings& settings, const express::Base& instance) {
+        std::unique_ptr<ifcopenshell::geometry::abstract_mapping> mapping(ifcopenshell::geometry::impl::mapping_implementations().construct(instance.file(), settings));
+		return mapping->map(instance);
+	}
+%}
+
+%inline %{
+	static std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*> create_shape(ifcopenshell::geometry::Settings& settings, const express::Base& instance, const express::Base& representation, const char* const geometry_library="opencascade", logger* logger = nullptr) {
+		return helper_fn_create_shape(logger_or_root(logger), geometry_library, settings, instance, representation);
+	}
+
+	// Manual definition of overload without representation argument
+	static std::variant<IfcGeom::Element*, IfcGeom::Representation::Representation*, IfcGeom::Transformation*> create_shape(ifcopenshell::geometry::Settings& settings, const express::Base& instance, const char* const geometry_library="opencascade", logger* logger = nullptr) {
+		return create_shape(settings, instance, express::Base(), geometry_library, logger);
+	}
+%}
+
+// @todo bring back serialization OCCT -> IFC by means of opencascade_geometry_ifc_writer_registry
+
+%template(OpaqueCoordinate_3) IfcGeom::OpaqueCoordinate<3>;
+%template(OpaqueCoordinate_4) IfcGeom::OpaqueCoordinate<4>;
+
+%newobject create_epeck;
+
+%inline %{
+	IfcGeom::OpaqueNumber* create_epeck(int i) {
+		return new IfcGeom::OpaqueNumber(i);
+	}
+	IfcGeom::OpaqueNumber* create_epeck(double d) {
+		return new IfcGeom::OpaqueNumber(d);
+	}
+	IfcGeom::OpaqueNumber* create_epeck(const std::string& s) {
+		return new IfcGeom::OpaqueNumber(std::stod(s));
+	}
+%}
+
+%inline %{
+	IfcGeom::ConversionResultShape* nary_union(PyObject* sequence) {
+		IfcGeom::ConversionResultShape* result = nullptr;
+		std::string backend_id;
+		auto identity = ifcopenshell::geometry::taxonomy::make<ifcopenshell::geometry::taxonomy::matrix4>();
+		for(Py_ssize_t i = 0; i < PySequence_Size(sequence); ++i) {
+			PyObject* element = PySequence_GetItem(sequence, i);
+			void* argp1 = nullptr;
+			auto res1 = SWIG_ConvertPtr(element, &argp1, SWIGTYPE_p_IfcGeom__ConversionResultShape, 0);
+			if (SWIG_IsOK(res1)) {
+				auto arg1 = reinterpret_cast<IfcGeom::ConversionResultShape*>(argp1);
+				auto element_backend_id = std::string(arg1->backend_id());
+				if (backend_id.empty()) {
+					backend_id = element_backend_id;
+					result = arg1->moved(identity);
+				} else {
+					if (element_backend_id != backend_id) {
+						delete result;
+						throw ifcopenshell::exception("nary_union requires shapes from the same geometry backend");
+					}
+					auto next = result->add(arg1);
+					if (!next) {
+						delete result;
+						throw ifcopenshell::exception("nary_union failed for backend " + backend_id);
+					}
+					delete result;
+					result = next;
+				}
+			}
+		}
+		if (!result) {
+			throw ifcopenshell::exception("nary_union requires at least one shape");
+		}
+		return result;
+	}
+%}
+
+%extend IfcGeom::ConversionResultShape {
+	std::string serialize_obj() {
+		ifcopenshell::geometry::Settings settings;
+		std::unique_ptr<IfcGeom::Representation::Triangulation> triangulation($self->Triangulate(settings));
+		std::ostringstream result;
+
+		for (auto it = triangulation->verts().begin(); it != triangulation->verts().end();) {
+			result << "v " << *(it++) << " " << *(it++) << " " << *(it++) << "\n";
+		}
+		for (auto it = triangulation->normals().begin(); it != triangulation->normals().end();) {
+			result << "vn " << *(it++) << " " << *(it++) << " " << *(it++) << "\n";
+		}
+
+		const bool has_normals = !triangulation->normals().empty();
+		for (auto it = triangulation->faces().begin(); it != triangulation->faces().end();) {
+			const auto v1 = *(it++) + 1;
+			const auto v2 = *(it++) + 1;
+			const auto v3 = *(it++) + 1;
+			if (has_normals) {
+				result << "f "
+					<< v1 << "//" << v1 << " "
+					<< v2 << "//" << v2 << " "
+					<< v3 << "//" << v3 << "\n";
+			} else {
+				result << "f " << v1 << " " << v2 << " " << v3 << "\n";
+			}
+		}
+
+		return result.str();
+	}
+
+	void convex_tag(bool b) {
+		(void)b;
+		throw ifcopenshell::exception("convex_tag is not available through the generic conversion result interface");
+	}
+
+	std::string serialize() {
+		std::string result;
+		ifcopenshell::geometry::taxonomy::matrix4 iden;
+		$self->Serialize(iden, result);
+		return result;
+	}
+
+	ConversionResultShape* solid_mt() {
+		IfcGeom::ConversionResultShape* r;
+		Py_BEGIN_ALLOW_THREADS;
+		r = $self->solid();
+		Py_END_ALLOW_THREADS;
+		return r;
+	}
+}
+
+#ifdef IFOPSH_WITH_CGAL
+
+%ignore hlr_writer;
+%ignore hlr_calc;
+%ignore occt_join;
+%ignore prefiltered_hlr;
+%ignore svgfill::svg_to_line_segments;
+%ignore svgfill::line_segments_to_polygons;
+%ignore svgfill::svg_to_polygons;
+%ignore svgfill::arrange_polygons;
+%ignore svgfill::abstract_arrangement;
+%ignore svgfill::context::delete_same_facet_edge_pairs;
+
+%template(svg_line_segments) std::vector<std::array<svgfill::point_2, 2>>;
+%template(svg_groups_of_line_segments) std::vector<std::vector<std::array<svgfill::point_2, 2>>>;
+%template(svg_point) std::array<double, 2>;
+%template(line_segment) std::array<svgfill::point_2, 2>;
+%template(svg_polygons) std::vector<svgfill::polygon_2>;
+%template(svg_groups_of_polygons) std::vector<std::vector<svgfill::polygon_2>>;
+%template(svg_loop) std::vector<std::array<double, 2>>;
+%template(svg_loops) std::vector<std::vector<std::array<double, 2>>>;
+
+%extend IfcGeom::OpaqueCoordinate {
+	%pythoncode %{
+		__len__ = size
+		def __iter__(self):
+			yield from (self.get(i) for i in range(len(self)))
+	%}
+}
+
+%extend IfcGeom::OpaqueNumber {
+	%pythoncode %{
+		__abs__ = abs
+	%}
+}
+
+%template(OpaqueCoordinate_3) IfcGeom::OpaqueCoordinate<3>;
+%template(OpaqueCoordinate_4) IfcGeom::OpaqueCoordinate<4>;
+
+#if 0
+%inline %{
+	IfcGeom::OpaqueNumber create_epeck(int i) {
+		return ifcopenshell::geometry::NumberEpeck(i);
+	}
+	IfcGeom::OpaqueNumber create_epeck(double d) {
+		return ifcopenshell::geometry::NumberEpeck(d);
+	}
+	IfcGeom::OpaqueNumber create_epeck(const std::string& s) {
+		return ifcopenshell::geometry::NumberEpeck(typename CGAL::Epeck::FT::ET(s));
+	}
+%}
+
+%inline %{
+	IfcGeom::ConversionResultShape* nary_union(PyObject* sequence) {
+		std::vector<const CGAL::Nef_polyhedron_3<CGAL::Epeck>*> nefs;
+		for(Py_ssize_t i = 0; i < PySequence_Size(sequence); ++i) {
+			PyObject* element = PySequence_GetItem(sequence, i);
+			void* argp1 = nullptr;
+			auto res1 = SWIG_ConvertPtr(element, &argp1, SWIGTYPE_p_IfcGeom__ConversionResultShape, 0);
+			if (SWIG_IsOK(res1)) {
+				auto arg1 = reinterpret_cast<IfcGeom::ConversionResultShape*>(argp1);
+				auto cgs = dynamic_cast<ifcopenshell::geometry::CgalShape*>(arg1);
+				if (cgs) {
+					nefs.push_back(&cgs->nef());
+				}
+			}
+		}
+		ifcopenshell::geometry::CgalShape* shp;
+		Py_BEGIN_ALLOW_THREADS;
+		CGAL::Nef_nary_union_3< CGAL::Nef_polyhedron_3<CGAL::Epeck> > accum;
+		for (auto& n : nefs) {
+			accum.add_polyhedron(*n);
+		}
+		shp = new ifcopenshell::geometry::CgalShape(accum.get_union());
+		Py_END_ALLOW_THREADS;
+		return shp;
+	}
+%}
+#endif
+
+%extend IfcGeom::ConversionResultShape {
+	std::string serialize_obj() {
+		std::ostringstream result;
+		auto cgs = dynamic_cast<ifcopenshell::geometry::CgalShape*>($self);
+		if (cgs) {
+			write_to_obj(cgs->nef(), result, std::numeric_limits<size_t>::max());
+		}		
+		return result.str();
+	}
+
+	void convex_tag(bool b) {
+		auto cgs = dynamic_cast<ifcopenshell::geometry::CgalShape*>($self);
+		if (cgs) {
+			cgs->convex_tag() = b;
+		}		
+	}
+
+	std::string serialize() {
+		std::string result;
+		ifcopenshell::geometry::taxonomy::matrix4 iden;
+		$self->Serialize(iden, result);
+		return result;
+	}
+
+	ConversionResultShape* solid_mt() {
+		IfcGeom::ConversionResultShape* r;
+		Py_BEGIN_ALLOW_THREADS;
+		r = $self->solid();
+		Py_END_ALLOW_THREADS;
+		return r;
+	}
+}
+
+%naturalvar svgfill::polygon_2::boundary;
+%naturalvar svgfill::polygon_2::inner_boundaries;
+%naturalvar svgfill::polygon_2::point_inside;
+
+%include "../svgfill/src/svgfill.h"
+
+%inline %{
+	std::vector<std::vector<svgfill::line_segment_2>> svg_to_line_segments(const std::string& data, const std::optional<std::string>& class_name) {
+		std::vector<std::vector<svgfill::line_segment_2>> r;
+		if (svgfill::svg_to_line_segments(data, class_name, r)) {
+			return r;
+		} else {
+			throw std::runtime_error("Failed to read SVG");
+		}
+	}
+
+	std::vector<std::vector<svgfill::polygon_2>> line_segments_to_polygons(svgfill::solver s, double eps, const std::vector<std::vector<svgfill::line_segment_2>>& segments) {
+		std::vector<std::vector<svgfill::polygon_2>> r;
+		if (svgfill::line_segments_to_polygons(s, eps, segments, r)) {
+			return r;
+		} else {
+			throw std::runtime_error("Failed process line segments");
+		}
+	}
+
+	std::vector<svgfill::polygon_2> svg_to_polygons(const std::string& data, const std::optional<std::string>& class_name) {
+		std::vector<svgfill::polygon_2> r;
+		if (svgfill::svg_to_polygons(data, class_name, r)) {
+			return r;
+		} else {
+			throw std::runtime_error("Failed to read SVG");
+		}	
+	}
+
+	std::vector<svgfill::polygon_2> arrange_polygons(svgfill::arrange_polygon_settings settings, const std::vector<svgfill::polygon_2>& polygons, logger* logger = nullptr) {
+		std::vector<svgfill::polygon_2> r;
+		if (svgfill::arrange_polygons(settings, polygons, r, logger_or_root(logger))) {
+			return r;
+		} else {
+			throw std::runtime_error("Failed to arrange polygons");
+		}
+	}
+%}
+
+%define assign_repr(item_name)
+
+%extend item_name {
+	%pythoncode %{
+		__repr__ = taxonomy_item_repr
+	%}
+};
+
+%enddef
+
+assign_repr(ifcopenshell::geometry::taxonomy::boolean_result)
+assign_repr(ifcopenshell::geometry::taxonomy::bspline_curve)
+assign_repr(ifcopenshell::geometry::taxonomy::bspline_surface)
+assign_repr(ifcopenshell::geometry::taxonomy::circle)
+assign_repr(ifcopenshell::geometry::taxonomy::collection)
+assign_repr(ifcopenshell::geometry::taxonomy::colour)
+assign_repr(ifcopenshell::geometry::taxonomy::cylinder)
+assign_repr(ifcopenshell::geometry::taxonomy::direction3)
+assign_repr(ifcopenshell::geometry::taxonomy::edge)
+assign_repr(ifcopenshell::geometry::taxonomy::ellipse)
+assign_repr(ifcopenshell::geometry::taxonomy::extrusion)
+assign_repr(ifcopenshell::geometry::taxonomy::face)
+assign_repr(ifcopenshell::geometry::taxonomy::line)
+assign_repr(ifcopenshell::geometry::taxonomy::loft)
+assign_repr(ifcopenshell::geometry::taxonomy::loop)
+assign_repr(ifcopenshell::geometry::taxonomy::matrix4)
+assign_repr(ifcopenshell::geometry::taxonomy::node)
+assign_repr(ifcopenshell::geometry::taxonomy::offset_curve)
+assign_repr(ifcopenshell::geometry::taxonomy::function_item)
+assign_repr(ifcopenshell::geometry::taxonomy::functor_item)
+assign_repr(ifcopenshell::geometry::taxonomy::piecewise_function)
+assign_repr(ifcopenshell::geometry::taxonomy::gradient_function)
+assign_repr(ifcopenshell::geometry::taxonomy::cant_function)
+assign_repr(ifcopenshell::geometry::taxonomy::offset_function)
+assign_repr(ifcopenshell::geometry::taxonomy::plane)
+assign_repr(ifcopenshell::geometry::taxonomy::point3)
+assign_repr(ifcopenshell::geometry::taxonomy::revolve)
+assign_repr(ifcopenshell::geometry::taxonomy::shell)
+assign_repr(ifcopenshell::geometry::taxonomy::solid)
+assign_repr(ifcopenshell::geometry::taxonomy::sphere)
+assign_repr(ifcopenshell::geometry::taxonomy::torus)
+assign_repr(ifcopenshell::geometry::taxonomy::style)
+assign_repr(ifcopenshell::geometry::taxonomy::sweep_along_curve)
+
+
+#endif