Merge branch 'master' into performance_improvements

# Conflicts:
#	src/ifcconvert/ColladaSerializer.cpp
#	src/ifcconvert/ColladaSerializer.h
#	src/ifcgeom/IfcGeomIterator.h
#	src/ifcgeom/IfcGeomRenderStyles.h

src/ifcgeom/IfcGeomElement.h

@@ -44,7 +44,7 @@ namespace IfcGeom {
 			for(int i = 1; i < 5; ++i) {
 				for (int j = 1; j < 4; ++j) {
 					const double trsf_value = trsf.Value(j,i);
-					const double matrix_value = i == 4 && settings.convert_back_units()
+                    const double matrix_value = i == 4 && settings.get(IteratorSettings::CONVERT_BACK_UNITS)
 						? trsf_value / settings.unit_magnitude()
 						: trsf_value;
 					_data.push_back(static_cast<P>(matrix_value));

src/ifcgeom/IfcGeomFunctions.cpp

@@ -1116,11 +1116,11 @@ IfcGeom::BRepElement<P>* IfcGeom::Kernel::create_brep_for_representation_and_pro
 	const std::string product_type = IfcSchema::Type::ToString(product->type());
 	ElementSettings element_settings(settings, getValue(GV_LENGTH_UNIT), product_type);
 
-	if ( !settings.disable_opening_subtractions() && openings && openings->size() ) {
+    if (!settings.get(IfcGeom::IteratorSettings::DISABLE_OPENING_SUBTRACTIONS) && openings && openings->size()) {
 		IfcGeom::IfcRepresentationShapeItems opened_shapes;
 		try {
 #if OCC_VERSION_HEX < 0x60900
-			const bool faster_booleans = settings.faster_booleans();
+            const bool faster_booleans = settings.get(IteratorSettings::FASTER_BOOLEANS);
 #else
 			const bool faster_booleans = true;
 #endif
@@ -1136,14 +1136,14 @@ IfcGeom::BRepElement<P>* IfcGeom::Kernel::create_brep_for_representation_and_pro
 		} catch(...) { 
 			Logger::Message(Logger::LOG_ERROR,"Error processing openings for:",product->entity); 
 		}
-		if ( settings.use_world_coords() ) {
+        if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
 			for ( IfcGeom::IfcRepresentationShapeItems::iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
 				it->prepend(trsf);
 			}
 			trsf = gp_Trsf();
 		}
 		shape = new IfcGeom::Representation::BRep(element_settings, representation->entity->id(), opened_shapes);
-	} else if ( settings.use_world_coords() ) {
+    } else if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
 		for ( IfcGeom::IfcRepresentationShapeItems::iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
 			it->prepend(trsf);
 		}

src/ifcgeom/IfcGeomIterator.h

@@ -86,6 +86,9 @@ namespace IfcGeom {
 	template <typename P>
 	class Iterator {
 	private:
+		Iterator(const Iterator&); // N/I
+		Iterator& operator=(const Iterator&); // N/I
+
 		Kernel kernel;
 		IteratorSettings settings;
 
@@ -110,6 +113,8 @@ namespace IfcGeom {
 		std::string unit_name;
 		// double?
 		P unit_magnitude;
+        gp_XYZ bounds_min_;
+        gp_XYZ bounds_max_;
 
 		void initUnits() {
 			IfcSchema::IfcProject::list::ptr projects = ifc_file->entitiesByType<IfcSchema::IfcProject>();
@@ -121,6 +126,7 @@ namespace IfcGeom {
 			}
 		}
 
+        std::set<boost::regex> names_to_include_or_exclude; // regex containing a name or a wildcard expression
 		std::set<IfcSchema::Type::Enum> entities_to_include_or_exclude;
 		bool include_entities_in_processing;
 
@@ -148,7 +154,7 @@ namespace IfcGeom {
 			} catch (...) {}
 
 			std::set<std::string> context_types;
-			if (!settings.exclude_solids_and_surfaces()) {
+            if (!settings.get(IteratorSettings::EXCLUDE_SOLIDS_AND_SURFACES)) {
 				// Really this should only be 'Model', as per 
 				// the standard 'Design' is deprecated. So,
 				// just for backwards compatibility:
@@ -157,7 +163,7 @@ namespace IfcGeom {
 				// DDS likes to output 'model view'
 				context_types.insert("model view");
 			}
-			if (settings.include_curves()) {
+            if (settings.get(IteratorSettings::INCLUDE_CURVES)) {
 				context_types.insert("plan");
 			}			
 
@@ -247,39 +253,74 @@ namespace IfcGeom {
 			done = 0;
 			total = representations->size();
 
+            for (int i = 1; i < 4; ++i) {
+                bounds_min_.SetCoord(i, std::numeric_limits<double>::infinity());
+                bounds_max_.SetCoord(i, -std::numeric_limits<double>::infinity());
+            }
+
+            IfcSchema::IfcProduct::list::ptr products = ifc_file->entitiesByType<IfcSchema::IfcProduct>();
+            for (IfcSchema::IfcProduct::list::it iter = products->begin(); iter != products->end(); ++iter) {
+                IfcSchema::IfcProduct* product = *iter;
+                if (product->hasObjectPlacement()) {
+                    gp_Trsf trsf; // Use a fresh trsf every time in order to prevent the result to be concatenated
+                    if (kernel.convert(product->ObjectPlacement(), trsf)) {
+                        const gp_XYZ& pos = trsf.TranslationPart();
+                        bounds_min_.SetX(std::min(bounds_min_.X(), pos.X()));
+                        bounds_min_.SetY(std::min(bounds_min_.Y(), pos.Y()));
+                        bounds_min_.SetZ(std::min(bounds_min_.Z(), pos.Z()));
+                        bounds_max_.SetX(std::max(bounds_max_.X(), pos.X()));
+                        bounds_max_.SetY(std::max(bounds_max_.Y(), pos.Y()));
+                        bounds_max_.SetZ(std::max(bounds_max_.Z(), pos.Z()));
+                    }
+                }
+            }
+
 			return true;
 		}
 
-		int progress() {
-			return 100 * done / total;
-		}
+		int progress() const { return 100 * done / total; }
 
-		const std::string& getUnitName() {
-			return unit_name;
-		}
+		const std::string& getUnitName() const { return unit_name; }
 
-		const P getUnitMagnitude() {
-			return unit_magnitude;
-		}
+		P getUnitMagnitude() const { return unit_magnitude; }
 	
-		const std::string getLog() {
-			return Logger::GetLog();
-		}
+		std::string getLog() const { return Logger::GetLog(); }
 
-		IfcParse::IfcFile* getFile() {
-			return ifc_file;
-		}
+		IfcParse::IfcFile* getFile() const { return ifc_file; }
 
+        /// @note Entity names are handled case-insensitively.
 		void includeEntities(const std::set<std::string>& entities) {
 			populate_set(entities);
 			include_entities_in_processing = true;
 		}
 
+        /// @note Entity names are handled case-insensitively.
 		void excludeEntities(const std::set<std::string>& entities) {
 			populate_set(entities);
 			include_entities_in_processing = false;
 		}
 
+        /// @note Arbitrary names or wildcard expressions are handled case-sensitively.
+        void include_entity_names(const std::vector<std::string>& names)
+        {
+            names_to_include_or_exclude.clear();
+            foreach(const std::string &name, names)
+                names_to_include_or_exclude.insert(IfcUtil::wildcard_string_to_regex(name));
+            include_entities_in_processing = true;
+        }
+
+        /// @note Arbitrary names or wildcard expressions are handled case-sensitively.
+        void exclude_entity_names(const std::vector<std::string>& names)
+        {
+            names_to_include_or_exclude.clear();
+            foreach(const std::string &name, names)
+                names_to_include_or_exclude.insert(IfcUtil::wildcard_string_to_regex(name));
+            include_entities_in_processing = false;
+        }
+
+        const gp_XYZ& bounds_min() const { return bounds_min_; }
+        const gp_XYZ& bounds_max() const { return bounds_max_; }
+
 	private:
 		// Move to the next IfcRepresentation
 		void _nextShape() {
@@ -340,7 +381,7 @@ namespace IfcGeom {
 						}
 					}
 					
-					const bool process_maps_for_current_representation = (!has_openings || settings.disable_opening_subtractions());
+					const bool process_maps_for_current_representation = (!has_openings || settings.get(IteratorSettings::DISABLE_OPENING_SUBTRACTIONS));
 					bool representation_processed_as_mapped_item = false;
 
 					IfcSchema::IfcRepresentation* representation_mapped_to = 0;
@@ -365,7 +406,7 @@ namespace IfcGeom {
 												IfcSchema::IfcProduct::list::ptr products_of_prodrep = (*it)->entity->getInverse(IfcSchema::Type::IfcProduct, -1)->as<IfcSchema::IfcProduct>();
 												products->push(products_of_prodrep);
 												for (IfcSchema::IfcProduct::list::it jt = products_of_prodrep->begin(); jt != products_of_prodrep->end(); ++jt) {
-													if (kernel.find_openings(*jt)->size() > 0 && !settings.disable_opening_subtractions()) {
+													if (kernel.find_openings(*jt)->size() > 0 && !settings.get(IteratorSettings::DISABLE_OPENING_SUBTRACTIONS)) {
 														all_product_without_openings = false;
 														break;
 													}
@@ -418,7 +459,7 @@ namespace IfcGeom {
 									for (IfcSchema::IfcProductRepresentation::list::it kt = prodreps->begin(); kt != prodreps->end(); ++kt) {
 										IfcSchema::IfcProduct::list::ptr prods = (*kt)->entity->getInverse(IfcSchema::Type::IfcProduct, -1)->as<IfcSchema::IfcProduct>();
 										for (IfcSchema::IfcProduct::list::it lt = prods->begin(); lt != prods->end(); ++lt) {
-											if (kernel.find_openings(*lt)->size() == 0 || settings.disable_opening_subtractions()) {
+											if (kernel.find_openings(*lt)->size() == 0 || settings.get(IteratorSettings::DISABLE_OPENING_SUBTRACTIONS)) {
                                                 if (!unfiltered_products->contains(*lt)) {
                                                     unfiltered_products->push(*lt);
                                                 }
@@ -440,6 +481,14 @@ namespace IfcGeom {
 								break;
 							}
 						}
+                        
+                        foreach(const boost::regex& r, names_to_include_or_exclude) {
+                            if (boost::regex_match((*jt)->Name(), r)) {
+                                found = true;
+                                break;
+                            }
+                        }
+                        
 						if (found == include_entities_in_processing) {
 							ifcproducts->push(*jt);
 						}
@@ -494,13 +543,17 @@ namespace IfcGeom {
 			return create();
 		}
 
-		Element<P>* get() {
-			// TODO: Test settings and throw
-			if (current_triangulation) return current_triangulation;
-			else if (current_serialization) return current_serialization;
-			else if (current_shape_model) return current_shape_model;
-			else return 0;
-		}
+        /// Gets or takes the representation of the current geometrical entity.
+        /// @param take_ownership Pass in 'true' as if wishing to maintain the element lifetime yourself.
+        Element<P>* get(bool take_ownership = false)
+        {
+            // TODO: Test settings and throw
+            Element<P>* ret = 0;
+            if (current_triangulation) { ret = current_triangulation; if (take_ownership) current_triangulation = 0; }
+            else if (current_serialization) { ret = current_serialization; if (take_ownership) current_serialization = 0; }
+            else if (current_shape_model) { ret = current_shape_model; if (take_ownership) current_shape_model = 0; }
+            return ret;
+        }
 
 		const Element<P>* getObject(int id) {
 
@@ -549,15 +602,15 @@ namespace IfcGeom {
 			} catch (...) {}
 
 			if (next_shape_model) {
-				if (settings.use_brep_data()) {
+				if (settings.get(IteratorSettings::USE_BREP_DATA)) {
 					try {
 						next_serialization = new SerializedElement<P>(*next_shape_model);
 					} catch (...) {
 						success = false;
 					}
-				} else if (!settings.disable_triangulation()) {
+				} else if (!settings.get(IteratorSettings::DISABLE_TRIANGULATION)) {
 					try {
-						if (ifcproduct_iterator == ifcproducts->begin() || settings.use_world_coords()) {
+						if (ifcproduct_iterator == ifcproducts->begin() || settings.get(IteratorSettings::USE_WORLD_COORDS)) {
 							next_triangulation = new TriangulationElement<P>(*next_shape_model);
 						} else {
 							next_triangulation = new TriangulationElement<P>(*next_shape_model, current_triangulation->geometry_pointer());
@@ -591,8 +644,9 @@ namespace IfcGeom {
 			unit_name = "METER";
 			unit_magnitude = 1.f;
 
-			kernel.setValue(IfcGeom::Kernel::GV_MAX_FACES_TO_SEW, settings.sew_shells() ? 1000 : -1);
-			kernel.setValue(IfcGeom::Kernel::GV_DIMENSIONALITY, (settings.include_curves() ? (settings.exclude_solids_and_surfaces() ? -1. : 0.) : +1.));
+            kernel.setValue(IfcGeom::Kernel::GV_MAX_FACES_TO_SEW, settings.get(IteratorSettings::SEW_SHELLS) ? 1000 : -1);
+            kernel.setValue(IfcGeom::Kernel::GV_DIMENSIONALITY, (settings.get(IteratorSettings::INCLUDE_CURVES)
+                ? (settings.get(IteratorSettings::EXCLUDE_SOLIDS_AND_SURFACES) ? -1. : 0.) : +1.));
 		}
 
 		bool owns_ifc_file;

src/ifcgeom/IfcGeomIteratorSettings.h

@@ -20,160 +20,145 @@
 #ifndef IFCGEOMITERATORSETTINGS_H
 #define IFCGEOMITERATORSETTINGS_H
 
-#include <string>
-
 #include "../ifcparse/IfcException.h"
+#include "../ifcparse/IfcUtil.h"
 
-namespace IfcGeom {
+namespace IfcGeom
+{
+    class IteratorSettings
+    {
+    public:
+        /// Enumeration of setting identifiers. These settings define the
+        /// behaviour of various aspects of IfcOpenShell.
+        enum Setting
+        {
+            /// Specifies whether vertices are welded, meaning that the coordinates
+            /// vector will only contain unique xyz-triplets. This results in a 
+            /// manifold mesh which is useful for modelling applications, but might 
+            /// result in unwanted shading artifacts in rendering applications.
+            WELD_VERTICES = 1,
+            /// Specifies whether to apply the local placements of building elements
+            /// directly to the coordinates of the representation mesh rather than
+            /// to represent the local placement in the 4x3 matrix, which will in that
+            /// case be the identity matrix.
+            USE_WORLD_COORDS = 1 << 1,
+            /// Internally IfcOpenShell measures everything in meters. This settings
+            /// specifies whether to convert IfcGeomObjects back to the units in which
+            /// the geometry in the IFC file is specified.
+            CONVERT_BACK_UNITS = 1 << 2,
+            /// Specifies whether to use the Open Cascade BREP format for representation
+            /// items rather than to create triangle meshes. This is useful is IfcOpenShell
+            /// is used as a library in an application that is also built on Open Cascade.
+            USE_BREP_DATA = 1 << 3,
+            /// Specifies whether to sew IfcConnectedFaceSets (open and closed shells) to
+            /// TopoDS_Shells or whether to keep them as a loose collection of faces.
+            SEW_SHELLS = 1 << 4,
+            /// Specifies whether to compose IfcOpeningElements into a single compound
+            /// in order to speed up the processing of opening subtractions.
+            FASTER_BOOLEANS = 1 << 5,
+            /// Disables the subtraction of IfcOpeningElement representations from
+            /// the related building element representations.
+            DISABLE_OPENING_SUBTRACTIONS = 1 << 6,
+            /// Disables the triangulation of the topological representations. Useful if
+            /// the client application understands Open Cascade's native format.
+            DISABLE_TRIANGULATION = 1 << 7,
+            /// Applies default materials to entity instances without a surface style.
+            APPLY_DEFAULT_MATERIALS = 1 << 8,
+            /// Specifies whether to include subtypes of IfcCurve.
+            INCLUDE_CURVES = 1 << 9,
+            /// Specifies whether to exclude subtypes of IfcSolidModel and IfcSurface.
+            EXCLUDE_SOLIDS_AND_SURFACES = 1 << 10,
+            /// Disables computation of normals. Saves time and file size and is useful
+            /// in instances where you're going to recompute normals for the exported
+            /// model in other modelling application in any case.
+            NO_NORMALS = 1 << 11,
+            /// Use entity names instead of unique IDs for naming elements.
+            /// Applicable for OBJ, DAE, and SVG output.
+            USE_ELEMENT_NAMES = 1 << 12,
+            /// Use entity GUIDs instead of unique IDs for naming elements.
+            /// Applicable for OBJ, DAE, and SVG output.
+            USE_ELEMENT_GUIDS = 1 << 13,
+            /// Use material names instead of unique IDs for naming materials.
+            /// Applicable for OBJ and DAE output.
+            USE_MATERIAL_NAMES = 1 << 14,
+            /// Centers the models upon serialization by the applying the center point of
+            /// the scene bounds as an offset. Applicable only for DAE output currently.
+            CENTER_MODEL = 1 << 15,
+            /// Generates UVs by using simple box projection. Requires normals.
+            /// Applicable only for DAE output currently.
+            GENERATE_UVS = 1 << 16,
+            /// Number of different setting flags.
+            NUM_SETTINGS = 16
+        };
+        /// Used to store logical OR combination of setting flags.
+        typedef unsigned SettingField;
 
-	class IteratorSettings {
-	public:
-		// Enumeration of setting identifiers. These settings define the
-		// behaviour of various aspects of IfcOpenShell.
+        IteratorSettings()
+            : settings_(WELD_VERTICES) // OR options that default to true here
+            , deflection_tolerance_(1.e-3)
+        {
+            memset(offset, 0, sizeof(offset));
+        }
 
-		// Specifies whether vertices are welded, meaning that the coordinates
-		// vector will only contain unique xyz-triplets. This results in a 
-		// manifold mesh which is useful for modelling applications, but might 
-		// result in unwanted shading artifacts in rendering applications.
-		static const int WELD_VERTICES = 1;
-		// Specifies whether to apply the local placements of building elements
-		// directly to the coordinates of the representation mesh rather than
-		// to represent the local placement in the 4x3 matrix, which will in that
-		// case be the identity matrix.
-		static const int USE_WORLD_COORDS = 2;
-		// Internally IfcOpenShell measures everything in meters. This settings
-		// specifies whether to convert IfcGeomObjects back to the units in which
-		// the geometry in the IFC file is specified.
-		static const int CONVERT_BACK_UNITS = 3;
-		// Specifies whether to use the Open Cascade BREP format for representation
-		// items rather than to create triangle meshes. This is useful is IfcOpenShell
-		// is used as a library in an application that is also built on Open Cascade.
-		static const int USE_BREP_DATA = 4;
-		// Specifies whether to sew IfcConnectedFaceSets (open and closed shells) to
-		// TopoDS_Shells or whether to keep them as a loose collection of faces.
-		static const int SEW_SHELLS = 5;
-		// Specifies whether to compose IfcOpeningElements into a single compound
-		// in order to speed up the processing of opening subtractions.
-		static const int FASTER_BOOLEANS = 6;
-		// Disables the subtraction of IfcOpeningElement representations from
-		// the related building element representations.
-		static const int DISABLE_OPENING_SUBTRACTIONS = 8;
-		// Disables the triangulation of the topological representations. Useful if
-		// the client application understands Open Cascade's native format.
-		static const int DISABLE_TRIANGULATION = 9;
-		// Applies default materials to entity instances without a surface style.
-		static const int APPLY_DEFAULT_MATERIALS = 10;
-		// Specifies whether to include subtypes of IfcCurve.
-		static const int INCLUDE_CURVES = 11;
-		// Specifies whether to exclude subtypes of IfcSolidModel and IfcSurface.
-		static const int EXCLUDE_SOLIDS_AND_SURFACES = 12;
+        /// Optional offset that is applied to serialized objects, (0,0,0) by default.
+        double offset[3];
 
-		// End of settings enumeration.
+        /// Note that this is independent of the IFC length unit, one millimeter by default.
+        double deflection_tolerance() const { return deflection_tolerance_; }
 
-	private:
-		bool _weld_vertices, _use_world_coords, _convert_back_units, _use_brep_data, _sew_shells, _faster_booleans, _disable_opening_subtractions, _disable_triangulation, _apply_default_materials, _include_curves, _exclude_solids_and_surfaces;
-		double _deflection_tolerance;
-	public:
-		IteratorSettings()
-			: _weld_vertices(true)
-			, _use_world_coords(false)
-			, _convert_back_units(false)
-			, _use_brep_data(false)
-			, _sew_shells(false)
-			, _faster_booleans(false)
-			, _disable_opening_subtractions(false)
-			, _disable_triangulation(false)
-			, _apply_default_materials(false)
-			, _include_curves(false)
-			, _exclude_solids_and_surfaces(false)
-			// TODO: Make deflection tolerance into a command line argument
-			// For now, stick to one millimeter. Note that this is independent of the IFC length unit.
-			, _deflection_tolerance(1.e-3)
-		{}
+        void set_deflection_tolerance(double value)
+        {
+            /// @todo Using deflection tolerance of 1e-6 or smaller hangs the conversion, research more in-depth.
+            /// This bug can be reproduced e.g. with the Duplex model that can be found from http://www.nibs.org/?page=bsa_commonbimfiles#project1
+            deflection_tolerance_ = value;
+            if (deflection_tolerance_ <= 1e-6) {
+                Logger::Message(Logger::LOG_WARNING, "Deflection tolerance cannot be set to <= 1e-6; using the default value 1e-3");
+                deflection_tolerance_ = 1e-3;
+            }
+        }
 
-		const bool& weld_vertices() const { return _weld_vertices; }
-		bool& weld_vertices() { return _weld_vertices; }
-		const bool& use_world_coords() const { return _use_world_coords; }
-		bool& use_world_coords() { return _use_world_coords; }
-		const bool& convert_back_units() const { return _convert_back_units; }
-		bool& convert_back_units() { return _convert_back_units; }
-		const bool& use_brep_data() const { return _use_brep_data; }
-		bool& use_brep_data() { return _use_brep_data; }
-		const bool& sew_shells() const { return _sew_shells; }
-		bool& sew_shells() { return _sew_shells; }
-		const bool& faster_booleans() const { return _faster_booleans; }
-		bool& faster_booleans() { return _faster_booleans; }
-		const bool& disable_opening_subtractions() const { return _disable_opening_subtractions; }
-		bool& disable_opening_subtractions() { return _disable_opening_subtractions; }
-		const bool& disable_triangulation() const { return _disable_triangulation; }
-		bool& disable_triangulation() { return _disable_triangulation; }
-		const bool& apply_default_materials() const { return _apply_default_materials; }
-		bool& apply_default_materials() { return _apply_default_materials; }
-		const bool& include_curves() const { return _include_curves; }
-		bool& include_curves() { return _include_curves; }
-		const bool& exclude_solids_and_surfaces() const { return _exclude_solids_and_surfaces; }
-		bool& exclude_solids_and_surfaces() { return _exclude_solids_and_surfaces; }
-		
-		const double& deflection_tolerance() const { return _deflection_tolerance; }
-		double& deflection_tolerance() { return _deflection_tolerance; }
-		
-		void set(int setting, bool value) {
-			switch (setting) {
-			case USE_WORLD_COORDS:
-				_use_world_coords = value;
-				break;
-			case WELD_VERTICES:
-				_weld_vertices = value;
-				break;
-			case CONVERT_BACK_UNITS:
-				_convert_back_units = value;
-				break;
-			case USE_BREP_DATA:
-				_use_brep_data = value;
-				break;
-			case FASTER_BOOLEANS:
-				_faster_booleans = value;
-				break;
-			case SEW_SHELLS:
-				_sew_shells = value;
-				break;
-			case DISABLE_OPENING_SUBTRACTIONS:
-				_disable_opening_subtractions = value;
-				break;
-			case DISABLE_TRIANGULATION:
-				_disable_triangulation = value;
-				break;
-			case APPLY_DEFAULT_MATERIALS:
-				_apply_default_materials = value;
-				break;
-			case INCLUDE_CURVES:
-				_include_curves = value;
-				break;
-			case EXCLUDE_SOLIDS_AND_SURFACES:
-				_exclude_solids_and_surfaces = value;
-				break;
-			default: throw IfcParse::IfcException("Invalid IteratorSetting");
-			}
-		}
-	};
-	
-	class ElementSettings : public IteratorSettings {
-	private:
-		double _unit_magnitude;
-		std::string _element_type;
-	public:
-		ElementSettings(const IteratorSettings& settings,
-			double unit_magnitude,
-			const std::string& element_type)
-			: IteratorSettings(settings)
-			, _unit_magnitude(unit_magnitude)
-			, _element_type(element_type)
-		{}
+        /// Get boolean value for a single settings or for a combination of settings.
+        bool get(SettingField setting) const
+        {
+            /// @todo If unknown setting value/combination: throw IfcParse::IfcException("Invalid IteratorSetting")?
+            return (settings_ & setting) != 0;
+        }
 
-		const double& unit_magnitude() const { return _unit_magnitude; }
-		const std::string& element_type() const { return _element_type; }
-	};
+        /// Set boolean value for a single settings or for a combination of settings.
+        void set(SettingField setting, bool value)
+        {
+            /// @todo If unknown setting value/combination: throw IfcParse::IfcException("Invalid IteratorSetting")?
+            if (value) {
+                settings_ |= setting;
+            } else {
+                settings_ &= ~setting;
+            }
+        }
 
+    protected:
+        SettingField settings_;
+        double deflection_tolerance_;
+    };
+
+    class ElementSettings : public IteratorSettings
+    {
+    public:
+        ElementSettings(const IteratorSettings& settings,
+            double unit_magnitude,
+            const std::string& element_type)
+            : IteratorSettings(settings)
+            , unit_magnitude_(unit_magnitude)
+            , element_type_(element_type)
+        {
+        }
+
+        double unit_magnitude() const { return unit_magnitude_; }
+        const std::string& element_type() const { return element_type_; }
+
+    private:
+        double unit_magnitude_;
+        std::string element_type_;
+    };
 }
 
-#endif
+#endif

src/ifcgeom/IfcGeomMaterial.cpp

@@ -30,5 +30,6 @@ const double* IfcGeom::Material::diffuse() const { if (hasDiffuse()) return &((*
 const double* IfcGeom::Material::specular() const { if (hasSpecular()) return &((*style->Specular()).R()); else return black; }
 double IfcGeom::Material::transparency() const { if (hasTransparency()) return *style->Transparency(); else return 0; }
 double IfcGeom::Material::specularity() const { if (hasSpecularity()) return *style->Specularity(); else return 0; }
-const std::string IfcGeom::Material::name() const { return style->Name(); }
+const std::string &IfcGeom::Material::name() const { return style->Name(); }
+const std::string &IfcGeom::Material::original_name() const { return style->original_name(); }
 bool IfcGeom::Material::operator==(const IfcGeom::Material& other) const { return style == other.style; }

src/ifcgeom/IfcGeomMaterial.h

@@ -41,10 +41,11 @@ namespace IfcGeom {
 		const double* specular() const;
 		double transparency() const;
 		double specularity() const;
-		const std::string name() const;
+		const std::string &name() const;
+		const std::string &original_name() const;
 		bool operator==(const Material& other) const;
 	};
 
 }
 
-#endif
+#endif

src/ifcgeom/IfcGeomRenderStyles.h

@@ -45,21 +45,21 @@ namespace IfcGeom {
 		};
 	private:
 		std::string name;
+        std::string original_name_;
 		boost::optional<int> id;
 		boost::optional<ColorComponent> diffuse, specular;
 		boost::optional<double> transparency;
 		boost::optional<double> specularity;
 	public:
-		SurfaceStyle() {
-			this->name = "surface-style";
-		}
+        SurfaceStyle() : name("surface-style") {}
 		SurfaceStyle(int id) : id(id) {
 			std::stringstream sstr; 
 			sstr << "surface-style-" << id; 
 			this->name = sstr.str(); 
 		}
-		SurfaceStyle(const std::string& name) : name(name) {}
-		SurfaceStyle(int id, const std::string& name) : id(id) {
+        SurfaceStyle(const std::string& name) : name(name), original_name_(name) {}
+        SurfaceStyle(int id, const std::string& name) : id(id), original_name_(name)
+        {
 			std::stringstream sstr; 
 			std::string sanitized = name;
 			std::transform(sanitized.begin(), sanitized.end(), sanitized.begin(), ::tolower);
@@ -76,8 +76,12 @@ namespace IfcGeom {
 			return name == other.name;
 		}
 		
+        /// ID name, e.g. "surface-style-66675-metal---aluminium"
 		const std::string& Name() const { return name; }
 
+        /// Original name, if available, e.g. "Metal - Aluminium"
+        const std::string& original_name() const { return original_name_; }
+
 		const boost::optional<ColorComponent>& Diffuse() const { return diffuse; }
 		const boost::optional<ColorComponent>& Specular() const { return specular; }
 		const boost::optional<double>& Transparency() const { return transparency; }
@@ -91,4 +95,4 @@ namespace IfcGeom {
 	const SurfaceStyle* get_default_style(const std::string& ifc_type);
 }
 
-#endif
+#endif

src/ifcgeom/IfcGeomRepresentation.cpp

@@ -38,7 +38,7 @@ IfcGeom::Representation::Serialization::Serialization(const BRep& brep)
 	for (IfcGeom::IfcRepresentationShapeItems::const_iterator it = brep.begin(); it != brep.end(); ++ it) {
 		const TopoDS_Shape& s = it->Shape();
 		gp_GTrsf trsf = it->Placement();
-		if (settings().convert_back_units()) {
+		if (settings().get(IteratorSettings::CONVERT_BACK_UNITS)) {
 			gp_Trsf scale;
 			scale.SetScaleFactor(1.0 / settings().unit_magnitude());
 			trsf.PreMultiply(scale);

src/ifcgeom/IfcGeomRepresentation.h

@@ -103,6 +103,7 @@ namespace IfcGeom {
 			std::vector<int> _faces;
 			std::vector<int> _edges;
 			std::vector<P> _normals;
+            std::vector<P> uvs_;
 			std::vector<int> _material_ids;
 			std::vector<Material> _materials;
 			VertexKeyMap welds;
@@ -113,8 +114,10 @@ namespace IfcGeom {
 			const std::vector<int>& faces() const { return _faces; }
 			const std::vector<int>& edges() const { return _edges; }
 			const std::vector<P>& normals() const { return _normals; }
+            const std::vector<P>& uvs() const { return uvs_; }
 			const std::vector<int>& material_ids() const { return _material_ids; }
 			const std::vector<Material>& materials() const { return _materials; }
+
 			Triangulation(const BRep& shape_model)
 					: Representation(shape_model.settings())
 					, _id(shape_model.getId())
@@ -133,7 +136,7 @@ namespace IfcGeom {
 						}
 					}
 
-					if (settings().apply_default_materials() && surface_style_id == -1) {
+					if (settings().get(IteratorSettings::APPLY_DEFAULT_MATERIALS) && surface_style_id == -1) {
 						Material material(IfcGeom::get_default_style(settings().element_type()));
 						std::vector<Material>::const_iterator mit = std::find(_materials.begin(), _materials.end(), material);
 						if (mit == _materials.end()) {
@@ -182,8 +185,9 @@ namespace IfcGeom {
 							BRepGProp_Face prop(face);
 							std::map<int,int> dict;
 
-							// Vertex normals are only calculated if vertices are not welded
-							const bool calculate_normals = !settings().weld_vertices();
+                            // Vertex normals are only calculated if vertices are not welded and calculation is not disable explicitly.
+                            const bool calculate_normals = !settings().get(IteratorSettings::WELD_VERTICES) &&
+                                !settings().get(IteratorSettings::NO_NORMALS);
 
 							for( int i = 1; i <= nodes.Length(); ++ i ) {
 								coords.push_back(nodes(i).Transformed(loc).XYZ());
@@ -246,6 +250,10 @@ namespace IfcGeom {
 						}
 					}
 
+                    if (!_normals.empty() && settings().get(IfcGeom::IteratorSettings::GENERATE_UVS)) {
+                        uvs_ = box_project_uvs(_verts, _normals);
+                    }
+
 					if (num_faces == 0) {
 						// Edges are only emitted if there are no faces. A mixed representation of faces
 						// and loose edges is discouraged by the standard. An alternative would be to use
@@ -277,14 +285,46 @@ namespace IfcGeom {
 				}
 			}
 			virtual ~Triangulation() {}
+
+            /// Generates UVs for a single mesh using box projection.
+            /// @todo Very simple impl. Assumes that input vertices and normals match 1:1.
+            static std::vector<P> box_project_uvs(const std::vector<P> &vertices, const std::vector<P> &normals)
+            {
+                std::vector<P> uvs;
+                uvs.resize(vertices.size() / 3 * 2);
+                for (size_t uv_idx = 0, v_idx = 0;
+                uv_idx < uvs.size() && v_idx < vertices.size() && v_idx < normals.size();
+                    uv_idx += 2, v_idx += 3) {
+
+                    P n_x = normals[v_idx], n_y = normals[v_idx + 1], n_z = normals[v_idx + 2];
+                    P v_x = vertices[v_idx], v_y = vertices[v_idx + 1], v_z = vertices[v_idx + 2];
+
+                    if (std::abs(n_x) > std::abs(n_y) && std::abs(n_x) > std::abs(n_z)) {
+                        uvs[uv_idx] = v_z;
+                        uvs[uv_idx + 1] = v_y;
+                    }
+                    if (std::abs(n_y) > std::abs(n_x) && std::abs(n_y) > std::abs(n_z)) {
+                        uvs[uv_idx] = v_x;
+                        uvs[uv_idx + 1] = v_z;
+                    }
+                    if (std::abs(n_z) > std::abs(n_x) && std::abs(n_z) > std::abs(n_y)) {
+                        uvs[uv_idx] = v_x;
+                        uvs[uv_idx + 1] = v_y;
+                    }
+                }
+
+                return uvs;
+            }
+
 		private:
 			// Welds vertices that belong to different faces
 			int addVertex(int material_index, const gp_XYZ& p) {
-				const P X = static_cast<P>(settings().convert_back_units() ? (p.X() / settings().unit_magnitude()) : p.X());
-				const P Y = static_cast<P>(settings().convert_back_units() ? (p.Y() / settings().unit_magnitude()) : p.Y());
-				const P Z = static_cast<P>(settings().convert_back_units() ? (p.Z() / settings().unit_magnitude()) : p.Z());
+                const bool convert = settings().get(IteratorSettings::CONVERT_BACK_UNITS);
+				const P X = static_cast<P>(convert ? (p.X() / settings().unit_magnitude()) : p.X());
+				const P Y = static_cast<P>(convert ? (p.Y() / settings().unit_magnitude()) : p.Y());
+				const P Z = static_cast<P>(convert ? (p.Z() / settings().unit_magnitude()) : p.Z());
 				int i = (int) _verts.size() / 3;
-				if (settings().weld_vertices()) {
+				if (settings().get(IteratorSettings::WELD_VERTICES)) {
 					const VertexKey key = std::make_pair(material_index, std::make_pair(X, std::make_pair(Y, Z)));
 					typename VertexKeyMap::const_iterator it = welds.find(key);
 					if ( it != welds.end() ) return it->second;
@@ -310,4 +350,4 @@ namespace IfcGeom {
 	}
 }
 
-#endif
+#endif