Merge developments from master into the python_wrapper branch

src/ifcgeom/IfcGeom.h

@@ -40,7 +40,7 @@
 #include "../ifcparse/IfcParse.h"
 #include "../ifcparse/IfcUtil.h"
 
-#include "../ifcgeom/IfcShapeList.h"
+#include "../ifcgeom/IfcRepresentationShapeItem.h"
 
 namespace IfcGeom {
 
@@ -73,17 +73,22 @@ namespace IfcGeom {
 		// the interpretation of IfcParamaterValues of IfcTrimmedCurves
 		// Default: -1.0 (= not set, fist try degrees, then radians)
 		GV_PLANEANGLE_UNIT,
+		// The precision used in boolean operations, setting this value too low results
+		// in artefacts and potentially modelling failures
+		// Default: 0.00001 (obtained from IfcGeometricRepresentationContext if available)
+		GV_PRECISION
 	};
 
 	bool convert_wire_to_face(const TopoDS_Wire& wire, TopoDS_Face& face);
-	bool convert_shapes(const IfcUtil::IfcBaseClass* L, ShapeList& result);
+	bool convert_shapes(const IfcUtil::IfcBaseClass* L, IfcRepresentationShapeItems& result);
 	bool is_shape_collection(const IfcUtil::IfcBaseClass* L);
-	const TopoDS_Shape* convert_shape(const IfcUtil::IfcBaseClass* L, TopoDS_Shape& result);
+	bool convert_shape(const IfcUtil::IfcBaseClass* L, TopoDS_Shape& result);
 	bool convert_wire(const IfcUtil::IfcBaseClass* L, TopoDS_Wire& result);
 	bool convert_curve(const IfcUtil::IfcBaseClass* L, Handle(Geom_Curve)& result);
 	bool convert_face(const IfcUtil::IfcBaseClass* L, TopoDS_Face& result);
-	bool convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, const ShapeList& entity_shapes, const gp_Trsf& entity_trsf, ShapeList& cut_shapes);
-	bool convert_openings_fast(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, const ShapeList& entity_shapes, const gp_Trsf& entity_trsf, ShapeList& cut_shapes);
+	bool convert_openings(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::IfcRelVoidsElement::list& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
+	bool convert_openings_fast(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::IfcRelVoidsElement::list& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
+	IfcSchema::IfcSurfaceStyleShading* get_surface_style(IfcSchema::IfcRepresentationItem* item);
 	bool create_solid_from_compound(const TopoDS_Shape& compound, TopoDS_Shape& solid);
 	bool is_compound(const TopoDS_Shape& shape);
 	bool is_convex(const TopoDS_Wire& wire);
@@ -94,9 +99,13 @@ namespace IfcGeom {
 	bool profile_helper(int numVerts, double* verts, int numFillets, int* filletIndices, double* filletRadii, gp_Trsf2d trsf, TopoDS_Face& face); 
 	double shape_volume(const TopoDS_Shape& s);
 	double face_area(const TopoDS_Face& f);
+	void apply_tolerance(TopoDS_Shape& s, double t);
 	void SetValue(GeomValue var, double value);
 	double GetValue(GeomValue var);
 	std::string create_brep_data(Ifc2x3::IfcProduct* s);
+	IfcSchema::IfcProductDefinitionShape* tesselate(TopoDS_Shape& shape, double deflection, IfcEntities es);
+
+	
 	
 	namespace Cache {
 		void Purge();

src/ifcgeom/IfcGeomCurves.cpp

@@ -77,13 +77,13 @@
 
 #include "../ifcgeom/IfcGeom.h"
 
-bool IfcGeom::convert(const Ifc2x3::IfcCircle::ptr l, Handle(Geom_Curve)& curve) {
+bool IfcGeom::convert(const IfcSchema::IfcCircle::ptr l, Handle(Geom_Curve)& curve) {
 	const double r = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	if ( r <= 0.0f ) { return false; }
 	gp_Trsf trsf;
-	Ifc2x3::IfcAxis2Placement placement = l->Position();
-	if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) {
-		IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)placement,trsf);
+	IfcSchema::IfcAxis2Placement placement = l->Position();
+	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
+		IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf2d;
 		IfcGeom::convert((IfcAxis2Placement2D*)placement,trsf2d);
@@ -93,27 +93,28 @@ bool IfcGeom::convert(const Ifc2x3::IfcCircle::ptr l, Handle(Geom_Curve)& curve)
 	curve = new Geom_Circle(ax, r);
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcEllipse::ptr l, Handle(Geom_Curve)& curve) {
+bool IfcGeom::convert(const IfcSchema::IfcEllipse::ptr l, Handle(Geom_Curve)& curve) {
 	double x = l->SemiAxis1() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	double y = l->SemiAxis2() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	if ( x == 0.0f || y == 0.0f || y > x ) { return false; }
 	gp_Trsf trsf;
-	Ifc2x3::IfcAxis2Placement placement = l->Position();
-	if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) {
-		IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)placement,trsf);
+	IfcSchema::IfcAxis2Placement placement = l->Position();
+	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
+		IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf2d;
-		IfcGeom::convert((Ifc2x3::IfcAxis2Placement2D*)placement,trsf2d);
+		IfcGeom::convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf2d);
 		trsf = trsf2d;
 	}
 	gp_Ax2 ax = gp_Ax2().Transformed(trsf);
 	curve = new Geom_Ellipse(ax, x, y);
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcLine::ptr l, Handle(Geom_Curve)& curve) {
+bool IfcGeom::convert(const IfcSchema::IfcLine::ptr l, Handle(Geom_Curve)& curve) {
 	gp_Pnt pnt;gp_Vec vec;
 	IfcGeom::convert(l->Pnt(),pnt);
 	IfcGeom::convert(l->Dir(),vec);	
+	// See note at IfcGeomWires.cpp:237
 	curve = new Geom_Line(pnt,vec);
 	return true;
 }

src/ifcgeom/IfcGeomFaces.cpp

@@ -78,10 +78,10 @@
 
 #include "../ifcgeom/IfcGeom.h"
 
-bool IfcGeom::convert(const Ifc2x3::IfcFace::ptr l, TopoDS_Face& face) {
-	Ifc2x3::IfcFaceBound::list bounds = l->Bounds();
-	Ifc2x3::IfcFaceBound::it it = bounds->begin();
-	Ifc2x3::IfcLoop::ptr loop = (*it)->Bound();
+bool IfcGeom::convert(const IfcSchema::IfcFace::ptr l, TopoDS_Face& face) {
+	IfcSchema::IfcFaceBound::list bounds = l->Bounds();
+	IfcSchema::IfcFaceBound::it it = bounds->begin();
+	IfcSchema::IfcLoop::ptr loop = (*it)->Bound();
 	TopoDS_Wire outer_wire;
 	if ( ! IfcGeom::convert_wire(loop,outer_wire) ) return false;
 	BRepBuilderAPI_MakeFace mf (outer_wire);
@@ -98,7 +98,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcFace::ptr l, TopoDS_Face& face) {
 		face = mf.Face();
 	} else {
 		for( ++it; it != bounds->end(); ++ it) {
-			Ifc2x3::IfcLoop::ptr loop = (*it)->Bound();
+			IfcSchema::IfcLoop::ptr loop = (*it)->Bound();
 			TopoDS_Wire wire;
 			if ( ! IfcGeom::convert_wire(loop,wire) ) return false;
 			mf.Add(wire);
@@ -183,17 +183,17 @@ bool IfcGeom::convert(const Ifc2x3::IfcFace::ptr l, TopoDS_Face& face) {
 	// return face_area(face) > 0.0001;
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcArbitraryClosedProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcArbitraryClosedProfileDef::ptr l, TopoDS_Face& face) {
 	TopoDS_Wire wire;
 	if ( ! IfcGeom::convert_wire(l->OuterCurve(),wire) ) return false;
 	return IfcGeom::convert_wire_to_face(wire,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcArbitraryProfileDefWithVoids::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcArbitraryProfileDefWithVoids::ptr l, TopoDS_Face& face) {
 	TopoDS_Wire profile;
 	if ( ! IfcGeom::convert_wire(l->OuterCurve(),profile) ) return false;
 	BRepBuilderAPI_MakeFace mf(profile);
-	Ifc2x3::IfcCurve::list voids = l->InnerCurves();
-	for( Ifc2x3::IfcCurve::it it = voids->begin(); it != voids->end(); ++ it ) {
+	IfcSchema::IfcCurve::list voids = l->InnerCurves();
+	for( IfcSchema::IfcCurve::it it = voids->begin(); it != voids->end(); ++ it ) {
 		TopoDS_Wire hole;
 		if ( IfcGeom::convert_wire(*it,hole) ) {
 			mf.Add(hole);
@@ -204,7 +204,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcArbitraryProfileDefWithVoids::ptr l, Topo
 	face = TopoDS::Face(sfs.Shape());
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcRectangleProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcRectangleProfileDef::ptr l, TopoDS_Face& face) {
 	const double x = l->XDim() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double y = l->YDim() / 2.0f  * IfcGeom::GetValue(GV_LENGTH_UNIT);
 
@@ -218,7 +218,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcRectangleProfileDef::ptr l, TopoDS_Face&
 	double coords[8] = {-x,-y,x,-y,x,y,-x,y};
 	return IfcGeom::profile_helper(4,coords,0,0,0,trsf2d,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcIShapeProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcIShapeProfileDef::ptr l, TopoDS_Face& face) {
 	const double x = l->OverallWidth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double y = l->OverallDepth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double d1 = l->WebThickness() / 2.0f  * IfcGeom::GetValue(GV_LENGTH_UNIT);
@@ -242,7 +242,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcIShapeProfileDef::ptr l, TopoDS_Face& fac
 	double radii[4] = {f,f,f,f};
 	return IfcGeom::profile_helper(12,coords,doFillet ? 4 : 0,fillets,radii,trsf2d,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCShapeProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcCShapeProfileDef::ptr l, TopoDS_Face& face) {
 	const double x = l->Depth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double y = l->Width() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double d1 = l->WallThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
@@ -267,7 +267,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCShapeProfileDef::ptr l, TopoDS_Face& fac
 	double radii[8] = {f2,f2,f1,f1,f1,f1,f2,f2};
 	return IfcGeom::profile_helper(12,coords,doFillet ? 8 : 0,fillets,radii,trsf2d,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcLShapeProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcLShapeProfileDef::ptr l, TopoDS_Face& face) {
 	const double y = l->Depth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double x = l->Width() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double d = l->Thickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
@@ -294,7 +294,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcLShapeProfileDef::ptr l, TopoDS_Face& fac
 	double radii[3] = {f2,f1,f2};
 	return IfcGeom::profile_helper(6,coords,doFillet ? 3 : 0,fillets,radii,trsf2d,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCircleProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcCircleProfileDef::ptr l, TopoDS_Face& face) {
 	const double r = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	if ( r == 0.0f ) {
 		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
@@ -311,7 +311,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCircleProfileDef::ptr l, TopoDS_Face& fac
 	w.Add(edge);
 	return IfcGeom::convert_wire_to_face(w,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCircleHollowProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcCircleHollowProfileDef::ptr l, TopoDS_Face& face) {
 	const double r = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double t = l->WallThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	

src/ifcgeom/IfcGeomFunctions.cpp

@@ -86,6 +86,12 @@
 
 #include <BRepGProp_Face.hxx>
 
+#include <BRepMesh.hxx>
+#include <BRepTools.hxx>
+
+#include <Poly_Triangulation.hxx>
+#include <Poly_Array1OfTriangle.hxx>
+
 #include <BRepTools.hxx>
 
 #include "../ifcgeom/IfcGeom.h"
@@ -126,15 +132,15 @@ const TopoDS_Shape& IfcGeom::ensure_fit_for_subtraction(const TopoDS_Shape& shap
 	return solid;
 }
 
-bool IfcGeom::convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, 
-							   const ShapeList& entity_shapes, const gp_Trsf& entity_trsf, ShapeList& cut_shapes) {
+bool IfcGeom::convert_openings(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::IfcRelVoidsElement::list& openings, 
+							   const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes) {
 	// Iterate over IfcOpeningElements
-	IfcGeom::ShapeList opening_shapes;
+	IfcGeom::IfcRepresentationShapeItems opening_shapes;
 	unsigned int last_size = 0;
-	for ( Ifc2x3::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
-		Ifc2x3::IfcRelVoidsElement::ptr v = *it;
-		Ifc2x3::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
-		if ( fes->is(Ifc2x3::Type::IfcOpeningElement) ) {
+	for ( IfcSchema::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
+		IfcSchema::IfcRelVoidsElement::ptr v = *it;
+		IfcSchema::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
+		if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {
 
 			// Convert the IfcRepresentation of the IfcOpeningElement
 			gp_Trsf opening_trsf;
@@ -143,26 +149,26 @@ bool IfcGeom::convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x
 			// Move the opening into the coordinate system of the IfcProduct
 			opening_trsf.PreMultiply(entity_trsf.Inverted());
 
-			Ifc2x3::IfcProductRepresentation::ptr prodrep = fes->Representation();
-			Ifc2x3::IfcRepresentation::list reps = prodrep->Representations();
+			IfcSchema::IfcProductRepresentation::ptr prodrep = fes->Representation();
+			IfcSchema::IfcRepresentation::list reps = prodrep->Representations();
 						
-			for ( Ifc2x3::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
+			for ( IfcSchema::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
 				IfcGeom::convert_shapes(*it2,opening_shapes);
 			}
 
 			const unsigned int current_size = (const unsigned int) opening_shapes.size();
 			for ( unsigned int i = last_size; i < current_size; ++ i ) {
-				opening_shapes[i].first->PreMultiply(opening_trsf);
+				opening_shapes[i].prepend(opening_trsf);
 			}
 			last_size = current_size;
 		}
 	}
 
 	// Iterate over the shapes of the IfcProduct
-	for ( IfcGeom::ShapeList::const_iterator it3 = entity_shapes.begin(); it3 != entity_shapes.end(); ++ it3 ) {
+	for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it3 = entity_shapes.begin(); it3 != entity_shapes.end(); ++ it3 ) {
 		TopoDS_Shape entity_shape_solid;
-		const TopoDS_Shape& entity_shape_unlocated = IfcGeom::ensure_fit_for_subtraction(*(it3->second),entity_shape_solid);
-		const gp_GTrsf& entity_shape_gtrsf = *(it3->first);
+		const TopoDS_Shape& entity_shape_unlocated = IfcGeom::ensure_fit_for_subtraction(it3->Shape(),entity_shape_solid);
+		const gp_GTrsf& entity_shape_gtrsf = it3->Placement();
 		TopoDS_Shape entity_shape;
 		if ( entity_shape_gtrsf.Form() == gp_Other ) {
 			Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to:",entity->entity);
@@ -172,10 +178,10 @@ bool IfcGeom::convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x
 		}
 
 		// Iterate over the shapes of the IfcOpeningElements
-		for ( IfcGeom::ShapeList::const_iterator it4 = opening_shapes.begin(); it4 != opening_shapes.end(); ++ it4 ) {
+		for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it4 = opening_shapes.begin(); it4 != opening_shapes.end(); ++ it4 ) {
 			TopoDS_Shape opening_shape_solid;
-			const TopoDS_Shape& opening_shape_unlocated = IfcGeom::ensure_fit_for_subtraction(*(it4->second),opening_shape_solid);
-			const gp_GTrsf& opening_shape_gtrsf = *(it4->first);
+			const TopoDS_Shape& opening_shape_unlocated = IfcGeom::ensure_fit_for_subtraction(it4->Shape(),opening_shape_solid);
+			const gp_GTrsf& opening_shape_gtrsf = it4->Placement();
 			if ( opening_shape_gtrsf.Form() == gp_Other ) {
 				Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to opening of:",entity->entity);
 			}
@@ -214,29 +220,24 @@ bool IfcGeom::convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x
 			}
 
 		}
-		cut_shapes.push_back(IfcGeom::LocationShape(new gp_GTrsf(),new TopoDS_Shape(entity_shape)));
-	}
-
-	// Delete references to opening transformations, but keep shapes in the cache
-	for ( IfcGeom::ShapeList::const_iterator it5 = opening_shapes.begin(); it5 != opening_shapes.end(); ++ it5 ) {
-		delete it5->first;
+		cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(entity_shape, &it3->Style()));
 	}
 
 	return true;
 }
 
-bool IfcGeom::convert_openings_fast(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, 
-							   const ShapeList& entity_shapes, const gp_Trsf& entity_trsf, ShapeList& cut_shapes) {
+bool IfcGeom::convert_openings_fast(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::IfcRelVoidsElement::list& openings, 
+							   const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes) {
 	
 	// Create a compound of all opening shapes in order to speed up the boolean operations
 	TopoDS_Compound opening_compound;
 	BRep_Builder builder;
 	builder.MakeCompound(opening_compound);
 
-	for ( Ifc2x3::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
-		Ifc2x3::IfcRelVoidsElement::ptr v = *it;
-		Ifc2x3::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
-		if ( fes->is(Ifc2x3::Type::IfcOpeningElement) ) {
+	for ( IfcSchema::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
+		IfcSchema::IfcRelVoidsElement::ptr v = *it;
+		IfcSchema::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
+		if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {
 
 			// Convert the IfcRepresentation of the IfcOpeningElement
 			gp_Trsf opening_trsf;
@@ -245,35 +246,32 @@ bool IfcGeom::convert_openings_fast(const Ifc2x3::IfcProduct::ptr entity, const
 			// Move the opening into the coordinate system of the IfcProduct
 			opening_trsf.PreMultiply(entity_trsf.Inverted());
 
-			Ifc2x3::IfcProductRepresentation::ptr prodrep = fes->Representation();
-			Ifc2x3::IfcRepresentation::list reps = prodrep->Representations();
+			IfcSchema::IfcProductRepresentation::ptr prodrep = fes->Representation();
+			IfcSchema::IfcRepresentation::list reps = prodrep->Representations();
 
-			IfcGeom::ShapeList opening_shapes;
+			IfcGeom::IfcRepresentationShapeItems opening_shapes;
 						
-			for ( Ifc2x3::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
+			for ( IfcSchema::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
 				IfcGeom::convert_shapes(*it2,opening_shapes);
 			}
 
 			for ( unsigned int i = 0; i < opening_shapes.size(); ++ i ) {
-				gp_GTrsf& gtrsf = *opening_shapes[i].first;
+				gp_GTrsf gtrsf = opening_shapes[i].Placement();
 				gtrsf.PreMultiply(opening_trsf);
 				const TopoDS_Shape& opening_shape = gtrsf.Form() == gp_Other
-					? BRepBuilderAPI_GTransform(*opening_shapes[i].second,gtrsf,true).Shape()
-					: (*opening_shapes[i].second).Moved(gtrsf.Trsf());
+					? BRepBuilderAPI_GTransform(opening_shapes[i].Shape(),gtrsf,true).Shape()
+					: (opening_shapes[i].Shape()).Moved(gtrsf.Trsf());
 				builder.Add(opening_compound,opening_shape);
 			}
 
-			for ( IfcGeom::ShapeList::const_iterator it5 = opening_shapes.begin(); it5 != opening_shapes.end(); ++ it5 ) {
-				delete it5->first;
-			}
 		}
 	}
 
 	// Iterate over the shapes of the IfcProduct
-	for ( IfcGeom::ShapeList::const_iterator it3 = entity_shapes.begin(); it3 != entity_shapes.end(); ++ it3 ) {
+	for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it3 = entity_shapes.begin(); it3 != entity_shapes.end(); ++ it3 ) {
 		TopoDS_Shape entity_shape_solid;
-		const TopoDS_Shape& entity_shape_unlocated = IfcGeom::ensure_fit_for_subtraction(*(it3->second),entity_shape_solid);
-		const gp_GTrsf& entity_shape_gtrsf = *(it3->first);
+		const TopoDS_Shape& entity_shape_unlocated = IfcGeom::ensure_fit_for_subtraction(it3->Shape(),entity_shape_solid);
+		const gp_GTrsf& entity_shape_gtrsf = it3->Placement();
 		TopoDS_Shape entity_shape;
 		if ( entity_shape_gtrsf.Form() == gp_Other ) {
 			Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to:",entity->entity);
@@ -290,7 +288,7 @@ bool IfcGeom::convert_openings_fast(const Ifc2x3::IfcProduct::ptr entity, const
 			BRepCheck_Analyzer analyser(brep_cut_result);
 			is_valid = analyser.IsValid() != 0;
 			if ( is_valid ) {
-				cut_shapes.push_back(IfcGeom::LocationShape(new gp_GTrsf(),new TopoDS_Shape(brep_cut_result)));
+				cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(brep_cut_result, &it3->Style()));
 			}
 		}
 		if ( !is_valid ) {
@@ -427,6 +425,11 @@ gp_Pnt IfcGeom::point_above_plane(const gp_Pln& pln, bool agree) {
 	}
 }
 
+void IfcGeom::apply_tolerance(TopoDS_Shape& s, double t) {
+	ShapeFix_ShapeTolerance tol;
+	tol.SetTolerance(s, t);
+}
+
 static double deflection_tolerance = 0.001;
 static double wire_creation_tolerance = 0.0001;
 static double minimal_face_area = 0.000001;
@@ -435,6 +438,7 @@ static double max_faces_to_sew = -1.0;
 static double ifc_length_unit = 1.0;
 static double ifc_planeangle_unit = -1.0;
 static double force_ccw_face_orientation = -1.0;
+static double modelling_precision = 0.00001;
 
 void IfcGeom::SetValue(GeomValue var, double value) {
 	switch (var) {
@@ -462,6 +466,9 @@ void IfcGeom::SetValue(GeomValue var, double value) {
 	case GV_FORCE_CCW_FACE_ORIENTATION:
 		force_ccw_face_orientation = value;
 		break;
+	case GV_PRECISION:
+		modelling_precision = value;
+		break;
 	default:
 		assert(!"never reach here");
 	}
@@ -488,11 +495,78 @@ double IfcGeom::GetValue(GeomValue var) {
 	case GV_FORCE_CCW_FACE_ORIENTATION:
 		return force_ccw_face_orientation;
 		break;
+	case GV_PRECISION:
+		return modelling_precision;
+		break;
 	}
 	assert(!"never reach here");
 	return 0;
 }
 
+IfcSchema::IfcProductDefinitionShape* IfcGeom::tesselate(TopoDS_Shape& shape, double deflection, IfcEntities es) {
+	BRepMesh::Mesh(shape, deflection);
+
+	IfcSchema::IfcFace::list faces (new IfcTemplatedEntityList<IfcSchema::IfcFace>());
+
+	for (TopExp_Explorer exp(shape, TopAbs_FACE); exp.More(); exp.Next()) {
+		const TopoDS_Face& face = TopoDS::Face(exp.Current());
+		TopLoc_Location loc;
+		Handle(Poly_Triangulation) tri = BRep_Tool::Triangulation(face, loc);
+
+		if (! tri.IsNull()) {
+			const TColgp_Array1OfPnt& nodes = tri->Nodes();
+			std::vector<IfcSchema::IfcCartesianPoint*> vertices;
+			for (int i = 1; i <= nodes.Length(); ++i) {
+				const gp_Pnt& pnt = nodes(i);
+				std::vector<double> xyz; xyz.push_back(pnt.X()); xyz.push_back(pnt.Y()); xyz.push_back(pnt.Z());
+				IfcSchema::IfcCartesianPoint* cpnt = new IfcSchema::IfcCartesianPoint(xyz);
+				vertices.push_back(cpnt);
+				es->push(cpnt);
+			}
+			const Poly_Array1OfTriangle& triangles = tri->Triangles();			
+			for (int i = 1; i <= triangles.Length(); ++ i) {
+				int n1, n2, n3;
+				triangles(i).Get(n1, n2, n3);
+				IfcSchema::IfcCartesianPoint::list points (new IfcTemplatedEntityList<IfcSchema::IfcCartesianPoint>());
+				points->push(vertices[n1-1]);
+				points->push(vertices[n2-1]);
+				points->push(vertices[n3-1]);
+				IfcSchema::IfcPolyLoop* loop = new IfcSchema::IfcPolyLoop(points);
+				IfcSchema::IfcFaceOuterBound* bound = new IfcSchema::IfcFaceOuterBound(loop, face.Orientation() != TopAbs_REVERSED);
+				IfcSchema::IfcFaceBound::list bounds (new IfcTemplatedEntityList<IfcSchema::IfcFaceBound>());
+				bounds->push(bound);
+				IfcSchema::IfcFace* face = new IfcSchema::IfcFace(bounds);
+				es->push(loop);
+				es->push(bound);
+				es->push(face);
+				faces->push(face);
+			}
+		}
+	}
+	IfcSchema::IfcOpenShell* shell = new IfcSchema::IfcOpenShell(faces);
+	IfcSchema::IfcConnectedFaceSet::list shells (new IfcTemplatedEntityList<IfcSchema::IfcConnectedFaceSet>());
+	shells->push(shell);
+	IfcSchema::IfcFaceBasedSurfaceModel* surface_model = new IfcSchema::IfcFaceBasedSurfaceModel(shells);
+
+	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
+	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
+
+	items->push(surface_model);
+
+	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
+		0, std::string("Facetation"), std::string("SurfaceModel"), items);
+
+	reps->push(rep);
+	IfcSchema::IfcProductDefinitionShape* shapedef = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
+
+	es->push(shell);
+	es->push(surface_model);
+	es->push(rep);
+	es->push(shapedef);
+
+	return shapedef;
+}
+
 std::string IfcGeom::create_brep_data(Ifc2x3::IfcProduct* ifc_product) {
 	if (!ifc_product->hasRepresentation()) return "";
 
@@ -507,7 +581,7 @@ std::string IfcGeom::create_brep_data(Ifc2x3::IfcProduct* ifc_product) {
 		}
 	}
 
-	IfcGeom::ShapeList shapes;
+	IfcGeom::IfcRepresentationShapeItems shapes;
 	if (!IfcGeom::convert_shapes(shape_rep,shapes)) {
 		return "";
 	}
@@ -519,42 +593,43 @@ std::string IfcGeom::create_brep_data(Ifc2x3::IfcProduct* ifc_product) {
 
 	// Does the IfcElement have any IfcOpenings?
 	// Note that openings for IfcOpeningElements are not processed
-	Ifc2x3::IfcRelVoidsElement::list openings = Ifc2x3::IfcRelVoidsElement::list();
-	if ( ifc_product->is(Ifc2x3::Type::IfcElement) && !ifc_product->is(Ifc2x3::Type::IfcOpeningElement) ) {
-		Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcElement>(ifc_product);
+	IfcSchema::IfcRelVoidsElement::list openings = IfcSchema::IfcRelVoidsElement::list();
+	if ( ifc_product->is(IfcSchema::Type::IfcElement) && !ifc_product->is(IfcSchema::Type::IfcOpeningElement) ) {
+		IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcElement>(ifc_product);
 		openings = element->HasOpenings();
 	}
 	// Is the IfcElement a decomposition of an IfcElement with any IfcOpeningElements?
-	if ( ifc_product->is(Ifc2x3::Type::IfcBuildingElementPart ) ) {
-		Ifc2x3::IfcBuildingElementPart::ptr part = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcBuildingElementPart>(ifc_product);
-		Ifc2x3::IfcRelDecomposes::list decomposes = part->Decomposes();
-		for ( Ifc2x3::IfcRelDecomposes::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
-			Ifc2x3::IfcObjectDefinition::ptr obdef = (*it)->RelatingObject();
-			if ( obdef->is(Ifc2x3::Type::IfcElement) ) {
-				Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcObjectDefinition,Ifc2x3::IfcElement>(obdef);
+	if ( ifc_product->is(IfcSchema::Type::IfcBuildingElementPart ) ) {
+		IfcSchema::IfcBuildingElementPart::ptr part = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcBuildingElementPart>(ifc_product);
+#ifdef USE_IFC4
+		IfcSchema::IfcRelAggregates::list decomposes = part->Decomposes();
+		for ( IfcSchema::IfcRelAggregates::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
+#else
+		IfcSchema::IfcRelDecomposes::list decomposes = part->Decomposes();
+		for ( IfcSchema::IfcRelDecomposes::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
+#endif
+			IfcSchema::IfcObjectDefinition::ptr obdef = (*it)->RelatingObject();
+			if ( obdef->is(IfcSchema::Type::IfcElement) ) {
+				IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcObjectDefinition,IfcSchema::IfcElement>(obdef);
 				openings->push(element->HasOpenings());
 			}
 		}
 	}
 
 	if ( openings && openings->Size() ) {
-		IfcGeom::ShapeList opened_shapes;
+		IfcGeom::IfcRepresentationShapeItems opened_shapes;
 		try {
 			IfcGeom::convert_openings(ifc_product,openings,shapes,trsf,opened_shapes);
 		} catch(...) { 
 			Logger::Message(Logger::LOG_ERROR,"Error processing openings for:",ifc_product->entity); 
 		}
-		for ( IfcGeom::ShapeList::const_iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
-			it->first->PreMultiply(trsf);
+		for ( IfcGeom::IfcRepresentationShapeItems::iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
+			it->prepend(trsf);
 		}
 		trsf = gp_Trsf();
-		for ( IfcGeom::ShapeList::const_iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
-			delete it->first;
-			delete it->second;
-		}
 	} else {
-		for ( IfcGeom::ShapeList::const_iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
-			it->first->PreMultiply(trsf);
+		for ( IfcGeom::IfcRepresentationShapeItems::iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
+			it->prepend(trsf);
 		}
 		trsf = gp_Trsf();
 	}
@@ -562,9 +637,9 @@ std::string IfcGeom::create_brep_data(Ifc2x3::IfcProduct* ifc_product) {
 	TopoDS_Compound compound;
 	BRep_Builder builder;
 	builder.MakeCompound(compound);
-	for ( IfcGeom::ShapeList::const_iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
-		const TopoDS_Shape& s = *(*it).second;
-		const gp_GTrsf& trsf = *(*it).first;
+	for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
+		const TopoDS_Shape& s = it->Shape();
+		const gp_GTrsf& trsf = it->Placement();
 		bool trsf_valid = false;
 		gp_Trsf _trsf;
 		try {

src/ifcgeom/IfcGeomHelpers.cpp

@@ -87,7 +87,7 @@ namespace IfcGeom {
 	if ( it != Cache::T.end() ) { e = it->second; return true; }
 #define CACHE(T,E,e) Cache::T[E->entity->id()] = e;
 
-bool IfcGeom::convert(const Ifc2x3::IfcCartesianPoint::ptr l, gp_Pnt& point) {
+bool IfcGeom::convert(const IfcSchema::IfcCartesianPoint::ptr l, gp_Pnt& point) {
 	IN_CACHE(IfcCartesianPoint,l,gp_Pnt,point)
 	std::vector<double> xyz = l->Coordinates();
 	point = gp_Pnt(
@@ -98,7 +98,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCartesianPoint::ptr l, gp_Pnt& point) {
 	CACHE(IfcCartesianPoint,l,point)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcDirection::ptr l, gp_Dir& dir) {
+bool IfcGeom::convert(const IfcSchema::IfcDirection::ptr l, gp_Dir& dir) {
 	IN_CACHE(IfcDirection,l,gp_Dir,dir)
 	std::vector<double> xyz = l->DirectionRatios();
 	dir = gp_Dir(
@@ -109,7 +109,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcDirection::ptr l, gp_Dir& dir) {
 	CACHE(IfcDirection,l,dir)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcVector::ptr l, gp_Vec& v) {
+bool IfcGeom::convert(const IfcSchema::IfcVector::ptr l, gp_Vec& v) {
 	IN_CACHE(IfcVector,l,gp_Vec,v)
 	gp_Dir d;
 	IfcGeom::convert(l->Orientation(),d);
@@ -117,7 +117,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcVector::ptr l, gp_Vec& v) {
 	CACHE(IfcVector,l,v)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement3D::ptr l, gp_Trsf& trsf) {
+bool IfcGeom::convert(const IfcSchema::IfcAxis2Placement3D::ptr l, gp_Trsf& trsf) {
 	IN_CACHE(IfcAxis2Placement3D,l,gp_Trsf,trsf)
 	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
 	IfcGeom::convert(l->Location(),o);
@@ -131,7 +131,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement3D::ptr l, gp_Trsf& trsf) {
 	CACHE(IfcAxis2Placement3D,l,trsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3D::ptr l, gp_Trsf& trsf) {
+bool IfcGeom::convert(const IfcSchema::IfcCartesianTransformationOperator3D::ptr l, gp_Trsf& trsf) {
 	IN_CACHE(IfcCartesianTransformationOperator3D,l,gp_Trsf,trsf)
 	gp_Pnt origin;
 	IfcGeom::convert(l->LocalOrigin(),origin);
@@ -150,7 +150,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3D::ptr l,
 	CACHE(IfcCartesianTransformationOperator3D,l,trsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2D::ptr l, gp_Trsf2d& trsf) {
+bool IfcGeom::convert(const IfcSchema::IfcCartesianTransformationOperator2D::ptr l, gp_Trsf2d& trsf) {
 	IN_CACHE(IfcCartesianTransformationOperator2D,l,gp_Trsf2d,trsf)
 	gp_Pnt origin;
 	IfcGeom::convert(l->LocalOrigin(),origin);
@@ -163,7 +163,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2D::ptr l,
 	CACHE(IfcCartesianTransformationOperator2D,l,trsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::ptr l, gp_GTrsf& gtrsf) {
+bool IfcGeom::convert(const IfcSchema::IfcCartesianTransformationOperator3DnonUniform::ptr l, gp_GTrsf& gtrsf) {
 	IN_CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gp_GTrsf,gtrsf)
 	gp_Trsf trsf;
 	gp_Pnt origin;
@@ -190,7 +190,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3DnonUnifo
 	CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gtrsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2DnonUniform::ptr l, gp_GTrsf2d& gtrsf) {
+bool IfcGeom::convert(const IfcSchema::IfcCartesianTransformationOperator2DnonUniform::ptr l, gp_GTrsf2d& gtrsf) {
 	IN_CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gp_GTrsf2d,gtrsf)
 	gp_Trsf2d trsf;
 	gp_Pnt origin;
@@ -209,9 +209,9 @@ bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2DnonUnifo
 	CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gtrsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcPlane::ptr pln, gp_Pln& plane) {
+bool IfcGeom::convert(const IfcSchema::IfcPlane::ptr pln, gp_Pln& plane) {
 	IN_CACHE(IfcPlane,pln,gp_Pln,plane)
-	Ifc2x3::IfcAxis2Placement3D::ptr l = pln->Position();
+	IfcSchema::IfcAxis2Placement3D::ptr l = pln->Position();
 	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
 	IfcGeom::convert(l->Location(),o);
 	bool hasRef = l->hasRefDirection();
@@ -224,7 +224,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcPlane::ptr pln, gp_Pln& plane) {
 	CACHE(IfcPlane,pln,plane)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement2D::ptr l, gp_Trsf2d& trsf) {
+bool IfcGeom::convert(const IfcSchema::IfcAxis2Placement2D::ptr l, gp_Trsf2d& trsf) {
 	IN_CACHE(IfcAxis2Placement2D,l,gp_Trsf2d,trsf)
 	gp_Pnt P; gp_Dir V (1,0,0);
 	IfcGeom::convert(l->Location(),P);
@@ -236,21 +236,21 @@ bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement2D::ptr l, gp_Trsf2d& trsf)
 	CACHE(IfcAxis2Placement2D,l,trsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcObjectPlacement::ptr l, gp_Trsf& trsf) {
+bool IfcGeom::convert(const IfcSchema::IfcObjectPlacement::ptr l, gp_Trsf& trsf) {
 	IN_CACHE(IfcObjectPlacement,l,gp_Trsf,trsf)
-	if ( ! l->is(Ifc2x3::Type::IfcLocalPlacement) ) return false;
-	Ifc2x3::IfcLocalPlacement::ptr current = reinterpret_pointer_cast<Ifc2x3::IfcObjectPlacement,Ifc2x3::IfcLocalPlacement>(l);
+	if ( ! l->is(IfcSchema::Type::IfcLocalPlacement) ) return false;
+	IfcSchema::IfcLocalPlacement::ptr current = reinterpret_pointer_cast<IfcSchema::IfcObjectPlacement,IfcSchema::IfcLocalPlacement>(l);
 	while (1) {
 		gp_Trsf trsf2;
-		Ifc2x3::IfcAxis2Placement relplacement = current->RelativePlacement();
-		if ( relplacement->is(Ifc2x3::Type::IfcAxis2Placement3D) ) {
-			IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)relplacement,trsf2);
+		IfcSchema::IfcAxis2Placement relplacement = current->RelativePlacement();
+		if ( relplacement->is(IfcSchema::Type::IfcAxis2Placement3D) ) {
+			IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)relplacement,trsf2);
 			trsf.PreMultiply(trsf2);
 		}
 		if ( current->hasPlacementRelTo() ) {
-			Ifc2x3::IfcObjectPlacement::ptr relto = current->PlacementRelTo();
-			if ( relto->is(Ifc2x3::Type::IfcLocalPlacement) )
-				current = reinterpret_pointer_cast<Ifc2x3::IfcObjectPlacement,Ifc2x3::IfcLocalPlacement>(current->PlacementRelTo());
+			IfcSchema::IfcObjectPlacement::ptr relto = current->PlacementRelTo();
+			if ( relto->is(IfcSchema::Type::IfcLocalPlacement) )
+				current = reinterpret_pointer_cast<IfcSchema::IfcObjectPlacement,IfcSchema::IfcLocalPlacement>(current->PlacementRelTo());
 			else break;			
 		} else break;
 	}

src/ifcgeom/IfcGeomObjects.cpp

@@ -18,6 +18,8 @@
  ********************************************************************************/
 
 #include <map>
+#include <stdexcept>
+#include <limits>
 
 #include <gp_Mat.hxx>
 #include <gp_Mat2d.hxx>
@@ -47,45 +49,51 @@
 #include "../ifcgeom/IfcGeom.h"
 
 // Welds vertices that belong to different faces
-bool weld_vertices = true;
+static bool weld_vertices = true;
 
-bool convert_back_units = false;
-bool use_faster_booleans = false;
-bool disable_subtractions = false;
+static bool convert_back_units = false;
+static bool use_faster_booleans = false;
+static bool disable_subtractions = false;
+static bool disable_triangulation = false;
 
-int IfcGeomObjects::IfcMesh::addvert(const gp_XYZ& p) {
+int IfcGeomObjects::IfcRepresentationTriangulation::addvert(int material_index, const gp_XYZ& p) {
 	const float X = convert_back_units ? (float) (p.X() / IfcGeom::GetValue(IfcGeom::GV_LENGTH_UNIT)) : (float)p.X();
 	const float Y = convert_back_units ? (float) (p.Y() / IfcGeom::GetValue(IfcGeom::GV_LENGTH_UNIT)) : (float)p.Y();
 	const float Z = convert_back_units ? (float) (p.Z() / IfcGeom::GetValue(IfcGeom::GV_LENGTH_UNIT)) : (float)p.Z();
-	int i = (int) verts.size() / 3;
+	int i = (int) _verts.size() / 3;
 	if ( weld_vertices ) {
-		const VertKey key = VertKey(X,std::pair<float,float>(Y,Z));
+		const VertKey key = std::make_pair(material_index, std::make_pair(X, std::make_pair(Y, Z)));
 		VertKeyMap::const_iterator it = welds.find(key);
 		if ( it != welds.end() ) return it->second;
 		i = (int) welds.size();
 		welds[key] = i;
 	}
-	verts.push_back(X);
-	verts.push_back(Y);
-	verts.push_back(Z);
+	_verts.push_back(X);
+	_verts.push_back(Y);
+	_verts.push_back(Z);
 	return i;
 }
 
-bool use_world_coords = false;
-bool use_brep_data = false;
+static bool use_world_coords = false;
+static bool use_brep_data = false;
 
 static IfcParse::IfcFile* ifc_file = 0;
 
-IfcGeomObjects::IfcMesh::IfcMesh(int i, const IfcGeom::ShapeList& shapes) {
-	id = i;
-
-	if ( use_brep_data ) {
+IfcGeomObjects::IfcRepresentationBrepData::IfcRepresentationBrepData(const IfcRepresentationShapeModel& shapes)
+	: _id(shapes.getId()) 
+{
+	try {
 		TopoDS_Compound compound;
 		BRep_Builder builder;
 		builder.MakeCompound(compound);
-		for ( IfcGeom::ShapeList::const_iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
-			const TopoDS_Shape& s = *(*it).second;
-			const gp_GTrsf& trsf = *(*it).first;
+		for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
+			const TopoDS_Shape& s = it->Shape();
+			gp_GTrsf trsf = it->Placement();
+			if (convert_back_units) {
+				gp_Trsf scale;
+				scale.SetScaleFactor(1.0 / IfcGeom::GetValue(IfcGeom::GV_LENGTH_UNIT));
+				trsf.PreMultiply(scale);
+			}
 			bool trsf_valid = false;
 			gp_Trsf _trsf;
 			try {
@@ -98,19 +106,38 @@ IfcGeomObjects::IfcMesh::IfcMesh(int i, const IfcGeom::ShapeList& shapes) {
 		}
 		std::stringstream sstream;
 		BRepTools::Write(compound,sstream);
-		brep_data = sstream.str();
-	} else
-	for ( IfcGeom::ShapeList::const_iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
+		_brep_data = sstream.str();
+	} catch(...) {
+		Logger::Message(Logger::LOG_ERROR,"Failed to serialize shape:",ifc_file->EntityById(_id)->entity);
+	}
+}
 
-		const TopoDS_Shape& s = *(*it).second;
-		const gp_GTrsf& trsf = *(*it).first;
+IfcGeomObjects::IfcRepresentationTriangulation::IfcRepresentationTriangulation(const IfcRepresentationShapeModel& shapes)
+	: _id(shapes.getId()) 
+{
+	for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
+
+		int surface_style_id = -1;
+		if (it->hasStyle()) {
+			Material adapter(&it->Style());
+			std::vector<Material>::const_iterator jt = std::find(_materials.begin(), _materials.end(), adapter);
+			if (jt == _materials.end()) {
+				surface_style_id = _materials.size();
+				_materials.push_back(adapter);
+			} else {
+				surface_style_id = jt - _materials.begin();
+			}
+		}
+
+		const TopoDS_Shape& s = it->Shape();
+		const gp_GTrsf& trsf = it->Placement();
 
 		// Triangulate the shape
 		try {
 			// BRepTools::Clean(s);
 			BRepMesh::Mesh(s, IfcGeom::GetValue(IfcGeom::GV_DEFLECTION_TOLERANCE));
 		} catch(...) {
-			Logger::Message(Logger::LOG_ERROR,"Failed to triangulate mesh:",ifc_file->EntityById(i)->entity);
+			Logger::Message(Logger::LOG_ERROR,"Failed to triangulate shape:",ifc_file->EntityById(_id)->entity);
 			continue;
 		}
 		TopExp_Explorer exp;
@@ -143,7 +170,7 @@ IfcGeomObjects::IfcMesh::IfcMesh(int i, const IfcGeom::ShapeList& shapes) {
 				for( int i = 1; i <= nodes.Length(); ++ i ) {
 					coords.push_back(nodes(i).Transformed(loc).XYZ());
 					trsf.Transforms(*coords.rbegin());
-					dict[i] = addvert(*coords.rbegin());
+					dict[i] = addvert(surface_style_id, *coords.rbegin());
 					
 					if ( calculate_normals ) {
 						const gp_Pnt2d& uv = uvs(i);
@@ -151,9 +178,9 @@ IfcGeomObjects::IfcMesh::IfcMesh(int i, const IfcGeom::ShapeList& shapes) {
 						gp_Vec normal_direction;
 						prop.Normal(uv.X(),uv.Y(),p,normal_direction);						
 						gp_Dir normal = gp_Dir(normal_direction.XYZ() * rotation_matrix);
-						normals.push_back((float)normal.X());
-						normals.push_back((float)normal.Y());
-						normals.push_back((float)normal.Z());
+						_normals.push_back((float)normal.X());
+						_normals.push_back((float)normal.Y());
+						_normals.push_back((float)normal.Z());
 					}
 				}
 
@@ -173,116 +200,142 @@ IfcGeomObjects::IfcMesh::IfcMesh(int i, const IfcGeom::ShapeList& shapes) {
 					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());
+					_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]);
+					_faces.push_back(dict[n1]);
+					_faces.push_back(dict[n2]);
+					_faces.push_back(dict[n3]);
+
+					_material_ids.push_back(surface_style_id);
 
 					addedge(n1,n2,edgecount,edges_temp);
 					addedge(n2,n3,edgecount,edges_temp);
 					addedge(n3,n1,edgecount,edges_temp);
 				}
 				for ( std::vector<std::pair<int,int> >::const_iterator it = edges_temp.begin(); it != edges_temp.end(); ++it ) {
-					edges.push_back(edgecount[*it]==1);
+					_edges.push_back(edgecount[*it]==1);
 				}
 			}
 		}
 	}
 }
 
-IfcGeomObjects::IfcObject::IfcObject(int my_id, 
-		int p_id, 
-		const std::string& n, 
-		const std::string& t, 
-		const std::string& g, 
-		const gp_Trsf& trsf) {
-
+IfcGeomObjects::IfcObject::IfcObject(
+	int id, 
+	int parent_id, 
+	const std::string& name, 
+	const std::string& type, 
+	const std::string& guid, 
+	const gp_Trsf& trsf)
+		: _id(id)
+		, _parent_id(parent_id)
+		, _name(name)
+		, _type(type)
+		, _guid(guid)
+{
 	// Convert the gp_Trsf into a 4x3 Matrix
 	for( int i = 1; i < 5; ++ i )
 		for ( int j = 1; j < 4; ++ j )
-			matrix.push_back((float)trsf.Value(j,i));
-
-	id = my_id;
-	parent_id = p_id;
-	name = n;
-	type = t;
-	guid = g;
+			_matrix.push_back((float)trsf.Value(j,i));
 }
 
-IfcGeomObjects::IfcGeomObject::IfcGeomObject(int my_id, 
-		int p_id, 
-		const std::string& n, 
-		const std::string& t, 
-		const std::string& g,
-		const gp_Trsf& trsf, 
-		IfcMesh* m) : IfcObject(my_id,p_id,n,t,g,trsf) {	
+IfcGeomObjects::IfcGeomShapeModelObject::IfcGeomShapeModelObject(
+	int id, 
+	int parent_id, 
+	const std::string& name, 
+	const std::string& type, 
+	const std::string& guid,
+	const gp_Trsf& trsf, 
+	IfcRepresentationShapeModel* shapes) 
+		: IfcObject(id,parent_id,name,type,guid,trsf)
+		, _mesh(shapes)
+{}
 
-	mesh = m;
-}
+IfcGeomObjects::IfcGeomBrepDataObject::IfcGeomBrepDataObject(
+	const IfcGeomShapeModelObject& shape_model)
+		: IfcObject(shape_model)
+		, _mesh(new IfcRepresentationBrepData(shape_model.mesh()))
+{}
+
+IfcGeomObjects::IfcGeomObject::IfcGeomObject(
+	const IfcGeomShapeModelObject& shape_model)
+		: IfcObject(shape_model)
+		, _mesh(new IfcRepresentationTriangulation(shape_model.mesh()))
+{}
 
 // A container and iterator for IfcShapeRepresentations
-Ifc2x3::IfcShapeRepresentation::list shapereps;
-Ifc2x3::IfcShapeRepresentation::it outer;
+static IfcSchema::IfcShapeRepresentation::list shapereps;
+static IfcSchema::IfcShapeRepresentation::it shaperep_iterator;
 
 // The object is fetched beforehand to be positive an entity actually exists
-IfcGeomObjects::IfcGeomObject* current_geom_obj;
+static IfcGeomObjects::IfcGeomObject* current_geom_obj = 0;
+static IfcGeomObjects::IfcGeomShapeModelObject* current_shape_model_obj = 0;
+static IfcGeomObjects::IfcGeomBrepDataObject* current_brep_data_obj = 0;
 
-// A container and iterator for IfcBuildingElements for the current IfcShapeRepresentation referenced by *outer
-Ifc2x3::IfcProduct::list entities;
-Ifc2x3::IfcProduct::it inner;
+// A container and iterator for IfcBuildingElements for the current IfcShapeRepresentation referenced by *shaperep_iterator
+static IfcSchema::IfcProduct::list entities;
+static IfcSchema::IfcProduct::it ifcproduct_iterator;
 
-int done;
-int total;
+static int done;
+static int total;
 
 // Move the the next IfcShapeRepresentation
 void _nextShape() {
 	entities.reset();
-	++ outer;
+	++ shaperep_iterator;
 	++ done;
 }
 
-int _getParentId(const Ifc2x3::IfcProduct::ptr ifc_product) {
+int _getParentId(const IfcSchema::IfcProduct::ptr ifc_product) {
 	int parent_id = -1;
 	// In case of an opening element, parent to the RelatingBuildingElement
-	if ( ifc_product->is(Ifc2x3::Type::IfcOpeningElement ) ) {
-		Ifc2x3::IfcOpeningElement::ptr opening = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcOpeningElement>(ifc_product);
-		Ifc2x3::IfcRelVoidsElement::list voids = opening->VoidsElements();
+	if ( ifc_product->is(IfcSchema::Type::IfcOpeningElement ) ) {
+		IfcSchema::IfcOpeningElement::ptr opening = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcOpeningElement>(ifc_product);
+		IfcSchema::IfcRelVoidsElement::list voids = opening->VoidsElements();
 		if ( voids->Size() ) {
-			Ifc2x3::IfcRelVoidsElement::ptr ifc_void = *voids->begin();
+			IfcSchema::IfcRelVoidsElement::ptr ifc_void = *voids->begin();
 			parent_id = ifc_void->RelatingBuildingElement()->entity->id();
 		}
-	} else if ( ifc_product->is(Ifc2x3::Type::IfcElement ) ) {
-		Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcElement>(ifc_product);
-		Ifc2x3::IfcRelFillsElement::list fills = element->FillsVoids();
+	} else if ( ifc_product->is(IfcSchema::Type::IfcElement ) ) {
+		IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcElement>(ifc_product);
+		IfcSchema::IfcRelFillsElement::list fills = element->FillsVoids();
 		// Incase of a RelatedBuildingElement parent to the opening element
 		if ( fills->Size() ) {
-			for ( Ifc2x3::IfcRelFillsElement::it it = fills->begin(); it != fills->end(); ++ it ) {
-				Ifc2x3::IfcRelFillsElement::ptr fill = *it;
-				Ifc2x3::IfcObjectDefinition* ifc_objectdef = fill->RelatingOpeningElement();
+			for ( IfcSchema::IfcRelFillsElement::it it = fills->begin(); it != fills->end(); ++ it ) {
+				IfcSchema::IfcRelFillsElement::ptr fill = *it;
+				IfcSchema::IfcObjectDefinition* ifc_objectdef = fill->RelatingOpeningElement();
 				if ( ifc_product == ifc_objectdef ) continue;
 				parent_id = ifc_objectdef->entity->id();
 			}
 		} 
 		// Else simply parent to the containing structure
 		if ( parent_id == -1 ) {
-			Ifc2x3::IfcRelContainedInSpatialStructure::list parents = element->ContainedInStructure();
+			IfcSchema::IfcRelContainedInSpatialStructure::list parents = element->ContainedInStructure();
 			if ( parents->Size() ) {
-				Ifc2x3::IfcRelContainedInSpatialStructure::ptr parent = *parents->begin();
+				IfcSchema::IfcRelContainedInSpatialStructure::ptr parent = *parents->begin();
 				parent_id = parent->RelatingStructure()->entity->id();
 			}
 		}
 	}
 	// Parent decompositions to the RelatingObject
 	if ( parent_id == -1 ) {
-		IfcEntities parents = ifc_product->entity->getInverse(Ifc2x3::Type::IfcRelAggregates);
-		parents->push(ifc_product->entity->getInverse(Ifc2x3::Type::IfcRelNests));
+		IfcEntities parents = ifc_product->entity->getInverse(IfcSchema::Type::IfcRelAggregates);
+		parents->push(ifc_product->entity->getInverse(IfcSchema::Type::IfcRelNests));
 		for ( IfcEntityList::it it = parents->begin(); it != parents->end(); ++ it ) {
-			Ifc2x3::IfcRelDecomposes::ptr decompose = reinterpret_pointer_cast<IfcBaseClass,Ifc2x3::IfcRelDecomposes>(*it);
-			Ifc2x3::IfcObjectDefinition* ifc_objectdef = decompose->RelatingObject();
+			IfcSchema::IfcRelDecomposes::ptr decompose = reinterpret_pointer_cast<IfcUtil::IfcBaseClass,IfcSchema::IfcRelDecomposes>(*it);
+			IfcSchema::IfcObjectDefinition* ifc_objectdef;
+#ifdef USE_IFC4
+			if (decompose->is(IfcSchema::Type::IfcRelAggregates)) {
+				ifc_objectdef = ((IfcSchema::IfcRelAggregates*)decompose)->RelatingObject();
+			} else {
+				continue;
+			}
+#else
+			ifc_objectdef = decompose->RelatingObject();
+#endif
 			if ( ifc_product == ifc_objectdef ) continue;
 			parent_id = ifc_objectdef->entity->id();
 		}
@@ -290,17 +343,16 @@ int _getParentId(const Ifc2x3::IfcProduct::ptr ifc_product) {
 	return parent_id;
 }
 
-// Returns the current IfcGeomObject*
-IfcGeomObjects::IfcGeomObject* _get() {
+IfcGeomObjects::IfcGeomShapeModelObject* create_shape_model_for_next_entity() {
 	while ( true ) {
-		Ifc2x3::IfcShapeRepresentation::ptr shaperep;
+		IfcSchema::IfcShapeRepresentation::ptr shaperep;
 
 		// Have we reached the end of our list of representations?
-		if ( outer == shapereps->end() ) {
+		if ( shaperep_iterator == shapereps->end() ) {
 			shapereps.reset();
 			return 0;
 		}
-		shaperep = *outer;
+		shaperep = *shaperep_iterator;
 
 		// Has the list of IfcProducts for this representation been initialized?
 		if ( ! entities ) {
@@ -314,11 +366,11 @@ IfcGeomObjects::IfcGeomObject* _get() {
 						continue;
 				}
 			}
-			Ifc2x3::IfcProductRepresentation::list prodreps = shaperep->OfProductRepresentation();
-			entities = Ifc2x3::IfcProduct::list( new IfcTemplatedEntityList<Ifc2x3::IfcProduct>() );
-			for ( Ifc2x3::IfcProductRepresentation::it it = prodreps->begin(); it != prodreps->end(); ++it ) {
-				if ( (*it)->is(Ifc2x3::Type::IfcProductDefinitionShape) ) {
-					Ifc2x3::IfcProductDefinitionShape::ptr pds = reinterpret_pointer_cast<Ifc2x3::IfcProductRepresentation,Ifc2x3::IfcProductDefinitionShape>(*it);
+			IfcSchema::IfcProductRepresentation::list prodreps = shaperep->OfProductRepresentation();
+			entities = IfcSchema::IfcProduct::list( new IfcTemplatedEntityList<IfcSchema::IfcProduct>() );
+			for ( IfcSchema::IfcProductRepresentation::it it = prodreps->begin(); it != prodreps->end(); ++it ) {
+				if ( (*it)->is(IfcSchema::Type::IfcProductDefinitionShape) ) {
+					IfcSchema::IfcProductDefinitionShape::ptr pds = reinterpret_pointer_cast<IfcSchema::IfcProductRepresentation,IfcSchema::IfcProductDefinitionShape>(*it);
 					entities->push(pds->ShapeOfProduct());
 				} else {
 					// http://buildingsmart-tech.org/ifc/IFC2x3/TC1/html/ifcrepresentationresource/lexical/ifcproductrepresentation.htm
@@ -327,9 +379,9 @@ IfcGeomObjects::IfcGeomObject* _get() {
 
 					// IfcProductRepresentation also lacks the INVERSE relation to IfcProduct
 					// Let's find the IfcProducts that reference the IfcProductRepresentation anyway
-					IfcEntities products = (*it)->entity->getInverse(Ifc2x3::Type::IfcProduct);
+					IfcEntities products = (*it)->entity->getInverse(IfcSchema::Type::IfcProduct);
 					for ( IfcEntityList::it it = products->begin(); it != products->end(); ++ it ) {
-						entities->push(reinterpret_pointer_cast<IfcBaseClass,Ifc2x3::IfcProduct>(*it));
+						entities->push(reinterpret_pointer_cast<IfcUtil::IfcBaseClass,IfcSchema::IfcProduct>(*it));
 					}
 				}
 			}
@@ -338,23 +390,23 @@ IfcGeomObjects::IfcGeomObject* _get() {
 				_nextShape();
 				continue;
 			}
-			inner = entities->begin();
+			ifcproduct_iterator = entities->begin();
 		}
 		// Have we reached the end of our list of IfcProducts?
-		if ( inner == entities->end() ) {
+		if ( ifcproduct_iterator == entities->end() ) {
 			_nextShape();
 			continue;
 		}
 		
-		IfcGeomObjects::IfcMesh* shape;
-		IfcGeom::ShapeList shapes;
+		IfcGeomObjects::IfcRepresentationShapeModel* shape;
+		IfcGeom::IfcRepresentationShapeItems shapes;
 
 		if ( !IfcGeom::convert_shapes(shaperep,shapes) ) {
 			_nextShape();
 			continue;
 		}
 
-		Ifc2x3::IfcProduct::ptr ifc_product = *inner;
+		IfcSchema::IfcProduct::ptr ifc_product = *ifcproduct_iterator;
 
 		int parent_id = -1;
 		try {
@@ -371,34 +423,35 @@ IfcGeomObjects::IfcGeomObject* _get() {
 
 		// Does the IfcElement have any IfcOpenings?
 		// Note that openings for IfcOpeningElements are not processed
-		Ifc2x3::IfcRelVoidsElement::list openings = Ifc2x3::IfcRelVoidsElement::list();
-		if ( ifc_product->is(Ifc2x3::Type::IfcElement) && !ifc_product->is(Ifc2x3::Type::IfcOpeningElement) ) {
-			Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcElement>(ifc_product);
+		IfcSchema::IfcRelVoidsElement::list openings = IfcSchema::IfcRelVoidsElement::list();
+		if ( ifc_product->is(IfcSchema::Type::IfcElement) && !ifc_product->is(IfcSchema::Type::IfcOpeningElement) ) {
+			IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcElement>(ifc_product);
 			openings = element->HasOpenings();
 		}
 		// Is the IfcElement a decomposition of an IfcElement with any IfcOpeningElements?
-		if ( ifc_product->is(Ifc2x3::Type::IfcBuildingElementPart ) ) {
-			Ifc2x3::IfcBuildingElementPart::ptr part = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcBuildingElementPart>(ifc_product);
-			Ifc2x3::IfcRelDecomposes::list decomposes = part->Decomposes();
-			for ( Ifc2x3::IfcRelDecomposes::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
-				Ifc2x3::IfcObjectDefinition::ptr obdef = (*it)->RelatingObject();
-				if ( obdef->is(Ifc2x3::Type::IfcElement) ) {
-					Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcObjectDefinition,Ifc2x3::IfcElement>(obdef);
+		if ( ifc_product->is(IfcSchema::Type::IfcBuildingElementPart ) ) {
+			IfcSchema::IfcBuildingElementPart::ptr part = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcBuildingElementPart>(ifc_product);
+#ifdef USE_IFC4
+			IfcSchema::IfcRelAggregates::list decomposes = part->Decomposes();
+			for ( IfcSchema::IfcRelAggregates::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
+#else
+			IfcSchema::IfcRelDecomposes::list decomposes = part->Decomposes();
+			for ( IfcSchema::IfcRelDecomposes::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
+#endif
+				IfcSchema::IfcObjectDefinition::ptr obdef = (*it)->RelatingObject();
+				if ( obdef->is(IfcSchema::Type::IfcElement) ) {
+					IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcObjectDefinition,IfcSchema::IfcElement>(obdef);
 					openings->push(element->HasOpenings());
 				}
 			}
 		}
 
 		if ( !disable_subtractions && openings && openings->Size() ) {
-			IfcGeom::ShapeList opened_shapes;
+			IfcGeom::IfcRepresentationShapeItems opened_shapes;
 			try {
 				if ( use_faster_booleans ) {
 					bool succes = IfcGeom::convert_openings_fast(ifc_product,openings,shapes,trsf,opened_shapes);
 					if ( ! succes ) {
-						for ( IfcGeom::ShapeList::const_iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
-							delete it->first;
-							delete it->second;
-						}
 						opened_shapes.clear();
 						IfcGeom::convert_openings(ifc_product,openings,shapes,trsf,opened_shapes);
 					}
@@ -409,61 +462,76 @@ IfcGeomObjects::IfcGeomObject* _get() {
 				Logger::Message(Logger::LOG_ERROR,"Error processing openings for:",ifc_product->entity); 
 			}
 			if ( use_world_coords ) {
-				for ( IfcGeom::ShapeList::const_iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
-					it->first->PreMultiply(trsf);
+				for ( IfcGeom::IfcRepresentationShapeItems::iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
+					it->prepend(trsf);
 				}
 				trsf = gp_Trsf();
 			}
-			shape = new IfcGeomObjects::IfcMesh(shaperep->entity->id(),opened_shapes);
-			for ( IfcGeom::ShapeList::const_iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
-				delete it->first;
-				delete it->second;
-			}
+			shape = new IfcGeomObjects::IfcRepresentationShapeModel(shaperep->entity->id(),opened_shapes);
 		} else if ( use_world_coords ) {
-			for ( IfcGeom::ShapeList::const_iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
-				it->first->PreMultiply(trsf);
+			for ( IfcGeom::IfcRepresentationShapeItems::iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
+				it->prepend(trsf);
 			}
 			trsf = gp_Trsf();
-			shape = new IfcGeomObjects::IfcMesh(shaperep->entity->id(),shapes);
+			shape = new IfcGeomObjects::IfcRepresentationShapeModel(shaperep->entity->id(),shapes);
 		} else {
-			shape = new IfcGeomObjects::IfcMesh(shaperep->entity->id(),shapes);
+			shape = new IfcGeomObjects::IfcRepresentationShapeModel(shaperep->entity->id(),shapes);
 		}
 
-		IfcGeomObjects::IfcGeomObject* geom_obj = new IfcGeomObjects::IfcGeomObject(ifc_product->entity->id(), parent_id, name, 
-			Ifc2x3::Type::ToString(ifc_product->type()), guid, trsf, shape);
-
-		for ( IfcGeom::ShapeList::const_iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
-			delete it->first;
-		}
-
-		return geom_obj;
+		return new IfcGeomObjects::IfcGeomShapeModelObject(ifc_product->entity->id(), parent_id, name, 
+			IfcSchema::Type::ToString(ifc_product->type()), guid, trsf, shape);
 	}	
 }
 
-bool IfcGeomObjects::Next() {
-	if ( current_geom_obj ) {
-		delete current_geom_obj->mesh;
-		delete current_geom_obj;
-	}
-	if ( entities ) {
-		++inner;
-	}
-	current_geom_obj = _get();
-	if ( ! current_geom_obj ) {
+bool try_and_create_representations_for_current_entity() {
+	current_shape_model_obj = create_shape_model_for_next_entity();
+	if (current_shape_model_obj == 0) {
 		return false;
-	} else {
-		return true;
 	}
+	
+	if (use_brep_data) {
+		current_brep_data_obj = new IfcGeomObjects::IfcGeomBrepDataObject(*current_shape_model_obj);
+		if (current_brep_data_obj == 0) {
+			return false;
+		}
+	}
+
+	if (!disable_triangulation) {
+		current_geom_obj = new IfcGeomObjects::IfcGeomObject(*current_shape_model_obj);
+		if (current_geom_obj == 0) {
+			return false;
+		}
+	}
+
+	return true;
 }
-std::vector<IfcGeomObjects::IfcObject*> returned_objects;
+
+bool IfcGeomObjects::Next() {
+	// Free all possible representations of the current geometrical entity
+	delete current_geom_obj;
+	delete current_brep_data_obj;
+	delete current_shape_model_obj;
+	current_geom_obj = 0;
+	current_brep_data_obj = 0;
+	current_shape_model_obj = 0;
+
+	// Increment the iterator over the list of products using the current
+	// shape representation
+	if (entities) {
+		++ifcproduct_iterator;
+	}
+
+	return try_and_create_representations_for_current_entity();
+}
+
+static std::vector<IfcGeomObjects::IfcObject*> returned_objects;
 bool IfcGeomObjects::CleanUp() {
 	// TODO: Correctly implement destructor for IfcFile
 	delete ifc_file;
 	IfcGeom::Cache::Purge();
-	for ( std::vector<IfcGeomObjects::IfcObject*>::const_iterator it = returned_objects.begin();
-		it != returned_objects.end(); 
-		++ it ) {
-			delete *it;			
+	std::vector<IfcGeomObjects::IfcObject*>::const_iterator it;
+	for (it = returned_objects.begin(); it != returned_objects.end(); ++ it ) {
+		delete *it;
 	}
 	returned_objects.clear();
 	return true;
@@ -472,8 +540,8 @@ const IfcGeomObjects::IfcObject* IfcGeomObjects::GetObject(int id) {
 	IfcObject* ifc_object = 0;
 	try {
 		const IfcParse::IfcEntity& ifc_entity = ifc_file->EntityById(id);
-		if ( ifc_entity->is(Ifc2x3::Type::IfcProduct) ) {
-			Ifc2x3::IfcProduct::ptr ifc_product = reinterpret_pointer_cast<IfcUtil::IfcBaseClass,Ifc2x3::IfcProduct>(ifc_entity);
+		if ( ifc_entity->is(IfcSchema::Type::IfcProduct) ) {
+			IfcSchema::IfcProduct::ptr ifc_product = reinterpret_pointer_cast<IfcUtil::IfcBaseClass,IfcSchema::IfcProduct>(ifc_entity);
 			int parent_id = -1;
 			try {
 				parent_id = _getParentId(ifc_product);
@@ -484,7 +552,7 @@ const IfcGeomObjects::IfcObject* IfcGeomObjects::GetObject(int id) {
 				IfcGeom::convert(ifc_product->ObjectPlacement(),trsf);
 			} catch (...) {}
 			ifc_object = new IfcObject(ifc_product->entity->id(),parent_id,name,
-				Ifc2x3::Type::ToString(ifc_product->type()),ifc_product->GlobalId(),trsf);
+				IfcSchema::Type::ToString(ifc_product->type()),ifc_product->GlobalId(),trsf);
 		}
 	} catch(...) {}
 	if ( !ifc_object ) ifc_object = new IfcObject(-1,-1,"","","",gp_Trsf());
@@ -492,46 +560,87 @@ const IfcGeomObjects::IfcObject* IfcGeomObjects::GetObject(int id) {
 	return ifc_object;
 }
 const IfcGeomObjects::IfcGeomObject* IfcGeomObjects::Get() {
+	if (disable_triangulation) {
+		throw std::runtime_error("No triangulation available");
+	}
 	return current_geom_obj;
 }
-double UnitPrefixToValue( Ifc2x3::IfcSIPrefix::IfcSIPrefix v ) {
-	if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_EXA   ) return (double) 1e18;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_PETA  ) return (double) 1e15;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_TERA  ) return (double) 1e12;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_GIGA  ) return (double) 1e9;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_MEGA  ) return (double) 1e6;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_KILO  ) return (double) 1e3;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_HECTO ) return (double) 1e2;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_DECA  ) return (double) 1;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_DECI  ) return (double) 1e-1;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_CENTI ) return (double) 1e-2;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_MILLI ) return (double) 1e-3;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_MICRO ) return (double) 1e-6;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_NANO  ) return (double) 1e-9;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_PICO  ) return (double) 1e-12;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_FEMTO ) return (double) 1e-15;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_ATTO  ) return (double) 1e-18;
+const IfcGeomObjects::IfcGeomShapeModelObject* IfcGeomObjects::GetShapeModel() {
+	return current_shape_model_obj;
+}
+const IfcGeomObjects::IfcGeomBrepDataObject* IfcGeomObjects::GetBrepData() {
+	if (!use_brep_data) {
+		throw std::runtime_error("No BRep data available");
+	}
+	return current_brep_data_obj;
+}
+double UnitPrefixToValue( IfcSchema::IfcSIPrefix::IfcSIPrefix v ) {
+	if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_EXA   ) return (double) 1e18;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_PETA  ) return (double) 1e15;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_TERA  ) return (double) 1e12;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_GIGA  ) return (double) 1e9;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_MEGA  ) return (double) 1e6;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_KILO  ) return (double) 1e3;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_HECTO ) return (double) 1e2;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_DECA  ) return (double) 1;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_DECI  ) return (double) 1e-1;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_CENTI ) return (double) 1e-2;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_MILLI ) return (double) 1e-3;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_MICRO ) return (double) 1e-6;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_NANO  ) return (double) 1e-9;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_PICO  ) return (double) 1e-12;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_FEMTO ) return (double) 1e-15;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_ATTO  ) return (double) 1e-18;
 	else return 1.0f;
 }
 
+void IfcGeomObjects::InitPrecision() {
+	IfcSchema::IfcGeometricRepresentationContext::list rep_contexts = ifc_file->EntitiesByType<IfcSchema::IfcGeometricRepresentationContext>();
+	// Currently, IfcGeometricRepresentationContext aren't used as much as they should be
+	// in the evaluation of shape representations, hence, we try to find the one with the
+	// lowest precision. Typically, a value of 1e-5 is encountered. This value is applied
+	// to all TopoDS_Shapes generated by one of the IfcGeom::convert() functions.
+	// TODO: Many of the empirically found tolerances should probably be substituted by
+	// one that is defined in the model file.
+	double lowest_precision_encountered = std::numeric_limits<double>::infinity();
+	bool any_precision_encountered = false;
+	for (IfcSchema::IfcGeometricRepresentationContext::it it = rep_contexts->begin(); it != rep_contexts->end(); ++it) {
+		IfcSchema::IfcGeometricRepresentationContext* rep_context = *it;
+		if (rep_context->is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) continue;
+		if (rep_context->hasPrecision()) {
+			const double precision = rep_context->Precision();
+			if (precision < lowest_precision_encountered) {
+				any_precision_encountered = true;
+				lowest_precision_encountered = precision;
+			}
+		}
+	}
+	if (any_precision_encountered) {
+		IfcGeom::SetValue(IfcGeom::GV_PRECISION, lowest_precision_encountered);
+	}
+}
+
+static std::string unit_name = "METER";
+static float unit_magnitude = 1.0f;
+
 void IfcGeomObjects::InitUnits() {
 	// Set default units, set length to meters, angles to undefined
 	IfcGeom::SetValue(IfcGeom::GV_LENGTH_UNIT,1.0);
 	IfcGeom::SetValue(IfcGeom::GV_PLANEANGLE_UNIT,-1.0);
 	
-	Ifc2x3::IfcUnitAssignment::list unit_assignments = ifc_file->EntitiesByType<Ifc2x3::IfcUnitAssignment>();
+	IfcSchema::IfcUnitAssignment::list unit_assignments = ifc_file->EntitiesByType<IfcSchema::IfcUnitAssignment>();
 	IfcUtil::IfcAbstractSelect::list units = IfcUtil::IfcAbstractSelect::list();
 	if ( unit_assignments->Size() ) {
-		Ifc2x3::IfcUnitAssignment::ptr unit_assignment = *unit_assignments->begin();
+		IfcSchema::IfcUnitAssignment::ptr unit_assignment = *unit_assignments->begin();
 		units = unit_assignment->Units();
 	}
 	if ( ! units ) {
 		// No units eh... Since tolerances and deflection are specified internally in meters
 		// we will try to find another indication of the model size.
-		Ifc2x3::IfcExtrudedAreaSolid::list extrusions = ifc_file->EntitiesByType<Ifc2x3::IfcExtrudedAreaSolid>();
+		IfcSchema::IfcExtrudedAreaSolid::list extrusions = ifc_file->EntitiesByType<IfcSchema::IfcExtrudedAreaSolid>();
 		if ( ! extrusions->Size() ) return;
 		double max_height = -1.0f;
-		for ( Ifc2x3::IfcExtrudedAreaSolid::it it = extrusions->begin(); it != extrusions->end(); ++ it ) {
+		for ( IfcSchema::IfcExtrudedAreaSolid::it it = extrusions->begin(); it != extrusions->end(); ++ it ) {
 			const double depth = (*it)->Depth();
 			if ( depth > max_height ) max_height = depth;
 		}
@@ -540,36 +649,46 @@ void IfcGeomObjects::InitUnits() {
 	}
 	try {
 		for ( IfcUtil::IfcAbstractSelect::it it = units->begin(); it != units->end(); ++ it ) {
+			std::string current_unit_name = "";
 			const IfcUtil::IfcAbstractSelect::ptr base = *it;
-			Ifc2x3::IfcSIUnit::ptr unit = Ifc2x3::IfcSIUnit::ptr();
+			IfcSchema::IfcSIUnit::ptr unit = IfcSchema::IfcSIUnit::ptr();
 			double value = 1.0f;
-			if ( base->is(Ifc2x3::Type::IfcConversionBasedUnit) ) {
-				const Ifc2x3::IfcConversionBasedUnit::ptr u = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcConversionBasedUnit>(base);
-				const Ifc2x3::IfcMeasureWithUnit::ptr u2 = u->ConversionFactor();
-				Ifc2x3::IfcUnit u3 = u2->UnitComponent();
-				if ( u3->is(Ifc2x3::Type::IfcSIUnit) ) {
-					unit = (Ifc2x3::IfcSIUnit*) u3;
+			if ( base->is(IfcSchema::Type::IfcConversionBasedUnit) ) {
+				const IfcSchema::IfcConversionBasedUnit::ptr u = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcConversionBasedUnit>(base);
+				current_unit_name = u->Name();
+				const IfcSchema::IfcMeasureWithUnit::ptr u2 = u->ConversionFactor();
+				IfcSchema::IfcUnit u3 = u2->UnitComponent();
+				if ( u3->is(IfcSchema::Type::IfcSIUnit) ) {
+					unit = (IfcSchema::IfcSIUnit*) u3;
 				}
-				Ifc2x3::IfcValue v = u2->ValueComponent();
+				IfcSchema::IfcValue v = u2->ValueComponent();
 				IfcUtil::IfcArgumentSelect* v2 = (IfcUtil::IfcArgumentSelect*) v;
 				const double f = *v2->wrappedValue();
 				value *= f;
-			} else if ( base->is(Ifc2x3::Type::IfcSIUnit) ) {
-				unit = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcSIUnit>(base);
+			} else if ( base->is(IfcSchema::Type::IfcSIUnit) ) {
+				unit = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcSIUnit>(base);
 			}
 			if ( unit ) {
 				if ( unit->hasPrefix() ) {
 					value *= UnitPrefixToValue(unit->Prefix());
 				}
-				Ifc2x3::IfcUnitEnum::IfcUnitEnum type = unit->UnitType();
-				if ( type == Ifc2x3::IfcUnitEnum::IfcUnit_LENGTHUNIT ) {
+				IfcSchema::IfcUnitEnum::IfcUnitEnum type = unit->UnitType();
+				if ( type == IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT ) {
 					IfcGeom::SetValue(IfcGeom::GV_LENGTH_UNIT,value);
-				} else if ( type == Ifc2x3::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT ) {
+					if (current_unit_name.empty()) {
+						if (unit->hasPrefix()) {
+							current_unit_name = IfcSchema::IfcSIPrefix::ToString(unit->Prefix());
+						}
+						current_unit_name += IfcSchema::IfcSIUnitName::ToString(unit->Name());
+					}
+					unit_magnitude = value;
+					unit_name = current_unit_name;
+				} else if ( type == IfcSchema::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT ) {
 					IfcGeom::SetValue(IfcGeom::GV_PLANEANGLE_UNIT,value);
 				}
 			}
 		}
-	} catch ( IfcException ex ) {
+	} catch ( IfcParse::IfcException ex ) {
 		Logger::Message(Logger::LOG_ERROR,ex.what());
 	}
 }
@@ -579,15 +698,17 @@ bool IfcGeomObjects::Init(const std::string fn) {
 }
 bool _Init() {
 	IfcGeomObjects::InitUnits();
+	IfcGeomObjects::InitPrecision();
 
-	shapereps = ifc_file->EntitiesByType<Ifc2x3::IfcShapeRepresentation>();
+	shapereps = ifc_file->EntitiesByType<IfcSchema::IfcShapeRepresentation>();
 	if ( ! shapereps ) return false;
 	
-	outer = shapereps->begin();
+	shaperep_iterator = shapereps->begin();
 	entities.reset();
-	current_geom_obj = _get();
-	
-	if ( ! current_geom_obj ) return false;
+
+	if (!try_and_create_representations_for_current_entity()) {
+		return false;
+	}
 
 	done = 0;
 	total = shapereps->Size();
@@ -637,15 +758,64 @@ void IfcGeomObjects::Settings(int setting, bool value) {
     case DISABLE_OPENING_SUBTRACTIONS:
         disable_subtractions = value;
         break;
+	case DISABLE_TRIANGULATION:
+        disable_triangulation = value;
+        break;
 	}
 }
 int IfcGeomObjects::Progress() {
 	return 100 * done / total;
 }
-std::string IfcGeomObjects::GetLog() {
+
+const std::string& IfcGeomObjects::GetUnitName() {
+	return unit_name;
+}
+
+const float IfcGeomObjects::GetUnitMagnitude() {
+	return unit_magnitude;
+}
+
+const std::string IfcGeomObjects::GetLog() {
 	return Logger::GetLog();
 }
 
 IfcParse::IfcFile* IfcGeomObjects::GetFile() {
   return ifc_file;
 }
+
+static double black[3] = {0,0,0};
+
+IfcGeomObjects::Material::Material(const IfcGeom::SurfaceStyle* style) : style(style) {}
+bool IfcGeomObjects::Material::hasDiffuse() const { return style->Diffuse(); }
+bool IfcGeomObjects::Material::hasSpecular() const { return style->Specular(); }
+bool IfcGeomObjects::Material::hasTransparency() const { return style->Transparency(); }
+bool IfcGeomObjects::Material::hasSpecularity() const { return style->Specularity(); }
+const double* IfcGeomObjects::Material::diffuse() const { if (hasDiffuse()) return &((*style->Diffuse()).R()); else return black; }
+const double* IfcGeomObjects::Material::specular() const { if (hasSpecular()) return &((*style->Specular()).R()); else return black; }
+double IfcGeomObjects::Material::transparency() const { if (hasTransparency()) return *style->Transparency(); else return 0; }
+double IfcGeomObjects::Material::specularity() const { if (hasSpecularity()) return *style->Specularity(); else return 0; }
+const std::string IfcGeomObjects::Material::name() const { return style->Name(); }
+bool IfcGeomObjects::Material::operator==(const IfcGeomObjects::Material& other) const { return style == other.style; }
+
+int IfcGeomObjects::IfcRepresentationBrepData::id() const { return _id; }
+const std::string& IfcGeomObjects::IfcRepresentationBrepData::brep_data() const { return _brep_data; }
+
+int IfcGeomObjects::IfcRepresentationTriangulation::id() const { return _id; }
+const std::vector<float>& IfcGeomObjects::IfcRepresentationTriangulation::verts() const { return _verts; }
+const std::vector<int>& IfcGeomObjects::IfcRepresentationTriangulation::faces() const { return _faces; }
+const std::vector<int>& IfcGeomObjects::IfcRepresentationTriangulation::edges() const { return _edges; }
+const std::vector<float>& IfcGeomObjects::IfcRepresentationTriangulation::normals() const { return _normals; }
+const std::vector<int>& IfcGeomObjects::IfcRepresentationTriangulation::material_ids() const { return _material_ids; }
+const std::vector<IfcGeomObjects::Material>& IfcGeomObjects::IfcRepresentationTriangulation::materials() const { return _materials; }
+
+int IfcGeomObjects::IfcObject::id() const { return _id; }
+int IfcGeomObjects::IfcObject::parent_id() const { return _parent_id; }
+const std::string& IfcGeomObjects::IfcObject::name() const { return _name; }
+const std::string& IfcGeomObjects::IfcObject::type() const { return _type; }
+const std::string& IfcGeomObjects::IfcObject::guid() const { return _guid; }
+const std::vector<float>& IfcGeomObjects::IfcObject::matrix() const { return _matrix; }
+
+const IfcGeomObjects::IfcRepresentationShapeModel& IfcGeomObjects::IfcGeomShapeModelObject::mesh() const { return *_mesh; }
+const IfcGeomObjects::IfcRepresentationTriangulation& IfcGeomObjects::IfcGeomObject::mesh() const { return *_mesh; }
+const IfcGeomObjects::IfcRepresentationBrepData& IfcGeomObjects::IfcGeomBrepDataObject::mesh() const { return *_mesh; }
+

src/ifcgeom/IfcGeomObjects.h

@@ -63,7 +63,7 @@
 #include <gp_Trsf2d.hxx>
 
 #include "../ifcparse/IfcParse.h"
-#include "../ifcgeom/IfcShapeList.h"
+#include "../ifcgeom/IfcRepresentationShapeItem.h"
 
 namespace IfcGeomObjects {
 
@@ -100,68 +100,187 @@ namespace IfcGeomObjects {
     // Disables the subtraction of IfcOpeningElement representations from
     // the related building element representations.
     const int DISABLE_OPENING_SUBTRACTIONS = 8;
+	// Disables the triangulation of the topological representations. Useful if
+	// the client application understands Open Cascade's native format.
+    const int DISABLE_TRIANGULATION = 9;
 
 	// End of settings enumeration.
 
-	// Some typedefs for convenience
-	typedef std::vector<int>::const_iterator IntIt;
-	typedef std::vector<float>::const_iterator FltIt;
-	// A nested pair of doubles to be able to store an XYZ coordinate in a map.
-	typedef std::pair< float,std::pair<float,float> > VertKey;
+	// 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 std::pair<int, std::pair<float,std::pair<float,float> > > VertKey;
 	typedef std::map<VertKey,int> VertKeyMap;
 	typedef std::pair<int,int> Edge;
 
-	class IfcMesh {
-	public:
-		int id;
-		std::vector<float> verts;
-		std::vector<int> faces;
-		std::vector<int> edges;
-		std::vector<float> normals;
-		std::string brep_data;
-		VertKeyMap welds;
-		
-		IfcMesh(int i, const IfcGeom::ShapeList& s);
+	class Material {
 	private:
-		int addvert(const gp_XYZ& p);
+		const IfcGeom::SurfaceStyle* style;
+	public:
+		explicit Material(const IfcGeom::SurfaceStyle* style);
+		// Material(const Material& other);
+		// Material& operator=(const Material& other);
+		bool hasDiffuse() const;
+		bool hasSpecular() const;
+		bool hasTransparency() const;
+		bool hasSpecularity() const;
+		const double* diffuse() const;
+		const double* specular() const;
+		double transparency() const;
+		double specularity() const;
+		const std::string name() const;
+		bool operator==(const Material& other) const;
+	};
+
+	class IfcRepresentationShapeModel {
+	private:
+		unsigned int id;
+		const IfcGeom::IfcRepresentationShapeItems shapes;
+		IfcRepresentationShapeModel(const IfcRepresentationShapeModel& other);
+		IfcRepresentationShapeModel& operator=(const IfcRepresentationShapeModel& other);
+	public:
+		IfcRepresentationShapeModel(unsigned int id, const IfcGeom::IfcRepresentationShapeItems& shapes)
+			: id(id)
+			, shapes(shapes)
+		{}
+		virtual ~IfcRepresentationShapeModel() {}
+		IfcGeom::IfcRepresentationShapeItems::const_iterator begin() const { return shapes.begin(); }
+		IfcGeom::IfcRepresentationShapeItems::const_iterator end() const { return shapes.end(); }
+		const unsigned int& getId() const { return id; }
+	};
+
+	class IfcRepresentationBrepData {
+	private:
+		int _id;
+		std::string _brep_data;
+	public:
+		int id() const;
+		const std::string& brep_data() const;
+		IfcRepresentationBrepData(const IfcRepresentationShapeModel& s);
+		virtual ~IfcRepresentationBrepData() {}
+	private:
+		IfcRepresentationBrepData();
+		IfcRepresentationBrepData(const IfcRepresentationBrepData&);
+		IfcRepresentationBrepData& operator=(const IfcRepresentationBrepData&);
+	};
+
+	class IfcRepresentationTriangulation {
+	private:
+		int _id;
+		std::vector<float> _verts;
+		std::vector<int> _faces;
+		std::vector<int> _edges;
+		std::vector<float> _normals;
+		std::vector<int> _material_ids;
+		std::vector<Material> _materials;
+		VertKeyMap welds;
+	public:
+		int id() const;
+		const std::vector<float>& verts() const;
+		const std::vector<int>& faces() const;
+		const std::vector<int>& edges() const;
+		const std::vector<float>& normals() const;
+		const std::vector<int>& material_ids() const;
+		const std::vector<Material>& materials() const;
+		IfcRepresentationTriangulation(const IfcRepresentationShapeModel& s);
+		virtual ~IfcRepresentationTriangulation() {}
+	private:
+		int addvert(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) {
 			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);
 		}
+		IfcRepresentationTriangulation();
+		IfcRepresentationTriangulation(const IfcRepresentationTriangulation&);
+		IfcRepresentationTriangulation& operator=(const IfcRepresentationTriangulation&);
 	};
 
 	class IfcObject {
+	private:
+		int _id;
+		int _parent_id;
+		std::string _name;
+		std::string _type;
+		std::string _guid;
+		std::vector<float> _matrix;
 	public:
-		int id;
-		int parent_id;
-		std::string name;
-		std::string type;
-		std::string guid;
-		std::vector<float> matrix;
-		IfcObject(int my_id, int p_id, const std::string& n, const std::string& t, const std::string& g, const gp_Trsf& trsf);
+		int id() const;
+		int parent_id() const;
+		const std::string& name() const;
+		const std::string& type() const;
+		const std::string& guid() const;
+		const std::vector<float>& matrix() const;
+		IfcObject(int id, int parent_id, const std::string& name, const std::string& type, const std::string& guid, const gp_Trsf& trsf);
+		virtual ~IfcObject() {}
+	};
+
+	class IfcGeomShapeModelObject : public IfcObject {
+	private:
+		IfcRepresentationShapeModel* _mesh;
+	public:
+		const IfcRepresentationShapeModel& mesh() const;
+		IfcGeomShapeModelObject(int id, int parent_id, const std::string& name, const std::string& type, const std::string& guid, const gp_Trsf& trsf, IfcRepresentationShapeModel* mesh);
+		virtual ~IfcGeomShapeModelObject() {
+			delete _mesh;
+		}
+	private:
+		IfcGeomShapeModelObject(const IfcGeomShapeModelObject& other);
+		IfcGeomShapeModelObject& operator=(const IfcGeomShapeModelObject& other);		
 	};
 
 	class IfcGeomObject : public IfcObject {
+	private:
+		IfcRepresentationTriangulation* _mesh;
 	public:
-		IfcMesh* mesh;
-		IfcGeomObject(int my_id, int p_id, const std::string& n, const std::string& t, const std::string& g, const gp_Trsf& trsf, IfcMesh* m);
+		const IfcRepresentationTriangulation& mesh() const;
+		IfcGeomObject(const IfcGeomShapeModelObject& shape_model);
+		virtual ~IfcGeomObject() {
+			delete _mesh;
+		}
+	private:
+		IfcGeomObject(const IfcGeomObject& other);
+		IfcGeomObject& operator=(const IfcGeomObject& other);
+	};
+
+	class IfcGeomBrepDataObject : public IfcObject {
+	private:
+		IfcRepresentationBrepData* _mesh;
+	public:
+		const IfcRepresentationBrepData& mesh() const;
+		IfcGeomBrepDataObject(const IfcGeomShapeModelObject& shape_model);
+		virtual ~IfcGeomBrepDataObject() {
+			delete _mesh;
+		}
+	private:
+		IfcGeomBrepDataObject(const IfcGeomBrepDataObject& other);
+		IfcGeomBrepDataObject& operator=(const IfcGeomBrepDataObject& other);
 	};
 
-	void InitUnits();
 	bool Init(const std::string fn);
 	bool Init(void* data, int len);
 	bool Init(const std::string fn, std::ostream* log1= 0, std::ostream* log2= 0);
 	bool Init(std::istream& f, int len, std::ostream* log1= 0, std::ostream* log2= 0);
+	
 	void Settings(int setting, bool value);
-	bool CleanUp();
+	void InitUnits();
+	void InitPrecision();
+	
 	const IfcGeomObject* Get();
-	bool Next();	
-	int Progress();
 	const IfcObject* GetObject(int id);
-	std::string GetLog();
-  IfcParse::IfcFile* GetFile();
+	const IfcGeomBrepDataObject* GetBrepData();
+	const IfcGeomShapeModelObject* GetShapeModel();
+	
+	bool Next();
+	int Progress();
+
+	const std::string& GetUnitName();
+	const float GetUnitMagnitude();
+	
+	const std::string GetLog();
+	IfcParse::IfcFile* GetFile();
+
+	bool CleanUp();
 }
 
 #endif

src/ifcgeom/IfcGeomRenderStyles.cpp

@@ -0,0 +1,161 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 <map>
+
+#include "IfcGeomRenderStyles.h"
+
+namespace IfcGeom {
+	namespace Cache {
+		std::map<int,SurfaceStyle> Style;
+		void PurgeStyleCache() {
+			Style.clear();
+		}
+	}
+}
+
+bool process_colour(IfcSchema::IfcColourRgb* colour, std::tr1::array<double, 3>& rgb) {
+	if (colour != 0) {
+		rgb[0] = colour->Red();
+		rgb[1] = colour->Green();
+		rgb[2] = colour->Blue();
+	}
+	return colour != 0;
+}
+
+bool process_colour(IfcUtil::IfcBaseEntity* factor, std::tr1::array<double, 3>& rgb) {
+	if (factor != 0) {
+		const double f = *factor->entity->getArgument(0);
+		rgb[0] = rgb[1] = rgb[2] = f;
+	}
+	return factor != 0;
+}
+
+bool process_colour(IfcSchema::IfcColourOrFactor colour_or_factor, std::tr1::array<double, 3>& rgb) {
+	if (colour_or_factor == 0) {
+		return false;
+	} else if (colour_or_factor->is(IfcSchema::Type::IfcColourRgb)) {
+		return process_colour(static_cast<IfcSchema::IfcColourRgb*>(colour_or_factor), rgb);
+	} else if (colour_or_factor->is(IfcSchema::Type::IfcNormalisedRatioMeasure)) {
+		return process_colour(static_cast<IfcUtil::IfcBaseEntity*>(colour_or_factor), rgb);
+	} else {
+		return false;
+	}
+}
+
+const IfcGeom::SurfaceStyle* IfcGeom::get_style(IfcSchema::IfcRepresentationItem* item) {
+	std::pair<IfcSchema::IfcSurfaceStyle*, IfcSchema::IfcSurfaceStyleShading*> shading_styles = get_surface_style<IfcSchema::IfcSurfaceStyleShading>(item);
+	if (shading_styles.second == 0) {
+		return 0;
+	}
+	int surface_style_id = shading_styles.first->entity->id();
+	std::map<int,SurfaceStyle>::const_iterator it = Cache::Style.find(surface_style_id);
+	if (it != Cache::Style.end()) {
+		return &(it->second);
+	}
+	SurfaceStyle surface_style;
+	if (shading_styles.first->hasName()) {
+		surface_style = SurfaceStyle(surface_style_id, shading_styles.first->Name());
+	} else {
+		surface_style = SurfaceStyle(surface_style_id);
+	}
+	std::tr1::array<double, 3> rgb;
+	if (process_colour(shading_styles.second->SurfaceColour(), rgb)) {
+		surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]));
+	}
+	if (shading_styles.second->is(IfcSchema::Type::IfcSurfaceStyleRendering)) {
+		IfcSchema::IfcSurfaceStyleRendering* rendering_style = static_cast<IfcSchema::IfcSurfaceStyleRendering*>(shading_styles.second);
+		if (rendering_style->hasDiffuseColour() && process_colour(rendering_style->DiffuseColour(), rgb)) {
+			SurfaceStyle::ColorComponent diffuse = surface_style.Diffuse().get_value_or(SurfaceStyle::ColorComponent(1,1,1));
+			surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(diffuse.R() * rgb[0], diffuse.G() * rgb[1], diffuse.B() * rgb[2]));
+		}
+		if (rendering_style->hasDiffuseTransmissionColour()) {
+			// Not supported
+		}
+		if (rendering_style->hasReflectionColour()) {
+			// Not supported
+		}
+		if (rendering_style->hasSpecularColour() && process_colour(rendering_style->SpecularColour(), rgb)) {
+			surface_style.Specular().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]));
+		}
+		if (rendering_style->hasSpecularHighlight()) {
+			// Not supported
+		}
+		if (rendering_style->hasTransmissionColour()) {
+			// Not supported
+		}
+		if (rendering_style->hasTransparency()) {
+			const double d = rendering_style->Transparency();
+			surface_style.Transparency().reset(d);
+		}
+	}
+	return &(Cache::Style[surface_style_id] = surface_style);
+}
+
+static std::map<std::string, IfcGeom::SurfaceStyle> default_materials;
+static IfcGeom::SurfaceStyle default_material;
+static bool default_materials_initialized = false;
+
+void InitDefaultMaterials() {
+	default_materials.insert(std::make_pair("IfcSite", IfcGeom::SurfaceStyle("IfcSite")));
+	default_materials["IfcSite"            ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.75, 0.8, 0.65));
+
+	default_materials.insert(std::make_pair("IfcSlab", IfcGeom::SurfaceStyle("IfcSlab")));
+	default_materials["IfcSlab"            ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.4 , 0.4, 0.4 ));
+	
+	default_materials.insert(std::make_pair("IfcWallStandardCase", IfcGeom::SurfaceStyle("IfcWallStandardCase")));
+	default_materials["IfcWallStandardCase"].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.9 , 0.9, 0.9 ));
+	
+	default_materials.insert(std::make_pair("IfcWall", IfcGeom::SurfaceStyle("IfcWall")));
+	default_materials["IfcWall"            ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.9 , 0.9, 0.9 ));
+	
+	default_materials.insert(std::make_pair("IfcWindow", IfcGeom::SurfaceStyle("IfcWindow")));
+	default_materials["IfcWindow"          ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.75, 0.8, 0.75));
+	default_materials["IfcWindow"          ].Transparency().reset(0.3);
+	
+	default_materials.insert(std::make_pair("IfcDoor", IfcGeom::SurfaceStyle("IfcDoor")));
+	default_materials["IfcDoor"            ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.55, 0.3, 0.15));
+	
+	default_materials.insert(std::make_pair("IfcBeam", IfcGeom::SurfaceStyle("IfcBeam")));
+	default_materials["IfcBeam"            ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.75, 0.7, 0.7 ));
+	
+	default_materials.insert(std::make_pair("IfcRailing", IfcGeom::SurfaceStyle("IfcRailing")));
+	default_materials["IfcRailing"         ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.65, 0.6, 0.6 ));
+	
+	default_materials.insert(std::make_pair("IfcMember", IfcGeom::SurfaceStyle("IfcMember")));
+	default_materials["IfcMember"          ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.65, 0.6, 0.6 ));
+	
+	default_materials.insert(std::make_pair("IfcPlate", IfcGeom::SurfaceStyle("IfcPlate")));
+	default_materials["IfcPlate"           ].Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.8 , 0.8, 0.8 ));
+
+	default_material = IfcGeom::SurfaceStyle("DefaultMaterial");
+	default_material.Diffuse().reset(IfcGeom::SurfaceStyle::ColorComponent(0.7, 0.7, 0.7));
+
+	default_materials_initialized = true;
+}
+
+const IfcGeom::SurfaceStyle* IfcGeom::get_default_style(const std::string& s) {
+	if (!default_materials_initialized) InitDefaultMaterials();
+	std::map<std::string, IfcGeom::SurfaceStyle>::const_iterator it = default_materials.find(s);
+	if (it == default_materials.end()) return &default_material;
+	else {
+		const IfcGeom::SurfaceStyle& surface_style = it->second;
+		return &surface_style;
+	}
+}

src/ifcgeom/IfcGeomRenderStyles.h

@@ -0,0 +1,152 @@
+/********************************************************************************
+ *                                                                              *
+ * 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 IFCGEOMRENDERSTYLES_H
+#define IFCGEOMRENDERSTYLES_H
+
+#ifdef __GNUC__
+#include <tr1/array>
+#else
+#include <array>
+#endif
+
+#ifdef USE_IFC4
+#include "../ifcparse/Ifc4.h"
+#else
+#include "../ifcparse/Ifc2x3.h"
+#endif
+
+namespace IfcGeom {
+	class SurfaceStyle {
+	public:
+		class ColorComponent {
+		private:
+			std::tr1::array<double, 3> data;
+		public:
+			ColorComponent(double r, double g, double b) {
+				data[0] = r; data[1] = g; data[2] = b;
+			}
+			const double& R() const { return data[0]; }
+			const double& G() const { return data[1]; }
+			const double& B() const { return data[2]; }
+			double& R() { return data[0]; }
+			double& G() { return data[1]; }
+			double& B() { return data[2]; }
+		};
+	private:
+		boost::optional<std::string> name;
+		boost::optional<int> id;
+		boost::optional<ColorComponent> diffuse, specular;
+		boost::optional<double> transparency;
+		boost::optional<double> specularity;
+	public:
+		SurfaceStyle() {}
+		SurfaceStyle(int id) : id(id) {}
+		SurfaceStyle(const std::string& name) : name(name) {}
+		SurfaceStyle(int id, const std::string& name) : id(id), name(name) {}
+		
+		// Not used at this point. In fact, equality testing in the current
+		// architecture can just as easily be accomplished by comparing the
+		// pointer addresses of the styles, as they are always referenced 
+		// from out of a global map of some sort.
+		bool operator==(const SurfaceStyle& other) {
+			if (name && other.name) {
+				return *name == *other.name;
+			} else if (id && other.id) {
+				return *id == *other.id;
+			} else {
+				return false;
+			}
+		}
+		
+		const std::string Name() const { 
+			if (name && id) {
+				std::stringstream sstr; 
+				sstr << (*id) << "_" << (*name);
+				return sstr.str(); 
+			} else if (name) { 
+				return *name; 
+			} else if (id) { 
+				std::stringstream sstr; 
+				sstr << "IfcSurfaceStyleShading_" << (*id); 
+				return sstr.str(); 
+			} else {
+				return "IfcSurfaceStyleShading";
+			}
+		}
+
+		const boost::optional<ColorComponent>& Diffuse() const { return diffuse; }
+		const boost::optional<ColorComponent>& Specular() const { return specular; }
+		const boost::optional<double>& Transparency() const { return transparency; }
+		const boost::optional<double>& Specularity() const { return specularity; }
+		boost::optional<ColorComponent>& Diffuse() { return diffuse; }
+		boost::optional<ColorComponent>& Specular() { return specular; }
+		boost::optional<double>& Transparency() { return transparency; }
+		boost::optional<double>& Specularity() { return specularity; }
+	};
+
+	template <typename T> std::pair<IfcSchema::IfcSurfaceStyle*, T*> get_surface_style(IfcSchema::IfcRepresentationItem* representation_item) {
+		IfcSchema::IfcStyledItem::list styled_items = representation_item->StyledByItem();
+		for (IfcSchema::IfcStyledItem::it jt = styled_items->begin(); jt != styled_items->end(); ++jt) {
+#ifdef USE_IFC4
+			IfcUtil::IfcAbstractSelect::list style_assignments = (*jt)->Styles();
+			for (IfcUtil::IfcAbstractSelect::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
+				if (!(*kt)->is(IfcSchema::Type::IfcPresentationStyleAssignment)) {
+					continue;
+				}
+				IfcSchema::IfcPresentationStyleAssignment::ptr style_assignment = (IfcSchema::IfcPresentationStyleAssignment::ptr) *kt;
+#else
+			IfcSchema::IfcPresentationStyleAssignment::list style_assignments = (*jt)->Styles();
+			for (IfcSchema::IfcPresentationStyleAssignment::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
+				IfcSchema::IfcPresentationStyleAssignment::ptr style_assignment = *kt;
+#endif
+				IfcUtil::IfcAbstractSelect::list styles = style_assignment->Styles();
+				for (IfcUtil::IfcAbstractSelect::it lt = styles->begin(); lt != styles->end(); ++lt) {
+					IfcUtil::IfcAbstractSelect::ptr style = *lt;
+					if (style->is(IfcSchema::Type::IfcSurfaceStyle)) {
+						IfcSchema::IfcSurfaceStyle* surface_style = (IfcSchema::IfcSurfaceStyle*) style;
+						if (surface_style->Side() != IfcSchema::IfcSurfaceSide::IfcSurfaceSide_NEGATIVE) {
+							IfcUtil::IfcAbstractSelect::list styles_elements = surface_style->Styles();
+							for (IfcUtil::IfcAbstractSelect::it mt = styles_elements->begin(); mt != styles_elements->end(); ++mt) {
+								if ((*mt)->is(T::Class())) {
+									return std::make_pair(surface_style, (T*) *mt);
+								}
+							}
+						}
+					}
+				}
+			}
+
+			// StyledByItem is a SET [0:1] OF IfcStyledItem, so we
+			// break after encountering the first IfcStyledItem
+			break;
+		}
+
+		return std::make_pair<IfcSchema::IfcSurfaceStyle*, T*>(0,0);
+	}
+
+	const SurfaceStyle* get_style(IfcSchema::IfcRepresentationItem* representation_item);
+	const SurfaceStyle* get_default_style(const std::string& ifc_type);
+	
+	namespace Cache {
+		void PurgeStyleCache();
+	}
+}
+
+#endif

src/ifcgeom/IfcGeomShapes.cpp

@@ -78,7 +78,7 @@
 
 #include "../ifcgeom/IfcGeom.h"
 
-bool IfcGeom::convert(const Ifc2x3::IfcExtrudedAreaSolid::ptr l, TopoDS_Shape& shape) {
+bool IfcGeom::convert(const IfcSchema::IfcExtrudedAreaSolid::ptr l, TopoDS_Shape& shape) {
 	TopoDS_Face face;
 	if ( ! IfcGeom::convert_face(l->SweptArea(),face) ) return false;
 	const double height = l->Depth() * IfcGeom::GetValue(GV_LENGTH_UNIT);
@@ -92,68 +92,74 @@ bool IfcGeom::convert(const Ifc2x3::IfcExtrudedAreaSolid::ptr l, TopoDS_Shape& s
 	shape.Move(trsf);
 	return ! shape.IsNull();
 }
-bool IfcGeom::convert(const Ifc2x3::IfcFacetedBrep::ptr l, ShapeList& shape) {
+bool IfcGeom::convert(const IfcSchema::IfcFacetedBrep::ptr l, IfcRepresentationShapeItems& shape) {
 	TopoDS_Shape s;
-	if ( const TopoDS_Shape* shape_id = IfcGeom::convert_shape(l->Outer(),s) ) {
-		shape.push_back(LocationShape(new gp_GTrsf(),shape_id));
+	if (IfcGeom::convert_shape(l->Outer(),s) ) {
+		shape.push_back(IfcRepresentationShapeItem(s, get_style(l->Outer())));
 		return true;
 	}
 	return false;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcFaceBasedSurfaceModel::ptr l, ShapeList& shapes) {
-	Ifc2x3::IfcConnectedFaceSet::list facesets = l->FbsmFaces();
-	for( Ifc2x3::IfcConnectedFaceSet::it it = facesets->begin(); it != facesets->end(); ++ it ) {
+bool IfcGeom::convert(const IfcSchema::IfcFaceBasedSurfaceModel::ptr l, IfcRepresentationShapeItems& shapes) {
+	IfcSchema::IfcConnectedFaceSet::list facesets = l->FbsmFaces();
+	const SurfaceStyle* collective_style = get_style(l);
+	for( IfcSchema::IfcConnectedFaceSet::it it = facesets->begin(); it != facesets->end(); ++ it ) {
 		TopoDS_Shape s;
-		if ( const TopoDS_Shape* shape_id = IfcGeom::convert_shape(*it,s) ) {
-			shapes.push_back(LocationShape(new gp_GTrsf(),shape_id));
+		const SurfaceStyle* shell_style = get_style(*it);
+		if (IfcGeom::convert_shape(*it,s)) {
+			shapes.push_back(IfcRepresentationShapeItem(s, shell_style ? shell_style : collective_style));
 		}
 	}
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcHalfSpaceSolid::ptr l, TopoDS_Shape& shape) {
-	Ifc2x3::IfcSurface::ptr surface = l->BaseSurface();
-	if ( ! surface->is(Ifc2x3::Type::IfcPlane) ) {
+bool IfcGeom::convert(const IfcSchema::IfcHalfSpaceSolid::ptr l, TopoDS_Shape& shape) {
+	IfcSchema::IfcSurface::ptr surface = l->BaseSurface();
+	if ( ! surface->is(IfcSchema::Type::IfcPlane) ) {
 		// Not implemented
 		return false;
 	}
 	gp_Pln pln;
-	IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcSurface,Ifc2x3::IfcPlane>(surface),pln);
+	IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcSurface,IfcSchema::IfcPlane>(surface),pln);
 	const gp_Pnt pnt = pln.Location().Translated( l->AgreementFlag() ? -pln.Axis().Direction() : pln.Axis().Direction());
 	shape = BRepPrimAPI_MakeHalfSpace(BRepBuilderAPI_MakeFace(pln),pnt).Solid();
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcPolygonalBoundedHalfSpace::ptr l, TopoDS_Shape& shape) {
+bool IfcGeom::convert(const IfcSchema::IfcPolygonalBoundedHalfSpace::ptr l, TopoDS_Shape& shape) {
 	TopoDS_Shape halfspace;
-	if ( ! IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcPolygonalBoundedHalfSpace,Ifc2x3::IfcHalfSpaceSolid>(l),halfspace) ) return false;	
+	if ( ! IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcPolygonalBoundedHalfSpace,IfcSchema::IfcHalfSpaceSolid>(l),halfspace) ) return false;	
 	TopoDS_Wire wire;
 	if ( ! IfcGeom::convert_wire(l->PolygonalBoundary(),wire) || ! wire.Closed() ) return false;	
 	gp_Trsf trsf;
 	convert(l->Position(),trsf);
 	TopoDS_Shape prism = BRepPrimAPI_MakePrism(BRepBuilderAPI_MakeFace(wire),gp_Vec(0,0,200));
 	gp_Trsf down; down.SetTranslation(gp_Vec(0,0,-100.0));
-	prism.Move(down*trsf);
+	prism.Move(trsf*down);
 	shape = BRepAlgoAPI_Common(halfspace,prism);
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcShellBasedSurfaceModel::ptr l, ShapeList& shapes) {
+bool IfcGeom::convert(const IfcSchema::IfcShellBasedSurfaceModel::ptr l, IfcRepresentationShapeItems& shapes) {
 	IfcUtil::IfcAbstractSelect::list shells = l->SbsmBoundary();
+	const SurfaceStyle* collective_style = get_style(l);
 	for( IfcUtil::IfcAbstractSelect::it it = shells->begin(); it != shells->end(); ++ it ) {
 		TopoDS_Shape s;
-		if ( const TopoDS_Shape* shape_id = IfcGeom::convert_shape(*it,s) ) {
-			shapes.push_back(LocationShape(new gp_GTrsf(),shape_id));
+		const SurfaceStyle* shell_style = 0;
+		if ((*it)->is(IfcSchema::Type::IfcRepresentationItem)) {
+			shell_style = get_style((IfcSchema::IfcRepresentationItem*)*it);
+		}
+		if (IfcGeom::convert_shape(*it,s)) {
+			shapes.push_back(IfcRepresentationShapeItem(s, shell_style ? shell_style : collective_style));
 		}
 	}
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcBooleanClippingResult::ptr l, TopoDS_Shape& shape) {
+bool IfcGeom::convert(const IfcSchema::IfcBooleanClippingResult::ptr l, TopoDS_Shape& shape) {
 	TopoDS_Shape s1, s2;
 	TopoDS_Wire boundary_wire;
-	Ifc2x3::IfcBooleanOperand operand2 = l->SecondOperand();
-	bool is_halfspace = operand2->is(Ifc2x3::Type::IfcHalfSpaceSolid);
-	bool is_bounded = operand2->is(Ifc2x3::Type::IfcPolygonalBoundedHalfSpace);
-	bool is_convex_bound = false;
+	IfcSchema::IfcBooleanOperand operand1 = l->FirstOperand();
+	IfcSchema::IfcBooleanOperand operand2 = l->SecondOperand();
+	bool is_halfspace = operand2->is(IfcSchema::Type::IfcHalfSpaceSolid);
 
-	if ( ! IfcGeom::convert_shape(l->FirstOperand(),s1) )
+	if ( ! IfcGeom::convert_shape(operand1,s1) )
 		return false;
 
 	const double first_operand_volume = shape_volume(s1);
@@ -166,13 +172,6 @@ bool IfcGeom::convert(const Ifc2x3::IfcBooleanClippingResult::ptr l, TopoDS_Shap
 		return true;
 	}
 
-	if ( is_bounded ) {
-		Ifc2x3::IfcPolygonalBoundedHalfSpace::ptr ifc_bounded_halfspace = 
-			(Ifc2x3::IfcPolygonalBoundedHalfSpace::ptr) operand2;		
-		IfcGeom::convert_wire(ifc_bounded_halfspace->PolygonalBoundary(),boundary_wire);
-		is_convex_bound = is_convex(boundary_wire);
-	}
-
 	if ( ! is_halfspace ) {
 		const double second_operand_volume = shape_volume(s2);
 		if ( second_operand_volume <= ALMOST_ZERO )
@@ -180,102 +179,19 @@ bool IfcGeom::convert(const Ifc2x3::IfcBooleanClippingResult::ptr l, TopoDS_Shap
 	}
 
 	bool valid_cut = false;
-	if ( !is_bounded || !is_convex_bound ) {
-		BRepAlgoAPI_Cut brep_cut(s1,s2);
-		if ( brep_cut.IsDone() ) {
-			TopoDS_Shape result = brep_cut;
-			bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
-			if ( is_valid ) {
-				shape = result;
-				valid_cut = true;
-			} 
-		}
-		if ( !valid_cut && !is_bounded ) {
-			Ifc2x3::IfcHalfSpaceSolid::ptr ifc_halfspace = (Ifc2x3::IfcHalfSpaceSolid::ptr) operand2;
-			Ifc2x3::IfcSurface::ptr surface = ifc_halfspace->BaseSurface();
-			if ( surface->is(Ifc2x3::Type::IfcPlane) ) {
-				gp_Pln pln;
-				IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcSurface,Ifc2x3::IfcPlane>(surface),pln);
-				gp_Pnt pnt = pln.Location();
-				bool reverse = ifc_halfspace->AgreementFlag();
-				gp_Vec direction = pln.Axis().Direction();
-				if ( reverse ) direction *= -1;
-				pnt.Translate(direction);
-				pln.SetLocation(pln.Location().Translated(direction * -0.0001));
-				TopoDS_Shape halfspace = BRepPrimAPI_MakeHalfSpace(BRepBuilderAPI_MakeFace(pln),pnt).Solid();
+	BRepAlgoAPI_Cut brep_cut(s1,s2);
+	if ( brep_cut.IsDone() ) {
+		TopoDS_Shape result = brep_cut;
 
-				BRepAlgoAPI_Cut brep_cut(s1,halfspace);
-				if ( brep_cut.IsDone() ) {
-					TopoDS_Shape result = brep_cut;
-					bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
-					if ( is_valid ) {
-						shape = result;
-						valid_cut = true;
-						Logger::Message(Logger::LOG_WARNING,"Slightly nudged the SecondOperand of:",l->entity);
-					} 
-				}
-			}
-		}
-	} else {
-		Ifc2x3::IfcPolygonalBoundedHalfSpace::ptr ifc_bounded_halfspace = 
-			(Ifc2x3::IfcPolygonalBoundedHalfSpace::ptr) operand2;
-		gp_Trsf trsf;
-		convert(ifc_bounded_halfspace->Position(),trsf);
-		TopoDS_Shape face = BRepBuilderAPI_MakeFace(boundary_wire).Face();
-		TopoDS_Shape prism = BRepPrimAPI_MakePrism (boundary_wire,gp_Vec(0,0,1),1);
-		prism.Move(trsf);
-		face.Move(trsf);
-
-		gp_Pln pln = plane_from_face(TopoDS::Face(face));
-		gp_Pnt pnt = point_above_plane(pln,ifc_bounded_halfspace->AgreementFlag());
-
-		TopoDS_Shape halfspace;
-		Ifc2x3::IfcHalfSpaceSolid::ptr ifc_halfspace = (Ifc2x3::IfcHalfSpaceSolid::ptr) operand2;
-		if ( ! IfcGeom::convert(ifc_halfspace,halfspace) ) return false;
-
-		TopoDS_Shape subtraction_volume = s1;
-		double subtraction_volume_volume = shape_volume(subtraction_volume);
-
-		const double minimal_substraction_difference = subtraction_volume_volume * 0.0001;
-
-		BRepAlgoAPI_Common brep_common(subtraction_volume,halfspace);
-		if ( brep_common.IsDone() ) {
-			TopoDS_Shape brep_common_shape = brep_common;
-			bool is_valid = BRepCheck_Analyzer(brep_common_shape).IsValid() != 0;
-			double new_subtraction_volume_volume = shape_volume(brep_common_shape);
-			double subtraction_volume_difference = subtraction_volume_volume - new_subtraction_volume_volume;
-			if ( is_valid && subtraction_volume_difference > minimal_substraction_difference ) {
-				subtraction_volume = brep_common_shape;
-				subtraction_volume_volume = new_subtraction_volume_volume;
-			}
-		}
-
-		TopExp_Explorer exp(prism,TopAbs_FACE);
-		while ( exp.More() ) {
-			TopoDS_Shape halfspace = halfspace_from_plane(plane_from_face(TopoDS::Face(exp.Current())),pnt);
-			BRepAlgoAPI_Common brep_common(subtraction_volume,halfspace);
-			if ( brep_common.IsDone() ) {
-				TopoDS_Shape brep_common_shape = brep_common;
-				bool is_valid = BRepCheck_Analyzer(brep_common_shape).IsValid() != 0;
-				double new_subtraction_volume_volume = shape_volume(brep_common_shape);
-				double subtraction_volume_difference = subtraction_volume_volume - new_subtraction_volume_volume;
-				if ( is_valid && subtraction_volume_difference > minimal_substraction_difference ) {
-					subtraction_volume = brep_common_shape;
-					subtraction_volume_volume = new_subtraction_volume_volume;
-				}
-			}
-			exp.Next();
-		}
-
-		BRepAlgoAPI_Cut brep_cut(s1,subtraction_volume);
-		if ( brep_cut.IsDone() ) {
-			TopoDS_Shape result = brep_cut;
-			bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
-			if ( is_valid ) {
-				shape = result;
-				valid_cut = true;
-			} 
-		}
+		ShapeFix_Shape fix(result);
+		fix.Perform();
+		result = fix.Shape();
+		
+		bool is_valid = BRepCheck_Analyzer(result).IsValid() != 0;
+		if ( is_valid ) {
+			shape = result;
+			valid_cut = true;
+		} 
 	}
 
 	if ( valid_cut ) {
@@ -288,10 +204,9 @@ bool IfcGeom::convert(const Ifc2x3::IfcBooleanClippingResult::ptr l, TopoDS_Shap
 	}
 
 	return true;
-
 }
-bool IfcGeom::convert(const Ifc2x3::IfcConnectedFaceSet::ptr l, TopoDS_Shape& shape) {
-	Ifc2x3::IfcFace::list faces = l->CfsFaces();
+bool IfcGeom::convert(const IfcSchema::IfcConnectedFaceSet::ptr l, TopoDS_Shape& shape) {
+	IfcSchema::IfcFace::list faces = l->CfsFaces();
 	bool facesAdded = false;
 	const unsigned int num_faces = faces->Size();
 	if ( num_faces < GetValue(GV_MAX_FACES_TO_SEW) ) {
@@ -299,7 +214,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcConnectedFaceSet::ptr l, TopoDS_Shape& sh
 		builder.SetTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
 		builder.SetMaxTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
 		builder.SetMinTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
-		for( Ifc2x3::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
+		for( IfcSchema::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
 			TopoDS_Face face;
 			if ( IfcGeom::convert_face(*it,face) && face_area(face) > GetValue(GV_MINIMAL_FACE_AREA) ) {
 				builder.Add(face);
@@ -320,7 +235,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcConnectedFaceSet::ptr l, TopoDS_Shape& sh
 		TopoDS_Compound compound;
 		BRep_Builder builder;
 		builder.MakeCompound(compound);
-		for( Ifc2x3::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
+		for( IfcSchema::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
 			TopoDS_Face face;
 			if ( IfcGeom::convert_face(*it,face) && face_area(face) > GetValue(GV_MINIMAL_FACE_AREA) ) {
 				builder.Add(compound,face);
@@ -334,52 +249,55 @@ bool IfcGeom::convert(const Ifc2x3::IfcConnectedFaceSet::ptr l, TopoDS_Shape& sh
 	}
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcMappedItem::ptr l, ShapeList& shapes) {
+bool IfcGeom::convert(const IfcSchema::IfcMappedItem::ptr l, IfcRepresentationShapeItems& shapes) {
 	gp_GTrsf gtrsf;
-	Ifc2x3::IfcCartesianTransformationOperator::ptr transform = l->MappingTarget();
-	if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator3DnonUniform) ) {
-		IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcCartesianTransformationOperator,
-			Ifc2x3::IfcCartesianTransformationOperator3DnonUniform>(transform),gtrsf);
-	} else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator2DnonUniform) ) {
+	IfcSchema::IfcCartesianTransformationOperator::ptr transform = l->MappingTarget();
+	if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3DnonUniform) ) {
+		IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcCartesianTransformationOperator,
+			IfcSchema::IfcCartesianTransformationOperator3DnonUniform>(transform),gtrsf);
+	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform) ) {
 		return false;
-	} else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator3D) ) {
+	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3D) ) {
 		gp_Trsf trsf;
-		IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcCartesianTransformationOperator,
-			Ifc2x3::IfcCartesianTransformationOperator3D>(transform),trsf);
+		IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcCartesianTransformationOperator,
+			IfcSchema::IfcCartesianTransformationOperator3D>(transform),trsf);
 		gtrsf = trsf;
-	} else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator2D) ) {
+	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2D) ) {
 		gp_Trsf2d trsf_2d;
-		IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcCartesianTransformationOperator,
-			Ifc2x3::IfcCartesianTransformationOperator2D>(transform),trsf_2d);
+		IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcCartesianTransformationOperator,
+			IfcSchema::IfcCartesianTransformationOperator2D>(transform),trsf_2d);
 		gtrsf = (gp_Trsf) trsf_2d;
 	}
-	Ifc2x3::IfcRepresentationMap::ptr map = l->MappingSource();
-	Ifc2x3::IfcAxis2Placement placement = map->MappingOrigin();
+	IfcSchema::IfcRepresentationMap::ptr map = l->MappingSource();
+	IfcSchema::IfcAxis2Placement placement = map->MappingOrigin();
 	gp_Trsf trsf;
-	if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) {
-		IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)placement,trsf);
+	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
+		IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf_2d;
-		IfcGeom::convert((Ifc2x3::IfcAxis2Placement2D*)placement,trsf_2d);
+		IfcGeom::convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf_2d);
 		trsf = trsf_2d;
 	}
 	gtrsf.Multiply(trsf);
 	const unsigned int previous_size = (const unsigned int) shapes.size();
 	bool b = IfcGeom::convert_shapes(map->MappedRepresentation(),shapes);
 	for ( unsigned int i = previous_size; i < shapes.size(); ++ i ) {
-		shapes[i].first->Multiply(gtrsf);
+		shapes[i].append(gtrsf);
 	}
 	return b;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcShapeRepresentation::ptr l, ShapeList& shapes) {
-	Ifc2x3::IfcRepresentationItem::list items = l->Items();
+
+bool IfcGeom::convert(const IfcSchema::IfcShapeRepresentation::ptr l, IfcRepresentationShapeItems& shapes) {
+	IfcSchema::IfcRepresentationItem::list items = l->Items();
 	if ( ! items->Size() ) return false;
-	for ( Ifc2x3::IfcRepresentationItem::it it = items->begin(); it != items->end(); ++ it ) {
-		if ( IfcGeom::is_shape_collection(*it) ) IfcGeom::convert_shapes(*it,shapes);
+	for ( IfcSchema::IfcRepresentationItem::it it = items->begin(); it != items->end(); ++ it ) {
+		IfcSchema::IfcRepresentationItem* representation_item = *it;
+		if ( IfcGeom::is_shape_collection(representation_item) ) IfcGeom::convert_shapes(*it,shapes);
 		else {
 			TopoDS_Shape s;
-			if ( const TopoDS_Shape* shape_id = IfcGeom::convert_shape(*it,s))
-				shapes.push_back(LocationShape(new gp_GTrsf(),shape_id));
+			if (IfcGeom::convert_shape(representation_item,s)) {
+				shapes.push_back(IfcRepresentationShapeItem(s, get_style(representation_item)));
+			}
 		}
 	}
 	return true;

src/ifcgeom/IfcGeomWires.cpp

@@ -82,7 +82,7 @@
 
 #include "../ifcgeom/IfcGeom.h"
 
-bool IfcGeom::convert(const Ifc2x3::IfcCompositeCurve::ptr l, TopoDS_Wire& wire) {
+bool IfcGeom::convert(const IfcSchema::IfcCompositeCurve::ptr l, TopoDS_Wire& wire) {
 	if ( IfcGeom::GetValue(GV_PLANEANGLE_UNIT)<0 ) {
 		Logger::Message(Logger::LOG_WARNING,"Creating a composite curve without unit information:",l->entity);
 
@@ -107,7 +107,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCompositeCurve::ptr l, TopoDS_Wire& wire)
         } catch (...) {}
 
 		// Restore to unknown unit state
-		//IfcGeom::SetValue(GV_PLANEANGLE_UNIT,-1.0);
+		IfcGeom::SetValue(GV_PLANEANGLE_UNIT,-1.0);
 
 		if ( succes_degrees && ! succes_radians ) {
 			use_degrees = true;
@@ -135,12 +135,14 @@ bool IfcGeom::convert(const Ifc2x3::IfcCompositeCurve::ptr l, TopoDS_Wire& wire)
 			Logger::Message(Logger::LOG_NOTICE,"Used degrees to create composite curve");
             wire = wire_degrees;
 		}
+
+		return use_radians || use_degrees;
 	}
-	Ifc2x3::IfcCompositeCurveSegment::list segments = l->Segments();
+	IfcSchema::IfcCompositeCurveSegment::list segments = l->Segments();
 	BRepBuilderAPI_MakeWire w;
 	//TopoDS_Vertex last_vertex;
-	for( Ifc2x3::IfcCompositeCurveSegment::it it = segments->begin(); it != segments->end(); ++ it ) {
-		const Ifc2x3::IfcCurve::ptr curve = (*it)->ParentCurve();
+	for( IfcSchema::IfcCompositeCurveSegment::it it = segments->begin(); it != segments->end(); ++ it ) {
+		const IfcSchema::IfcCurve::ptr curve = (*it)->ParentCurve();
 		TopoDS_Wire wire2;
 		if ( ! IfcGeom::convert_wire(curve,wire2) ) {
 			Logger::Message(Logger::LOG_ERROR,"Failed to convert curve:",curve->entity);
@@ -169,13 +171,13 @@ bool IfcGeom::convert(const Ifc2x3::IfcCompositeCurve::ptr l, TopoDS_Wire& wire)
 	wire = w.Wire();
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
-	Ifc2x3::IfcCurve::ptr basis_curve = l->BasisCurve();
-	bool isConic = basis_curve->is(Ifc2x3::Type::IfcConic);
+bool IfcGeom::convert(const IfcSchema::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
+	IfcSchema::IfcCurve::ptr basis_curve = l->BasisCurve();
+	bool isConic = basis_curve->is(IfcSchema::Type::IfcConic);
 	double parameterFactor = isConic ? IfcGeom::GetValue(GV_PLANEANGLE_UNIT) : IfcGeom::GetValue(GV_LENGTH_UNIT);
 	Handle(Geom_Curve) curve;
 	if ( ! IfcGeom::convert_curve(basis_curve,curve) ) return false;
-	bool trim_cartesian = l->MasterRepresentation() == Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN;
+	bool trim_cartesian = l->MasterRepresentation() == IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN;
 	IfcUtil::IfcAbstractSelect::list trims1 = l->Trim1();
 	IfcUtil::IfcAbstractSelect::list trims2 = l->Trim2();
 	bool trimmed1 = false;
@@ -188,22 +190,22 @@ bool IfcGeom::convert(const Ifc2x3::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
 	BRepBuilderAPI_MakeWire w;
 	for ( IfcUtil::IfcAbstractSelect::it it = trims1->begin(); it != trims1->end(); it ++ ) {
 		const IfcUtil::IfcAbstractSelect::ptr i = *it;
-		if ( i->is(Ifc2x3::Type::IfcCartesianPoint) ) {
-			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcCartesianPoint>(i), pnts[sense_agreement] );
+		if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) {
+			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcCartesianPoint>(i), pnts[sense_agreement] );
 			has_pnts[sense_agreement] = true;
-		} else if ( i->is(Ifc2x3::Type::IfcParameterValue) ) {
-			const double value = *reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcUtil::IfcArgumentSelect>(i)->wrappedValue();
+		} else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
+			const double value = *((IfcUtil::IfcBaseEntity*)i)->entity->getArgument(0);
 			flts[sense_agreement] = value * parameterFactor;
 			has_flts[sense_agreement] = true;
 		}
 	}
 	for ( IfcUtil::IfcAbstractSelect::it it = trims2->begin(); it != trims2->end(); it ++ ) {
 		const IfcUtil::IfcAbstractSelect::ptr i = *it;
-		if ( i->is(Ifc2x3::Type::IfcCartesianPoint) ) {
-			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcCartesianPoint>(i), pnts[1-sense_agreement] );
+		if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) {
+			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcCartesianPoint>(i), pnts[1-sense_agreement] );
 			has_pnts[1-sense_agreement] = true;
-		} else if ( i->is(Ifc2x3::Type::IfcParameterValue) ) {
-			const double value = *reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcUtil::IfcArgumentSelect>(i)->wrappedValue();
+		} else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
+			const double value = *((IfcUtil::IfcBaseEntity*)i)->entity->getArgument(0);
 			flts[1-sense_agreement] = value * parameterFactor;
 			has_flts[1-sense_agreement] = true;
 		}
@@ -232,6 +234,15 @@ bool IfcGeom::convert(const Ifc2x3::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
 		}
 	}
 	if ( (!trim_cartesian || trim_cartesian_failed) && (has_flts[0] && has_flts[1]) ) {
+		// The Geom_Line is constructed from a gp_Pnt and gp_Dir, whereas the IfcLine
+		// is defined by an IfcCartesianPoint and an IfcVector with Magnitude. Because
+		// the vector is normalised when passed to Geom_Line constructor the magnitude
+		// needs to be factored in with the IfcParameterValue here.
+		if ( basis_curve->is(IfcSchema::Type::IfcLine) ) {
+			IfcSchema::IfcLine* line = static_cast<IfcSchema::IfcLine*>(basis_curve);
+			const double magnitude = line->Dir()->Magnitude();
+			flts[0] *= magnitude; flts[1] *= magnitude;
+		}
 		if ( isConic && ALMOST_THE_SAME(fmod(flts[1]-flts[0],(double)(M_PI*2.0)),0.0f) ) {
 			w.Add(BRepBuilderAPI_MakeEdge(curve));
 		} else {
@@ -248,12 +259,12 @@ bool IfcGeom::convert(const Ifc2x3::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
 		return false;
 	}
 }
-bool IfcGeom::convert(const Ifc2x3::IfcPolyline::ptr l, TopoDS_Wire& result) {
-	Ifc2x3::IfcCartesianPoint::list points = l->Points();
+bool IfcGeom::convert(const IfcSchema::IfcPolyline::ptr l, TopoDS_Wire& result) {
+	IfcSchema::IfcCartesianPoint::list points = l->Points();
 
 	BRepBuilderAPI_MakeWire w;
 	gp_Pnt P1;gp_Pnt P2;
-	for( Ifc2x3::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) {
+	for( IfcSchema::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) {
 		IfcGeom::convert(*it,P2);
 		if ( it != points->begin() && ( !P1.IsEqual(P2,GetValue(GV_POINT_EQUALITY_TOLERANCE)) ) )
 			w.Add(BRepBuilderAPI_MakeEdge(P1,P2));
@@ -263,13 +274,13 @@ bool IfcGeom::convert(const Ifc2x3::IfcPolyline::ptr l, TopoDS_Wire& result) {
 	result = w.Wire();
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcPolyLoop::ptr l, TopoDS_Wire& result) {
-	Ifc2x3::IfcCartesianPoint::list points = l->Polygon();
+bool IfcGeom::convert(const IfcSchema::IfcPolyLoop::ptr l, TopoDS_Wire& result) {
+	IfcSchema::IfcCartesianPoint::list points = l->Polygon();
 
 	BRepBuilderAPI_MakeWire w;
 	gp_Pnt P1;gp_Pnt P2;gp_Pnt F;
 	int count = 0;
-	for( Ifc2x3::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) {
+	for( IfcSchema::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) {
 		IfcGeom::convert(*it,P2);
 		if ( it != points->begin() && ( !P1.IsEqual(P2,GetValue(GV_POINT_EQUALITY_TOLERANCE)) ) ) {
 			w.Add(BRepBuilderAPI_MakeEdge(P1,P2));

src/ifcgeom/IfcRegister.cpp

@@ -28,10 +28,10 @@ namespace IfcGeom {
 	}
 }
 
-using namespace Ifc2x3;
+using namespace IfcSchema;
 using namespace IfcUtil;
 
-bool IfcGeom::convert_shapes(const IfcBaseClass* l, ShapeList& r) {
+bool IfcGeom::convert_shapes(const IfcBaseClass* l, IfcRepresentationShapeItems& r) {
 #include "IfcRegisterConvertShapes.h"
 	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
 	return false;
@@ -40,13 +40,21 @@ bool IfcGeom::is_shape_collection(const IfcBaseClass* l) {
 #include "IfcRegisterIsShapeCollection.h"
 	return false;
 }
-const TopoDS_Shape* IfcGeom::convert_shape(const IfcBaseClass* l, TopoDS_Shape& r) {
+bool IfcGeom::convert_shape(const IfcBaseClass* l, TopoDS_Shape& r) {
 	const unsigned int id = l->entity->id();
+	bool success = false;
+	bool processed = false;
 	std::map<int,TopoDS_Shape>::const_iterator it = Cache::Shape.find(id);
-	if ( it != Cache::Shape.end() ) { r = it->second; return &(it->second); }
+	if ( it != Cache::Shape.end() ) { r = it->second; return true; }
 #include "IfcRegisterConvertShape.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
-	return 0;
+	if ( processed ) { 
+		const double precision = IfcGeom::GetValue(GV_PRECISION);
+		IfcGeom::apply_tolerance(r, precision);
+		Cache::Shape[id] = r;
+	} else {
+		Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	}
+	return success;
 }
 bool IfcGeom::convert_wire(const IfcBaseClass* l, TopoDS_Wire& r) {
 #include "IfcRegisterConvertWire.h"

src/ifcgeom/IfcRegister.h

@@ -41,7 +41,7 @@
 #include "../ifcparse/IfcUtil.h"
 #include "../ifcparse/IfcParse.h"
 
-using namespace Ifc2x3;
+using namespace IfcSchema;
 
 SHAPES(IfcShellBasedSurfaceModel);
 SHAPES(IfcFaceBasedSurfaceModel);

src/ifcgeom/IfcRegisterConvertShape.h

@@ -1,14 +1,16 @@
 #include "IfcRegisterUndef.h"
 #define SHAPE(T) \
-	if ( l->is(T::Class()) ) { \
+	if ( !processed && l->is(T::Class()) ) { \
+		processed = true; \
 		try { \
 			if ( convert((T*)l,r) ) { \
-				Cache::Shape[id] = r; \
-				return &(Cache::Shape[id]); \
+				success = true; \
 			} \
 		} catch(...) {  } \
-		Logger::Message(Logger::LOG_ERROR,"Failed to convert:",l->entity); \
-		return 0; \
+		if ( !success) { \
+			Logger::Message(Logger::LOG_ERROR,"Failed to convert:",l->entity); \
+			return false; \
+		} \
 	}
 #include "IfcRegisterDef.h"
 

src/ifcgeom/IfcRegisterGeomHeader.h

@@ -1,6 +1,6 @@
 #include "IfcRegisterUndef.h"
 #define CLASS(T,V) bool convert(const T::ptr L, V& r);
-#define SHAPES(T) CLASS(T,ShapeList)
+#define SHAPES(T) CLASS(T,IfcRepresentationShapeItems)
 #define SHAPE(T) CLASS(T,TopoDS_Shape)
 #define WIRE(T) CLASS(T,TopoDS_Wire)
 #define FACE(T) CLASS(T,TopoDS_Face)

src/ifcgeom/IfcRepresentationShapeItem.h

@@ -0,0 +1,52 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/IfcGeomRenderStyles.h"
+
+namespace IfcGeom {	
+	class IfcRepresentationShapeItem {
+	private:
+		gp_GTrsf placement;
+		TopoDS_Shape shape;
+		const SurfaceStyle* style;
+	public:
+		IfcRepresentationShapeItem(const gp_GTrsf& placement, const TopoDS_Shape& shape, const SurfaceStyle* style)
+			: placement(placement), shape(shape), style(style) {}
+		IfcRepresentationShapeItem(const gp_GTrsf& placement, const TopoDS_Shape& shape)
+			: placement(placement), shape(shape), style(0) {}
+		IfcRepresentationShapeItem(const TopoDS_Shape& shape, const SurfaceStyle* style)
+			: shape(shape), style(style) {}
+		IfcRepresentationShapeItem(const TopoDS_Shape& shape)
+			: 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 != 0; }
+		const SurfaceStyle& Style() const { return *style; }
+	};
+	typedef std::vector<IfcRepresentationShapeItem> IfcRepresentationShapeItems;
+}
+#endif