Begin to implement IfcConvert enhancements discussed in #20. Remove C++-specific getters and setters and use the same set() and get() functions in in both C++ and Python. Enhance output of IfcConvert, especially in error situations (spamming a hundred lines of options always hides the original error message), utilize Boost's foreach macro to provide cleaner iteration code.

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

@@ -1103,11 +1103,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
@@ -1123,14 +1123,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;
 
@@ -121,6 +124,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 +152,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 +161,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");
 			}			
 
@@ -250,36 +254,46 @@ namespace IfcGeom {
 			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;
 		}
 
+        // 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;
+        }
+
+        // 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;
+        }
+
 	private:
 		// Move to the next IfcRepresentation
 		void _nextShape() {
@@ -330,6 +344,14 @@ namespace IfcGeom {
 									break;
 								}
 							}
+
+                            foreach(const boost::regex& r, names_to_include_or_exclude) {
+                                if (boost::regex_match((*it)->Name(), r)) {
+                                    found = true;
+                                    break;
+                                }
+                            }
+
 							if (found == include_entities_in_processing) {
 								ifcproducts->push(*jt);
 							}
@@ -382,13 +404,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) {
 
@@ -430,12 +456,12 @@ namespace IfcGeom {
 				current_shape_model = create_shape_model_for_next_entity();
 			} catch (...) {}
 			if (!current_shape_model) return false;
-			if (settings.use_brep_data()) {
+            if (settings.get(IteratorSettings::USE_BREP_DATA)) {
 				try {
 					current_serialization = new SerializedElement<P>(*current_shape_model);
 				} catch (...) {}
 				return !!current_serialization;
-			} else if (!settings.disable_triangulation()) {
+            } else if (!settings.get(IteratorSettings::DISABLE_TRIANGULATION)) {
 				try {
 					current_triangulation = new TriangulationElement<P>(*current_shape_model);
 				} catch (...) {}
@@ -457,8 +483,8 @@ 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,130 @@
 #ifndef IFCGEOMITERATORSETTINGS_H
 #define IFCGEOMITERATORSETTINGS_H
 
-#include <string>
-
 #include "../ifcparse/IfcException.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 objects and materials.
+            /// Applicable for .obj and .dae output.
+            //USE_NAMES = 1 << 12,
+            /// Use entity GUIDs instead of unique IDs for naming objects.
+            /// Overrides possible usage of --use-names for objects but not for materials.
+            /// Applicable for .obj and .dae output.
+            //USE_GUIDS = 1 << 13,
+            /// 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 << 14,
+            /// Generates UVs by using simple box projection. Requires normals.
+            /// Applicable only for .dae output currently.
+            //GENERATE_UVS = 1 << 15,
+            //NUM_SETTINGS = 15
+        };
+        /// 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_; }
+        /// @todo Sanity check for the value
+        void set_deflection_tolerance(double value) { deflection_tolerance_ = value; }
 
-	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)
-		{}
+        bool get(SettingField setting) const
+        {
+            /// @todo If unknown setting value/combination: throw IfcParse::IfcException("Invalid IteratorSetting")?
+            return (settings_ & setting) != 0;
+        }
 
-		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)
-		{}
+        void set(SettingField setting, bool value)
+        {
+            /// @todo If unknown setting value/combination: throw IfcParse::IfcException("Invalid IteratorSetting")?
+            if (value) {
+                settings_ |= setting;
+            } else {
+                settings_ &= ~setting;
+            }
+        }
 
-		const double& unit_magnitude() const { return _unit_magnitude; }
-		const std::string& element_type() const { return _element_type; }
-	};
+    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/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

@@ -132,7 +132,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,7 +182,7 @@ namespace IfcGeom {
 							std::map<int,int> dict;
 
 							// Vertex normals are only calculated if vertices are not welded
-							const bool calculate_normals = !settings().weld_vertices();
+							const bool calculate_normals = !settings().get(IteratorSettings::WELD_VERTICES);
 
 							for( int i = 1; i <= nodes.Length(); ++ i ) {
 								coords.push_back(nodes(i).Transformed(loc).XYZ());
@@ -278,11 +278,12 @@ namespace IfcGeom {
 		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;