Include-what-you-use

src/ifcgeom_schema_agnostic/GeometrySerializer.h

@@ -21,7 +21,7 @@
 #define GEOMETRYSERIALIZER_H
 
 #include "../ifcgeom_schema_agnostic/Serializer.h"
-#include "../ifcgeom/IfcGeomElement.h"
+#include "../ifcgeom_schema_agnostic/IfcGeomElement.h"
 
 class SerializerSettings : public IfcGeom::IteratorSettings
 {

src/ifcgeom_schema_agnostic/IfcGeomElement.h

@@ -0,0 +1,220 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCGEOMELEMENT_H
+#define IFCGEOMELEMENT_H
+
+#include <string>
+#include <algorithm>
+
+#include "../ifcparse/Argument.h"
+#include "../ifcparse/IfcGlobalId.h"
+
+#include "../ifcgeom_schema_agnostic/IfcGeomRepresentation.h"
+#include "../ifcgeom_schema_agnostic/IfcGeomIteratorSettings.h"
+#include "../ifcgeom_schema_agnostic/ifc_geom_api.h"
+
+namespace IfcGeom {
+
+	class Matrix {
+	private:
+		std::vector<double> _data;
+	public:
+		Matrix(const ElementSettings& settings, const gp_Trsf& trsf) {
+			// Convert the gp_Trsf into a 4x3 Matrix
+			// Note that in case the CONVERT_BACK_UNITS setting is enabled
+			// the translation component of the matrix needs to be divided
+			// by the magnitude of the IFC model length unit because
+			// internally in IfcOpenShell everything is measured in meters.
+			for(int i = 1; i < 5; ++i) {
+				for (int j = 1; j < 4; ++j) {
+					const double trsf_value = trsf.Value(j,i);
+                    const double matrix_value = i == 4 && settings.get(IteratorSettings::CONVERT_BACK_UNITS)
+						? trsf_value / settings.unit_magnitude()
+						: trsf_value;
+					_data.push_back(static_cast<double>(matrix_value));
+				}
+			}
+		}
+		const std::vector<double>& data() const { return _data; }
+	};
+
+	class Transformation {
+	private:
+		ElementSettings settings_;
+		gp_Trsf trsf_;
+		Matrix matrix_;
+	public:
+		Transformation(const ElementSettings& settings, const gp_Trsf& trsf)
+			: settings_(settings)
+			, trsf_(trsf)
+			, matrix_(settings, trsf) 
+		{}
+		const gp_Trsf& data() const { return trsf_; }
+		const Matrix& matrix() const { return matrix_; }
+
+		Transformation inverted() const {
+			return Transformation(settings_, trsf_.Inverted());
+		}
+
+		Transformation multiplied(const Transformation& other) const {
+			return Transformation(settings_, trsf_.Multiplied(other.data()));
+		}
+	};
+
+	class Element {
+	private:
+		int _id;
+		int _parent_id;
+		std::string _name;
+		std::string _type;
+		std::string _guid;
+		std::string _context;
+		std::string _unique_id;
+		Transformation _transformation;
+        IfcUtil::IfcBaseEntity* product_;
+		std::vector<const IfcGeom::Element*> _parents;
+	public:
+
+		friend bool operator == (const Element& element1, const Element& element2) {
+			return element1.id() == element2.id();
+		}
+
+		// Use the id to compare, or the elevation is the elements are IfcBuildingStoreys and the elevation is set
+		friend bool operator < (const Element& element1, const Element& element2) {
+			if (element1.type() == "IfcBuildingStorey" && element2.type() == "IfcBuildingStorey") {
+				size_t attr_index = element1.product()->declaration().attribute_index("Elevation");
+				Argument* elev_attr1 = element1.product()->data().getArgument(attr_index);
+				Argument* elev_attr2 = element2.product()->data().getArgument(attr_index);
+
+				if (!elev_attr1->isNull() && !elev_attr2->isNull()) {
+					double elev1 = *elev_attr1;
+					double elev2 = *elev_attr2;
+
+					return elev1 < elev2;
+				}
+			}
+
+			return element1.id() < element2.id();
+		}
+
+		int id() const { return _id; }
+		int parent_id() const { return _parent_id; }
+		const std::string& name() const { return _name; }
+		const std::string& type() const { return _type; }
+		const std::string& guid() const { return _guid; }
+		const std::string& context() const { return _context; }
+		const std::string& unique_id() const { return _unique_id; }
+		const Transformation& transformation() const { return _transformation; }
+        IfcUtil::IfcBaseEntity* product() const { return product_; }
+		const std::vector<const IfcGeom::Element*> parents() const { return _parents; }
+		void SetParents(std::vector<const IfcGeom::Element*> newparents) { _parents = newparents; }
+
+		Element(const ElementSettings& settings, int id, int parent_id, const std::string& name, const std::string& type,
+            const std::string& guid, const std::string& context, const gp_Trsf& trsf, IfcUtil::IfcBaseEntity* product)
+			: _id(id), _parent_id(parent_id), _name(name), _type(type), _guid(guid), _context(context), _transformation(settings, trsf)
+            , product_(product)
+		{ 
+			std::ostringstream oss;
+
+			if (type == "IfcProject") {
+				oss << "project";
+			} else {
+				try {
+					oss << "product-" << IfcParse::IfcGlobalId(guid).formatted();
+				} catch (const std::exception& e) {
+					oss << "product";
+					Logger::Error(e);
+				}
+			}
+
+			if (!_context.empty()) {
+				std::string ctx = _context;
+                boost::to_lower(ctx);
+                boost::replace_all(ctx, " ", "-");
+				oss << "-" << ctx;
+			}
+
+			_unique_id = oss.str();
+		}
+		virtual ~Element() {}
+	};
+
+	class BRepElement : public Element {
+	private:
+		boost::shared_ptr<IfcGeom::Representation::BRep> _geometry;
+	public:
+		const boost::shared_ptr<IfcGeom::Representation::BRep>& geometry_pointer() const { return _geometry; }
+		const IfcGeom::Representation::BRep& geometry() const { return *_geometry; }
+		BRepElement(int id, int parent_id, const std::string& name, const std::string& type, const std::string& guid,
+            const std::string& context, const gp_Trsf& trsf, const boost::shared_ptr<IfcGeom::Representation::BRep>& geometry,
+			IfcUtil::IfcBaseEntity* product)
+			: Element(geometry->settings() ,id, parent_id, name, type, guid, context, trsf, product)
+			, _geometry(geometry)
+		{}
+
+		bool calculate_projected_surface_area(double& along_x, double& along_y, double& along_z) const {
+			const auto& trsf = this->transformation().data();
+			const gp_Mat& mat = trsf.HVectorialPart();
+			gp_Ax3 ax(trsf.TranslationPart(), mat.Column(3), mat.Column(1));
+			return geometry().calculate_projected_surface_area(ax, along_x, along_y, along_z);
+		}
+	private:
+		BRepElement(const BRepElement& other);
+		BRepElement& operator=(const BRepElement& other);		
+	};
+
+	class TriangulationElement : public Element {
+	private:
+		boost::shared_ptr< IfcGeom::Representation::Triangulation > _geometry;
+	public:
+		const IfcGeom::Representation::Triangulation& geometry() const { return *_geometry; }
+		const boost::shared_ptr< IfcGeom::Representation::Triangulation>& geometry_pointer() const { return _geometry; }
+		TriangulationElement(const IfcGeom::BRepElement& shape_model)
+			: Element(shape_model)
+			, _geometry(boost::shared_ptr<IfcGeom::Representation::Triangulation>(new IfcGeom::Representation::Triangulation(shape_model.geometry())))
+		{}
+		TriangulationElement(const IfcGeom::Element& element, const boost::shared_ptr<IfcGeom::Representation::Triangulation>& geometry)
+			: Element(element)
+			, _geometry(geometry)
+		{}
+	private:
+		TriangulationElement(const TriangulationElement& other);
+		TriangulationElement& operator=(const TriangulationElement& other);
+	};
+
+	class SerializedElement : public Element {
+	private:
+		IfcGeom::Representation::Serialization* _geometry;
+	public:
+		const IfcGeom::Representation::Serialization& geometry() const { return *_geometry; }
+		SerializedElement(const BRepElement& shape_model)
+			: Element(shape_model)
+			, _geometry(new IfcGeom::Representation::Serialization(shape_model.geometry()))
+		{}
+		virtual ~SerializedElement() {
+			delete _geometry;
+		}
+	private:
+		SerializedElement(const SerializedElement& other);
+		SerializedElement& operator=(const SerializedElement& other);
+	};
+}
+
+#endif

src/ifcgeom_schema_agnostic/IfcGeomIteratorSettings.h

@@ -0,0 +1,207 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCGEOMITERATORSETTINGS_H
+#define IFCGEOMITERATORSETTINGS_H
+
+#include "ifc_geom_api.h"
+
+#include "../ifcparse/IfcException.h"
+#include "../ifcparse/IfcBaseClass.h"
+
+#include <set>
+#include <array>
+
+namespace IfcGeom
+{
+    class IFC_GEOM_API IteratorSettings
+    {
+    public:
+        /// Enumeration of setting identifiers. These settings define the
+        /// behaviour of various aspects of IfcOpenShell.
+        enum Setting : uint64_t
+        {
+            /// Specifies whether vertices are welded, meaning that the coordinates
+            /// vector will only contain unique xyz-triplets. This results in a 
+            /// manifold mesh which is useful for modelling applications, but might 
+            /// result in unwanted shading artifacts in rendering applications.
+            WELD_VERTICES = 1,
+            /// Specifies whether to apply the local placements of building elements
+            /// directly to the coordinates of the representation mesh rather than
+            /// to represent the local placement in the 4x3 matrix, which will in that
+            /// case be the identity matrix.
+            USE_WORLD_COORDS = 1 << 1,
+            /// Internally IfcOpenShell measures everything in meters. This settings
+            /// specifies whether to convert IfcGeomObjects back to the units in which
+            /// the geometry in the IFC file is specified.
+            CONVERT_BACK_UNITS = 1 << 2,
+            /// Specifies whether to use the Open Cascade BREP format for representation
+            /// items rather than to create triangle meshes. This is useful is IfcOpenShell
+            /// is used as a library in an application that is also built on Open Cascade.
+            USE_BREP_DATA = 1 << 3,
+            /// Specifies whether to sew IfcConnectedFaceSets (open and closed shells) to
+            /// TopoDS_Shells or whether to keep them as a loose collection of faces.
+            SEW_SHELLS = 1 << 4,
+            /// Disables the subtraction of IfcOpeningElement representations from
+            /// the related building element representations.
+            DISABLE_OPENING_SUBTRACTIONS = 1 << 5,
+            /// Disables the triangulation of the topological representations. Useful if
+            /// the client application understands Open Cascade's native format.
+            DISABLE_TRIANGULATION = 1 << 6,
+            /// Applies default materials to entity instances without a surface style or
+			/// product-level material association.
+            APPLY_DEFAULT_MATERIALS = 1 << 7,
+            /// Specifies whether to include subtypes of IfcCurve.
+            INCLUDE_CURVES = 1 << 8,
+            /// Specifies whether to exclude subtypes of IfcSolidModel and IfcSurface.
+            EXCLUDE_SOLIDS_AND_SURFACES = 1 << 9,
+            /// Disables computation of normals. Saves time and file size and is useful
+            /// in instances where you're going to recompute normals for the exported
+            /// model in other modelling application in any case.
+            NO_NORMALS = 1 << 10,
+            /// Generates UVs by using simple box projection. Requires normals.
+            /// Applicable for OBJ and DAE output.
+            GENERATE_UVS = 1 << 11,
+            /// Specifies whether to slice representations according to associated
+			/// IfcMaterialLayerSets.
+            APPLY_LAYERSETS = 1 << 12,
+			/// Emit the relative placements from IFC instead of a flat listing of
+			/// absolute placements.
+			ELEMENT_HIERARCHY = 1 << 13,
+			/// Emit placements relative to the IfcSite. Useful if the IfcSite itself
+			/// introduces a placement with a large geospatial offset that inhibits
+			/// rendering.
+			SITE_LOCAL_PLACEMENT = 1 << 14,
+			/// Emit placements relative to the IfcBuilding. Useful if the IfcBuilding 
+			/// itself introduces a placement with a large geospatial offset that
+			/// inhibits rendering.
+			BUILDING_LOCAL_PLACEMENT = 1 << 15,
+			/// After geometry interpretation, lookup an IfcOpenShell-specific quantity set
+			/// and compare values for validation.
+			VALIDATE_QUANTITIES = 1 << 16,
+			/// Assigns the first layer material to the entire product
+			LAYERSET_FIRST = 1 << 17,
+			/// Adds arrow heads to edge segments to signify edge direction. Useful as a
+			/// debugging mechanism for face orientation or advanced brep IfcOrientedEdge.
+			EDGE_ARROWS = 1 << 18,
+			/// Disables the evaluation of IfcBooleanResult and simply returns FirstOperand
+			DISABLE_BOOLEAN_RESULT = 1 << 19,
+			/// Disables wire intersection checks. These checks are done on faces to prevent
+			/// self-intersections of face bounds. Self-intersections reduce the reliability
+			/// of boolean operations and may lead to crashes.
+			NO_WIRE_INTERSECTION_CHECK = 1 << 20,
+			/// Set wire intersection tolerance to 0. By default the above check is done
+			/// using a tolerance criterium. So that when a vertex is a certain epsilon
+			/// distance away from an edge this is flagged as an intersection.
+			NO_WIRE_INTERSECTION_TOLERANCE = 1 << 21,
+			/// Strictly use the tolerance from the IFC model. Typically this value is
+			/// increased 10-fold to have more reliable boolean subtraction results.
+			STRICT_TOLERANCE = 1 << 22,
+			/// Write boolean operands to file in current directory for debugging purposes
+			DEBUG_BOOLEAN = 1 << 23,
+			/// Try to perform boolean subtractions in 2d. Defaults to true.
+			BOOLEAN_ATTEMPT_2D = 1 << 24,
+			/// Number of different setting flags.
+			NUM_SETTINGS = 25,
+        };
+
+        IteratorSettings()
+            : settings_(WELD_VERTICES | BOOLEAN_ATTEMPT_2D) // OR options that default to true here
+            , deflection_tolerance_(1.e-3)
+			, angular_tolerance_(0.5)
+        {
+        }
+
+        /// Note that this is independent of the IFC length unit, one millimeter by default.
+        double deflection_tolerance() const { return deflection_tolerance_; }
+		double angular_tolerance() const { return angular_tolerance_; }
+		double force_space_transparency() const { return force_space_transparency_; }
+		std::set<int> context_ids() const { return context_ids_; }
+
+		/// @todo Using deflection tolerance of 1e-6 or smaller hangs the conversion, research more in-depth.
+		/// This bug can be reproduced e.g. with the Duplex model that can be found from http://www.nibs.org/?page=bsa_commonbimfiles#project1
+		void set_deflection_tolerance(double value);
+
+		void set_angular_tolerance(double value) {
+			angular_tolerance_ = value;
+		}
+
+		void force_space_transparency(double value) {
+			force_space_transparency_ = value;
+		}
+
+		void set_context_ids(std::vector<int> value) {
+			context_ids_ = std::set<int>(value.begin(), value.end());
+		}
+
+        /// Get boolean value for a single settings or for a combination of settings.
+        bool get(uint64_t setting) const
+        {
+            /// @todo If unknown setting value/combination: throw IfcParse::IfcException("Invalid IteratorSetting")?
+            return (settings_ & setting) != 0;
+        }
+
+        /// Set boolean value for a single settings or for a combination of settings.
+        void set(uint64_t setting, bool value)
+        {
+            /// @todo If unknown setting value/combination: throw IfcParse::IfcException("Invalid IteratorSetting")?
+            if (value) {
+                settings_ |= setting;
+            } else {
+                settings_ &= ~setting;
+            }
+        }
+
+        /// Optional offset that is applied to serialized objects, (0,0,0) by default.
+        std::array<double,3> offset = std::array<double,3>{0.0, 0.0, 0.0};
+        /// Optional rotation that is applied to serialized objects, (0,0,0,1) by default.
+        std::array<double,4> rotation = std::array<double,4>{0.0, 0.0, 0.0, 1.0};
+
+		uint64_t get_raw() const {
+			return settings_;
+		}
+
+    protected:
+		uint64_t settings_;
+        double deflection_tolerance_, angular_tolerance_, force_space_transparency_;
+		std::set<int> context_ids_;
+    };
+
+    class IFC_GEOM_API ElementSettings : public IteratorSettings
+    {
+    public:
+        ElementSettings(const IteratorSettings& settings,
+            double unit_magnitude,
+            const std::string& element_type)
+            : IteratorSettings(settings)
+            , unit_magnitude_(unit_magnitude)
+            , element_type_(element_type)
+        {
+        }
+
+        double unit_magnitude() const { return unit_magnitude_; }
+        const std::string& element_type() const { return element_type_; }
+
+    private:
+        double unit_magnitude_;
+        std::string element_type_;
+    };
+}
+
+#endif

src/ifcgeom_schema_agnostic/IfcGeomRenderStyles.h

@@ -20,7 +20,7 @@
 #ifndef IFCGEOMRENDERSTYLES_H
 #define IFCGEOMRENDERSTYLES_H
 
-#include "../ifcgeom/ifc_geom_api.h"
+#include "../ifcgeom_schema_agnostic/ifc_geom_api.h"
 
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/algorithm/string/replace.hpp>

src/ifcgeom_schema_agnostic/IfcGeomRepresentation.cpp

@@ -0,0 +1,533 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include "IfcGeomRepresentation.h"
+
+#include <BRep_Tool.hxx>
+#include <BRepTools.hxx>
+#include <BRep_Builder.hxx>
+#include <Geom_Plane.hxx>
+#include <TopoDS_Compound.hxx>
+#include <BRepGProp.hxx>
+#include <GProp_GProps.hxx>
+
+#include "../ifcparse/IfcLogger.h"
+#include "../ifcgeom_schema_agnostic/Kernel.h"
+
+IfcGeom::Representation::Serialization::Serialization(const BRep& brep)
+	: Representation(brep.settings())
+	, id_(brep.id())
+{
+	TopoDS_Compound compound = brep.as_compound();
+	for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = brep.begin(); it != brep.end(); ++ it) {
+		int sid = -1;
+		
+		if (it->hasStyle() && it->Style().Diffuse()) {
+			const IfcGeom::SurfaceStyle::ColorComponent& clr = *it->Style().Diffuse();
+			surface_styles_.push_back(clr.R());
+			surface_styles_.push_back(clr.G());
+			surface_styles_.push_back(clr.B());
+
+			sid = it->Style().Id().get_value_or(-1);
+		} else {
+			surface_styles_.push_back(-1.);
+			surface_styles_.push_back(-1.);
+			surface_styles_.push_back(-1.);
+		}
+
+		if (it->hasStyle() && it->Style().Transparency()) {
+			surface_styles_.push_back(1. - *it->Style().Transparency());
+		} else {
+			surface_styles_.push_back(1.);
+		}
+
+		surface_style_ids_.push_back(sid);
+	}
+	std::stringstream sstream;
+	BRepTools::Write(compound,sstream);
+	brep_data_ = sstream.str();
+}
+
+// todo copied from kernel
+#include <BRepBuilderAPI_Transform.hxx>
+#include <BRepBuilderAPI_GTransform.hxx>
+
+TopoDS_Shape apply_transformation(const TopoDS_Shape& s, const gp_Trsf& t) {
+	if (t.Form() == gp_Identity) {
+		return s;
+	} else {
+		/// @todo set to 1. and exactly 1. or use epsilon?
+		if (t.ScaleFactor() != 1.) {
+			return BRepBuilderAPI_Transform(s, t, true);
+		} else {
+			return s.Moved(t);
+		}
+	}
+}
+
+TopoDS_Shape apply_transformation(const TopoDS_Shape& s, const gp_GTrsf& t) {
+	if (t.Form() == gp_Other) {
+		return BRepBuilderAPI_GTransform(s, t, true);
+	} else {
+		return apply_transformation(s, t.Trsf());
+	}
+}
+
+TopoDS_Compound IfcGeom::Representation::BRep::as_compound(bool force_meters) const {
+	TopoDS_Compound compound;
+	BRep_Builder builder;
+	builder.MakeCompound(compound);
+	for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = begin(); it != end(); ++it) {
+		const TopoDS_Shape& s = it->Shape();
+		gp_GTrsf trsf = it->Placement();
+
+		if (!force_meters && settings().get(IteratorSettings::CONVERT_BACK_UNITS)) {
+			gp_Trsf scale;
+			scale.SetScaleFactor(1.0 / settings().unit_magnitude());
+			trsf.PreMultiply(scale);
+		}
+
+		const TopoDS_Shape moved_shape = apply_transformation(s, trsf);
+		builder.Add(compound, moved_shape);
+	}
+	return compound;
+}
+
+namespace {
+	void accumulate(const gp_Ax3& ax, const gp_Dir& normal, double area, double& along_x, double& along_y, double& along_z) {
+		along_x += area * fabs(ax.XDirection().Dot(normal));
+		along_y += area * fabs(ax.YDirection().Dot(normal));
+		along_z += area * fabs(ax.Direction().Dot(normal));
+	}
+
+	void surface_area_along_direction(double tol, const TopoDS_Shape& s, const gp_Ax3& ax, double& along_x, double& along_y, double& along_z) {
+		along_x = along_y = along_z = 0.;
+
+		bool meshed = false;
+
+		TopExp_Explorer exp(s, TopAbs_FACE);
+		for (; exp.More(); exp.Next()) {
+			const TopoDS_Face& face = TopoDS::Face(exp.Current());
+			Handle(Geom_Surface) surf = BRep_Tool::Surface(face);
+			Handle(Geom_Plane) plane = Handle(Geom_Plane)::DownCast(surf);
+
+			if (surf->DynamicType() == STANDARD_TYPE(Geom_Plane)) {
+				GProp_GProps prop_area;
+				BRepGProp::SurfaceProperties(face, prop_area);
+				const double area = prop_area.Mass();
+
+				accumulate(ax, plane->Position().Direction(), area, along_x, along_y, along_z);
+			} else {
+
+				if (!meshed) {
+					try {
+						BRepMesh_IncrementalMesh(s, tol);
+					} catch (...) {
+						Logger::Message(Logger::LOG_ERROR, "Failed to triangulate shape");
+						return;
+					}
+					meshed = true;
+				}
+
+				TopLoc_Location loc;
+				Handle(Poly_Triangulation) tri = BRep_Tool::Triangulation(face, loc);
+				if (!tri.IsNull()) {
+					std::vector<gp_XYZ> coords;
+					coords.reserve(tri->NbNodes());
+
+					for (int i = 1; i <= tri->NbNodes(); ++i) {
+						coords.push_back(tri->Node(i).Transformed(loc).XYZ());
+					}
+
+					const Poly_Array1OfTriangle& triangles = tri->Triangles();
+					for (int i = 1; i <= triangles.Length(); ++i) {
+						int n1, n2, n3;
+
+						if (face.Orientation() == TopAbs_REVERSED) {
+							triangles(i).Get(n3, n2, n1);
+						} else {
+							triangles(i).Get(n1, n2, n3);
+						}
+
+						const gp_XYZ& pt1 = coords[n1 - 1];
+						const gp_XYZ& pt2 = coords[n2 - 1];
+						const gp_XYZ& pt3 = coords[n3 - 1];
+						const gp_Vec v1 = pt2 - pt1;
+						const gp_Vec v2 = pt3 - pt2;
+						const gp_Vec v3 = pt1 - pt3;
+						const gp_Vec normal_vector = v1 ^ v2;
+						if (normal_vector.Magnitude() > ALMOST_ZERO) {
+							gp_Dir normal = gp_Dir();
+
+							double edge_lengths[3] = { v1.Magnitude(), v2.Magnitude(), v3.Magnitude() };
+							std::sort(&edge_lengths[0], &edge_lengths[2]);
+
+							const double& a = edge_lengths[0];
+							const double& b = edge_lengths[1];
+							const double& c = edge_lengths[2];
+
+							const double area = 0.25 * sqrt((a + (b + c))*(c - (a - b))*(c + (a - b))*(a + (b - c)));
+							accumulate(ax, normal, area, along_x, along_y, along_z);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+bool IfcGeom::Representation::BRep::calculate_surface_area(double& area) const {
+	try {
+		area = 0.;
+
+		for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = begin(); it != end(); ++it) {
+			GProp_GProps prop;
+			BRepGProp::SurfaceProperties(it->Shape(), prop);
+			area += prop.Mass();
+		}
+
+		return true;
+	} catch (...) {
+		Logger::Error("Error during calculation of surface area");
+		return false;
+	}
+}
+
+bool IfcGeom::Representation::BRep::calculate_volume(double& volume) const {
+	try {
+		volume = 0.;
+
+		for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = begin(); it != end(); ++it) {
+			if (Kernel::is_manifold(it->Shape())) {
+				GProp_GProps prop;
+				BRepGProp::VolumeProperties(it->Shape(), prop);
+				volume += prop.Mass();
+			} else {
+				return false;
+			}
+		}
+
+		return true;
+	} catch (...) {
+		Logger::Error("Error during calculation of volume");
+		return false;
+	}
+}
+
+bool IfcGeom::Representation::BRep::calculate_projected_surface_area(const gp_Ax3 & ax, double & along_x, double & along_y, double & along_z) const {
+	try {
+		along_x = along_y = along_z = 0.;
+
+		for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = begin(); it != end(); ++it) {
+			double x, y, z;
+			surface_area_along_direction(settings().deflection_tolerance(), it->Shape(), ax, x, y, z);
+
+			if (Kernel::is_manifold(it->Shape())) {
+				x /= 2.;
+				y /= 2.;
+				z /= 2.;
+			}
+
+			along_x += x;
+			along_y += y;
+			along_z += z;
+		}
+
+		return true;
+	} catch (...) {
+		Logger::Error("Error during calculation of projected surface area");
+		return false;
+	}
+}
+
+IfcGeom::Representation::Triangulation::Triangulation(const BRep& shape_model)
+	: Representation(shape_model.settings())
+	, id_(shape_model.id())
+	, weld_offset_(0)
+{
+	for (IfcGeom::IfcRepresentationShapeItems::const_iterator iit = shape_model.begin(); iit != shape_model.end(); ++iit) {
+
+		// Don't weld vertices that belong to different items to prevent non-manifold situations.
+		weld_offset_ += welds.size();
+		welds.clear();
+
+		int surface_style_id = -1;
+		if (iit->hasStyle()) {
+			Material adapter(iit->StylePtr());
+			std::vector<Material>::const_iterator jt = std::find(_materials.begin(), _materials.end(), adapter);
+			if (jt == _materials.end()) {
+				surface_style_id = (int)_materials.size();
+				_materials.push_back(adapter);
+			} else {
+				surface_style_id = (int)(jt - _materials.begin());
+			}
+		}
+
+		if (settings().get(IteratorSettings::APPLY_DEFAULT_MATERIALS) && surface_style_id == -1) {
+			Material material(IfcGeom::get_default_style(settings().element_type()));
+			std::vector<Material>::const_iterator mit = std::find(_materials.begin(), _materials.end(), material);
+			if (mit == _materials.end()) {
+				surface_style_id = (int)_materials.size();
+				_materials.push_back(material);
+			} else {
+				surface_style_id = (int)(mit - _materials.begin());
+			}
+		}
+
+		const TopoDS_Shape& s = iit->Shape();
+		const gp_GTrsf& trsf = iit->Placement();
+
+		// Triangulate the shape
+		try {
+			BRepMesh_IncrementalMesh(s, settings().deflection_tolerance(), false, settings().angular_tolerance());
+		} catch (...) {
+			Logger::Message(Logger::LOG_ERROR, "Failed to triangulate shape");
+			continue;
+		}
+
+		// Iterates over the faces of the shape
+		int num_faces = 0;
+		TopExp_Explorer exp;
+		for (exp.Init(s, TopAbs_FACE); exp.More(); exp.Next(), ++num_faces) {
+			TopoDS_Face face = TopoDS::Face(exp.Current());
+			TopLoc_Location loc;
+			Handle_Poly_Triangulation tri = BRep_Tool::Triangulation(face, loc);
+
+			if (tri.IsNull()) {
+				Logger::Message(Logger::LOG_ERROR, "Triangulation missing for face");
+			} else {
+				// A 3x3 matrix to rotate the vertex normals
+				const gp_Mat rotation_matrix = trsf.VectorialPart();
+
+				// Keep track of the number of times an edge is used
+				// Manifold edges (i.e. edges used twice) are deemed invisible
+				std::map<std::pair<int, int>, int> edgecount;
+				std::vector<std::pair<int, int> > edges_temp;
+
+				std::vector<gp_XYZ> coords;
+				BRepGProp_Face prop(face);
+				std::map<int, int> dict;
+
+				// Vertex normals are only calculated if vertices are not welded and calculation is not disable explicitly.
+				const bool calculate_normals = !settings().get(IteratorSettings::WELD_VERTICES) &&
+					!settings().get(IteratorSettings::NO_NORMALS);
+
+				for (int i = 1; i <= tri->NbNodes(); ++i) {
+					coords.push_back(tri->Node(i).Transformed(loc).XYZ());
+					trsf.Transforms(*coords.rbegin());
+					dict[i] = addVertex(surface_style_id, *coords.rbegin());
+
+					if (calculate_normals) {
+						const gp_Pnt2d& uv = tri->UVNode(i);
+						gp_Pnt p;
+						gp_Vec normal_direction;
+						prop.Normal(uv.X(), uv.Y(), p, normal_direction);
+						gp_Vec normal(0., 0., 0.);
+						if (normal_direction.Magnitude() > 1.e-9) {
+							normal = gp_Dir(normal_direction.XYZ() * rotation_matrix);
+						} else {
+							Handle_Geom_Surface surf = BRep_Tool::Surface(face);
+							// Special case the normal at the poles of a spherical surface
+							if (surf->DynamicType() == STANDARD_TYPE(Geom_SphericalSurface)) {
+								if (fabs(fabs(uv.Y()) - M_PI / 2.) < 1.e-9) {
+									const bool is_top = uv.Y() > 0;
+									const bool is_forward = face.Orientation() == TopAbs_FORWARD;
+									const double z = (is_top == is_forward) ? 1. : -1.;
+									normal = gp_Dir(gp_XYZ(0, 0, z) * rotation_matrix);
+								}
+							}
+							// TODO: Do the same for conical surfaces, but they are rare in IFC.
+						}
+						_normals.push_back(normal.X());
+						_normals.push_back(normal.Y());
+						_normals.push_back(normal.Z());
+					}
+				}
+
+				const Poly_Array1OfTriangle& triangles = tri->Triangles();
+				for (int i = 1; i <= triangles.Length(); ++i) {
+					int n1, n2, n3;
+					if (face.Orientation() == TopAbs_REVERSED)
+						triangles(i).Get(n3, n2, n1);
+					else triangles(i).Get(n1, n2, n3);
+
+					/* An alternative would be to calculate normals based
+						* on the coordinates of the mesh vertices */
+						/*
+						const gp_XYZ pt1 = coords[n1-1];
+						const gp_XYZ pt2 = coords[n2-1];
+						const gp_XYZ pt3 = coords[n3-1];
+						const gp_XYZ v1 = pt2-pt1;
+						const gp_XYZ v2 = pt3-pt2;
+						gp_Dir normal = gp_Dir(v1^v2);
+						_normals.push_back((float)normal.X());
+						_normals.push_back((float)normal.Y());
+						_normals.push_back((float)normal.Z());
+						*/
+
+					_faces.push_back(dict[n1]);
+					_faces.push_back(dict[n2]);
+					_faces.push_back(dict[n3]);
+
+					_material_ids.push_back(surface_style_id);
+
+					addEdge(dict[n1], dict[n2], edgecount, edges_temp);
+					addEdge(dict[n2], dict[n3], edgecount, edges_temp);
+					addEdge(dict[n3], dict[n1], edgecount, edges_temp);
+				}
+				for (std::vector<std::pair<int, int> >::const_iterator jt = edges_temp.begin(); jt != edges_temp.end(); ++jt) {
+					if (edgecount[*jt] == 1) {
+						// non manifold edge, face boundary
+						_edges.push_back(jt->first);
+						_edges.push_back(jt->second);
+					}
+				}
+			}
+		}
+
+		if (!_normals.empty() && settings().get(IfcGeom::IteratorSettings::GENERATE_UVS)) {
+			uvs_ = box_project_uvs(_verts, _normals);
+		}
+
+		if (num_faces == 0) {
+			// Edges are only emitted if there are no faces. A mixed representation of faces
+			// and loose edges is discouraged by the standard. An alternative would be to use
+			// TopExp_Explorer texp(s, TopAbs_EDGE, TopAbs_FACE) to find edges that do not
+			// belong to any face.
+			for (TopExp_Explorer texp(s, TopAbs_EDGE); texp.More(); texp.Next()) {
+				BRepAdaptor_Curve crv(TopoDS::Edge(texp.Current()));
+				GCPnts_QuasiUniformDeflection tessellater(crv, settings().deflection_tolerance());
+				int n = tessellater.NbPoints();
+				int previous = -1;
+
+				for (int i = 1; i <= n; ++i) {
+					gp_XYZ p = tessellater.Value(i).XYZ();
+
+					int current = addVertex(surface_style_id, p);
+
+					std::vector<std::pair<int, int>> segments;
+					if (i > 1) {
+						segments.push_back(std::make_pair(previous, current));
+					}
+
+					if (settings().get(IfcGeom::IteratorSettings::EDGE_ARROWS)) {
+						// In case you want direction arrows on your edges
+						double u = tessellater.Parameter(i);
+						gp_XYZ p2, p3;
+						gp_Pnt tmp;
+						gp_Vec tmp2;
+						crv.D1(u, tmp, tmp2);
+						gp_Dir d1, d2, d3, d4;
+						d1 = tmp2;
+						if (texp.Current().Orientation() == TopAbs_REVERSED) {
+							d1 = -d1;
+						}
+						if (fabs(d1.Z()) < 0.5) {
+							d2 = d1.Crossed(gp::DZ());
+						} else {
+							d2 = d1.Crossed(gp::DY());
+						}
+						d3 = d1.XYZ() + d2.XYZ();
+						d4 = d1.XYZ() - d2.XYZ();
+						p2 = p - d3.XYZ() / 10.;
+						p3 = p - d4.XYZ() / 10.;
+						trsf.Transforms(p2);
+						trsf.Transforms(p3);
+						trsf.Transforms(p);
+
+						int left = addVertex(surface_style_id, p2);
+						int right = addVertex(surface_style_id, p3);
+
+						segments.push_back(std::make_pair(left, current));
+						segments.push_back(std::make_pair(right, current));
+					}
+
+					for (auto& sgmt : segments) {
+						_edges.push_back(sgmt.first);
+						_edges.push_back(sgmt.second);
+						_material_ids.push_back(surface_style_id);
+					}
+
+					previous = current;
+				}
+			}
+		}
+
+		BRepTools::Clean(s);
+	}
+}
+
+/// Generates UVs for a single mesh using box projection.
+/// @todo Very simple impl. Assumes that input vertices and normals match 1:1.
+
+inline std::vector<double> IfcGeom::Representation::Triangulation::box_project_uvs(const std::vector<double>& vertices, const std::vector<double>& normals)
+{
+	std::vector<double> uvs;
+	uvs.resize(vertices.size() / 3 * 2);
+	for (size_t uv_idx = 0, v_idx = 0;
+		uv_idx < uvs.size() && v_idx < vertices.size() && v_idx < normals.size();
+		uv_idx += 2, v_idx += 3) {
+
+		double n_x = normals[v_idx], n_y = normals[v_idx + 1], n_z = normals[v_idx + 2];
+		double v_x = vertices[v_idx], v_y = vertices[v_idx + 1], v_z = vertices[v_idx + 2];
+
+		if (std::abs(n_x) > std::abs(n_y) && std::abs(n_x) > std::abs(n_z)) {
+			uvs[uv_idx] = v_z;
+			uvs[uv_idx + 1] = v_y;
+		}
+		if (std::abs(n_y) > std::abs(n_x) && std::abs(n_y) > std::abs(n_z)) {
+			uvs[uv_idx] = v_x;
+			uvs[uv_idx + 1] = v_z;
+		}
+		if (std::abs(n_z) > std::abs(n_x) && std::abs(n_z) > std::abs(n_y)) {
+			uvs[uv_idx] = v_x;
+			uvs[uv_idx + 1] = v_y;
+		}
+	}
+
+	return uvs;
+}
+
+// Welds vertices that belong to different faces
+
+inline int IfcGeom::Representation::Triangulation::addVertex(int material_index, const gp_XYZ & p) {
+	const bool convert = settings().get(IteratorSettings::CONVERT_BACK_UNITS);
+	const double X = convert ? (p.X() / settings().unit_magnitude()) : p.X();
+	const double Y = convert ? (p.Y() / settings().unit_magnitude()) : p.Y();
+	const double Z = convert ? (p.Z() / settings().unit_magnitude()) : p.Z();
+	int i = (int)_verts.size() / 3;
+	if (settings().get(IteratorSettings::WELD_VERTICES)) {
+		const VertexKey key = std::make_pair(material_index, std::make_pair(X, std::make_pair(Y, Z)));
+		typename VertexKeyMap::const_iterator it = welds.find(key);
+		if (it != welds.end()) return it->second;
+		i = (int)(welds.size() + weld_offset_);
+		welds[key] = i;
+	}
+	_verts.push_back(X);
+	_verts.push_back(Y);
+	_verts.push_back(Z);
+	return i;
+}
+
+inline void IfcGeom::Representation::Triangulation::addEdge(int n1, int n2, std::map<std::pair<int, int>, int>& edgecount, std::vector<std::pair<int, int>>& edges_temp) {
+	const Edge e = Edge((std::min)(n1, n2), (std::max)(n1, n2));
+	if (edgecount.find(e) == edgecount.end()) edgecount[e] = 1;
+	else edgecount[e] ++;
+	edges_temp.push_back(e);
+}

src/ifcgeom_schema_agnostic/IfcGeomRepresentation.h

@@ -0,0 +1,187 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCGEOMREPRESENTATION_H
+#define IFCGEOMREPRESENTATION_H
+
+#include <BRepMesh_IncrementalMesh.hxx>
+#include <BRepGProp_Face.hxx>
+
+#include <Poly_Triangulation.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
+
+#include <TopoDS.hxx>
+#include <BRepTools.hxx>
+#include <TopExp_Explorer.hxx>
+
+#include <BRepAdaptor_Curve.hxx>
+#include <GCPnts_QuasiUniformDeflection.hxx>
+#include <Geom_SphericalSurface.hxx>
+
+#include "../ifcgeom_schema_agnostic/IfcGeomIteratorSettings.h"
+#include "../ifcgeom_schema_agnostic/IfcGeomMaterial.h"
+#include "../ifcgeom_schema_agnostic/IfcRepresentationShapeItem.h"
+
+#include <TopoDS_Compound.hxx>
+
+#include <map>
+
+namespace IfcGeom {
+
+	namespace Representation {
+
+		class IFC_GEOM_API Representation {
+			Representation(const Representation&); //N/A
+			Representation& operator =(const Representation&); //N/A
+		protected:
+			const ElementSettings settings_;
+		public:
+			explicit Representation(const ElementSettings& settings)
+				: settings_(settings) 
+			{}
+			const ElementSettings& settings() const { return settings_; }
+			virtual ~Representation() {}
+		};
+
+		class IFC_GEOM_API BRep : public Representation {
+		private:
+			std::string id_;
+			const IfcGeom::IfcRepresentationShapeItems shapes_;
+			BRep(const BRep& other);
+			BRep& operator=(const BRep& other);
+		public:
+			BRep(const ElementSettings& settings, const std::string& id, const IfcGeom::IfcRepresentationShapeItems& shapes)
+				: Representation(settings)
+				, id_(id)
+				, shapes_(shapes)
+			{}
+			virtual ~BRep() {}
+			IfcGeom::IfcRepresentationShapeItems::const_iterator begin() const { return shapes_.begin(); }
+			IfcGeom::IfcRepresentationShapeItems::const_iterator end() const { return shapes_.end(); }
+			const IfcGeom::IfcRepresentationShapeItems& shapes() const { return shapes_; }
+			const std::string& id() const { return id_; }
+			TopoDS_Compound as_compound(bool force_meters = false) const;
+
+			bool calculate_volume(double&) const;
+			bool calculate_surface_area(double&) const;
+			bool calculate_projected_surface_area(const gp_Ax3& ax, double& along_x, double& along_y, double& along_z) const;
+		};
+
+		class IFC_GEOM_API Serialization : public Representation  {
+		private:
+			std::string id_;
+			std::string brep_data_;
+			std::vector<double> surface_styles_;
+			std::vector<int> surface_style_ids_;
+		public:
+			const std::string& brep_data() const { return brep_data_; }
+			const std::vector<double>& surface_styles() const { return surface_styles_; }
+			const std::vector<int>& surface_style_ids() const { return surface_style_ids_; }
+			Serialization(const BRep& brep);
+			virtual ~Serialization() {}
+			const std::string& id() const { return id_; }
+		private:
+			Serialization();
+			Serialization(const Serialization&);
+			Serialization& operator=(const Serialization&);
+		};
+
+		class Triangulation : public Representation {
+		private:
+			// A nested pair of floats and a material index to be able to store an XYZ coordinate in a map.
+			// TODO: Make this a std::tuple when compilers add support for that.
+			typedef typename std::pair<double, std::pair<double, double> > Coordinate;
+			typedef typename std::pair<int, Coordinate> VertexKey;
+			typedef std::map<VertexKey, int> VertexKeyMap;
+			typedef std::pair<int, int> Edge;
+
+			std::string id_;
+			std::vector<double> _verts;
+			std::vector<int> _faces;
+			std::vector<int> _edges;
+			std::vector<double> _normals;
+            std::vector<double> uvs_;
+			std::vector<int> _material_ids;
+			std::vector<Material> _materials;
+			size_t weld_offset_;
+			VertexKeyMap welds;
+
+			// when read from serialization, the element needs to take ownership of the styles,
+			// the material vector is constructor off of this.
+			// @todo this can be improved
+			std::vector<std::shared_ptr<IfcGeom::SurfaceStyle>> styles_;
+
+		public:
+			const std::string& id() const { return id_; }
+			const std::vector<double>& verts() const { return _verts; }
+			const std::vector<int>& faces() const { return _faces; }
+			const std::vector<int>& edges() const { return _edges; }
+			const std::vector<double>& normals() const { return _normals; }
+            const std::vector<double>& uvs() const { return uvs_; }
+			const std::vector<int>& material_ids() const { return _material_ids; }
+			const std::vector<Material>& materials() const { return _materials; }
+
+			Triangulation(const BRep& shape_model);
+			
+			Triangulation(
+				ElementSettings settings,
+				const std::string& id,
+				const std::vector<double>& verts,
+				const std::vector<int>& faces,
+				const std::vector<int>& edges,
+				const std::vector<double>& normals,
+				const std::vector<double>& uvs,
+				const std::vector<int>& material_ids,
+				const std::vector<std::shared_ptr<IfcGeom::SurfaceStyle>>& styles)
+				: Representation(settings)
+				, id_(id)
+				, _verts(verts)
+				, _faces(faces)
+				, _edges(edges)
+				, _normals(normals)
+				, uvs_(uvs)
+				, _material_ids(material_ids)
+				, styles_(styles)
+			{
+				for (auto& s : styles_) {
+					_materials.push_back(IfcGeom::Material(s));
+				}
+			}
+
+			virtual ~Triangulation() {}
+
+            /// Generates UVs for a single mesh using box projection.
+            /// @todo Very simple impl. Assumes that input vertices and normals match 1:1.
+			static std::vector<double> box_project_uvs(const std::vector<double> &vertices, const std::vector<double> &normals);
+
+		private:
+			// Welds vertices that belong to different faces
+			int addVertex(int material_index, const gp_XYZ& p);
+			inline void addEdge(int n1, int n2, std::map<std::pair<int, int>, int>& edgecount, std::vector<std::pair<int, int> >& edges_temp);
+
+			Triangulation();
+			Triangulation(const Triangulation&);
+			Triangulation& operator=(const Triangulation&);
+		};
+
+	}
+}
+
+#endif

src/ifcgeom_schema_agnostic/IfcGeomShapeType.h

@@ -0,0 +1,38 @@
+/********************************************************************************
+*                                                                              *
+* This file is part of IfcOpenShell.                                           *
+*                                                                              *
+* IfcOpenShell is free software: you can redistribute it and/or modify         *
+* it under the terms of the Lesser GNU General Public License as published by  *
+* the Free Software Foundation, either version 3.0 of the License, or          *
+* (at your option) any later version.                                          *
+*                                                                              *
+* IfcOpenShell is distributed in the hope that it will be useful,              *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+* Lesser GNU General Public License for more details.                          *
+*                                                                              *
+* You should have received a copy of the Lesser GNU General Public License     *
+* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+*                                                                              *
+********************************************************************************/
+
+#ifndef IFCGEOMSHAPETYPE_H
+#define IFCGEOMSHAPETYPE_H
+
+namespace IfcGeom {
+
+	enum ShapeType {
+		ST_SHAPELIST,
+		ST_SHAPE,
+		ST_FACE,
+		ST_WIRE,
+		ST_CURVE,
+		ST_EDGE,
+		ST_VERTEX,
+		ST_OTHER
+	};
+
+}
+
+#endif

src/ifcgeom_schema_agnostic/IfcGeomTree.h

@@ -0,0 +1,507 @@
+/********************************************************************************
+*                                                                              *
+* This file is part of IfcOpenShell.                                           *
+*                                                                              *
+* IfcOpenShell is free software: you can redistribute it and/or modify         *
+* it under the terms of the Lesser GNU General Public License as published by  *
+* the Free Software Foundation, either version 3.0 of the License, or          *
+* (at your option) any later version.                                          *
+*                                                                              *
+* IfcOpenShell is distributed in the hope that it will be useful,              *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+* Lesser GNU General Public License for more details.                          *
+*                                                                              *
+* You should have received a copy of the Lesser GNU General Public License     *
+* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+*                                                                              *
+********************************************************************************/
+
+#ifndef IFCGEOMTREE_H
+#define IFCGEOMTREE_H
+
+#include "../ifcparse/IfcFile.h"
+
+#include "../ifcgeom_schema_agnostic/IfcGeomElement.h"
+#include "../ifcgeom_schema_agnostic/IfcGeomIterator.h"
+#include "../ifcgeom_schema_agnostic/IfcGeomMaterial.h"
+#include "../ifcgeom_schema_agnostic/Kernel.h"
+
+#include <NCollection_UBTree.hxx>
+#include <BRepBndLib.hxx>
+#include <Bnd_Box.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepAlgoAPI_Common.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+#include <BRepExtrema_DistShapeShape.hxx>
+#include <BRepClass3d_SolidClassifier.hxx>
+#include <TopTools_DataMapOfShapeInteger.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepExtrema_ExtPF.hxx>
+
+namespace IfcGeom {
+
+	struct ray_intersection_result {
+		double distance;
+		int style_index;
+		IfcUtil::IfcBaseEntity* instance;
+		std::array<double, 3> position;
+		std::array<double, 3> normal;
+		double ray_distance;
+		double dot_product;
+	};
+
+	namespace {
+
+		// Approximates the distance `other` protrudes into `volume` by finding the
+		// max face-vertex distance for every face, and taking the minimal value of
+		// those. Note that this uses the internal `BRepExtrema_ExtPF` which only
+		// returns solutions whose when the vertex projected onto the face is contained
+		// within the face boundaries. In case of concave `volume` this is desirable.
+
+		double max_distance_inside(const TopoDS_Shape& volume, const TopoDS_Shape& other) {
+			TopExp_Explorer exp_v(volume.Reversed(), TopAbs_FACE);
+
+			double min_face_vertex_distance = std::numeric_limits<double>::infinity();
+
+			for (; exp_v.More(); exp_v.Next()) {
+				const TopoDS_Face& f = TopoDS::Face(exp_v.Current());
+
+				BRepExtrema_ExtPF epf;
+				epf.Initialize(f, Extrema_ExtFlag_MIN);
+
+				double face_vertex_distance = 0.;
+
+				TopExp_Explorer exp_o(other, TopAbs_VERTEX);
+				for (; exp_o.More(); exp_o.Next()) {
+					const TopoDS_Vertex& v = TopoDS::Vertex(exp_o.Current());
+					epf.Perform(v, f);
+					if (epf.IsDone() && epf.NbExt() == 1) {
+						double d = epf.SquareDistance(1);
+						if (d > face_vertex_distance) {
+							face_vertex_distance = d;
+						}
+					}
+				}
+
+				if (face_vertex_distance < min_face_vertex_distance) {
+					min_face_vertex_distance = face_vertex_distance;
+				}
+			}
+
+			if (min_face_vertex_distance == std::numeric_limits<double>::infinity()) {
+				return -1.;
+			} else {
+				return std::sqrt(min_face_vertex_distance);
+			}
+		}
+	}
+
+	namespace impl {
+		template <typename T>
+		class tree {
+
+			bool test(const TopoDS_Shape& A, const TopoDS_Shape& B, bool completely_within, double extend) const {
+				if (extend > 0.) {
+					BRepExtrema_DistShapeShape dss(A, B);
+					if (dss.Perform() && dss.NbSolution() >= 1) {
+						if (dss.Value() <= extend) {
+							distances_.push_back(dss.Value());
+							protrusion_distances_.push_back(max_distance_inside(B, A));
+						}						
+						return dss.Value() <= extend;
+					}
+				} else {
+					if (IfcGeom::Kernel::count(A, TopAbs_SHELL) == 0 ||
+						IfcGeom::Kernel::count(B, TopAbs_SHELL) == 0)
+					{
+						return false;
+					}
+
+					if (completely_within) {
+						BRepAlgoAPI_Cut cut(B, A);
+						if (cut.IsDone()) {
+							if (IfcGeom::Kernel::count(cut.Shape(), TopAbs_SHELL) == 0) {
+								return true;
+							}
+						}
+					} else {
+						BRepAlgoAPI_Common common(A, B);
+						if (common.IsDone()) {
+							if (IfcGeom::Kernel::count(common.Shape(), TopAbs_SHELL) > 0) {
+								return true;
+							}
+						}
+					}
+				}
+				return false;
+			}
+
+		protected:
+
+			// @todo this is ugly, embed this in the return type
+			mutable std::vector<double> distances_;
+			mutable std::vector<double> protrusion_distances_;
+
+		public:
+
+			void add(const T& t, const Bnd_Box& b) {
+				tree_.Add(t, b);
+			}
+
+			void add(const T& t, const TopoDS_Shape& s) {
+				Bnd_Box b;
+				BRepBndLib::AddClose(s, b);
+				add(t, b);
+				shapes_[t] = s;
+			}
+
+			std::vector<T> select_box(const T& t, bool completely_within = false, double extend=-1.e-5) const {
+				typename map_t::const_iterator it = shapes_.find(t);
+				if (it == shapes_.end()) {
+					return std::vector<T>();
+				}
+
+				Bnd_Box b;
+				BRepBndLib::AddClose(it->second, b);
+
+				// Gap is assumed to be positive throughout the codebase,
+				// but at least for IsOut() in the selector a negative
+				// Gap should work as well.
+				b.SetGap(b.GetGap() + extend); 
+				
+				return select_box(b, completely_within);
+			}
+
+			std::vector<T> select_box(const gp_Pnt& p, double extend=0.0) const {
+				Bnd_Box b;
+				b.Add(p);
+				b.SetGap(b.GetGap() + extend);
+				return select_box(b);
+			}
+
+			std::vector<T> select_box(const Bnd_Box& b, bool completely_within = false) const {
+				selector s(b);
+				tree_.Select(s);
+				if (completely_within) {
+					std::vector<T> ts = s.results();
+					std::vector<T> ts_filtered;
+					ts_filtered.reserve(ts.size());
+					typename std::vector<T>::const_iterator it = ts.begin();
+					for (; it != ts.end(); ++it) {
+						const TopoDS_Shape& shp = shapes_.find(*it)->second;
+						Bnd_Box B;
+						BRepBndLib::AddClose(shp, B);
+
+						// BndBox::CornerMin() /-Max() introduced in OCCT 6.8
+						double x1, y1, z1, x2, y2, z2;
+						b.Get(x1, y1, z1, x2, y2, z2);
+						double gap = B.GetGap();
+						gp_Pnt p1(x1 - gap, y1 - gap, z1 - gap);
+						gp_Pnt p2(x2 + gap, y2 + gap, z2 + gap);
+						
+						if (!b.IsOut(p1) && !b.IsOut(p2)) {
+							ts_filtered.push_back(*it);
+						}
+					}
+					return ts_filtered;
+				} else {
+					return s.results();
+				}
+			}
+
+			std::vector<T> select(const T& t, bool completely_within = false, double extend = 0.0) const {
+				distances_.clear();
+				protrusion_distances_.clear();
+
+				std::vector<T> ts = select_box(t, completely_within, extend);
+				if (ts.empty()) {
+					return ts;
+				}
+
+				const TopoDS_Shape& A = shapes_.find(t)->second;
+
+				std::vector<T> ts_filtered;
+				ts_filtered.reserve(ts.size());
+
+				typename std::vector<T>::const_iterator it = ts.begin();
+				for (it = ts.begin(); it != ts.end(); ++it) {
+					const TopoDS_Shape& B = shapes_.find(*it)->second;
+
+					if (test(A, B, completely_within, extend)) {
+						ts_filtered.push_back(*it);
+					}
+				}
+
+				return ts_filtered;
+			}
+
+			std::vector<T> select(const TopoDS_Shape& s, bool completely_within = false, double extend = -1.e-5) const {
+				distances_.clear();
+				protrusion_distances_.clear();
+
+				Bnd_Box bb;
+				BRepBndLib::AddClose(s, bb);
+				bb.SetGap(bb.GetGap() + extend);
+
+				std::vector<T> ts = select_box(bb, completely_within);
+
+				if (ts.empty()) {
+					return ts;
+				}
+
+				std::vector<T> ts_filtered;
+				ts_filtered.reserve(ts.size());
+
+				typename std::vector<T>::const_iterator it = ts.begin();
+				for (it = ts.begin(); it != ts.end(); ++it) {
+					const TopoDS_Shape& B = shapes_.find(*it)->second;
+
+					if (test(s, B, completely_within, extend)) {
+						ts_filtered.push_back(*it);
+					}
+				}
+
+				return ts_filtered;
+			}
+
+			std::vector<T> select(const IfcGeom::BRepElement* elem, bool completely_within = false, double extend = -1.e-5) const {
+				auto compound = elem->geometry().as_compound();
+				compound.Move(elem->transformation().data());
+				return select(compound, completely_within, extend);
+			}
+
+			std::vector<T> select(const gp_Pnt& p, double extend=0.0) const {
+				distances_.clear();
+				protrusion_distances_.clear();
+
+				std::vector<T> ts = select_box(p, extend);
+				if (ts.empty()) {
+					return ts;
+				}
+
+				std::vector<T> ts_filtered;
+				ts_filtered.reserve(ts.size());
+
+				TopoDS_Vertex v;
+				if (extend > 0.) {
+					BRep_Builder B;
+					B.MakeVertex(v, p, Precision::Confusion());
+				}
+
+				typename std::vector<T>::const_iterator it = ts.begin();
+				for (it = ts.begin(); it != ts.end(); ++it) {
+					const TopoDS_Shape& B = shapes_.find(*it)->second;
+					if (extend > 0.0) {
+						BRepExtrema_DistShapeShape dss(v, B);
+						if (dss.Perform() && dss.NbSolution() >= 1 && dss.Value() <= extend) {
+							distances_.push_back(dss.Value());							
+							protrusion_distances_.push_back(max_distance_inside(B, v));
+
+							ts_filtered.push_back(*it);
+						}
+					} else {
+						TopExp_Explorer exp(B, TopAbs_SOLID);
+						for (; exp.More(); exp.Next()) {
+							BRepClass3d_SolidClassifier cls(exp.Current(), p, 1e-5);
+							if (cls.State() != TopAbs_OUT) {
+								ts_filtered.push_back(*it);
+								break;
+							}
+						}
+					}
+				}
+
+				return ts_filtered;
+			}
+
+		protected:
+			typedef NCollection_UBTree<T, Bnd_Box> tree_t;
+			typedef std::map<T, TopoDS_Shape> map_t;
+
+			tree_t tree_;
+			map_t shapes_;
+			
+			bool enable_face_styles_ = false;
+
+			class selector : public tree_t::Selector
+			{
+			public:
+				selector(const Bnd_Box& b)
+					: tree_t::Selector()
+					, bounds_(b)
+				{}
+
+				Standard_Boolean Reject(const Bnd_Box& b) const {
+					return bounds_.IsOut(b);
+				}
+
+				Standard_Boolean Accept(const T& o) {
+					results_.push_back(o);
+					return Standard_True;
+				}
+
+				const std::vector<T>& results() const {
+					return results_;
+				}
+
+			private:
+				std::vector<T> results_;
+				const Bnd_Box& bounds_;
+			};
+
+		};
+	}
+
+	class tree : public impl::tree<IfcUtil::IfcBaseEntity*> {
+	public:
+
+		tree() {};
+
+		tree(IfcParse::IfcFile& f) {
+			add_file(f, IfcGeom::IteratorSettings());
+		}
+
+		tree(IfcParse::IfcFile& f, const IfcGeom::IteratorSettings& settings) {
+			add_file(f, settings);
+		}
+
+		tree(IfcGeom::Iterator& it) {
+			add_file(it);
+		}		
+
+		void add_file(IfcParse::IfcFile& f, const IfcGeom::IteratorSettings& settings) {
+			IfcGeom::IteratorSettings settings_ = settings;
+			settings_.set(IfcGeom::IteratorSettings::DISABLE_TRIANGULATION, true);
+			settings_.set(IfcGeom::IteratorSettings::USE_WORLD_COORDS, true);
+			settings_.set(IfcGeom::IteratorSettings::SEW_SHELLS, true);
+
+			IfcGeom::Iterator it(settings_, &f);
+
+			add_file(it);
+		}
+
+		void add_file(IfcGeom::Iterator& it) {
+			if (it.initialize()) {
+				do {
+					add_element(dynamic_cast<IfcGeom::BRepElement*>(it.get()));
+				} while (it.next());
+			}
+		}
+
+		void add_element(IfcGeom::BRepElement* elem) {
+			if (!elem) {
+				return;
+			}
+			auto compound = elem->geometry().as_compound();
+			compound.Move(elem->transformation().data());
+			add(elem->product(), compound);
+			auto git = elem->geometry().begin();
+
+			if (enable_face_styles_) {
+				TopoDS_Iterator it(compound);
+				for (; it.More(); it.Next(), ++git) {
+					std::unique_ptr<IfcGeom::Material> adaptor;					
+					if (git->hasStyle()) {
+						adaptor.reset(new Material(git->StylePtr()));
+					} else {
+						adaptor.reset(new Material(IfcGeom::get_default_style(elem->type())));
+					}
+					
+					// Assumption is that the number of styles is small, so the linear lookup time is not significant.
+					auto sit = std::find(styles_.begin(), styles_.end(), *adaptor);
+					int index;
+					if (sit == styles_.end()) {
+						index = styles_.size();
+						styles_.push_back(*adaptor);
+					} else {
+						index = std::distance(styles_.begin(), sit);
+					}
+
+					TopExp_Explorer exp(it.Value(), TopAbs_FACE);
+					for (; exp.More(); exp.Next()) {
+						face_styles_.Bind(exp.Current(), index);
+					}
+				}
+			}
+		}
+
+		const std::vector<double>& distances() const {
+			return distances_;
+		}
+
+		const std::vector<double>& protrusion_distances() const {
+			return protrusion_distances_;
+		}
+
+		std::vector<IfcGeom::ray_intersection_result> select_ray(const gp_Pnt& p0, const gp_Dir& d, double length = 1000.) const {
+			gp_Pnt p1 = p0.XYZ() + d.XYZ() * length;
+			auto E = BRepBuilderAPI_MakeEdge(p0, p1).Edge();
+			Bnd_Box bb;
+			bb.Add(p0);
+			bb.Add(p1);
+			auto candidates = select_box(bb);
+
+			std::multimap<double, ray_intersection_result> ordered;
+
+			for (auto& c : candidates) {
+				BRepExtrema_DistShapeShape dss(E, shapes_.find(c)->second);
+				for (int i = 1; i <= dss.NbSolution(); ++i) {
+					if (dss.SupportTypeShape1(i) != BRepExtrema_IsOnEdge) {
+						// @todo set to 0, is it on the first verteX?
+						continue;
+					}
+					if (dss.SupportTypeShape2(i) != BRepExtrema_IsInFace) {
+						continue;
+					}
+					double u, v, w;
+					dss.ParOnEdgeS1(i, u);
+					auto face = TopoDS::Face(dss.SupportOnShape2(i));
+					int sidx = -1;
+					if (enable_face_styles_) {
+						sidx = face_styles_.Find(face);
+					}
+					dss.ParOnFaceS2(i, v, w);
+					BRepGProp_Face prop(face);
+					gp_Pnt P;
+					gp_Vec V;
+					prop.Normal(v, w, P, V);
+					ordered.insert({ u,	{ u, sidx, c,
+						{P.X(), P.Y(), P.Z()},
+						{V.X(), V.Y(), V.Z()},
+						d.XYZ().Dot(p0.XYZ() - P.XYZ()),
+						V.Dot(d)
+					} });
+				}
+			}
+
+			std::vector<ray_intersection_result> result;
+			for (auto& p : ordered) {
+				result.push_back(p.second);
+			}
+
+			return result;
+		}
+
+		bool enable_face_styles() const {
+			return enable_face_styles_;
+		}
+
+		void enable_face_styles(bool b) {
+			enable_face_styles_ = b;
+		}
+
+		const std::vector<IfcGeom::Material>& styles() const {
+			return styles_;
+		}
+
+	protected:
+		typedef TopTools_DataMapOfShapeInteger face_style_map_t;
+
+		face_style_map_t face_styles_;
+		std::vector<IfcGeom::Material> styles_;
+	};
+
+}
+
+#endif

src/ifcgeom_schema_agnostic/IfcRepresentationShapeItem.h

@@ -0,0 +1,56 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCSHAPELIST_H
+#define IFCSHAPELIST_H
+
+#include <gp_GTrsf.hxx>
+#include <TopoDS_Shape.hxx>
+
+#include "../ifcgeom_schema_agnostic/IfcGeomRenderStyles.h"
+
+namespace IfcGeom {	
+	class IFC_GEOM_API IfcRepresentationShapeItem {
+	private:
+		int id;
+		gp_GTrsf placement;
+		TopoDS_Shape shape;
+		std::shared_ptr<const SurfaceStyle> style;
+	public:
+		IfcRepresentationShapeItem(int id, const gp_GTrsf& placement, const TopoDS_Shape& shape, std::shared_ptr<const SurfaceStyle> style)
+			: id(id), placement(placement), shape(shape), style(style) {}
+		IfcRepresentationShapeItem(int id, const gp_GTrsf& placement, const TopoDS_Shape& shape)
+			: id(id), placement(placement), shape(shape), style(0) {}
+		IfcRepresentationShapeItem(int id, const TopoDS_Shape& shape, std::shared_ptr<const SurfaceStyle> style)
+			: id(id), shape(shape), style(style) {}
+		IfcRepresentationShapeItem(int id, const TopoDS_Shape& shape)
+			: id(id), shape(shape), style(0) {}
+		void append(const gp_GTrsf& trsf) { placement.Multiply(trsf); }
+		void prepend(const gp_GTrsf& trsf) { placement.PreMultiply(trsf); }
+		const TopoDS_Shape& Shape() const { return shape; }
+		const gp_GTrsf& Placement() const { return placement; }
+		bool hasStyle() const { return !!style; }
+		const SurfaceStyle& Style() const { return *style; }
+		const std::shared_ptr<const SurfaceStyle> StylePtr() const { return style; }
+		void setStyle(std::shared_ptr<const SurfaceStyle> newStyle) { style = newStyle; }
+		int ItemId() const { return id; }
+	};
+	typedef std::vector<IfcRepresentationShapeItem> IfcRepresentationShapeItems;
+}
+#endif

src/ifcgeom_schema_agnostic/IteratorImplementation.h

@@ -20,10 +20,11 @@
 #ifndef ITERATOR_IMPLEMENTATION_H
 #define ITERATOR_IMPLEMENTATION_H
 
+#include "../ifcparse/IfcFile.h"
+
 #include "../ifcgeom_schema_agnostic/IfcGeomFilter.h"
 #include "../ifcgeom_schema_agnostic/GeometrySerializer.h"
-#include "../ifcparse/IfcFile.h"
-#include "../ifcgeom/IfcGeomIteratorSettings.h"
+#include "../ifcgeom_schema_agnostic/IfcGeomIteratorSettings.h"
 
 #include <gp_XYZ.hxx>
 

src/ifcgeom_schema_agnostic/Kernel.h

@@ -2,8 +2,8 @@
 #define ITERATOR_KERNEL_H
 
 #include "../ifcparse/IfcFile.h"
-#include "../ifcgeom/IfcGeomIteratorSettings.h"
-#include "../ifcgeom/IfcRepresentationShapeItem.h"
+#include "../ifcgeom_schema_agnostic/IfcGeomIteratorSettings.h"
+#include "../ifcgeom_schema_agnostic/IfcRepresentationShapeItem.h"
 
 #ifdef HAS_SCHEMA_2x3
 #include "../ifcparse/Ifc2x3.h"
@@ -40,6 +40,13 @@
 #include <gp_Trsf.hxx>
 #include <gp_GTrsf.hxx>
 
+static const double ALMOST_ZERO = 1.e-9;
+
+template <typename T>
+inline static bool ALMOST_THE_SAME(const T& a, const T& b, double tolerance = ALMOST_ZERO) {
+	return fabs(a - b) < tolerance;
+}
+
 namespace IfcGeom {
 
 	class BRepElement;

src/ifcgeom_schema_agnostic/ifc_geom_api.h

@@ -0,0 +1,37 @@
+/********************************************************************************
+*                                                                              *
+* This file is part of IfcOpenShell.                                           *
+*                                                                              *
+* IfcOpenShell is free software: you can redistribute it and/or modify         *
+* it under the terms of the Lesser GNU General Public License as published by  *
+* the Free Software Foundation, either version 3.0 of the License, or          *
+* (at your option) any later version.                                          *
+*                                                                              *
+* IfcOpenShell is distributed in the hope that it will be useful,              *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+* Lesser GNU General Public License for more details.                          *
+*                                                                              *
+* You should have received a copy of the Lesser GNU General Public License     *
+* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+*                                                                              *
+********************************************************************************/
+
+#ifndef IFC_GEOM_API_H
+#define IFC_GEOM_API_H
+
+#ifdef IFC_SHARED_BUILD
+  #ifdef _WIN32
+    #ifdef IFC_GEOM_EXPORTS
+      #define IFC_GEOM_API __declspec(dllexport)
+    #else
+      #define IFC_GEOM_API __declspec(dllimport)
+    #endif
+  #else // simply assume *nix + GCC-like compiler
+    #define IFC_GEOM_API __attribute__((visibility("default")))
+  #endif
+#else
+  #define IFC_GEOM_API
+#endif
+
+#endif