*** See: https://sourceforge.net/p/ifcopenshell/discussion/1782718/thread/6bd0f843/ ***

Massive refactor of the IfcGeomObjects module, which is now the IfcGeom::Iterator class.

src/ifcconvert/ColladaSerializer.cpp

@@ -35,7 +35,7 @@ std::string collada_id(const std::string& s) {
 	return id;
 }
 
-void ColladaSerializer::ColladaExporter::ColladaGeometries::addFloatSource(const std::string& mesh_id, const std::string& suffix, const std::vector<float>& floats, const char* coords /* = "XYZ" */) {
+void ColladaSerializer::ColladaExporter::ColladaGeometries::addFloatSource(const std::string& mesh_id, const std::string& suffix, const std::vector<double>& floats, const char* coords /* = "XYZ" */) {
 	COLLADASW::FloatSource source(mSW);
 	source.setId(mesh_id + suffix);
 	source.setArrayId(mesh_id + suffix + COLLADASW::LibraryGeometries::ARRAY_ID_SUFFIX);
@@ -45,13 +45,18 @@ void ColladaSerializer::ColladaExporter::ColladaGeometries::addFloatSource(const
 		source.getParameterNameList().push_back(std::string(1, coords[i]));
 	}
 	source.prepareToAppendValues();
-	for (std::vector<float>::const_iterator it = floats.begin(); it != floats.end(); ++it) {
+	for (std::vector<double>::const_iterator it = floats.begin(); it != floats.end(); ++it) {
 		source.appendValues(*it);
 	}
 	source.finish();
 }
 			
-void ColladaSerializer::ColladaExporter::ColladaGeometries::write(const std::string mesh_id, const std::string& default_material_name, const std::vector<float>& positions, const std::vector<float>& normals, const std::vector<int>& indices, const std::vector<int> material_ids, const std::vector<IfcGeomObjects::Material>& materials) {
+void ColladaSerializer::ColladaExporter::ColladaGeometries::write(const std::string mesh_id, const std::string& default_material_name, const std::vector<double>& positions, const std::vector<double>& normals, const std::vector<int>& indices, const std::vector<int> material_ids, const std::vector<IfcGeom::Material>& materials) {
+	// The goal of the IfcGeom::Iterator is to filter out empty geometries, but
+	// since this function would crash trying to deference the material_ids in
+	// that case, a hard return statement is added just in case.
+	if (indices.empty()) return;
+
 	openMesh(mesh_id);
 
 	// The normals vector can be empty for example when the WELD_VERTICES setting is used.
@@ -70,17 +75,13 @@ void ColladaSerializer::ColladaExporter::ColladaGeometries::write(const std::str
 	
 	std::vector<int>::const_iterator index_range_start = indices.begin();
 	std::vector<int>::const_iterator material_it = material_ids.begin();
-	int previous_material_id = -2;
+	int previous_material_id = -1;
 	for (std::vector<int>::const_iterator it = indices.begin(); ; it += 3) {
-		const int current_material_id = material_it == material_ids.end()
-			? -3
-			: *(material_it++);
+		const int current_material_id = *(material_it++);
 		const int num_triangles = std::distance(index_range_start, it) / 3;
 		if ((previous_material_id != current_material_id && num_triangles > 0) || (it == indices.end())) {
 			COLLADASW::Triangles triangles(mSW);
-			triangles.setMaterial(collada_id(previous_material_id < 0
-				? default_material_name
-				: materials[previous_material_id].name()));
+			triangles.setMaterial(materials[previous_material_id].name());
 			triangles.setCount(num_triangles);
 			int offset = 0;
 			triangles.getInputList().push_back(COLLADASW::Input(COLLADASW::InputSemantic::VERTEX,"#" + mesh_id + COLLADASW::LibraryGeometries::VERTICES_ID_SUFFIX, offset++ ) );
@@ -113,7 +114,7 @@ void ColladaSerializer::ColladaExporter::ColladaGeometries::close() {
 	closeLibrary();
 }
 			
-void ColladaSerializer::ColladaExporter::ColladaScene::add(const std::string& node_id, const std::string& node_name, const std::string& geom_name, const std::vector<std::string>& material_ids, const std::vector<float>& matrix) {
+void ColladaSerializer::ColladaExporter::ColladaScene::add(const std::string& node_id, const std::string& node_name, const std::string& geom_name, const std::vector<std::string>& material_ids, const std::vector<double>& matrix) {
 	if (!scene_opened) {
 		openVisualScene(scene_id);
 		scene_opened = true;
@@ -155,7 +156,7 @@ void ColladaSerializer::ColladaExporter::ColladaScene::write() {
 	}
 }
 		
-void ColladaSerializer::ColladaExporter::ColladaMaterials::ColladaEffects::write(const IfcGeomObjects::Material& material) {
+void ColladaSerializer::ColladaExporter::ColladaMaterials::ColladaEffects::write(const IfcGeom::Material& material) {
 	openEffect(collada_id(material.name()) + "-fx");
 	COLLADASW::EffectProfile effect(mSW);
 	effect.setShaderType(COLLADASW::EffectProfile::LAMBERT);
@@ -186,20 +187,20 @@ void ColladaSerializer::ColladaExporter::ColladaMaterials::ColladaEffects::close
 	closeLibrary();
 }
 			
-void ColladaSerializer::ColladaExporter::ColladaMaterials::add(const IfcGeomObjects::Material& material) {
+void ColladaSerializer::ColladaExporter::ColladaMaterials::add(const IfcGeom::Material& material) {
 	if (!contains(material)) {
 		effects.write(material);
 		materials.push_back(material);
 	}
 }
 
-bool ColladaSerializer::ColladaExporter::ColladaMaterials::contains(const IfcGeomObjects::Material& material) {
+bool ColladaSerializer::ColladaExporter::ColladaMaterials::contains(const IfcGeom::Material& material) {
 	return std::find(materials.begin(), materials.end(), material) != materials.end();
 }
 
 void ColladaSerializer::ColladaExporter::ColladaMaterials::write() {
 	effects.close();
-	for (std::vector<IfcGeomObjects::Material>::const_iterator it = materials.begin(); it != materials.end(); ++it) {
+	for (std::vector<IfcGeom::Material>::const_iterator it = materials.begin(); it != materials.end(); ++it) {
 		const std::string& material_name = collada_id((*it).name());
 		openMaterial(material_name);
 		addInstanceEffect("#" + material_name + "-fx");
@@ -218,18 +219,10 @@ void ColladaSerializer::ColladaExporter::startDocument(const std::string& unit_n
 	asset.add();
 }
 
-void ColladaSerializer::ColladaExporter::writeTesselated(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<float>& matrix, const std::vector<float>& vertices, const std::vector<float>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, const std::vector<IfcGeomObjects::Material>& _materials) {
-	const IfcGeomObjects::Material default_for_type = IfcGeomObjects::Material(IfcGeom::get_default_style(type));
+void ColladaSerializer::ColladaExporter::write(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<double>& matrix, const std::vector<double>& vertices, const std::vector<double>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, const std::vector<IfcGeom::Material>& _materials) {
 	std::vector<std::string> material_references;
-	const bool needs_default = std::find(material_ids.begin(), material_ids.end(), -1) != material_ids.end();
-	if (needs_default) {
-		if (!materials.contains(default_for_type)) {
-			materials.add(default_for_type);
-		}
-		material_references.push_back(collada_id(default_for_type.name()));
-	}	
-	for (std::vector<IfcGeomObjects::Material>::const_iterator it = _materials.begin(); it != _materials.end(); ++it) {
-		const IfcGeomObjects::Material& material = *it;
+	for (std::vector<IfcGeom::Material>::const_iterator it = _materials.begin(); it != _materials.end(); ++it) {
+		const IfcGeom::Material& material = *it;
 		if (!materials.contains(material)) {
 			materials.add(material);
 		}
@@ -273,9 +266,9 @@ void ColladaSerializer::writeHeader() {
 	exporter.startDocument(unit_name, unit_magnitude);
 }
 
-void ColladaSerializer::writeTesselated(const IfcGeomObjects::IfcGeomObject* o) {
-	const IfcGeomObjects::IfcRepresentationTriangulation& mesh = o->mesh();
-	exporter.writeTesselated(o->guid(), o->name(), o->type(), o->id(), o->matrix(), mesh.verts(), mesh.normals(), mesh.faces(), mesh.material_ids(), mesh.materials());
+void ColladaSerializer::write(const IfcGeom::TriangulationElement<double>* o) {
+	const IfcGeom::Representation::Triangulation<double>& mesh = o->geometry();
+	exporter.write(o->guid(), o->name(), o->type(), o->id(), o->transformation().matrix().data(), mesh.verts(), mesh.normals(), mesh.faces(), mesh.material_ids(), mesh.materials());
 }
 
 void ColladaSerializer::finalize() {

src/ifcconvert/ColladaSerializer.h

@@ -35,7 +35,7 @@
 #include <COLLADASWBaseInputElement.h>
 #include <COLLADASWAsset.h>
 
-#include "../ifcgeom/IfcGeomObjects.h"
+#include "../ifcgeom/IfcGeomIterator.h"
 
 #include "../ifcconvert/GeometrySerializer.h"
 
@@ -51,8 +51,8 @@ private:
 			explicit ColladaGeometries(COLLADASW::StreamWriter& stream)
 				: COLLADASW::LibraryGeometries(&stream)
 			{}
-			void addFloatSource(const std::string& mesh_id, const std::string& suffix, const std::vector<float>& floats, const char* coords = "XYZ");
-			void write(const std::string mesh_id, const std::string& default_material_name, const std::vector<float>& positions, const std::vector<float>& normals, const std::vector<int>& indices, const std::vector<int> material_ids, const std::vector<IfcGeomObjects::Material>& materials);
+			void addFloatSource(const std::string& mesh_id, const std::string& suffix, const std::vector<double>& floats, const char* coords = "XYZ");
+			void write(const std::string mesh_id, const std::string& default_material_name, const std::vector<double>& positions, const std::vector<double>& normals, const std::vector<int>& indices, const std::vector<int> material_ids, const std::vector<IfcGeom::Material>& materials);
 			void close();
 		};
 		class ColladaScene : public COLLADASW::LibraryVisualScenes
@@ -66,7 +66,7 @@ private:
 				, scene_id(scene_id)
 				, scene_opened(false)			
 			{}
-			void add(const std::string& node_id, const std::string& node_name, const std::string& geom_name, const std::vector<std::string>& material_ids, const std::vector<float>& matrix);
+			void add(const std::string& node_id, const std::string& node_name, const std::string& geom_name, const std::vector<std::string>& material_ids, const std::vector<double>& matrix);
 			void write();
 		};
 		class ColladaMaterials : public COLLADASW::LibraryMaterials
@@ -78,34 +78,34 @@ private:
 				explicit ColladaEffects(COLLADASW::StreamWriter& stream)
 					: COLLADASW::LibraryEffects(&stream)
 				{}
-				void write(const IfcGeomObjects::Material& material);
+				void write(const IfcGeom::Material& material);
 				void close();
 			};
-			std::vector<IfcGeomObjects::Material> materials;
+			std::vector<IfcGeom::Material> materials;
 			ColladaEffects effects;
 		public:
 			explicit ColladaMaterials(COLLADASW::StreamWriter& stream)
 				: COLLADASW::LibraryMaterials(&stream)
 				, effects(stream)
 			{}
-			void add(const IfcGeomObjects::Material& material);
-			bool contains(const IfcGeomObjects::Material& material);
+			void add(const IfcGeom::Material& material);
+			bool contains(const IfcGeom::Material& material);
 			void write();
 		};
 		class DeferredObject {
 		public:
 			std::string guid, name, type;
 			int obj_id;
-			std::vector<float> matrix;
-			std::vector<float> vertices;
-			std::vector<float> normals;
+			std::vector<double> matrix;
+			std::vector<double> vertices;
+			std::vector<double> normals;
 			std::vector<int> indices;
 			std::vector<int> material_ids;
-			std::vector<IfcGeomObjects::Material> materials;
+			std::vector<IfcGeom::Material> materials;
 			std::vector<std::string> material_references;
-			DeferredObject(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<float>& matrix, const std::vector<float>& vertices,
-				const std::vector<float>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, 
-				const std::vector<IfcGeomObjects::Material>& materials, const std::vector<std::string>& material_references)
+			DeferredObject(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<double>& matrix, const std::vector<double>& vertices,
+				const std::vector<double>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, 
+				const std::vector<IfcGeom::Material>& materials, const std::vector<std::string>& material_references)
 				: guid(guid)
 				, name(name)
 				, type(type)
@@ -136,7 +136,7 @@ private:
 		std::vector<DeferredObject> deferreds;
 		virtual ~ColladaExporter() {}
 		void startDocument(const std::string& unit_name, float unit_magnitude);
-		void writeTesselated(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<float>& matrix, const std::vector<float>& vertices, const std::vector<float>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, const std::vector<IfcGeomObjects::Material>& materials);
+		void write(const std::string& guid, const std::string& name, const std::string& type, int obj_id, const std::vector<double>& matrix, const std::vector<double>& vertices, const std::vector<double>& normals, const std::vector<int>& indices, const std::vector<int>& material_ids, const std::vector<IfcGeom::Material>& materials);
 		void endDocument();
 	};
 	ColladaExporter exporter;
@@ -149,8 +149,8 @@ public:
 	{}
 	bool ready();
 	void writeHeader();
-	void writeTesselated(const IfcGeomObjects::IfcGeomObject* o);
-	void writeShapeModel(const IfcGeomObjects::IfcGeomShapeModelObject* o) {}
+	void write(const IfcGeom::TriangulationElement<double>* o);
+	void write(const IfcGeom::ShapeModelElement<double>* o) {}
 	void finalize();
 	bool isTesselated() const { return true; }
 	void setUnitNameAndMagnitude(const std::string& name, float magnitude) {

src/ifcconvert/GeometrySerializer.h

@@ -20,7 +20,7 @@
 #ifndef GEOMETRYSERIALIZER_H
 #define GEOMETRYSERIALIZER_H
 
-#include "../ifcgeom/IfcGeomObjects.h"
+#include "../ifcgeom/IfcGeomIterator.h"
 
 class GeometrySerializer {
 public:
@@ -29,8 +29,8 @@ public:
 	virtual void finalize() = 0;
 	virtual bool isTesselated() const = 0;
 	virtual ~GeometrySerializer() {} 
-	virtual void writeTesselated(const IfcGeomObjects::IfcGeomObject* o) = 0;
-	virtual void writeShapeModel(const IfcGeomObjects::IfcGeomShapeModelObject* o) = 0;
+	virtual void write(const IfcGeom::TriangulationElement<double>* o) = 0;
+	virtual void write(const IfcGeom::ShapeModelElement<double>* o) = 0;
 	virtual void setUnitNameAndMagnitude(const std::string& name, float magnitude) = 0;
 };
 

src/ifcconvert/IfcConvert.cpp

@@ -33,7 +33,7 @@
 
 #include <boost/program_options.hpp>
 
-#include "../ifcgeom/IfcGeomObjects.h"
+#include "../ifcgeom/IfcGeomIterator.h"
 
 #include "../ifcconvert/ColladaSerializer.h"
 #include "../ifcconvert/IgesSerializer.h"
@@ -177,13 +177,16 @@ int main(int argc, char** argv) {
 		return 1;
 	}
 
-	IfcGeomObjects::Settings(IfcGeomObjects::USE_WORLD_COORDS, use_world_coords);
-	IfcGeomObjects::Settings(IfcGeomObjects::WELD_VERTICES, weld_vertices);
-	IfcGeomObjects::Settings(IfcGeomObjects::SEW_SHELLS, sew_shells);
-	IfcGeomObjects::Settings(IfcGeomObjects::CONVERT_BACK_UNITS, convert_back_units);
-	IfcGeomObjects::Settings(IfcGeomObjects::FASTER_BOOLEANS, merge_boolean_operands);
-	IfcGeomObjects::Settings(IfcGeomObjects::FORCE_CCW_FACE_ORIENTATION, force_ccw_face_orientation);
-	IfcGeomObjects::Settings(IfcGeomObjects::DISABLE_OPENING_SUBTRACTIONS, disable_opening_subtractions);
+	IfcGeom::IteratorSettings settings;
+
+	settings.set(IfcGeom::IteratorSettings::APPLY_DEFAULT_MATERIALS,      true);
+	settings.set(IfcGeom::IteratorSettings::USE_WORLD_COORDS,             use_world_coords);
+	settings.set(IfcGeom::IteratorSettings::WELD_VERTICES,                weld_vertices);
+	settings.set(IfcGeom::IteratorSettings::SEW_SHELLS,                   sew_shells);
+	settings.set(IfcGeom::IteratorSettings::CONVERT_BACK_UNITS,           convert_back_units);
+	settings.set(IfcGeom::IteratorSettings::FASTER_BOOLEANS,              merge_boolean_operands);
+	settings.set(IfcGeom::IteratorSettings::FORCE_CCW_FACE_ORIENTATION,   force_ccw_face_orientation);
+	settings.set(IfcGeom::IteratorSettings::DISABLE_OPENING_SUBTRACTIONS, disable_opening_subtractions);
 
 	std::string output_extension = output_filename.substr(output_filename.size()-4);
 	for (std::string::iterator c = output_extension.begin(); c != output_extension.end(); ++c) {
@@ -198,7 +201,7 @@ int main(int argc, char** argv) {
 		const std::string mtl_filename = output_filename.substr(0,output_filename.size()-3) + "mtl";
 		if (!use_world_coords) {
 			Logger::Message(Logger::LOG_NOTICE, "Using world coords when writing WaveFront OBJ files");
-			IfcGeomObjects::Settings(IfcGeomObjects::USE_WORLD_COORDS, true);
+			settings.set(IfcGeom::IteratorSettings::USE_WORLD_COORDS, true);
 		}
 		serializer = new WaveFrontOBJSerializer(output_filename, mtl_filename);
 #ifdef WITH_OPENCOLLADA
@@ -219,6 +222,8 @@ int main(int argc, char** argv) {
 		return 1;
 	}
 
+	IfcGeom::Iterator<double> context_iterator(settings, input_filename);
+
 	if (!serializer->ready()) {
 		Logger::Message(Logger::LOG_ERROR, "Unable to open output file for writing");
 		write_log();
@@ -226,7 +231,7 @@ int main(int argc, char** argv) {
 	}
 
 	if (!serializer->isTesselated()) {
-		IfcGeomObjects::Settings(IfcGeomObjects::DISABLE_TRIANGULATION, true);
+		
 		if (weld_vertices) {
 			Logger::Message(Logger::LOG_NOTICE, "Weld vertices setting ignored when writing STEP or IGES files");
 		}
@@ -235,14 +240,14 @@ int main(int argc, char** argv) {
 	time_t start,end;
 	time(&start);
 	// Parse the file supplied in argv[1]. Returns true on succes.
-	if ( ! IfcGeomObjects::Init(input_filename, &std::cout, &log_stream) ) {
+	if (!context_iterator.findContext()) {
 		Logger::Message(Logger::LOG_ERROR, "Unable to parse .ifc file or no geometrical entities found");
 		write_log();
 		return 1;
 	}
 
 	if (convert_back_units) {
-		serializer->setUnitNameAndMagnitude(IfcGeomObjects::GetUnitName(), IfcGeomObjects::GetUnitMagnitude());
+		serializer->setUnitNameAndMagnitude(context_iterator.getUnitName(), context_iterator.getUnitMagnitude());
 	} else {
 		serializer->setUnitNameAndMagnitude("METER", 1.0f);
 	}
@@ -255,16 +260,10 @@ int main(int argc, char** argv) {
 	Logger::Status("Creating geometry...");
 
 	// The functions IfcGeomObjects::Get() and IfcGeomObjects::Next() wrap an iterator of all geometrical entities in the Ifc file.
-	// IfcGeomObjects::Get() returns an IfcGeomObjects::IfcGeomObject (see IfcGeomObjects.h for definition)
+	// IfcGeomObjects::Get() returns an IfcGeom::TriangulationElement (see IfcGeomIterator.h for definition)
 	// IfcGeomObjects::Next() is used to poll whether more geometrical entities are available    
 	do {
-		const IfcGeomObjects::IfcObject* geom_object;
-		
-		if (serializer->isTesselated()) {
-			geom_object = IfcGeomObjects::Get();
-		} else {
-			geom_object = IfcGeomObjects::GetShapeModel();
-		}
+		const IfcGeom::Element<double>* geom_object = context_iterator.get();
 
 		std::string lowercase_type = geom_object->type();
 		for (std::string::iterator c = lowercase_type.begin(); c != lowercase_type.end(); ++c) {
@@ -273,16 +272,16 @@ int main(int argc, char** argv) {
 		if (ignore_types.find(lowercase_type) != ignore_types.end()) continue;
 
 		if (serializer->isTesselated()) {
-			serializer->writeTesselated(static_cast<const IfcGeomObjects::IfcGeomObject*>(geom_object));
+			serializer->write(static_cast<const IfcGeom::TriangulationElement<double>*>(geom_object));
 		} else {
-			serializer->writeShapeModel(static_cast<const IfcGeomObjects::IfcGeomShapeModelObject*>(geom_object));
+			serializer->write(static_cast<const IfcGeom::ShapeModelElement<double>*>(geom_object));
 		}
-
-		const int progress = IfcGeomObjects::Progress() / 2;
-		if ( old_progress!= progress ) Logger::ProgressBar(progress);
+		
+		const int progress = context_iterator.progress() / 2;
+		if (old_progress!= progress) Logger::ProgressBar(progress);
 		old_progress = progress;
 	
-	} while ( IfcGeomObjects::Next() );
+	} while (context_iterator.next());
 
 	serializer->finalize();
 	delete serializer;

src/ifcconvert/IgesSerializer.h

@@ -24,7 +24,7 @@
 #include <IGESControl_Writer.hxx>
 #include <Interface_Static.hxx>
 
-#include "../ifcgeom/IfcGeomObjects.h"
+#include "../ifcgeom/IfcGeomIterator.h"
 
 #include "../ifcconvert/OpenCascadeBasedSerializer.h"
 

src/ifcconvert/OpenCascadeBasedSerializer.cpp

@@ -34,17 +34,19 @@ bool OpenCascadeBasedSerializer::ready() {
 	return succeeded;
 }
 
-void OpenCascadeBasedSerializer::writeShapeModel(const IfcGeomObjects::IfcGeomShapeModelObject* o) {		
-	for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = o->mesh().begin(); it != o->mesh().end(); ++ it) {
+void OpenCascadeBasedSerializer::write(const IfcGeom::ShapeModelElement<double>* o) {		
+	for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = o->geometry().begin(); it != o->geometry().end(); ++ it) {
 		gp_GTrsf gtrsf = it->Placement();
+
+		const std::vector<double>& matrix = o->transformation().matrix().data();
 		
 		// Convert the matrix back into a transformation object. The tolerance values
 		// are taken into consideration to reconstruct the form of the transformation.
 		gp_Trsf o_trsf;
 		o_trsf.SetValues(
-			o->matrix()[0], o->matrix()[3], o->matrix()[6], o->matrix()[ 9],
-			o->matrix()[1], o->matrix()[4], o->matrix()[7], o->matrix()[10], 
-			o->matrix()[2], o->matrix()[5], o->matrix()[8], o->matrix()[11],
+			matrix[0], matrix[3], matrix[6], matrix[ 9],
+			matrix[1], matrix[4], matrix[7], matrix[10], 
+			matrix[2], matrix[5], matrix[8], matrix[11],
 			1e-5, 1e-5
 		);
 		gtrsf.PreMultiply(o_trsf);

src/ifcconvert/OpenCascadeBasedSerializer.h

@@ -20,7 +20,7 @@
 #ifndef OPENCASCADEBASEDSERIALIZER_H
 #define OPENCASCADEBASEDSERIALIZER_H
 
-#include "../ifcgeom/IfcGeomObjects.h"
+#include "../ifcgeom/IfcGeomIterator.h"
 
 #include "../ifcconvert/GeometrySerializer.h"
 
@@ -38,8 +38,8 @@ public:
 	void writeMaterial(const IfcGeom::SurfaceStyle& style) {}
 	bool ready();
 	virtual void writeShape(const TopoDS_Shape& shape) = 0;
-	void writeTesselated(const IfcGeomObjects::IfcGeomObject* o) {}
-	void writeShapeModel(const IfcGeomObjects::IfcGeomShapeModelObject* o);
+	void write(const IfcGeom::TriangulationElement<double>* o) {}
+	void write(const IfcGeom::ShapeModelElement<double>* o);
 	bool isTesselated() const { return false; }
 };
 

src/ifcconvert/StepSerializer.h

@@ -24,7 +24,7 @@
 #include <STEPControl_Writer.hxx>
 #include <Interface_Static.hxx>
 
-#include "../ifcgeom/IfcGeomObjects.h"
+#include "../ifcgeom/IfcGeomIterator.h"
 
 #include "../ifcconvert/OpenCascadeBasedSerializer.h"
 

src/ifcconvert/WavefrontObjSerializer.cpp

@@ -43,7 +43,7 @@ void WaveFrontOBJSerializer::writeHeader() {
 	mtl_stream << "# File generated by IfcOpenShell " << IFCOPENSHELL_VERSION << "\n";	
 }
 
-void WaveFrontOBJSerializer::writeMaterial(const IfcGeomObjects::Material& style) {			
+void WaveFrontOBJSerializer::writeMaterial(const IfcGeom::Material& style) {			
 	mtl_stream << "newmtl " << style.name() << "\n";
 	if (style.hasDiffuse()) {
 		const double* diffuse = style.diffuse();
@@ -65,7 +65,7 @@ void WaveFrontOBJSerializer::writeMaterial(const IfcGeomObjects::Material& style
 		}
 	}
 }
-void WaveFrontOBJSerializer::writeTesselated(const IfcGeomObjects::IfcGeomObject* o) {
+void WaveFrontOBJSerializer::write(const IfcGeom::TriangulationElement<double>* o) {
 
 	std::string tmp = o->name().empty() ? o->guid() : o->name();
 
@@ -74,16 +74,16 @@ void WaveFrontOBJSerializer::writeTesselated(const IfcGeomObjects::IfcGeomObject
 	obj_stream << "g " << name << "\n";
 	obj_stream << "s 1" << "\n";
 
-	const IfcGeomObjects::IfcRepresentationTriangulation& mesh = o->mesh();
+	const IfcGeom::Representation::Triangulation<double>& mesh = o->geometry();
 	
 	const int vcount = mesh.verts().size() / 3;
-	for ( std::vector<float>::const_iterator it = mesh.verts().begin(); it != mesh.verts().end(); ) {
+	for ( std::vector<double>::const_iterator it = mesh.verts().begin(); it != mesh.verts().end(); ) {
 		const double x = *(it++);
 		const double y = *(it++);
 		const double z = *(it++);
 		obj_stream << "v " << x << " " << y << " " << z << "\n";
 	}
-	for ( std::vector<float>::const_iterator it = mesh.normals().begin(); it != mesh.normals().end(); ) {
+	for ( std::vector<double>::const_iterator it = mesh.normals().begin(); it != mesh.normals().end(); ) {
 		const double x = *(it++);
 		const double y = *(it++);
 		const double z = *(it++);
@@ -97,12 +97,7 @@ void WaveFrontOBJSerializer::writeTesselated(const IfcGeomObjects::IfcGeomObject
 		
 		const int material_id = *(material_it++);
 		if (material_id != previous_material_id) {
-			IfcGeomObjects::Material material(0);
-			if (material_id >= 0) {
-				material = mesh.materials()[material_id];
-			} else {
-				material = IfcGeomObjects::Material(IfcGeom::get_default_style(o->type()));
-			}
+			const IfcGeom::Material& material = mesh.materials()[material_id];
 			const std::string material_name = material.name();
 			obj_stream << "usemtl " << material_name << "\n";
 			if (materials.find(material_name) == materials.end()) {

src/ifcconvert/WavefrontObjSerializer.h

@@ -44,9 +44,9 @@ public:
 	virtual ~WaveFrontOBJSerializer() {}
 	bool ready();
 	void writeHeader();
-	void writeMaterial(const IfcGeomObjects::Material& style);
-	void writeTesselated(const IfcGeomObjects::IfcGeomObject* o);
-	void writeShapeModel(const IfcGeomObjects::IfcGeomShapeModelObject* o) {}
+	void writeMaterial(const IfcGeom::Material& style);
+	void write(const IfcGeom::TriangulationElement<double>* o);
+	void write(const IfcGeom::ShapeModelElement<double>* o) {}
 	void finalize() {}
 	bool isTesselated() const { return true; }
 	void setUnitNameAndMagnitude(const std::string& name, float magnitude) {}