Geometry caching

src/ifcgeom/IfcGeom.h

@@ -288,9 +288,9 @@ private:
 	MAKE_TYPE_NAME(Cache) cache;
 #endif
 
-	std::map<int, SurfaceStyle> style_cache;
+	std::map<int, std::shared_ptr<const SurfaceStyle>> style_cache;
 
-	const SurfaceStyle* internalize_surface_style(const std::pair<IfcUtil::IfcBaseClass*, IfcUtil::IfcBaseClass*>& shading_style);
+	std::shared_ptr<const SurfaceStyle> internalize_surface_style(const std::pair<IfcUtil::IfcBaseClass*, IfcUtil::IfcBaseClass*>& shading_style);
 
 public:
 	MAKE_TYPE_NAME(Kernel)()
@@ -364,9 +364,9 @@ public:
 	bool convert_openings_fast(const IfcSchema::IfcProduct* entity, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
 	void assert_closed_wire(TopoDS_Wire& wire);
 
-	bool convert_layerset(const IfcSchema::IfcProduct*, std::vector<Handle_Geom_Surface>&, std::vector<const SurfaceStyle*>&, std::vector<double>&);
-	bool apply_layerset(const IfcRepresentationShapeItems&, const std::vector<Handle_Geom_Surface>&, const std::vector<const SurfaceStyle*>&, IfcRepresentationShapeItems&);
-	bool apply_folded_layerset(const IfcRepresentationShapeItems&, const std::vector< std::vector<Handle_Geom_Surface> >&, const std::vector<const SurfaceStyle*>&, IfcRepresentationShapeItems&);
+	bool convert_layerset(const IfcSchema::IfcProduct*, std::vector<Handle_Geom_Surface>&, std::vector<std::shared_ptr<const SurfaceStyle>>&, std::vector<double>&);
+	bool apply_layerset(const IfcRepresentationShapeItems&, const std::vector<Handle_Geom_Surface>&, const std::vector<std::shared_ptr<const SurfaceStyle>>&, IfcRepresentationShapeItems&);
+	bool apply_folded_layerset(const IfcRepresentationShapeItems&, const std::vector< std::vector<Handle_Geom_Surface> >&, const std::vector<std::shared_ptr<const SurfaceStyle>>&, IfcRepresentationShapeItems&);
 	bool fold_layers(const IfcSchema::IfcWall*, const IfcRepresentationShapeItems&, const std::vector<Handle_Geom_Surface>&, const std::vector<double>&, std::vector< std::vector<Handle_Geom_Surface> >&);
 
 	bool split_solid_by_surface(const TopoDS_Shape&, const Handle_Geom_Surface&, TopoDS_Shape&, TopoDS_Shape&);
@@ -443,8 +443,8 @@ public:
 	const IfcSchema::IfcMaterial* get_single_material_association(const IfcSchema::IfcProduct*);
 	IfcSchema::IfcRepresentation* representation_mapped_to(const IfcSchema::IfcRepresentation* representation);
 	IfcSchema::IfcProduct::list::ptr products_represented_by(const IfcSchema::IfcRepresentation*);
-	const SurfaceStyle* get_style(const IfcSchema::IfcRepresentationItem*);
-	const SurfaceStyle* get_style(const IfcSchema::IfcMaterial*);
+	std::shared_ptr<const SurfaceStyle> get_style(const IfcSchema::IfcRepresentationItem*);
+	std::shared_ptr<const SurfaceStyle> get_style(const IfcSchema::IfcMaterial*);
 	
 	template <typename T> std::pair<IfcSchema::IfcSurfaceStyle*, T*> _get_surface_style(const IfcSchema::IfcStyledItem* si) {
 		std::vector<IfcSchema::IfcPresentationStyle*> prs_styles;

src/ifcgeom/IfcGeomFunctions.cpp

@@ -907,7 +907,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 			}
 
 		}
-		cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(it3->ItemId(), it3->Placement(), entity_shape, &it3->Style()));
+		cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(it3->ItemId(), it3->Placement(), entity_shape, it3->StylePtr()));
 	}
 
 	return true;
@@ -1123,7 +1123,7 @@ bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity,
 				continue;
 			}
 
-			cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(it3->ItemId(), result, &it3->Style()));
+			cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(it3->ItemId(), result, it3->StylePtr()));
 
 			// For manifold first operands we're not even going to try if processing
 			// as loose faces gives a better result.
@@ -1848,7 +1848,7 @@ IfcGeom::BRepElement* IfcGeom::Kernel::create_brep_for_representation_and_produc
 				std::vector<double> thickness;
 				std::vector<Handle_Geom_Surface> layers;
 				std::vector< std::vector<Handle_Geom_Surface> > folded_layers;
-				std::vector<const SurfaceStyle*> styles;
+				std::vector<std::shared_ptr<const SurfaceStyle>> styles;
 				if (convert_layerset(product, layers, styles, thickness)) {
 
 					IfcSchema::IfcRelAssociates::list::ptr associations = product->HasAssociations();
@@ -1889,7 +1889,7 @@ IfcGeom::BRepElement* IfcGeom::Kernel::create_brep_for_representation_and_produc
 
 	const IfcSchema::IfcMaterial* single_material = get_single_material_association(product);
 	if (single_material) {
-		const IfcGeom::SurfaceStyle* s = get_style(single_material);
+		auto s = get_style(single_material);
 		for (IfcGeom::IfcRepresentationShapeItems::iterator it = shapes.begin(); it != shapes.end(); ++it) {
 			if (!it->hasStyle() && s) {
 				it->setStyle(s);
@@ -1917,8 +1917,8 @@ IfcGeom::BRepElement* IfcGeom::Kernel::create_brep_for_representation_and_produc
 		for (auto& s : shapes) {
 			if (s.hasStyle()) {
 				for (auto& p : style_cache) {
-					if (&p.second == &s.Style()) {
-						p.second.Transparency() = settings.force_space_transparency();
+					if (p.second == s.StylePtr()) {
+						std::const_pointer_cast<IfcGeom::SurfaceStyle>(p.second)->Transparency() = settings.force_space_transparency();
 					}
 				}
 			}
@@ -2303,7 +2303,7 @@ std::pair<std::string, double> IfcGeom::Kernel::initializeUnits(IfcSchema::IfcUn
 	return std::pair<std::string, double>(unit_name, unit_magnitude);
 }
 
-bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std::vector<Handle_Geom_Surface>& surfaces, std::vector<const SurfaceStyle*>& styles, std::vector<double>& thicknesses) {
+bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std::vector<Handle_Geom_Surface>& surfaces, std::vector<std::shared_ptr<const SurfaceStyle>>& styles, std::vector<double>& thicknesses) {
 	IfcSchema::IfcMaterialLayerSetUsage* usage = 0;
 	Handle_Geom_Surface reference_surface;
 
@@ -3063,7 +3063,7 @@ namespace {
 #endif
 }
 
-bool IfcGeom::Kernel::apply_folded_layerset(const IfcRepresentationShapeItems& items, const std::vector< std::vector<Handle_Geom_Surface> >& surfaces, const std::vector<const SurfaceStyle*>& styles, IfcRepresentationShapeItems& result) {
+bool IfcGeom::Kernel::apply_folded_layerset(const IfcRepresentationShapeItems& items, const std::vector< std::vector<Handle_Geom_Surface> >& surfaces, const std::vector<std::shared_ptr<const SurfaceStyle>>& styles, IfcRepresentationShapeItems& result) {
 	Bnd_Box bb;
 	TopoDS_Shape input;
 	flatten_shape_list(items, input, false);
@@ -3148,8 +3148,8 @@ bool IfcGeom::Kernel::apply_folded_layerset(const IfcRepresentationShapeItems& i
 		for (IfcRepresentationShapeItems::const_iterator it = items.begin(); it != items.end(); ++it) {
 			TopoDS_Shape a,b;
 			if (split_solid_by_shell(it->Shape(), shells.First(), a, b)) {
-				result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), b, styles[0] ? styles[0] : &it->Style()));
-				result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), a, styles[1] ? styles[1] : &it->Style()));
+				result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), b, !!styles[0] ? styles[0] : it->StylePtr()));
+				result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), a, !!styles[1] ? styles[1] : it->StylePtr()));
 			} else {
 				continue;
 			}
@@ -3168,7 +3168,7 @@ bool IfcGeom::Kernel::apply_folded_layerset(const IfcRepresentationShapeItems& i
 			std::vector<TopoDS_Shape> slices;
 			if (split(*this, it->Shape(), shells, getValue(GV_PRECISION), slices) && slices.size() == styles.size()) {
 				for (size_t i = 0; i < slices.size(); ++i) {
-					result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), slices[i], styles[i] ? styles[i] : &it->Style()));
+					result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), slices[i], !!styles[i] ? styles[i] : it->StylePtr()));
 				}
 			} else {
 				return false;
@@ -3181,7 +3181,7 @@ bool IfcGeom::Kernel::apply_folded_layerset(const IfcRepresentationShapeItems& i
 
 }
 
-bool IfcGeom::Kernel::apply_layerset(const IfcRepresentationShapeItems& items, const std::vector<Handle_Geom_Surface>& surfaces, const std::vector<const SurfaceStyle*>& styles, IfcRepresentationShapeItems& result) {
+bool IfcGeom::Kernel::apply_layerset(const IfcRepresentationShapeItems& items, const std::vector<Handle_Geom_Surface>& surfaces, const std::vector<std::shared_ptr<const SurfaceStyle>>& styles, IfcRepresentationShapeItems& result) {
 	if (surfaces.size() < 3) {
 
 		return false;
@@ -3191,8 +3191,8 @@ bool IfcGeom::Kernel::apply_layerset(const IfcRepresentationShapeItems& items, c
 		for (IfcRepresentationShapeItems::const_iterator it = items.begin(); it != items.end(); ++it) {
 			TopoDS_Shape a,b;
 			if (split_solid_by_surface(it->Shape(), surfaces[1], a, b)) {
-				result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), b, styles[0] ? styles[0] : &it->Style()));
-				result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), a, styles[1] ? styles[1] : &it->Style()));
+				result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), b, !!styles[0] ? styles[0] : it->StylePtr()));
+				result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), a, !!styles[1] ? styles[1] : it->StylePtr()));
 			} else {
 				continue;
 			}
@@ -3259,7 +3259,7 @@ bool IfcGeom::Kernel::apply_layerset(const IfcRepresentationShapeItems& items, c
 			std::vector<TopoDS_Shape> slices;
 			if (split(*this, it->Shape(), operands, getValue(GV_PRECISION), slices) && slices.size() == styles.size()) {
 				for (size_t i = 0; i < slices.size(); ++i) {
-					result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), slices[i], styles[i] ? styles[i] : &it->Style()));
+					result.push_back(IfcRepresentationShapeItem(it->ItemId(), it->Placement(), slices[i], !!styles[i] ? styles[i] : it->StylePtr()));
 				}
 			} else {
 				return false;

src/ifcgeom/IfcGeomIteratorImplementation.h

@@ -777,11 +777,25 @@ namespace IfcGeom {
 
 				Logger::SetProduct(product);
 
+				bool read_from_cache = false;
 				BRepElement* element;
-				if (ifcproduct_iterator == ifcproducts->begin() || !geometry_reuse_ok_for_current_representation_) {
-					element = kernel.create_brep_for_representation_and_product(settings, representation, product);
-				} else {
-					element = kernel.create_brep_for_processed_representation(settings, representation, product, current_shape_model);
+
+#ifdef WITH_HDF5
+				if (cache_) {
+					auto from_cache = cache_->read(*ifc_file, product->GlobalId(), representation->data().id());
+					if (from_cache) {
+						read_from_cache = true;
+						element = (BRepElement*) from_cache;
+					}
+				}
+#endif
+
+				if (!read_from_cache) {
+					if (ifcproduct_iterator == ifcproducts->begin() || !geometry_reuse_ok_for_current_representation_) {
+						element = kernel.create_brep_for_representation_and_product(settings, representation, product);
+					} else {
+						element = kernel.create_brep_for_processed_representation(settings, representation, product, current_shape_model);
+					}
 				}
 
 				Logger::SetProduct(boost::none);
@@ -791,6 +805,12 @@ namespace IfcGeom {
 					continue;
 				}
 
+#ifdef WITH_HDF5
+				if (cache_ && !read_from_cache) {
+					cache_->write(element);
+				}
+#endif
+
 				return element;
 			}
 		}
@@ -1003,14 +1023,42 @@ namespace IfcGeom {
                         Logger::Message(Logger::LOG_ERROR, "Getting a serialized element from model failed.");
 					}
 				} else if (!settings.get(IteratorSettings::DISABLE_TRIANGULATION)) {
-					try {
-						if (ifcproduct_iterator == ifcproducts->begin() || !geometry_reuse_ok_for_current_representation_) {
-							next_triangulation = new TriangulationElement(*next_shape_model);
-						} else {
-							next_triangulation = new TriangulationElement(*next_shape_model, current_triangulation->geometry_pointer());
+
+					bool read_from_cache = false;
+
+#ifdef WITH_HDF5
+					if (cache_) {
+						// the part before the hyphen is the representation id
+						auto gid2 = next_shape_model->geometry().id();
+						auto hyphen = gid2.find("-");
+						if (hyphen != std::string::npos) {
+							gid2 = gid2.substr(0, hyphen);
+						}
+
+						auto from_cache = cache_->read(*ifc_file, next_shape_model->guid(), boost::lexical_cast<int>(gid2), HdfSerializer::READ_TRIANGULATION);
+						if (from_cache) {
+							read_from_cache = true;
+							next_triangulation = (TriangulationElement*)from_cache;
+						}
+					}
+#endif
+
+					if (!read_from_cache) {
+						try {
+							if (ifcproduct_iterator == ifcproducts->begin() || !geometry_reuse_ok_for_current_representation_) {
+								next_triangulation = new TriangulationElement(*next_shape_model);
+							} else {
+								next_triangulation = new TriangulationElement(*next_shape_model, current_triangulation->geometry_pointer());
+							}
+
+#ifdef WITH_HDF5
+							if (cache_) {
+								cache_->write(next_triangulation);
+							}
+#endif
+						} catch (...) {
+							Logger::Message(Logger::LOG_ERROR, "Getting a triangulation element from model failed.");
 						}
-					} catch (...) {
-                        Logger::Message(Logger::LOG_ERROR, "Getting a triangulation element from model failed.");
 					}
 				}
 			}

src/ifcgeom/IfcGeomRenderStyles.cpp

@@ -56,25 +56,31 @@ namespace {
 
 #define Kernel MAKE_TYPE_NAME(Kernel)
 
-const IfcGeom::SurfaceStyle* IfcGeom::Kernel::internalize_surface_style(const std::pair<IfcUtil::IfcBaseClass*, IfcUtil::IfcBaseClass*>& shading_styles) {
+std::shared_ptr<const IfcGeom::SurfaceStyle> IfcGeom::Kernel::internalize_surface_style(const std::pair<IfcUtil::IfcBaseClass*, IfcUtil::IfcBaseClass*>& shading_styles) {
 	if (shading_styles.second == 0) {
 		return 0;
 	}
 	int surface_style_id = shading_styles.first->data().id();
-	std::map<int,SurfaceStyle>::const_iterator it = style_cache.find(surface_style_id);
+	auto it = style_cache.find(surface_style_id);
 	if (it != style_cache.end()) {
-		return &(it->second);
+		return it->second;
 	}
-	SurfaceStyle surface_style;
-
+	
+	
 	IfcSchema::IfcSurfaceStyle* style = shading_styles.first->as<IfcSchema::IfcSurfaceStyle>();
 	IfcSchema::IfcSurfaceStyleShading* shading = shading_styles.second->as<IfcSchema::IfcSurfaceStyleShading>();
 
+	std::shared_ptr<SurfaceStyle> surface_style_ptr;
+
 	if (style->Name()) {
-		surface_style = SurfaceStyle(surface_style_id, *style->Name());
+		surface_style_ptr.reset(new SurfaceStyle(surface_style_id, *style->Name()));
 	} else {
-		surface_style = SurfaceStyle(surface_style_id);
+		surface_style_ptr.reset(new SurfaceStyle(surface_style_id));
 	}
+
+	std::shared_ptr<const SurfaceStyle> surface_style_ptr_const = std::const_pointer_cast<const SurfaceStyle>(surface_style_ptr);
+	SurfaceStyle& surface_style = *surface_style_ptr;
+
 	double rgb[3];
 	if (process_colour(shading->SurfaceColour(), rgb)) {
 		surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]));
@@ -113,14 +119,14 @@ const IfcGeom::SurfaceStyle* IfcGeom::Kernel::internalize_surface_style(const st
 			surface_style.Transparency().reset(d);
 		}
 	}
-	return &(style_cache[surface_style_id] = surface_style);
+	return style_cache[surface_style_id] = surface_style_ptr_const;
 }
 
-const IfcGeom::SurfaceStyle* IfcGeom::Kernel::get_style(const IfcSchema::IfcRepresentationItem* item) {
+std::shared_ptr<const IfcGeom::SurfaceStyle> IfcGeom::Kernel::get_style(const IfcSchema::IfcRepresentationItem* item) {
 	return internalize_surface_style(get_surface_style<IfcSchema::IfcSurfaceStyleShading>(item));	
 }
 
-const IfcGeom::SurfaceStyle* IfcGeom::Kernel::get_style(const IfcSchema::IfcMaterial* material) {
+std::shared_ptr<const IfcGeom::SurfaceStyle> IfcGeom::Kernel::get_style(const IfcSchema::IfcMaterial* material) {
 	IfcSchema::IfcMaterialDefinitionRepresentation::list::ptr defs = material->HasRepresentation();
 	for (IfcSchema::IfcMaterialDefinitionRepresentation::list::it jt = defs->begin(); jt != defs->end(); ++jt) {
 		IfcSchema::IfcRepresentation::list::ptr reps = (*jt)->Representations();
@@ -135,6 +141,6 @@ const IfcGeom::SurfaceStyle* IfcGeom::Kernel::get_style(const IfcSchema::IfcMate
 			}
 		}
 	}
-	IfcGeom::SurfaceStyle material_style = IfcGeom::SurfaceStyle(material->data().id(), material->Name());
-	return &(style_cache[material->data().id()] = material_style);
+	auto material_style = std::make_shared<IfcGeom::SurfaceStyle>(material->data().id(), material->Name());
+	return style_cache[material->data().id()] = material_style;
 }

src/ifcgeom/IfcGeomRepresentation.h

@@ -121,6 +121,11 @@ namespace IfcGeom {
 			size_t weld_offset_;
 			VertexKeyMap welds;
 
+			// when read from serialization, the element needs to take ownership of the styles,
+			// the material vector is constructor off of this.
+			// @todo this can be improved
+			std::vector<std::shared_ptr<SurfaceStyle>> styles_;
+
 		public:
 			const std::string& id() const { return id_; }
 			const std::vector<double>& verts() const { return _verts; }
@@ -144,7 +149,7 @@ namespace IfcGeom {
 
 					int surface_style_id = -1;
 					if (iit->hasStyle()) {
-						Material adapter(&iit->Style());
+						Material adapter(iit->StylePtr());
 						std::vector<Material>::const_iterator jt = std::find(_materials.begin(), _materials.end(), adapter);
 						if (jt == _materials.end()) {
 							surface_style_id = (int)_materials.size();
@@ -349,6 +354,32 @@ namespace IfcGeom {
                     BRepTools::Clean(s);
 				}
 			}
+			
+			Triangulation(
+				ElementSettings settings,
+				const std::string& id,
+				const std::vector<double>& verts,
+				const std::vector<int>& faces,
+				const std::vector<int>& edges,
+				const std::vector<double>& normals,
+				const std::vector<double>& uvs,
+				const std::vector<int>& material_ids,
+				const std::vector<std::shared_ptr<SurfaceStyle>>& styles)
+				: Representation(settings)
+				, id_(id)
+				, _verts(verts)
+				, _faces(faces)
+				, _edges(edges)
+				, _normals(normals)
+				, uvs_(uvs)
+				, _material_ids(material_ids)
+				, styles_(styles)
+			{
+				for (auto& s : styles_) {
+					_materials.push_back(IfcGeom::Material(s));
+				}
+			}
+
 			virtual ~Triangulation() {}
 
             /// Generates UVs for a single mesh using box projection.

src/ifcgeom/IfcGeomShapes.cpp

@@ -434,9 +434,9 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRevolvedAreaSolid* l, TopoDS_S
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, IfcRepresentationShapeItems& shape) {
 	TopoDS_Shape s;
-	const SurfaceStyle* collective_style = get_style(l);
+	auto collective_style = get_style(l);
 	if (convert_shape(l->Outer(),s) ) {
-		const SurfaceStyle* indiv_style = get_style(l->Outer());
+		auto indiv_style = get_style(l->Outer());
 
 		IfcSchema::IfcClosedShell::list::ptr voids(new IfcSchema::IfcClosedShell::list);
 		if (l->declaration().is(IfcSchema::IfcFacetedBrepWithVoids::Class())) {
@@ -466,10 +466,10 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, IfcRepre
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcFaceBasedSurfaceModel* l, IfcRepresentationShapeItems& shapes) {
 	bool part_success = false;
 	IfcSchema::IfcConnectedFaceSet::list::ptr facesets = l->FbsmFaces();
-	const SurfaceStyle* collective_style = get_style(l);
+	auto collective_style = get_style(l);
 	for( IfcSchema::IfcConnectedFaceSet::list::it it = facesets->begin(); it != facesets->end(); ++ it ) {
 		TopoDS_Shape s;
-		const SurfaceStyle* shell_style = get_style(*it);
+		auto shell_style = get_style(*it);
 		if (convert_shape(*it,s)) {
 			shapes.push_back(IfcRepresentationShapeItem(l->data().id(), s, shell_style ? shell_style : collective_style));
 			part_success |= true;
@@ -527,10 +527,10 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolygonalBoundedHalfSpace* l,
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, IfcRepresentationShapeItems& shapes) {
 	aggregate_of_instance::ptr shells = l->SbsmBoundary();
-	const SurfaceStyle* collective_style = get_style(l);
+	auto collective_style = get_style(l);
 	for( aggregate_of_instance::it it = shells->begin(); it != shells->end(); ++ it ) {
 		TopoDS_Shape s;
-		const SurfaceStyle* shell_style = 0;
+		decltype(collective_style) shell_style;
 		if ((*it)->declaration().is(IfcSchema::IfcRepresentationItem::Class())) {
 			shell_style = get_style((IfcSchema::IfcRepresentationItem*)*it);
 		}
@@ -845,7 +845,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, IfcRepresentati
 	}
 	gtrsf.Multiply(trsf);
 
-	const IfcGeom::SurfaceStyle* mapped_item_style = get_style(l);
+	auto mapped_item_style = get_style(l);
 	
 	const size_t previous_size = shapes.size();
 	bool b = convert_shapes(map->MappedRepresentation(), shapes);
@@ -893,7 +893,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcGeometricSet* l, IfcRepresenta
 	aggregate_of_instance::ptr elements = l->Elements();
 	if ( !elements->size() ) return false;
 	bool part_succes = false;
-	const IfcGeom::SurfaceStyle* parent_style = get_style(l);
+	auto parent_style = get_style(l);
 	for (aggregate_of_instance::it it = elements->begin(); it != elements->end(); ++it) {
 		auto element = *it;
 		TopoDS_Shape s;
@@ -917,7 +917,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcGeometricSet* l, IfcRepresenta
 		}
 
 		part_succes = true;
-		const IfcGeom::SurfaceStyle* style = 0;
+		decltype(parent_style) style = 0;
 		if (element->declaration().is(IfcSchema::IfcPoint::Class())) {
 			style = get_style((IfcSchema::IfcPoint*) element);
 		}

src/ifcgeom/IfcGeomTree.h

@@ -338,7 +338,7 @@ namespace IfcGeom {
 				for (; it.More(); it.Next(), ++git) {
 					std::unique_ptr<IfcGeom::Material> adaptor;					
 					if (git->hasStyle()) {
-						adaptor.reset(new Material(&git->Style()));
+						adaptor.reset(new Material(git->StylePtr()));
 					} else {
 						adaptor.reset(new Material(IfcGeom::get_default_style(elem->type())));
 					}

src/ifcgeom/IfcRegister.cpp

@@ -30,7 +30,7 @@ bool IfcGeom::Kernel::convert_shapes(const IfcBaseInterface* l, IfcRepresentatio
 	if (shape_type(l) != ST_SHAPELIST) {
 		TopoDS_Shape shp;
 		if (convert_shape(l, shp)) {
-			const IfcGeom::SurfaceStyle* style = nullptr;
+			std::shared_ptr<const IfcGeom::SurfaceStyle> style;
 			if (l->as<IfcSchema::IfcRepresentationItem>()) {
 				style = get_style(l->as<IfcSchema::IfcRepresentationItem>());
 			}

src/ifcgeom/IfcRepresentationShapeItem.h

@@ -31,13 +31,13 @@ namespace IfcGeom {
 		int id;
 		gp_GTrsf placement;
 		TopoDS_Shape shape;
-		const SurfaceStyle* style;
+		std::shared_ptr<const SurfaceStyle> style;
 	public:
-		IfcRepresentationShapeItem(int id, const gp_GTrsf& placement, const TopoDS_Shape& shape, const SurfaceStyle* style)
+		IfcRepresentationShapeItem(int id, const gp_GTrsf& placement, const TopoDS_Shape& shape, std::shared_ptr<const SurfaceStyle> style)
 			: id(id), placement(placement), shape(shape), style(style) {}
 		IfcRepresentationShapeItem(int id, const gp_GTrsf& placement, const TopoDS_Shape& shape)
 			: id(id), placement(placement), shape(shape), style(0) {}
-		IfcRepresentationShapeItem(int id, const TopoDS_Shape& shape, const SurfaceStyle* style)
+		IfcRepresentationShapeItem(int id, const TopoDS_Shape& shape, std::shared_ptr<const SurfaceStyle> style)
 			: id(id), shape(shape), style(style) {}
 		IfcRepresentationShapeItem(int id, const TopoDS_Shape& shape)
 			: id(id), shape(shape), style(0) {}
@@ -45,9 +45,10 @@ namespace IfcGeom {
 		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; }
+		bool hasStyle() const { return !!style; }
 		const SurfaceStyle& Style() const { return *style; }
-		void setStyle(const SurfaceStyle* newStyle) { style = newStyle; }
+		const std::shared_ptr<const SurfaceStyle> StylePtr() const { return style; }
+		void setStyle(std::shared_ptr<const SurfaceStyle> newStyle) { style = newStyle; }
 		int ItemId() const { return id; }
 	};
 	typedef std::vector<IfcRepresentationShapeItem> IfcRepresentationShapeItems;