Initial commit

src/ifcblender/IfcBlender.py

@@ -0,0 +1,51 @@
+import bpy, mathutils
+from bpy.props import *
+from io_utils import ImportHelper
+
+class ImportIFC(bpy.types.Operator, ImportHelper):
+    '''Load an IFC File'''
+    bl_idname = "import_scene.ifc"
+    bl_label = "Import IFC"
+
+    filename_ext = ".ifc"
+    filter_glob = StringProperty(default="*.ifc", options={'HIDDEN'})
+    
+    def execute(self, context):
+        import IFCimport
+        IFCimport.init_objs(self.filepath)
+        ids = {}
+        while True:
+            ob = IFCimport.current_obj()
+            print (ob.name)
+            if not ob.type in ['IFCSPACE','IFCOPENINGELEMENT']:
+                f = ob.mesh.faces
+                v = ob.mesh.verts
+                m = ob.matrix
+                if ob.mesh.id in ids: me = ids[ob.mesh.id]
+                else:
+                    verts = []
+                    faces = []
+                    for i in range(0,len(f),3):
+                        faces.append([f[i+0],f[i+1],f[i+2]])
+                    for i in range(0,len(v),3):
+                        verts.append([v[i+0],v[i+1],v[i+2]])
+                    me = bpy.data.meshes.new('mesh%d'%ob.mesh.id)
+                    me.from_pydata(verts,[],faces)
+                    if ob.type in bpy.data.materials:
+                        mat = bpy.data.materials[ob.type]
+                        mat.use_fake_user = True
+                    else: mat = bpy.data.materials.new(ob.type)
+                    me.materials.append(mat)
+                    ids[ob.mesh.id] = me
+                bob = bpy.data.objects.new(ob.name,me)
+                bob.matrix_world = mathutils.Matrix([m[0],m[1],m[2],0],[m[3],m[4],m[5],0],[m[6],m[7],m[8],0],[m[9],m[10],m[11],1])
+                bpy.context.scene.objects.link(bob)
+                me.update()
+            if not IFCimport.next_obj(): break
+        return {'FINISHED'}
+    
+def menu_func_import(self, context):
+    self.layout.operator(ImportIFC.bl_idname, text="Industry Foundation Classes (.ifc)")
+def register():
+    bpy.types.INFO_MT_file_import.append(menu_func_import)
+register()

src/ifcmax/IfcMax.cpp

@@ -0,0 +1,174 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include "Max.h"
+#include "stdmat.h"
+#include "decomp.h"
+#include "shape.h"
+#include "splshape.h"
+#include "dummy.h"
+#include "istdplug.h"
+
+#include "../ifcmax/IfcMax.h"
+#include "../ifcmax/MaxMaterials.h"
+#include "../ifcparse/IfcGeomObjects.h"
+
+int controlsInit = false;
+
+BOOL WINAPI DllMain(HINSTANCE hinstDLL,ULONG fdwReason,LPVOID lpvReserved) {	
+	if (!controlsInit) {
+		controlsInit = true;
+		InitCommonControls();
+	}	
+	return true;
+}
+
+__declspec( dllexport ) const TCHAR* LibDescription() {
+	return _T("IfcOpenShell IFC Importer");
+}
+
+__declspec( dllexport ) int LibNumberClasses() { return 1; }
+
+static class IFCImpClassDesc:public ClassDesc {
+public:
+	int                     IsPublic() {return 1;}
+	void *                  Create(BOOL loading = FALSE) {return new IFCImp;} 
+	const TCHAR *			ClassName() {return _T("IFCImp");}
+	SClass_ID               SuperClassID() {return SCENE_IMPORT_CLASS_ID;} 
+	Class_ID                ClassID() {return Class_ID(0x3f230dbf, 0x5b3015c2);}
+	const TCHAR*			Category() {return _T("Chrutilities");}
+} IFCImpDesc;
+
+__declspec( dllexport ) ClassDesc* LibClassDesc(int i) {
+	return i == 0 ? &IFCImpDesc : 0;
+}
+
+__declspec( dllexport ) ULONG LibVersion() {
+	return VERSION_3DSMAX;
+}
+
+int IFCImp::ExtCount() { return 1; }
+
+const TCHAR * IFCImp::Ext(int n) {
+	return n == 0 ? _T("IFC") : _T("");
+}
+
+const TCHAR * IFCImp::LongDesc() {
+	return _T("IfcOpenShell IFC Importer for 3ds Max");
+}
+
+const TCHAR * IFCImp::ShortDesc() {
+	return _T("Industry Foundation Classes");
+}
+
+const TCHAR * IFCImp::AuthorName() {
+	return _T("Thomas Krijnen");
+}
+
+const TCHAR * IFCImp::CopyrightMessage() {
+	return _T("Copyight (c) 2011 IfcOpenShell");
+}
+
+const TCHAR * IFCImp::OtherMessage1() {
+	return _T("");
+}
+
+const TCHAR * IFCImp::OtherMessage2() {
+	return _T("");
+}
+
+unsigned int IFCImp::Version() {
+	return 12;
+}
+
+static BOOL CALLBACK AboutBoxDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
+	return TRUE;
+}       
+
+void IFCImp::ShowAbout(HWND hWnd) {} 
+
+DWORD WINAPI fn(LPVOID arg) { return 0; }
+
+int IFCImp::DoImport(const TCHAR *name, ImpInterface *impitfc, Interface *itfc, BOOL suppressPrompts) {
+
+	itfc->ProgressStart("Importing file...", TRUE, fn, NULL);
+
+	if ( ! IfcGeomObjects::Init((char*)name) ) return false;
+
+	std::map<int, TriObject*> dict;
+	MtlBaseLib* mats = itfc->GetSceneMtls();
+	int slot = mats->Count();
+
+	do{
+
+		const IfcGeomObjects::IfcGeomObject* o = IfcGeomObjects::Get();
+		
+		Mtl *m;
+		const int matIndex = mats->FindMtlByName(MSTR(o->type.c_str()));
+		if ( matIndex == -1 ) {
+			StdMat2* stdm = GetMaterial(o->type);
+			m = stdm;
+			m->SetName(o->type.c_str());
+			mats->Add(m);
+			itfc->PutMtlToMtlEditor(m,slot++);
+		} else {
+			m = static_cast<Mtl*>((*mats)[matIndex]);
+		} 
+		
+		std::map<int, TriObject*>::const_iterator it = dict.find(o->mesh->id);
+
+		TriObject* tri;
+		if ( it == dict.end() ) {
+			tri = CreateNewTriObject();
+			const int numVerts = o->mesh->verts.size()/3;
+			tri->mesh.setNumVerts(numVerts);
+			for( int i = 0; i < numVerts; i ++ ) {
+				tri->mesh.setVert(i,o->mesh->verts[3*i+0],o->mesh->verts[3*i+1],o->mesh->verts[3*i+2]);
+			}
+			const int numFaces = o->mesh->faces.size()/3;
+			tri->mesh.setNumFaces(numFaces);
+			for( int i = 0; i < numFaces; i ++ ) {
+				tri->mesh.faces[i].setVerts(o->mesh->faces[3*i+0],o->mesh->faces[3*i+1],o->mesh->faces[3*i+2]);
+				tri->mesh.faces[i].setEdgeVisFlags(o->mesh->edges[3*i+0],o->mesh->edges[3*i+1],o->mesh->edges[3*i+2]);
+			}
+			tri->mesh.InvalidateTopologyCache();
+			tri->mesh.InvalidateGeomCache();	
+			tri->mesh.buildNormals();
+			tri->mesh.BuildStripsAndEdges();
+			dict[o->mesh->id] = tri;
+		} else {
+			tri = (*it).second;
+		}
+
+		ImpNode* node = impitfc->CreateNode();
+		node->Reference(tri);
+		node->SetName(o->name.c_str());
+		node->GetINode()->SetMtl(m);
+		node->SetTransform(0,Matrix3 ( Point3(o->matrix[0],o->matrix[1],o->matrix[2]),Point3(o->matrix[3],o->matrix[4],o->matrix[5]),
+			Point3(o->matrix[6],o->matrix[7],o->matrix[8]),Point3(o->matrix[9],o->matrix[10],o->matrix[11]) ));
+		impitfc->AddNodeToScene(node);
+
+		itfc->ProgressUpdate(IfcGeomObjects::Progress(),true,"");
+
+	} while ( IfcGeomObjects::Next() );
+
+	itfc->ProgressEnd();
+	
+	return true;
+}

src/ifcmax/IfcMax.def

@@ -0,0 +1,8 @@
+LIBRARY ifcmax.dli
+EXPORTS
+	LibDescription			@1
+	LibNumberClasses		@2
+	LibClassDesc			@3
+	LibVersion				@4
+SECTIONS
+	.data READ WRITE

src/ifcmax/IfcMax.h

@@ -0,0 +1,52 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCMAX_H
+#define IFCMAX_H
+
+#include "Max.h"
+#include "istdplug.h"
+#include "stdmat.h"
+#include "decomp.h"
+#include "shape.h"
+#include "splshape.h"
+#include "dummy.h"
+
+extern ClassDesc* GetIFCImpDesc();
+
+//extern HINSTANCE hInstance;
+
+class IFCImp : public SceneImport 
+{
+public:
+	int ExtCount();                   //  = 1
+	const TCHAR * Ext(int n);         //  = "IFC"
+	const TCHAR * LongDesc();         //  = "IfcOpenShell IFC Importer for 3ds Max"
+	const TCHAR * ShortDesc();        //  = "Industry Foundation Classes"
+	const TCHAR * AuthorName();       //  = "Thomas Krijnen"
+	const TCHAR * CopyrightMessage(); //  = "Copyight (c) 2011 IfcOpenShell"
+	const TCHAR * OtherMessage1();    //  = ""
+	const TCHAR * OtherMessage2();    //  = ""
+	unsigned int Version();           //  = 12
+	void	ShowAbout(HWND hWnd);
+	int		DoImport(const TCHAR *name,ImpInterface *ei,Interface *i, BOOL suppressPrompts);
+	//static BOOL resetScene;
+};
+
+#endif

src/ifcmax/MaxMaterials.h

@@ -0,0 +1,48 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * This file defines materials for use in 3ds Max for several IFC datatypes     *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <string>
+
+#include "Max.h"
+#include "stdmat.h"
+
+StdMat2* GetMaterial(const std::string& s) {
+	StdMat2* mat = NewDefaultStdMat();
+	TimeValue t (-1);
+	mat->SetSpecular(Color(0.2f,0.2f,0.2f),t);
+	mat->SetAmbient(Color(0.1f,0.1f,0.1f),t);
+	mat->SetWire( s == "IFCSPACE" || s == "IFCOPENINGELEMENT" );
+	if ( s == "IFCSITE" ) { mat->SetDiffuse(Color(0.75f,0.8f,0.65f),t); }
+	if ( s == "IFCSLAB" ) { mat->SetDiffuse(Color(0.4f,0.4f,0.4f),t); }
+	if ( s == "IFCWALLSTANDARDCASE" ) { mat->SetDiffuse(Color(0.9f,0.9f,0.9f),t); }
+	if ( s == "IFCWALL" ) { mat->SetDiffuse(Color(0.9f,0.9f,0.9f),t); }
+	if ( s == "IFCWINDOW" ) { mat->SetDiffuse(Color(0.75f,0.8f,0.75f),t); mat->SetSpecular(Color(1.0f,1.0f,1.0f),t); 
+	mat->SetAmbient(Color(0.0f,0.0f,0.0f),t); mat->SetShininess(500.0f,t); mat->SetOpacity(0.3f,t); }
+	if ( s == "IFCDOOR" ) { mat->SetDiffuse(Color(0.55f,0.3f,0.15f),t); }
+	if ( s == "IFCBEAM" ) { mat->SetDiffuse(Color(0.75f,0.7f,0.7f),t); }
+	if ( s == "IFCRAILING" ) { mat->SetDiffuse(Color(0.75f,0.7f,0.7f),t); }
+	if ( s == "IFCMEMBER" ) { mat->SetDiffuse(Color(0.75f,0.7f,0.7f),t); }
+	return mat;
+}

src/ifcobj/IfcObj.cpp

@@ -0,0 +1,88 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * This is a brief example of how IfcOpenShell can be interfaced from within    *
+ * a C++ context. The application reads an .ifc file and outputs geometry in    *
+ * the Wavefront .obj file format.                                              *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <fstream>
+#include <set>
+
+#include "../ifcparse/IfcGeomObjects.h"
+#include "../ifcobj/ObjMaterials.h"
+
+int main ( int argc, char** argv ) {
+	if ( argc != 2 ) {
+		std::cout << "usage: IfcObj <filename.ifc>" << std::endl;
+		return 1;
+	}
+	const std::string fnObj = std::string(argv[1]) + ".obj";
+	const std::string fnMtl = std::string(argv[1]) + ".mtl";
+	ofstream fObj(fnObj.c_str());
+	ofstream fMtl(fnMtl.c_str());
+	if ( ! ( fObj.is_open() && fMtl.is_open() ) ) {
+		std::cout << "[Error] unable to open output file for writing" << std::endl;
+		return 1;
+	}
+
+	// Parse the file supplied in argv[1]. Returns true on succes.
+	// The second argument defines whether geometry will be defined using global or local coordinates.
+	if ( ! IfcGeomObjects::Init(argv[1],true) ) {
+		std::cout << "[Error] unable to parse .ifc file or no geometrical entities found" << std::endl;
+		return 1;
+	}
+
+	fObj << "# File generated by IfcOpenShell" << std::endl;
+	fObj << "mtllib " << fnMtl << std::endl;
+	std::set<std::string> materials;
+
+	// 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 IfcObjects.h for definition)
+	// IfcGeomObjects::Next() is used to poll whether more geometrical entities are available
+	do {
+		const IfcGeomObjects::IfcGeomObject* o = IfcGeomObjects::Get();
+		if ( o->type == "IFCSPACE" || o->type == "IFCOPENINGELEMENT" ) continue;
+		fObj << "o " << o->name << std::endl;
+		fObj << "usemtl " << o->type << std::endl;
+		materials.insert(o->type);
+		const int vcount = o->mesh->verts.size() / 3;
+		for ( IfcGeomObjects::FltIt it = o->mesh->verts.begin(); it != o->mesh->verts.end(); ) {
+			const float x = *(it++);
+			const float y = *(it++);
+			const float z = *(it++);
+			fObj << "v " << x << " " << y << " " << z << std::endl;
+		}
+		for ( IfcGeomObjects::IntIt it = o->mesh->faces.begin(); it != o->mesh->faces.end(); ) {
+			const int v1 = *(it++)-vcount;
+			const int v2 = *(it++)-vcount;
+			const int v3 = *(it++)-vcount;
+			fObj << "f " << v1 << " " << v2 << " " << v3 << std::endl;
+		}
+	} while ( IfcGeomObjects::Next() );
+
+	// Writes the material settings, defined in Materials.h
+	fMtl << "# File generated by IfcOpenShell" << std::endl;
+	for( std::set<std::string>::iterator it = materials.begin(); it != materials.end(); ++ it ) {
+		fMtl << GetMaterial(*it);
+	}
+}

src/ifcobj/Materials.cpp

@@ -0,0 +1,5 @@
+#include "../IfcObj/Materials.h"
+
+void InitMaterials() {
+	materials["IFCSITE"] = ObjMaterial("IFCSITE",0.7f,0.8f,0.5f);
+}

src/ifcobj/ObjMaterials.h

@@ -0,0 +1,63 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * This file defines materials in .mtl format for several IFC datatypes         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <string>
+#include <sstream>
+
+class ObjMaterial {
+private:
+	std::string data;
+public:
+	ObjMaterial(const std::string& name,
+		float Kd_r = 0.7f,float Kd_g = 0.7f,float Kd_b = 0.7f,
+		float Ks_r = 0.2f,float Ks_g = 0.2f,float Ks_b = 0.2f, 
+		float Ka_r = 0.1f,float Ka_g = 0.1f,float Ka_b = 0.1f,
+		float Ns = 10.0f, float Tr = 1.0f) {
+			std::stringstream ss;
+			ss << "newmtl " << name << std::endl;
+			ss << "Kd " << Kd_r << " " << Kd_g << " " << Kd_b << std::endl;
+			ss << "Ks " << Ks_r << " " << Ks_g << " " << Ks_b << std::endl;
+			ss << "Ka " << Ka_r << " " << Ka_g << " " << Ka_b << std::endl;
+			ss << "Ns " << Ns << std::endl;
+			ss << "Tr " << Tr << std::endl;
+			ss << "d " << Tr << std::endl;
+			ss << "D " << Tr << std::endl;
+			data = ss.str();
+	}
+	friend ostream& operator<<(ostream& o, const ObjMaterial& m) {o << m.data; return o;}
+};
+
+ObjMaterial GetMaterial(const std::string& s) {
+	if ( s == "IFCSITE" ) { return ObjMaterial("IFCSITE",0.75f,0.8f,0.65f); }
+	if ( s == "IFCSLAB" ) { return ObjMaterial("IFCSLAB",0.4f,0.4f,0.4f); }
+	if ( s == "IFCWALLSTANDARDCASE" ) { return ObjMaterial("IFCWALLSTANDARDCASE",0.9f,0.9f,0.9f); }
+	if ( s == "IFCWALL" ) { return ObjMaterial("IFCWALL",0.9f,0.9f,0.9f); }
+	if ( s == "IFCWINDOW" ) { return ObjMaterial("IFCWINDOW",0.75f,0.8f,0.75f,1.0f,1.0f,1.0f,0.0f,0.0f,0.0f,500.0f,0.3f); }
+	if ( s == "IFCDOOR" ) { return ObjMaterial("IFCDOOR",0.55f,0.3f,0.15f); }
+	if ( s == "IFCBEAM" ) { return ObjMaterial("IFCBEAM",0.75f,0.7f,0.7f); }
+	if ( s == "IFCRAILING" ) { return ObjMaterial("IFCRAILING",0.75f,0.7f,0.7f); }
+	if ( s == "IFCMEMBER" ) { return ObjMaterial("IFCRAILING",0.75f,0.7f,0.7f); }
+	return ObjMaterial(s);
+}

src/ifcparse/IfcEnum.cpp

@@ -0,0 +1,42 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <string>
+
+#include "../ifcparse/IfcEnum.h"
+
+IfcSchema::Enum::IfcTypes IfcSchema::Enum::FromString(const std::string& a) {
+
+#define IFC_PARSE_STR_ENUM
+#include "../ifcparse/IfcSchema.h"
+#undef IFC_PARSE_STR_ENUM
+
+	return IfcUnknown;
+}
+
+std::string IfcSchema::Enum::ToString(IfcTypes t) {
+	std::string r = "Ifc";
+	r.reserve(64);
+
+#define IFC_PARSE_ENUM_STR
+#include "../ifcparse/IfcSchema.h"
+#undef IFC_PARSE_ENUM_STR
+
+	return "";
+}

src/ifcparse/IfcEnum.h

@@ -0,0 +1,47 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFC_ENUM_H
+#define IFC_ENUM_H
+
+#include <string>
+#ifdef _MSC_VER
+  #define strcasecmp _stricmp
+#else
+  #include <strings.h>
+#endif
+
+namespace IfcSchema {
+	namespace Enum {
+
+		enum IfcTypes {
+
+#define IFC_PARSE_ENUM
+#include "../ifcparse/IfcSchema.h"
+#undef IFC_PARSE_ENUM
+
+			IfcUnknown,
+			IfcDontCare,
+			ALL
+		};
+		IfcTypes FromString(const std::string& a);
+		std::string ToString(IfcTypes t);
+	}
+}
+#endif

src/ifcparse/IfcGeom.cpp

@@ -0,0 +1,372 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * Implementations of the various conversion functions required by IfcSchema.h. *
+ * The functions are prototyped in IfcTypes.h. Functions that convert a         *
+ * TopoDS_Shape or TopoDS_Wire are called from IfcGeom::convert_shape and       *
+ * IfcGeom::convert_wire respectively                                           *
+ *                                                                              *
+ ********************************************************************************/
+
+#include "../ifcparse/IfcParse.h"
+#include "../ifcparse/IfcTypes.h"
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Vec2d.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Mat.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Ax2d.hxx>
+#include <gp_Pln.hxx>
+
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_Array1OfInteger.hxx>
+#include <Geom2d_BSplineCurve.hxx>
+#include <Geom_BSplineCurve.hxx>
+
+#include <BRepOffsetAPI_Sewing.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <BRepBuilderAPI_MakePolygon.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+
+#include <BRepPrimAPI_MakePrism.hxx>
+#include <BRepBuilderAPI_MakeShell.hxx>
+#include <BRepBuilderAPI_MakeSolid.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+#include <ShapeFix_Solid.hxx>
+
+#include <TopLoc_Location.hxx>
+
+bool IfcGeom::convert(IfcSchema::ExtrudedAreaSolid* IfcExtrudedAreaSolid, TopoDS_Shape& shape) {
+	TopoDS_Face face;
+	if ( ! IfcGeom::convert_face(IfcExtrudedAreaSolid->Profile(),face) ) return false;
+	const float height = IfcExtrudedAreaSolid->Height() * Ifc::Scale;
+	gp_Trsf trsf;
+	convert((IfcSchema::Axis2Placement3D*) IfcExtrudedAreaSolid->Placement().get(),trsf);
+
+	gp_Vec dir3;
+	convert((IfcSchema::Direction*) IfcExtrudedAreaSolid->Dir().get(),dir3);
+
+	gp_Vec extrude = dir3.Scaled(height);
+	
+	shape = BRepPrimAPI_MakePrism(face,extrude);
+	shape.Move(trsf);
+	return ! shape.IsNull();
+}
+bool IfcGeom::convert(IfcSchema::FacetedBrep* IfcFacetedBrep, TopoDS_Shape& shape) {
+	return IfcGeom::convert_shape(IfcFacetedBrep->Shell(),shape);
+}
+bool IfcGeom::convert(IfcSchema::FaceBasedSurfaceModel* IfcFaceBasedSurfaceModel, TopoDS_Shape& shape) {
+	return IfcGeom::convert((IfcSchema::ShellBasedSurfaceModel*) IfcFaceBasedSurfaceModel,shape);
+}
+bool IfcGeom::convert(IfcSchema::HalfSpaceSolid* IfcHalfSpaceSolid, TopoDS_Shape& shape) {
+	IfcEntity surf = IfcHalfSpaceSolid->Surface();
+	if ( surf->dt != IfcSchema::Enum::IfcPlane ) return false;
+	IfcSchema::Plane* IfcPlane = (IfcSchema::Plane*)surf.get();
+	gp_Pln pln;
+	IfcGeom::convert(IfcPlane,pln);
+	gp_Pnt pnt = pln.Location();
+	if ( !IfcHalfSpaceSolid->Flag() ^ (IfcHalfSpaceSolid->dt == IfcSchema::Enum::IfcPolygonalBoundedHalfSpace) ) pnt.Translate(pln.Axis().Direction());
+	else pnt.Translate(-pln.Axis().Direction());
+	shape = BRepPrimAPI_MakeHalfSpace(BRepBuilderAPI_MakeFace(pln),pnt).Solid();
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::PolygonalBoundedHalfSpace* IfcPolygonalBoundedHalfSpace, TopoDS_Shape& shape) {
+	TopoDS_Shape halfspace;
+	if ( ! IfcGeom::convert((IfcSchema::HalfSpaceSolid*)IfcPolygonalBoundedHalfSpace,halfspace) ) return false;	
+	TopoDS_Wire wire;
+	if ( ! IfcGeom::convert_wire(IfcPolygonalBoundedHalfSpace->Boundary(),wire) ) return false;	
+	gp_Trsf trsf;
+	convert((IfcSchema::Axis2Placement3D*) IfcPolygonalBoundedHalfSpace->Placement().get(),trsf);
+	TopoDS_Shape extrusion = BRepPrimAPI_MakePrism(BRepBuilderAPI_MakeFace(wire),gp_Vec(0,0,20000.0));
+	gp_Trsf down; down.SetTranslation(gp_Vec(0,0,-10000.0));
+	extrusion.Move(down);
+	extrusion.Move(trsf);
+	shape = BRepAlgoAPI_Cut(extrusion,halfspace);
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::ShellBasedSurfaceModel* IfcShellBasedSurfaceModel, TopoDS_Shape& shape) {
+	IfcEntities shells = IfcShellBasedSurfaceModel->Shells();
+	BRep_Builder builder;
+	TopoDS_Compound c;
+	builder.MakeCompound(c);
+	for( IfcParse::Entities::it it = shells->begin(); it != shells->end(); ++ it ) {
+		TopoDS_Shape s;
+		if ( IfcGeom::convert_shape(*it,s) ) {
+			builder.Add(c,s);
+		}
+	}
+	shape = c;
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::BooleanClippingResult* IfcBooleanClippingResult, TopoDS_Shape& shape) {
+	TopoDS_Shape s1, s2;
+	bool res1 = IfcGeom::convert_shape(IfcBooleanClippingResult->First(),s1);
+	if ( ! res1 ) return false;
+	bool res2 = IfcGeom::convert_shape(IfcBooleanClippingResult->Second(),s2);
+	if ( res2 )
+		shape = BRepAlgoAPI_Cut(s1,s2);
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::ClosedShell* IfcClosedShell, TopoDS_Shape& shape) {
+	if ( ! IfcGeom::convert((IfcSchema::OpenShell*) IfcClosedShell,shape) ) return false;
+	ShapeFix_Solid solid;
+	solid.LimitTolerance(0.001);
+	shape = solid.SolidFromShell(TopoDS::Shell(shape));
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::ConnectedFaceSet* IfcConnectedFaceSet, TopoDS_Shape& shape) {
+	return IfcGeom::convert((IfcSchema::OpenShell*) IfcConnectedFaceSet,shape);
+}
+bool IfcGeom::convert(IfcSchema::OpenShell* IfcOpenShell, TopoDS_Shape& shape) {
+	BRepOffsetAPI_Sewing builder;
+	builder.SetTolerance(0.001);
+	IfcEntities faces = IfcOpenShell->Faces();
+	bool facesAdded = false;
+	for( IfcParse::Entities::it it = faces->begin(); it != faces->end(); ++ it ) {
+		TopoDS_Face face;
+		if ( IfcGeom::convert((IfcSchema::Face*) (*it).get(),face) ) {
+			builder.Add(face);
+			facesAdded = true;
+		} else {
+			std::cout << "[Warning] Invalid face:" << std::endl << (*it).get()->toString() << std::endl;
+		}
+	}
+	if ( ! facesAdded ) return false;
+	builder.Perform();
+	shape = builder.SewedShape();
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::Face* IfcFace, TopoDS_Face& face) {
+	IfcEntities bounds = IfcFace->Bounds();
+	IfcParse::Entities::it it = bounds->begin();
+	IfcSchema::FaceBound* bound = (IfcSchema::FaceBound*)(*it).get();
+
+	IfcEntity loop = bound->Loop();
+	TopoDS_Wire wire;
+	if ( ! IfcGeom::convert_wire(loop,wire) ) return false;
+	BRepBuilderAPI_MakeFace mf = BRepBuilderAPI_MakeFace(wire);
+	BRepBuilderAPI_FaceError er = mf.Error();
+	if ( er == BRepBuilderAPI_NotPlanar ) {
+		std::cout << "[Notice] Trying to fix non-planar face" << std::endl;
+		ShapeFix_ShapeTolerance FTol;
+		FTol.SetTolerance(wire, 0.01, TopAbs_WIRE);
+		mf = BRepBuilderAPI_MakeFace(wire);
+		er = mf.Error();
+	}
+	if ( er != BRepBuilderAPI_FaceDone ) return false;
+
+	if ( bounds->size == 1 ) {
+		face = mf.Face();
+		return true;
+	}
+
+	for( ++ it; it != bounds->end(); ++ it ) {
+		IfcSchema::FaceBound* bound = (IfcSchema::FaceBound*)(*it).get();
+		IfcEntity loop = bound->Loop();
+		TopoDS_Wire hole;
+		IfcGeom::convert_wire(loop,hole);
+		mf.Add(hole);
+	}
+
+	ShapeFix_Shape sfs(mf.Face());
+	sfs.Perform();
+	face = TopoDS::Face(sfs.Shape());
+	return true;		
+}
+bool IfcGeom::convert(IfcSchema::CartesianPoint* IfcCartesianPoint, gp_Pnt& p) {
+	if ( IfcCartesianPoint->arg(0)->count() == 3 )
+		p = gp_Pnt(IfcCartesianPoint->X() * Ifc::Scale,IfcCartesianPoint->Y() * Ifc::Scale,IfcCartesianPoint->Z() * Ifc::Scale);
+	else
+		p = gp_Pnt(IfcCartesianPoint->X() * Ifc::Scale,IfcCartesianPoint->Y() * Ifc::Scale,0.0f);
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::Direction* IfcDirection, gp_Vec& v) {
+	if ( IfcDirection->arg(0)->count() == 3 )
+		v = gp_Vec(IfcDirection->X(),IfcDirection->Y(),IfcDirection->Z());
+	else
+		v = gp_Vec(IfcDirection->X(),IfcDirection->Y(),0.0f);
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::ArbitraryClosedProfileDef* IfcArbitraryClosedProfileDef, TopoDS_Wire& wire) {
+	return IfcGeom::convert_wire(IfcArbitraryClosedProfileDef->Polyline(),wire);
+}
+bool IfcGeom::convert(IfcSchema::ArbitraryProfileDefWithVoids* IfcArbitraryProfileDefWithVoids, TopoDS_Face& face) {
+	TopoDS_Wire profile;
+	if ( ! IfcGeom::convert_wire(IfcArbitraryProfileDefWithVoids->Polyline(),profile) ) return false;
+	BRepBuilderAPI_MakeFace mf = BRepBuilderAPI_MakeFace(profile);
+	IfcEntities voids = IfcArbitraryProfileDefWithVoids->Voids();
+	for( IfcParse::Entities::it it = voids->begin(); it != voids->end(); ++ it ) {
+		TopoDS_Wire hole;
+		if ( IfcGeom::convert_wire(*it,hole) ) {
+			mf.Add(hole);
+		}
+	}
+	ShapeFix_Shape sfs(mf.Face());
+	sfs.Perform();
+	face = TopoDS::Face(sfs.Shape());
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::RectangleProfileDef* IfcRectangleProfileDef,class TopoDS_Wire& wire) {
+	const float x = IfcRectangleProfileDef->Width() / 2.0f * Ifc::Scale;
+	const float y = IfcRectangleProfileDef->Height() / 2.0f  * Ifc::Scale;
+
+	if ( x == 0.0f || y == 0.0f ) {
+		std::cout << "[Notice] Skipping zero sized profile" << std::endl;
+		return false;
+	}
+	
+	gp_Trsf2d trsf;
+	IfcGeom::convert((IfcSchema::Axis2Placement2D*)IfcRectangleProfileDef->Placement().get(),trsf);
+	
+	gp_XY p1 (-x,-y);trsf.Transforms(p1);gp_Pnt P1(p1.X(),p1.Y(),0.0f);
+	gp_XY p2 ( x,-y);trsf.Transforms(p2);gp_Pnt P2(p2.X(),p2.Y(),0.0f);
+	gp_XY p3 ( x, y);trsf.Transforms(p3);gp_Pnt P3(p3.X(),p3.Y(),0.0f);
+	gp_XY p4 (-x, y);trsf.Transforms(p4);gp_Pnt P4(p4.X(),p4.Y(),0.0f);
+	
+	BRepBuilderAPI_MakeWire w;
+	w.Add(BRepBuilderAPI_MakeEdge(P1,P2));
+	w.Add(BRepBuilderAPI_MakeEdge(P2,P3));
+	w.Add(BRepBuilderAPI_MakeEdge(P3,P4));
+	w.Add(BRepBuilderAPI_MakeEdge(P4,P1));
+	wire = w.Wire();
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::Polyline* IfcPolyline, TopoDS_Wire& result) {
+	IfcEntities points = IfcPolyline->Points();
+
+	BRepBuilderAPI_MakeWire w;
+	for( IfcParse::Entities::it it = points->begin(); it != points->end(); ++ it ) {
+		gp_Pnt P1;gp_Pnt P2;
+		IfcGeom::convert((IfcSchema::CartesianPoint*)(*it).get(),P1);
+		IfcParse::Entities::it next = it + 1;
+		if ( next == points->end() ) next = points->begin();
+		IfcGeom::convert((IfcSchema::CartesianPoint*)(*next).get(),P2);
+		if ( P1.X() == P2.X() && P1.Y() == P2.Y() && P1.Z() == P2.Z() ) continue;
+		TopoDS_Edge e = BRepBuilderAPI_MakeEdge(P1,P2);
+		w.Add(e);
+	}
+
+	result = w.Wire();
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::Polyloop* IfcPolyloop, TopoDS_Wire& result) {
+	return IfcGeom::convert((IfcSchema::Polyline*)IfcPolyloop,result);
+}
+bool IfcGeom::convert(IfcSchema::Axis2Placement3D* IfcAxis2Placement3D, gp_Trsf& trsf) {
+	gp_Pnt o;gp_Vec x = gp_Vec(1,0,0);gp_Vec z = gp_Vec(0,0,1);
+
+	IfcGeom::convert((IfcSchema::CartesianPoint*) IfcAxis2Placement3D->Origin().get(),o);
+	try {
+	IfcGeom::convert((IfcSchema::Direction*) IfcAxis2Placement3D->Dir1().get(),z);
+	IfcGeom::convert((IfcSchema::Direction*) IfcAxis2Placement3D->Dir2().get(),x);
+	} catch( IfcParse::IfcException& ) {}
+
+	gp_Ax3 axis(o,z,x);
+	gp_Ax3 def(gp_Pnt(),gp_Dir(0,0,1),gp_Dir(1,0,0));
+	trsf.SetTransformation(axis,def);
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::Plane* IfcPlane, gp_Pln& plane) {
+	IfcSchema::Axis2Placement3D* IfcAxis2Placement3D = (IfcSchema::Axis2Placement3D*) IfcPlane->Placement().get();
+	gp_Pnt o;gp_Vec x;gp_Vec z;
+
+	IfcGeom::convert((IfcSchema::CartesianPoint*) IfcAxis2Placement3D->Origin().get(),o);
+	IfcGeom::convert((IfcSchema::Direction*) IfcAxis2Placement3D->Dir1().get(),z);
+	IfcGeom::convert((IfcSchema::Direction*) IfcAxis2Placement3D->Dir2().get(),x);
+
+	gp_Ax3 axis(o,z,x);
+	plane = gp_Pln(axis);
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::Axis2Placement2D* IfcAxis2Placement2D, gp_Trsf2d& trsf) {	
+	gp_Pnt P; gp_Vec V;
+
+	IfcGeom::convert((IfcSchema::CartesianPoint*) IfcAxis2Placement2D->Origin().get(),P);
+	IfcGeom::convert((IfcSchema::Direction*) IfcAxis2Placement2D->Dir1().get(),V);
+
+	gp_Ax2d axis (gp_Pnt2d(P.X(),P.Y()),gp_Vec2d(V.X(),V.Y()));
+	trsf.SetTransformation(axis,gp_Ax2d());
+	return true;
+}
+bool IfcGeom::convert(IfcSchema::LocalPlacement* IfcLocalPlacement, gp_Trsf& trsf) {
+	while (1) {
+		gp_Trsf trsf2;
+		IfcGeom::convert((IfcSchema::Axis2Placement3D*) IfcLocalPlacement->Placement().get(),trsf2);
+		trsf.PreMultiply(trsf2);
+		try {
+			IfcLocalPlacement = (IfcSchema::LocalPlacement*) IfcLocalPlacement->Parent().get();
+		} catch ( IfcParse::IfcException ) { break; }
+	}
+	return true;
+}
+bool IfcGeom::convert_openings(const IfcSchema::BuildingElement* IfcBuildingElement, 
+							   const IfcEntities openings, TopoDS_Shape& result, const gp_Trsf& trsf2) {
+	for ( IfcParse::Entities::it it = openings->begin(); it != openings->end(); ++ it ) {
+		IfcSchema::RelVoidsElement* IfcRelVoidsElement = (IfcSchema::RelVoidsElement*)(*it).get();
+		IfcSchema::BuildingElement* IfcOpeningElement = (IfcSchema::BuildingElement*) IfcRelVoidsElement->Opening().get();
+		gp_Trsf trsf;
+		IfcGeom::convert((IfcSchema::LocalPlacement*) IfcOpeningElement->Placement().get(),trsf);
+		gp_Trsf trsf3 = trsf2.Inverted();
+		IfcSchema::ProductDefinitionShape* IfcProductDefinitionShape = (IfcSchema::ProductDefinitionShape*) IfcOpeningElement->Shape().get();
+		IfcEntities IfcShapeReps = IfcProductDefinitionShape->ShapeReps();
+		for ( IfcParse::Entities::it shaperep = IfcShapeReps->begin(); shaperep != IfcShapeReps->end(); ++shaperep ) {
+			IfcSchema::ShapeRepresentation* IfcShapeRepresentation = (IfcSchema::ShapeRepresentation*) (*shaperep).get();
+			IfcEntities IfcShapes = IfcShapeRepresentation->Shapes();
+			for ( IfcParse::Entities::it shape = IfcShapes->begin(); shape != IfcShapes->end(); ++shape ) {
+				TopoDS_Shape s;
+				if ( ! IfcGeom::convert_shape(*shape,s) ) continue;
+				s.Move(trsf);
+				s.Move(trsf3);
+				result = BRepAlgoAPI_Cut(result,s);
+			}
+		}
+	}
+	return true;
+}
+bool IfcGeom::convert_wire_to_face(const TopoDS_Wire& wire, TopoDS_Face& face) {
+	BRepBuilderAPI_MakeFace mf = BRepBuilderAPI_MakeFace(wire);
+	BRepBuilderAPI_FaceError er = mf.Error();
+	if ( er == BRepBuilderAPI_NotPlanar ) {
+		std::cout << "[Notice] Trying to fix non-planar face" << std::endl;
+		ShapeFix_ShapeTolerance FTol;
+		FTol.SetTolerance(wire, 0.01, TopAbs_WIRE);
+		mf = BRepBuilderAPI_MakeFace(wire);
+		er = mf.Error();
+	}
+	if ( er != BRepBuilderAPI_FaceDone ) return false;
+	face = mf.Face();
+	return true;
+}

src/ifcparse/IfcGeom.h

@@ -0,0 +1,67 @@
+#ifndef IFCGEOM_H
+#define IFCGEOM_H
+#include "../ifcparse/IfcParse.h"
+#include "../ifcparse/IfcTypes.h"
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Vec2d.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Mat.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Ax2d.hxx>
+#include <gp_Pln.hxx>
+
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_Array1OfInteger.hxx>
+#include <Geom2d_BSplineCurve.hxx>
+#include <Geom_BSplineCurve.hxx>
+
+#include <BRepOffsetAPI_Sewing.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+#include <BRepBuilderAPI_MakePolygon.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Face.hxx>
+
+#include <BRepPrimAPI_MakePrism.hxx>
+#include <BRepBuilderAPI_MakeShell.hxx>
+#include <BRepBuilderAPI_MakeSolid.hxx>
+#include <BRepPrimAPI_MakeHalfSpace.hxx>
+#include <BRepAlgoAPI_Cut.hxx>
+
+#include <ShapeFix_Shape.hxx>
+#include <ShapeFix_ShapeTolerance.hxx>
+
+#include <TopLoc_Location.hxx>
+
+#define SCALE 1000.0f
+
+/*
+namespace IFCgeom {
+	bool convert( Entity* L, gp_Vec*& CC );
+	bool convert( Entity* L, gp_Pnt*& CC );
+	bool convert( Entity* L, gp_Vec2d*& CC );
+	bool convert( Entity* L, gp_Pnt2d*& CC );
+	bool convert ( Entity* L, gp_Ax3*& ax3 );
+	bool convert ( Entity* L, gp_Trsf*& trsf );
+	bool convert ( Entity* L, gp_Trsf2d*& trsf );
+	bool convert ( Entity* L, gp_Pln*& pln );
+	bool convert ( const Entity* L, TopoDS_Wire& wire, int& count );
+	bool convert( const Entity* L, TopoDS_Face& face);
+	bool convert( const Entity* L, TopoDS_Shape& shape);
+	bool move ( const Entity* L, gp_Trsf& trsf );
+	bool move ( const Entity* L, TopoDS_Shape& shape );
+	bool hasopenings( const Entity* L );
+	bool open( const Entity* L, TopoDS_Shape& shape );
+	bool open( const Entity* L, TopoDS_Shape& shape, gp_Trsf trsf2 );
+}
+*/
+#endif

src/ifcparse/IfcGeomObjects.cpp

@@ -0,0 +1,275 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include <map>
+
+#include <gp_Trsf.hxx>
+#include <TopoDS_Compound.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepTools.hxx>
+#include <BRep_Tool.hxx>
+#include <TopExp_Explorer.hxx>
+#include <BRepMesh.hxx>
+#include <Poly_Triangulation.hxx>
+#include <Poly_PolygonOnTriangulation.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <TShort_Array1OfShortReal.hxx>
+#include <Poly_Array1OfTriangle.hxx>
+
+#include "../ifcparse/IfcGeomObjects.h"
+#include "../ifcparse/IfcGeom.h"
+#include "../ifcparse/IfcEnum.h"
+#include "../ifcparse/IfcTypes.h"
+
+// Welds vertices that belong to different faces
+int IfcGeomObjects::IfcMesh::addvert(gp_Pnt p) {
+	int i = 0; const float X = (float)p.X();const float Y = (float)p.Y();const float Z = (float)p.Z();
+	for ( std::vector<float>::const_iterator it = verts.begin(); it != verts.end(); ) {
+		const float x = *it; ++it;
+		const float y = *it; ++it;
+		const float z = *it; ++it;
+		if ( X == x && Y == y && Z == z ) return i;
+		++i;
+	}
+	verts.push_back(X);
+	verts.push_back(Y);
+	verts.push_back(Z);
+	return i;
+}
+
+IfcGeomObjects::IfcMesh::IfcMesh(int i, TopoDS_Shape s) {
+	id = i;
+
+	// Triangulate the shape
+	try {
+	BRepTools::Clean(s);
+	BRepMesh::Mesh(s,0.001f);
+	} catch(...) {
+		std::cout << "[Error] Failed to triangulate IFC Entity #" << i << std::endl;
+		return;
+	}
+	TopExp_Explorer exp;
+
+	// Iterates over the faces of the shape
+	for ( exp.Init(s,TopAbs_FACE); exp.More(); exp.Next() ) {
+		TopoDS_Face face = TopoDS::Face(exp.Current());
+		TopLoc_Location loc;
+		Handle_Poly_Triangulation tri = BRep_Tool::Triangulation(face,loc);
+
+		if ( ! tri.IsNull() ) {
+			
+			// Keep track of the number of times an edge is used
+			// Manifold edges (i.e. edges used twice) are deemed invisible
+			std::map<std::pair<int,int>,int> edgecount;
+			std::vector<std::pair<int,int> > edges_temp;
+
+			const TColgp_Array1OfPnt& nodes = tri->Nodes();
+			std::map<int,int> dict;
+			for( int i = 1; i <= nodes.Length(); ++ i ) {
+				dict[i] = addvert(nodes(i).Transformed(loc));
+			}
+
+			const Poly_Array1OfTriangle& triangles = tri->Triangles();			
+			for( int i = 1; i <= triangles.Length(); ++ i ) {
+				int n1,n2,n3;
+				if ( face.Orientation() == TopAbs_REVERSED )
+					triangles(i).Get(n3,n2,n1);
+				else triangles(i).Get(n1,n2,n3);
+				faces.push_back(dict[n1]);
+				faces.push_back(dict[n2]);
+				faces.push_back(dict[n3]);
+
+				addedge(n1,n2,edgecount,edges_temp);
+				addedge(n2,n3,edgecount,edges_temp);
+				addedge(n3,n1,edgecount,edges_temp);
+			}
+			for ( std::vector<std::pair<int,int> >::const_iterator it = edges_temp.begin(); it != edges_temp.end(); ++it ) {
+				edges.push_back(edgecount[*it]==1);
+			}
+		}
+	}
+}
+
+IfcGeomObjects::IfcGeomObject::IfcGeomObject( const std::string& n, const std::string& t, gp_Trsf trsf, IfcMesh* m ) {
+	// Convert the gp_Trsf into a 4x3 Matrix
+	for( int i = 1; i < 5; ++ i )
+		for ( int j = 1; j < 4; ++ j )
+			matrix.push_back((float)trsf.Value(j,i));
+
+	name = n;
+	type = t;
+	mesh = m;
+}
+
+// A container and iterator for IfcShapeRepresentations
+IfcEntities shapereps;
+IfcParse::Entities::it outer;
+
+// The triangulated shape is stored globally because it can be used by multiple IfcBuildingElements
+IfcGeomObjects::IfcMesh* shape;
+// The compound shape is stored globally because multiple IfcShapeRepresentations 
+// can have IfcBuildingElements with different IfcOpeningElements
+TopoDS_Compound shapes;
+
+// The object is fetched beforehand to be positive an entity actually exists
+IfcGeomObjects::IfcGeomObject* currentGeomObj;
+
+// A container and iterator for IfcBuildingElements for the current IfcShapeRepresentation referenced by *outer
+IfcEntities entities;
+IfcParse::Entities::it inner;
+
+bool use_world_coords;
+int done;
+int total;
+
+// Move the the next IfcShapeRepresentation
+void _nextShape() {
+	if ( shape ) delete shape;
+	shapes.Nullify();
+	shape = 0;
+	entities.reset();
+	++ outer;
+	++ done;
+}
+
+// Returns the current IfcGeomObject*
+IfcGeomObjects::IfcGeomObject* _get() {
+	while ( true ) {
+		IfcEntity shaperep;
+		if ( outer == shapereps->end() ) {
+			shapereps.reset();
+			return 0;
+		}
+		shaperep = *outer;
+		if ( ! entities ) {
+			if ( shaperep->arg(1)->s() != "Body" ) {
+				_nextShape();
+				continue;
+			}
+#ifdef _DEBUG
+			std::cout << shaperep->toString() << std::endl;
+#endif
+			// Find the IfcBuildingElements that refer to the current IfcShapeRepresentation
+			entities = shaperep->parents(IfcSchema::Enum::IfcProductDefinitionShape)->parents();
+			entities->pushs(shaperep->parents(IfcSchema::Enum::IfcRepresentationMap)->parents(IfcSchema::Enum::IfcMappedItem)
+				->parents(IfcSchema::Enum::IfcShapeRepresentation,1,"Body")->parents(IfcSchema::Enum::IfcProductDefinitionShape)->parents());
+			if ( ! entities->size ) {
+				_nextShape();
+				continue;
+			}
+			inner = entities->begin();
+		}
+		if ( inner == entities->end() ) {
+			_nextShape();
+			continue;
+		}
+		if ( shapes.IsNull() ) {
+			BRep_Builder builder;
+			builder.MakeCompound (shapes);
+
+			bool hasShapes = false;
+			IfcEntities l = ((IfcSchema::ShapeRepresentation*)shaperep.get())->Shapes();
+			for( IfcParse::Entities::it it = l->begin(); it != l->end(); ++ it ) {
+				const IfcEntity ifcshape = *it;
+				if ( ifcshape->dt == IfcSchema::Enum::IfcMappedItem ) continue;
+				TopoDS_Shape ss;
+				if ( IfcGeom::convert_shape(ifcshape,ss) ) {
+					builder.Add(shapes,ss);
+					hasShapes = true;
+#ifdef _DEBUG
+					std::cout << ifcshape->toString() << std::endl;
+#endif
+				}
+			}
+			if ( ! hasShapes || shapes.IsNull() ) {
+				_nextShape();
+				continue;
+			}
+		}
+
+		IfcSchema::BuildingElement* entity = (IfcSchema::BuildingElement*)(*inner).get();
+#ifdef _DEBUG
+		std::cout << entity->toString() << std::endl;
+#endif
+		const std::string guid = entity->Guid();
+		gp_Trsf trsf;
+		try {
+			IfcGeom::convert((IfcSchema::LocalPlacement*)(entity->Placement().get()),trsf);
+		} catch( IfcParse::IfcException& e ) {std::cout << "[Error] " << e.what() << std::endl; _nextShape(); }
+		IfcEntities openings = IfcEntities();
+		if ( entity->dt != IfcSchema::Enum::IfcOpeningElement ) {
+			openings = entity->parents(IfcSchema::Enum::IfcRelVoidsElement);
+		}
+
+		if ( (openings && openings->size) || use_world_coords ) {
+			if ( shape ) delete shape;
+			TopoDS_Shape temp_shape (shapes);
+			try {
+				if (openings && openings->size) IfcGeom::convert_openings(entity,openings,temp_shape,trsf);
+			} catch( IfcParse::IfcException& e ) {std::cout << "[Warning] " << e.what() << std::endl; }
+			if ( use_world_coords ) {
+				shape = new IfcGeomObjects::IfcMesh(shaperep->id,temp_shape.Moved(trsf));
+				trsf = gp_Trsf();
+			} else {
+				shape = new IfcGeomObjects::IfcMesh(shaperep->id,temp_shape);
+			}
+		} else if ( ! shape ) {
+			shape = new IfcGeomObjects::IfcMesh(shaperep->id,shapes);
+		}
+		return new IfcGeomObjects::IfcGeomObject(guid, entity->datatype(), trsf, shape);		
+	}
+}
+
+extern bool IfcGeomObjects::Next() {
+	if ( entities ) {
+		++inner;
+	}
+	delete currentGeomObj;
+	currentGeomObj = _get();
+	if ( ! currentGeomObj ) {
+		delete shape;
+		Ifc::Dispose();
+		return false;
+	} else {
+		return true;
+	}
+}
+extern const IfcGeomObjects::IfcGeomObject* IfcGeomObjects::Get() {
+	return currentGeomObj;
+}
+extern bool IfcGeomObjects::Init(char* fn, bool world_coords) {
+	use_world_coords = world_coords;
+	if ( !Ifc::Init(fn) ) return false;
+
+	shapereps = Ifc::EntitiesByType(IfcSchema::Enum::IfcShapeRepresentation);
+	if ( ! shapereps ) return false;
+	
+	outer = shapereps->begin();
+	entities.reset();
+	currentGeomObj = _get();
+	
+	if ( ! currentGeomObj ) return false;
+
+	done = 0;
+	total = shapereps->size;
+	return 1;
+}
+extern int IfcGeomObjects::Progress() {
+	return 100 * done / total;
+}

src/ifcparse/IfcGeomObjects.h

@@ -0,0 +1,102 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * Geometrical data in an IFC file consists of shapes (IfcShapeRepresentation)  *
+ * and instances (SUBTYPE OF IfcBuildingElement e.g. IfcWindow).                *
+ *                                                                              *
+ * IfcMesh is a class that represents a triangulated IfcShapeRepresentation.    *
+ *   IfcMesh.verts is a 1 dimensional vector of float defining the cartesian    *
+ *      coordinates of the vertices of the triangulated shape in the format of  *
+ *      [x1,y1,z1,..,xn,yn,zn]                                                  *
+ *   IfcMesh.faces is a 1 dimensional vector of int containing the indices of   *
+ *     the triangles referencing positions in IfcMesh.verts                     *
+ *   IfcMesh.edges is a 1 dimensional vector of int in {0,1} that dictates      *
+ *	   the visibility of the edges that span the faces in IfcMesh.faces         *
+ *                                                                              *
+ * IfcGeomObject represents the actual IfcBuildingElements.                     *
+ *   IfcGeomObject.name is the GUID of the element                              *
+ *   IfcGeomObject.type is the datatype of the element e.g. IFCWINDOW           *
+ *   IfcGeomObject.mesh is a pointer to an IfcMesh                              *
+ *   IfcGeomObject.matrix is a 4x3 matrix that defines the orientation and      *
+ *     translation of the mesh in relation to the world origin                  *
+ *                                                                              *
+ * Init(char* fn, bool world_coords) parses the IFC file in fn, returns true
+ *   on succes, world_coords = true will result in all IfcGeomObject.matrix
+ *   being an identity matrix and IfcMesh.verts containing global positions
+ *                                                                              *
+ * Get() returns a pointer to the current IfcGeomObject
+ *                                                                              * 
+ * Next() returns true if there is an entity yet available 
+ *                                                                              *
+ * Progress() returns an int in [0..100] that indicates the overall progress
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCOBJECTS_H
+#define IFCOBJECTS_H
+
+#include <map>
+#include <vector>
+
+#include <gp_Trsf.hxx>
+#include <gp_Pnt.hxx>
+#include <TopoDS.hxx>
+
+namespace IfcGeomObjects {
+
+	typedef std::vector<int>::const_iterator IntIt;
+	typedef std::vector<float>::const_iterator FltIt;
+
+	class IfcMesh {
+	public:
+		int id;
+		std::vector<float> verts;
+		std::vector<int> faces;
+		std::vector<int> edges;
+		
+		IfcMesh(int i, TopoDS_Shape s);
+	private:
+		int addvert(gp_Pnt p);
+		inline void addedge(int n1, int n2, std::map<std::pair<int,int>,int>& edgecount, std::vector<std::pair<int,int> >& edges_temp) {
+			if ( edgecount.find(std::pair<int,int>((std::min)(n1,n2),(std::max)(n1,n2))) == edgecount.end() )
+				edgecount[std::pair<int,int>((std::min)(n1,n2),(std::max)(n1,n2))] = 0;
+			edgecount[std::pair<int,int>((std::min)(n1,n2),(std::max)(n1,n2))] ++;
+			edges_temp.push_back(std::pair<int,int>((std::min)(n1,n2),(std::max)(n1,n2)));
+		}
+	};
+
+	class IfcGeomObject {
+	public:
+		std::string name;
+		std::string type;
+		std::vector<float> matrix;
+		IfcMesh* mesh;
+		IfcGeomObject( const std::string& n, const std::string& t, gp_Trsf trsf, IfcMesh* m );
+	};
+
+	extern bool Init(char* fn, bool world_coords = false);
+	extern const IfcGeomObject* Get();
+	extern bool Next();	
+	extern int Progress();
+
+}
+
+#endif

src/ifcparse/IfcMacro.h

@@ -0,0 +1,193 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * Macro definitions that expand the schema definition in IfcSchema.h into      *
+ * C++ code.                                                                    *
+ *                                                                              *
+ ********************************************************************************/
+
+#undef IFC_CLASS
+#undef IFC_SHAPE_CLASS
+#undef IFC_FACE_CLASS
+#undef IFC_SKIP_CLASS
+#undef IFC_WIRE_CLASS
+#undef IFC_HELPER_CLASS
+#undef IFC_END_CLASS
+#undef IFC_REF
+#undef IFC_REFS
+#undef IFC_FLT
+#undef IFC_FLT_SUB
+#undef IFC_INT
+#undef IFC_STR
+#undef IFC_BOOL
+
+#ifdef IFC_PARSE_HEADER
+#define IFC_CLASS(N,T) class N : public IfcParse::Entity { public:
+#define IFC_SHAPE_CLASS(N) IFC_CLASS(N,"")
+#define IFC_FACE_CLASS(N) IFC_CLASS(N,"")
+#define IFC_WIRE_CLASS(N) IFC_CLASS(N,"")
+#define IFC_HELPER_CLASS(N) IFC_CLASS(N,"")
+#define IFC_SKIP_CLASS(N)
+#define IFC_END_CLASS };
+#define IFC_REF(C,N,I) IfcEntity N();
+#define IFC_REFS(C,N,I) IfcEntities N();
+#define IFC_FLT(C,N,I) float N();
+#define IFC_FLT_SUB(C,N,I,J) float N();
+#define IFC_INT(C,N,I) int N();
+#define IFC_STR(C,N,I) std::string N();
+#define IFC_BOOL(C,N,I) bool N();
+#endif
+
+#ifdef IFC_PARSE_SOURCE
+#define IFC_CLASS(N,T)
+#define IFC_SHAPE_CLASS(N)
+#define IFC_FACE_CLASS(N)
+#define IFC_WIRE_CLASS(N)
+#define IFC_HELPER_CLASS(N)
+#define IFC_SKIP_CLASS(N)
+#define IFC_END_CLASS
+#define IFC_REF(C,N,I) IfcEntity C::N() { return this->arg(I)->ref(); }
+#define IFC_REFS(C,N,I) IfcEntities C::N() { return this->arg(I)->refs(); }
+#define IFC_FLT(C,N,I) float C::N() { return this->arg(I)->f(); }
+#define IFC_FLT_SUB(C,N,I,J) float C::N() { return this->arg(I)->arg(J)->f(); }
+#define IFC_INT(C,N,I) int C::N() { return this->arg(I)->i(); }
+#define IFC_STR(C,N,I) std::string C::N() { return this->arg(I)->s(); }
+#define IFC_BOOL(C,N,I) bool C::N() { return this->arg(I)->b(); }
+#endif
+
+#ifdef IFC_PARSE_ENUM
+#define IFC_SHAPE_CLASS(N) Ifc##N,
+#define IFC_WIRE_CLASS(N) Ifc##N,
+#define IFC_FACE_CLASS(N) Ifc##N,
+#define IFC_CLASS(N,T) Ifc##N,
+#define IFC_HELPER_CLASS(N) Ifc##N,
+#define IFC_SKIP_CLASS(N)
+#define IFC_END_CLASS
+#define IFC_REF(C,N,I)
+#define IFC_REFS(C,N,I)
+#define IFC_FLT(C,N,I)
+#define IFC_FLT_SUB(C,N,I,J)
+#define IFC_INT(C,N,I)
+#define IFC_STR(C,N,I)
+#define IFC_BOOL(C,N,I)
+#endif
+
+#ifdef IFC_PARSE_STR_ENUM
+#define IFC_SHAPE_CLASS(N) if ( strcasecmp(a.c_str()+3,#N) == 0 ) { return IfcSchema::Enum::Ifc##N; }
+#define IFC_FACE_CLASS(N) IFC_SHAPE_CLASS(N)
+#define IFC_WIRE_CLASS(N) IFC_SHAPE_CLASS(N)
+#define IFC_HELPER_CLASS(N) IFC_SHAPE_CLASS(N)
+#define IFC_CLASS(N,T) IFC_SHAPE_CLASS(N)
+#define IFC_SKIP_CLASS(N) if ( strcasecmp(a.c_str()+3,#N) == 0 ) { return IfcSchema::Enum::IfcDontCare; }
+#define IFC_END_CLASS
+#define IFC_REF(C,N,I)
+#define IFC_REFS(C,N,I)
+#define IFC_FLT(C,N,I)
+#define IFC_FLT_SUB(C,N,I,J)
+#define IFC_INT(C,N,I)
+#define IFC_STR(C,N,I)
+#define IFC_BOOL(C,N,I)
+#endif
+
+#ifdef IFC_PARSE_ENUM_STR
+#define IFC_SHAPE_CLASS(N) if ( t == IfcSchema::Enum::Ifc##N ) return "Ifc" #N;
+#define IFC_FACE_CLASS(N) IFC_SHAPE_CLASS(N)
+#define IFC_WIRE_CLASS(N) IFC_SHAPE_CLASS(N)
+#define IFC_HELPER_CLASS(N) IFC_SHAPE_CLASS(N)
+#define IFC_CLASS(N,T) IFC_SHAPE_CLASS(N)
+#define IFC_SKIP_CLASS(N)
+#define IFC_END_CLASS
+#define IFC_REF(C,N,I)
+#define IFC_REFS(C,N,I)
+#define IFC_FLT(C,N,I)
+#define IFC_FLT_SUB(C,N,I,J)
+#define IFC_INT(C,N,I)
+#define IFC_STR(C,N,I)
+#define IFC_BOOL(C,N,I)
+#endif
+
+#ifdef IFC_GEOM_HEADER
+#define IFC_SHAPE_CLASS(N) bool convert(IfcSchema::N* Ifc##N,TopoDS_Shape& result);
+#define IFC_FACE_CLASS(N) bool convert(IfcSchema::N* Ifc##N,TopoDS_Face& result);
+#define IFC_WIRE_CLASS(N) bool convert(IfcSchema::N* Ifc##N,TopoDS_Wire& result);
+#define IFC_HELPER_CLASS(N)
+#define IFC_CLASS(N,T) bool convert(IfcSchema::N* Ifc##N,T& result);
+#define IFC_SKIP_CLASS(N)
+#define IFC_END_CLASS
+#define IFC_REF(C,N,I)
+#define IFC_REFS(C,N,I)
+#define IFC_FLT(C,N,I)
+#define IFC_FLT_SUB(C,N,I,J)
+#define IFC_INT(C,N,I)
+#define IFC_STR(C,N,I)
+#define IFC_BOOL(C,N,I)
+#endif
+
+#ifdef IFC_SHAPE_SRC
+#define IFC_SHAPE_CLASS(N) if ( L->dt == IfcSchema::Enum::Ifc##N ) { IfcSchema::N* x = (IfcSchema::N*) L.get(); bool b = false; try { b = IfcGeom::convert(x,result); } catch(IfcParse::IfcException& e) { std::cout << "[Error] " << e.what() << std::endl;} catch(StdFail_NotDone&) { std::cout << "[Error] Unknown modelling error" << std::endl; } if (!b) std::cout << "[Error] Failed to convert:" << std::endl << x->toString() << std::endl; return b; }
+#define IFC_FACE_CLASS(N)
+#define IFC_WIRE_CLASS(N)
+#define IFC_HELPER_CLASS(N)
+#define IFC_CLASS(N,T)
+#define IFC_SKIP_CLASS(N)
+#define IFC_END_CLASS
+#define IFC_REF(C,N,I)
+#define IFC_REFS(C,N,I)
+#define IFC_FLT(C,N,I)
+#define IFC_FLT_SUB(C,N,I,J)
+#define IFC_INT(C,N,I)
+#define IFC_STR(C,N,I)
+#define IFC_BOOL(C,N,I)
+#endif
+
+#ifdef IFC_WIRE_SRC
+#define IFC_SHAPE_CLASS(N)
+#define IFC_FACE_CLASS(N)
+#define IFC_WIRE_CLASS(N) if ( L->dt == IfcSchema::Enum::Ifc##N ) { IfcSchema::N* x = (IfcSchema::N*) L.get(); return IfcGeom::convert(x,result); }
+#define IFC_HELPER_CLASS(N)
+#define IFC_CLASS(N,T)
+#define IFC_SKIP_CLASS(N)
+#define IFC_END_CLASS
+#define IFC_REF(C,N,I)
+#define IFC_REFS(C,N,I)
+#define IFC_FLT(C,N,I)
+#define IFC_FLT_SUB(C,N,I,J)
+#define IFC_INT(C,N,I)
+#define IFC_STR(C,N,I)
+#define IFC_BOOL(C,N,I)
+#endif
+
+#ifdef IFC_FACE_SRC
+#define IFC_SHAPE_CLASS(N)
+#define IFC_FACE_CLASS(N)  if ( L->dt == IfcSchema::Enum::Ifc##N ) { IfcSchema::N* x = (IfcSchema::N*) L.get(); return IfcGeom::convert(x,result); }
+#define IFC_WIRE_CLASS(N) if ( L->dt == IfcSchema::Enum::Ifc##N ) { IfcSchema::N* x = (IfcSchema::N*) L.get(); if ( ! IfcGeom::convert(x,wire) ) return false; return IfcGeom::convert_wire_to_face(wire,result); }
+#define IFC_HELPER_CLASS(N)
+#define IFC_CLASS(N,T)
+#define IFC_SKIP_CLASS(N)
+#define IFC_END_CLASS
+#define IFC_REF(C,N,I)
+#define IFC_REFS(C,N,I)
+#define IFC_FLT(C,N,I)
+#define IFC_FLT_SUB(C,N,I,J)
+#define IFC_INT(C,N,I)
+#define IFC_STR(C,N,I)
+#define IFC_BOOL(C,N,I)
+#endif

src/ifcparse/IfcParse.cpp

@@ -0,0 +1,398 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include "../ifcparse/IfcParse.h"
+#include "../ifcparse/IfcEnum.h"
+#include "../ifcparse/IfcTypes.h"
+
+using namespace IfcParse;
+
+Argument::Argument(const std::string& s) {
+	const char first = s[0];
+	const int strlen = s.size();
+	const char last = s[strlen-1];		
+	if ( first == '#' ) {
+		type = IDENTIFIER;
+		std::istringstream iss(s.substr(1));
+		iss >> _data;
+	} else if ( first == '(' || first == ')' || first == '=' || first == '$' || first == '*' || first == ';' || first == ',' ) {
+		type = OPERATOR;
+		_data = first;
+	} else if ( first == '\'' && last == '\'' ) {
+		type = STRING;
+		_data = -1;
+		std::string t = s.substr(1,s.size()-2);
+		for ( int i = 0; i < (int)argstrings.size(); ++ i ) if ( argstrings[i] == t ) { _data = i; break; }
+		if ( _data == -1 ) { _data = argstrings.size(); argstrings.push_back(t); }
+	} else if ( first == '.' && last == '.' ) {
+		type = ENUMERATION;
+		_data = -1;
+		std::string t = s.substr(1,s.size()-2);
+		for ( int i = 0; i < (int)enumstrings.size(); ++ i ) if ( enumstrings[i] == t ) { _data = i; break; }
+		if ( _data == -1 ) { _data = enumstrings.size(); enumstrings.push_back(t); }
+	} else if ( ( first >= 48 && first <= 57 ) || first == '-' || first == '.' ) {
+		type = NUMBER;
+		std::istringstream iss(s);
+		iss >> _number;
+	} else {
+		type = DATATYPE;
+		_data = -1;
+		for ( int i = 0; i < (int)datatypes.size(); ++ i ) if ( datatypes[i] == s ) { _data = i; break; }
+		if ( _data == -1 ) { _data = datatypes.size(); datatypes.push_back(s); }
+	}
+}
+std::string Argument::s() const {
+	if ( type == OPERATOR ) { std::string r; r.push_back((char)_data); return r; }
+	if ( type == DATATYPE ) return datatypes[_data];
+	if ( type == STRING ) return argstrings[_data];
+	if ( type == ENUMERATION ) return enumstrings[_data];
+	throw IfcException();
+}
+float Argument::f() const {
+	if ( type != NUMBER ) throw IfcException();
+	return _number;
+}
+int Argument::i() const {
+	if ( type != IDENTIFIER ) throw IfcException();
+	return _data;
+}
+bool Argument::b() const {
+	if ( type != ENUMERATION ) throw IfcException();
+	return s() == "T";
+}
+bool Argument::isOp(char op) const {
+	return type == OPERATOR && ( op == 0 || op == ((char)_data) );
+}
+std::string Argument::toString() const {
+	if ( type == DATATYPE ) return s();
+	else if ( type == OPERATOR ) return s();
+	std::stringstream ss;
+	if ( type == NUMBER ) ss << f();
+	else if ( type == STRING ) ss << "'" << s() << "'";
+	else if ( type == ENUMERATION ) ss << "." << s() << ".";
+	else if ( type == IDENTIFIER ) ss << "#" << i();
+	return ss.str();
+}
+std::vector<std::string> Argument::datatypes;
+std::vector<std::string> Argument::argstrings;
+std::vector<std::string> Argument::enumstrings;
+
+ArgumentList::ArgumentList() {
+	_levels.push_back(this);
+	_current = this;
+	_arg = 0;
+}
+void ArgumentList::_push() {
+	ArgumentList* a = new ArgumentList();
+	_levels.push_back(a);
+	_args.push_back(a);
+	_current = a;
+}
+void ArgumentList::_pop() {
+	if ( _levels.empty() ) return;
+	_current = _levels.back();
+	_levels.pop_back();
+}
+void ArgumentList::_append(const Argument* v) {
+	ArgumentList* a = new ArgumentList();
+	a->_arg = v;
+	_current->_args.push_back(a);
+}
+
+std::string ArgumentList::toString() const {
+	if ( _arg ) return _arg->toString();
+	std::stringstream ss; ss << "(";
+	std::vector<ArgumentList*>::const_iterator it;
+	for ( it = _args.begin() ; it != _args.end(); ++ it ) {
+		if ( it != _args.begin() ) ss << ",";
+		ss << (*it)->toString();
+	}
+	ss << ")";
+	return ss.str();
+}
+
+float ArgumentList::f() const { return _arg->f(); }
+bool ArgumentList::b() const { return _arg->b(); }
+int ArgumentList::i() const { return _arg->i(); }
+std::string ArgumentList::s() const { return _arg->s(); }
+int ArgumentList::count() const { return _arg ? 1 : _args.size(); }
+ArgumentList* ArgumentList::arg(int i) const { return _args[i]; }
+
+EntityPtr ArgumentList::ref() const {
+	if ( _arg->isOp('$') ) throw IfcException();
+	return Ifc::EntityById(_arg->i());
+}
+EntitiesPtr ArgumentList::refs() const {
+	EntitiesPtr l (new Entities());
+	std::vector<ArgumentList*>::const_iterator it;
+	for ( it = _args.begin(); it != _args.end(); ++ it ) {
+		ArgumentList* a = *it;
+		if ( a->_arg && a->_arg->type == Argument::IDENTIFIER ) {
+			l->push(Ifc::EntityById(a->_arg->i()));
+		}
+	}
+	return l;
+}
+ArgumentList::~ArgumentList() {
+	if ( _arg ) delete _arg;
+	else {
+		while( ! _args.empty() ) {
+			delete _args.back(); _args.pop_back();
+		}
+	}
+}
+inline bool Entity::term(char last) {
+	return last == '(' || last == ')' || last == '=' || last == ',' || last == ';';
+}
+Entity::Entity(std::istream* ss, std::vector<int>& refs) {
+	std::string curvar;
+	curvar.reserve(64);
+	bool inStr = false;
+	char c[1] = "";
+	int state = -1;
+	args = 0;
+	_dt = 0;
+	id = -1;
+	do {
+		ss->read(c,1);
+		if ( !inStr && ((*c) == ' ' || (*c) == '\r' || (*c) == '\n' || (*c) == '\t') ) continue;
+		if ( curvar.size() && !inStr && ( term(*c) || term(*curvar.rbegin())) ) {
+			Argument* v = new Argument(curvar);
+			curvar.clear();
+			curvar.push_back(*c);
+			if ( state < 10 ) state ++;
+			if ( state == 0 ) {
+				if ( v->type == Argument::IDENTIFIER ) {
+					id = v->i(); 
+				} else {
+					state = -1;
+				}
+			} else if ( state == 1 ) {
+				if ( ! v->isOp('=') ) state = -1;
+			} else if ( state == 2 ) {
+				if ( v->type == Argument::DATATYPE ) {
+					dt = IfcSchema::Enum::FromString(v->s());
+					_dt = v;
+					continue;
+				}
+			} else if ( args ) {
+				if ( v->isOp('(') ) args->_push();
+				else if ( v->isOp(')') ) args->_pop();
+				else if ( ! v->isOp(',') && !v->isOp(';') ) {
+					args->_append(v);
+					if ( v->type == Argument::IDENTIFIER ) refs.push_back(v->i());
+					continue;
+				}
+			} else if ( v->isOp('(') ) {
+				args = new ArgumentList();
+			}
+			delete v;
+		} else curvar.push_back(*c);
+		if ( *c == '\'' ) inStr = !inStr;
+	} while ( !ss->eof() && (*c != ';' || inStr) );
+}
+Entity::~Entity() {
+	delete args;
+	delete _dt;
+}
+bool Entity::isAssignment() const {
+	return args > 0;
+}
+std::string Entity::datatype() const {
+	if ( _dt ) return _dt->s();
+	else return IfcSchema::Enum::ToString(dt);
+}
+ArgumentList* Entity::arg(int i) const {
+	return this->args->arg(i);
+}
+std::string Entity::toString() const {
+	std::stringstream ss;
+	if ( isAssignment() ) {
+		ss << "#" << id << "=" << datatype() << args->toString();
+	}
+	return ss.str();
+}
+EntitiesPtr Entity::parents(IfcSchema::Enum::IfcTypes c) {
+	EntitiesPtr l = EntitiesPtr(new Entities());
+	EntitiesPtr all = Ifc::EntitiesByReference(id);
+	if ( ! all ) return l;
+	for( Entities::it it = all->begin(); it != all->end();++  it  ) {
+		if ( c == IfcSchema::Enum::ALL || (*it)->dt == c ) {
+			l->push(*it);
+		}
+	}
+	return l;
+}
+EntitiesPtr Entity::parents(IfcSchema::Enum::IfcTypes c, int i, const std::string& a) {
+	EntitiesPtr l = EntitiesPtr(new Entities());
+	EntitiesPtr all = parents(c);
+	for( Entities::it it = all->begin(); it != all->end();++ it  ) {
+		if ( (*it)->arg(i)->s() == a ) {
+			l->push(*it);
+		}
+	}
+	return l;
+}
+
+void Entities::push(EntityPtr l) {
+	if ( l ) {
+		ls.push_back(l);
+		size = ls.size();
+	}
+}
+void Entities::pushs(EntitiesPtr l) {
+	for( it i = l->begin(); i != l->end(); ++i  ) {
+		if ( *i ) ls.push_back(*i);
+	}
+	size = ls.size();
+}
+Entities::it Entities::begin() { return ls.begin(); }
+Entities::it Entities::end() { return ls.end(); }
+EntitiesPtr Entities::parents(IfcSchema::Enum::IfcTypes c) {
+	EntitiesPtr l = EntitiesPtr(new Entities());
+	for( it i = begin(); i != end(); ++i  ) {
+		l->pushs((*i)->parents(c));
+	}
+	return l;
+}
+EntitiesPtr Entities::parents(IfcSchema::Enum::IfcTypes c, int ar, const std::string& a) {
+	EntitiesPtr l = EntitiesPtr(new Entities());
+	for( it i = begin(); i != end(); ++i  ) {
+		l->pushs((*i)->parents(c,ar,a));
+	}
+	return l;
+}
+EntityPtr Entities::operator[] (int i) {
+	return ls[i];
+}
+Entities::Entities() {
+	size = 0;
+}
+
+File::File(std::string fn, bool debug) {
+	valid = false;
+	std::ifstream f(fn.c_str());
+	if ( ! f.is_open() ) return;
+	valid = true;
+	std::istream *pf = (std::istream*) &f;
+	while( !pf->eof() ) {
+		std::vector<int> refs;
+		EntityPtr il (new Entity(pf,refs));
+		if ( il->isAssignment() ) {
+			if ( debug )
+				std::cout << il->toString();
+			if ( il->dt == IfcSchema::Enum::IfcDontCare ) {
+				continue;
+			}
+			EntitiesPtr l = EntitiesByType(il->dt);
+			if ( l == 0 ) {
+				l = EntitiesPtr(new Entities());
+				bytype[il->dt] = l;
+			}
+			l->push(il);
+			byid[il->id] = il;
+			
+			std::vector<int>::const_iterator it;
+			for( it = refs.begin(); it != refs.end();++ it  ) {
+				const int _id = *it;
+				EntitiesPtr L = EntitiesByReference(_id);
+				if ( L == 0 ) {
+					L = EntitiesPtr(new Entities());
+					byref[_id] = L;
+				}
+				L->push(il);
+			}
+		}
+	}
+	f.close();
+}
+EntitiesPtr File::EntitiesByType(IfcSchema::Enum::IfcTypes t) {
+	std::map<IfcSchema::Enum::IfcTypes,EntitiesPtr>::const_iterator it;
+	it = bytype.find(t);
+	return (it == bytype.end()) ? EntitiesPtr() : (*it).second;
+}
+EntitiesPtr File::EntitiesByReference(int t) {
+	std::map<int,EntitiesPtr>::const_iterator it;
+	it = byref.find(t);
+	return (it == byref.end()) ? EntitiesPtr() : (*it).second;
+}
+EntityPtr File::EntityById(int id) {
+	std::map<int,EntityPtr>::const_iterator it;
+	it = byid.find(id);
+	if ( it == byid.end() ) throw IfcException(id);
+	return (*it).second;
+}
+IfcException::IfcException(int id) {
+	std::stringstream ss;
+	ss << "Unable to find IFC Entity #" << id;
+	w = ss.str();
+}
+
+IfcException::IfcException() {
+	w = "Unexpected argument supplied";
+}
+
+const char* IfcException::what() const throw(){ return w.c_str(); }
+IfcException::~IfcException() throw(){ }
+
+EntitiesPtr Ifc::EntitiesByType(IfcSchema::Enum::IfcTypes t) {
+	return f->EntitiesByType(t);
+}
+EntitiesPtr Ifc::EntitiesByReference(int t) {
+	return f->EntitiesByReference(t);
+}
+EntityPtr Ifc::EntityById(int id) {
+	return f->EntityById(id);
+}
+bool Ifc::Init(std::string fn) {
+	f = new File(fn, false);
+	IfcEntities units = EntitiesByType(IfcSchema::Enum::IfcSIUnit);
+	Ifc::Scale = 1.0f;
+	if ( units )
+	for ( IfcParse::Entities::it it = units->begin(); it != units->end(); it ++ ) {
+		IfcSchema::SIUnit* unit = (IfcSchema::SIUnit*)(*it).get();
+		if ( unit->Type() == "LENGTHUNIT" ) {
+			if      ( unit->Prefix() == "EXA"   ) Ifc::Scale = (float) 1e18;
+			else if ( unit->Prefix() == "PETA"  ) Ifc::Scale = (float) 1e15;
+			else if ( unit->Prefix() == "TERA"  ) Ifc::Scale = (float) 1e12;
+			else if ( unit->Prefix() == "GIGA"  ) Ifc::Scale = (float) 1e9;
+			else if ( unit->Prefix() == "MEGA"  ) Ifc::Scale = (float) 1e6;
+			else if ( unit->Prefix() == "KILO"  ) Ifc::Scale = (float) 1e3;
+			else if ( unit->Prefix() == "HECTO" ) Ifc::Scale = (float) 1e2;
+			else if ( unit->Prefix() == "DECA"  ) Ifc::Scale = (float) 1;
+			else if ( unit->Prefix() == "DECI"  ) Ifc::Scale = (float) 1e-1;
+			else if ( unit->Prefix() == "CENTI" ) Ifc::Scale = (float) 1e-2;
+			else if ( unit->Prefix() == "MILLI" ) Ifc::Scale = (float) 1e-3;
+			else if ( unit->Prefix() == "MICRO" ) Ifc::Scale = (float) 1e-6;
+			else if ( unit->Prefix() == "NANO"  ) Ifc::Scale = (float) 1e-9;
+			else if ( unit->Prefix() == "PICO"  ) Ifc::Scale = (float) 1e-12;
+			else if ( unit->Prefix() == "FEMTO" ) Ifc::Scale = (float) 1e-15;
+			else if ( unit->Prefix() == "ATTO"  ) Ifc::Scale = (float) 1e-18;
+		}
+	}
+	return f->valid;
+}
+void Ifc::Dispose() {
+	delete f;
+	Argument::datatypes.clear();
+	Argument::argstrings.clear();
+	Argument::enumstrings.clear();
+}
+File* Ifc::f = 0;
+float Ifc::Scale = 1.0f;

src/ifcparse/IfcParse.h

@@ -0,0 +1,189 @@
+/********************************************************************************
+*                                                                              *
+* This file is part of IfcOpenShell.                                           *
+*                                                                              *
+* IfcOpenShell is free software: you can redistribute it and/or modify         *
+* it under the terms of the Lesser GNU General Public License as published by  *
+* the Free Software Foundation, either version 3.0 of the License, or          *
+* (at your option) any later version.                                          *
+*                                                                              *
+* IfcOpenShell is distributed in the hope that it will be useful,              *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+* Lesser GNU General Public License for more details.                          *
+*                                                                              *
+* You should have received a copy of the Lesser GNU General Public License     *
+* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+*                                                                              *
+********************************************************************************/
+
+#ifndef IFCPARSE_H
+#define IFCPARSE_H
+
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <vector>
+#include <fstream>
+#include <cstring>
+#include <map>
+#include <exception>
+
+// Pick a shared pointer implementation
+#ifdef __GNUC__
+  #include <tr1/memory>
+  #define SHARED_PTR std::tr1::shared_ptr
+#else
+  #ifdef _MSC_VER
+    #include <memory>
+    #define SHARED_PTR std::tr1::shared_ptr
+  #else
+    #include <boost/shared_ptr.hpp>
+    #define SHARED_PTR boost::shared_ptr
+  #endif
+#endif
+
+#include "../ifcparse/IfcEnum.h"
+
+class Ifc;
+
+namespace IfcParse {
+
+	class Argument {
+	private:
+		static std::vector<std::string> datatypes;
+		static std::vector<std::string> enumstrings;
+		static std::vector<std::string> argstrings;
+
+		int _data;
+		float _number;	
+	public:
+		enum vartype { IDENTIFIER, STRING, NUMBER, OPERATOR, ENUMERATION, DATATYPE };
+		vartype type;
+
+		Argument(const std::string& s);
+
+		bool isOp(char op = 0) const;
+
+		float f() const;
+		int i() const;
+		std::string s() const;
+		bool b() const;
+
+		std::string toString() const;
+
+		std::string typeString() const;
+
+		friend class ::Ifc;
+	};
+
+	class Entity;
+	class Entities;
+	typedef SHARED_PTR<Entity> EntityPtr;
+	typedef SHARED_PTR<Entities> EntitiesPtr;
+
+	class ArgumentList {
+	private:
+		std::vector<ArgumentList*> _levels;
+		std::vector<ArgumentList*> _args;
+		ArgumentList* _current;
+		const Argument* _arg;
+		void _push();
+		void _pop();
+		void _append(const Argument* v);
+	public:	
+		ArgumentList();
+		~ArgumentList();
+
+		float f() const;
+		int i() const;
+		std::string s() const;
+		bool b() const;
+		EntityPtr ref() const;
+		EntitiesPtr refs() const;
+		ArgumentList* arg(int i) const;
+
+		int count() const;	
+		std::string toString() const;
+
+		friend class Entity;
+	};
+
+	class Entity {
+	private:
+		inline bool term(char last);
+	public:
+		int id;
+		IfcSchema::Enum::IfcTypes dt;
+		ArgumentList* args;
+		Argument* _dt;
+
+		Entity(std::istream* ss, std::vector<int>& refs);
+		~Entity();
+
+		ArgumentList* arg(int i) const;
+		std::string toString() const;
+
+		EntitiesPtr parents(IfcSchema::Enum::IfcTypes c = IfcSchema::Enum::ALL);
+		EntitiesPtr parents(IfcSchema::Enum::IfcTypes c, int i, const std::string& a);
+		bool isAssignment() const;
+		std::string datatype() const;
+	};
+
+	class Entities {
+	private:
+		std::vector<EntityPtr> ls;
+	public:
+		int size;
+		typedef std::vector<EntityPtr>::const_iterator it;
+		void push(EntityPtr l);
+		void pushs(EntitiesPtr l);
+		it begin();
+		it end();
+		EntitiesPtr parents(IfcSchema::Enum::IfcTypes c = IfcSchema::Enum::ALL);
+		EntitiesPtr parents(IfcSchema::Enum::IfcTypes c, int i, const std::string& a);
+		Entities();
+		EntityPtr operator[] (int i);
+	};
+
+	class File {
+	public:
+		std::map<IfcSchema::Enum::IfcTypes,EntitiesPtr> bytype;
+		std::map<int,EntityPtr> byid;
+		std::map<int,EntitiesPtr> byref;
+		bool valid;
+
+		File(std::string fn, bool debug = false);
+		EntitiesPtr EntitiesByType(IfcSchema::Enum::IfcTypes t);
+		EntitiesPtr EntitiesByReference(int id);
+		EntityPtr EntityById(int id);
+	};
+
+	class IfcException : public std::exception {
+	private:
+		std::string w;
+	public:
+		IfcException(int id);
+		IfcException();
+		~IfcException() throw();
+		virtual const char* what() const throw();
+	};
+
+}
+
+typedef IfcParse::EntityPtr IfcEntity;
+typedef IfcParse::EntitiesPtr IfcEntities;
+
+class Ifc {
+private:
+	static IfcParse::File* f;
+public:
+	static IfcEntities EntitiesByType(IfcSchema::Enum::IfcTypes t);
+	static IfcEntities EntitiesByReference(int id);
+	static IfcEntity EntityById(int id);
+	static bool Init(std::string fn);
+	static void Dispose();
+	static float Scale;
+};
+
+#endif

src/ifcparse/IfcSchema.h

@@ -0,0 +1,196 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * This file provides a (quite ugly) partial reproduction of the entities       *
+ * defined in IFC2X3.exp. Macro's are used to expand the definitions into C++   * 
+ * code in various contexts, several enumerations, class defenitions and        *
+ * conversion functions.                                                        *
+ *                                                                              *
+ * IFC_SHAPE_CLASS   A class that will be mapped directly to a TopoDS_Shape     *
+ * IFC_FACE_CLASS    A class that will be mapped directly to a TopoDS_Face      *
+ * IFC_WIRE_CLASS    A class that will be mapped directly to a TopoDS_Wire      *
+ *                       These functions are automatically injected in          *
+ *                       IfcGeom::convert_shape and IfcGeom::convert_wire       *
+ *                       respectively and their function is called when the     *
+ *                       corresponding datatype is encountered.                 *
+ * IFC_CLASS         A class that will be mapped to another class aiding        *
+ *                       generation of shapes or wires.                         *
+ * IFC_HELPER_CLASS  A class that is not mapped to a geometrical representation *
+ *                       but is included in IfcSchema::Enum and has a class def *
+ * IFC_SKIP_CLASS    This datatype will not be stored when encountered, use to  *                     
+ *                   save memory. Enumeration type: IfcDontCare.                *
+ *                                                                              *
+ *                   Other datatypes will be assigned IfcUnknown, but their     *
+ *                   datatypes can still be checked using string comparisons    *
+ *                                                                              *
+ ********************************************************************************/
+
+#include "../ifcparse/IfcMacro.h"
+
+IFC_SHAPE_CLASS(ExtrudedAreaSolid)
+IFC_REF(ExtrudedAreaSolid,Profile,0)
+IFC_REF(ExtrudedAreaSolid,Placement,1)
+IFC_REF(ExtrudedAreaSolid,Dir,2)
+IFC_FLT(ExtrudedAreaSolid,Height,3)
+IFC_END_CLASS
+
+IFC_SHAPE_CLASS(FacetedBrep)
+IFC_REF(FacetedBrep,Shell,0)
+IFC_END_CLASS
+
+IFC_SHAPE_CLASS(ClosedShell)
+IFC_REFS(ClosedShell,Faces,0)
+IFC_END_CLASS
+
+IFC_SHAPE_CLASS(OpenShell)
+IFC_REFS(OpenShell,Faces,0)
+IFC_END_CLASS
+
+IFC_SHAPE_CLASS(ShellBasedSurfaceModel)
+IFC_REFS(ShellBasedSurfaceModel,Shells,0)
+IFC_END_CLASS
+
+IFC_SHAPE_CLASS(FaceBasedSurfaceModel)
+IFC_REFS(FaceBasedSurfaceModel,FaceSets,0)
+IFC_END_CLASS
+
+IFC_SHAPE_CLASS(ConnectedFaceSet)
+IFC_END_CLASS
+
+IFC_SHAPE_CLASS(HalfSpaceSolid)
+IFC_REF(HalfSpaceSolid,Surface,0)
+IFC_BOOL(HalfSpaceSolid,Flag,1)
+IFC_END_CLASS
+
+IFC_SHAPE_CLASS(PolygonalBoundedHalfSpace)
+IFC_REF(PolygonalBoundedHalfSpace,Surface,0)
+IFC_BOOL(PolygonalBoundedHalfSpace,Flag,1)
+IFC_REF(PolygonalBoundedHalfSpace,Placement,2)
+IFC_REF(PolygonalBoundedHalfSpace,Boundary,3)
+IFC_END_CLASS
+
+IFC_SHAPE_CLASS(BooleanClippingResult)
+IFC_REF(BooleanClippingResult,First,1)
+IFC_REF(BooleanClippingResult,Second,2)
+IFC_END_CLASS
+
+IFC_CLASS(Face,TopoDS_Face)
+IFC_REFS(Face,Bounds,0)
+IFC_END_CLASS
+
+IFC_HELPER_CLASS(FaceBound)
+IFC_REF(FaceBound,Loop,0)
+IFC_BOOL(FaceBound,Flag,1)
+IFC_END_CLASS
+
+IFC_CLASS(Plane,gp_Pln)
+IFC_REF(Plane,Placement,0)
+IFC_END_CLASS
+
+IFC_WIRE_CLASS(ArbitraryClosedProfileDef)
+IFC_REF(ArbitraryClosedProfileDef,Polyline,2)
+IFC_END_CLASS
+
+IFC_FACE_CLASS(ArbitraryProfileDefWithVoids)
+IFC_REF(ArbitraryProfileDefWithVoids,Polyline,2)
+IFC_REFS(ArbitraryProfileDefWithVoids,Voids,3)
+IFC_END_CLASS
+
+IFC_WIRE_CLASS(RectangleProfileDef)
+IFC_REF(RectangleProfileDef,Placement,2)
+IFC_FLT(RectangleProfileDef,Width,3)
+IFC_FLT(RectangleProfileDef,Height,4)
+IFC_END_CLASS
+
+IFC_CLASS(CartesianPoint,gp_Pnt)
+IFC_FLT_SUB(CartesianPoint,X,0,0)
+IFC_FLT_SUB(CartesianPoint,Y,0,1)
+IFC_FLT_SUB(CartesianPoint,Z,0,2)
+IFC_END_CLASS
+
+IFC_CLASS(Direction,gp_Vec)
+IFC_FLT_SUB(Direction,X,0,0)
+IFC_FLT_SUB(Direction,Y,0,1)
+IFC_FLT_SUB(Direction,Z,0,2)
+IFC_END_CLASS
+
+IFC_CLASS(Axis2Placement3D,gp_Trsf)
+IFC_REF(Axis2Placement3D,Origin,0)
+IFC_REF(Axis2Placement3D,Dir1,1)
+IFC_REF(Axis2Placement3D,Dir2,2)
+IFC_END_CLASS
+
+IFC_CLASS(Axis2Placement2D,gp_Trsf2d)
+IFC_REF(Axis2Placement2D,Origin,0)
+IFC_REF(Axis2Placement2D,Dir1,1)
+IFC_END_CLASS
+
+IFC_CLASS(LocalPlacement,gp_Trsf)
+IFC_REF(LocalPlacement,Parent,0)
+IFC_REF(LocalPlacement,Placement,1)
+IFC_END_CLASS
+
+IFC_WIRE_CLASS(Polyline)
+IFC_REFS(Polyline,Points,0)
+IFC_END_CLASS
+
+IFC_WIRE_CLASS(Polyloop)
+IFC_REFS(Polyloop,Points,0)
+IFC_END_CLASS
+
+IFC_HELPER_CLASS(BuildingElement)
+IFC_STR(BuildingElement,Guid,0)
+IFC_REF(BuildingElement,Owner,1)
+IFC_STR(BuildingElement,Name,2)
+IFC_REF(BuildingElement,Placement,5)
+IFC_REF(BuildingElement,Shape,6)
+IFC_END_CLASS
+
+IFC_HELPER_CLASS(ShapeRepresentation)
+IFC_REFS(ShapeRepresentation,Shapes,3)
+IFC_END_CLASS
+
+IFC_HELPER_CLASS(SIUnit)
+IFC_STR(SIUnit,Type,1)
+IFC_STR(SIUnit,Prefix,2)
+IFC_STR(SIUnit,Name,3)
+IFC_END_CLASS
+
+IFC_HELPER_CLASS(ProductDefinitionShape)
+IFC_REFS(ProductDefinitionShape,ShapeReps,2)
+IFC_END_CLASS
+IFC_HELPER_CLASS(RepresentationMap)
+IFC_END_CLASS
+IFC_HELPER_CLASS(MappedItem)
+IFC_END_CLASS
+IFC_HELPER_CLASS(RelVoidsElement)
+IFC_REF(RelVoidsElement,Opening,5)
+IFC_END_CLASS
+IFC_HELPER_CLASS(OpeningElement)
+IFC_END_CLASS
+
+IFC_SKIP_CLASS(PropertySingleValue)
+IFC_SKIP_CLASS(PropertySet)
+IFC_SKIP_CLASS(ComplexProperty)
+IFC_SKIP_CLASS(RelDefinesByProperty)
+IFC_SKIP_CLASS(MaterialLayer)
+IFC_SKIP_CLASS(MaterialLayerSet)
+IFC_SKIP_CLASS(MaterialLayerSetUsage)

src/ifcparse/IfcTypes.cpp

@@ -0,0 +1,57 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include "StdFail_NotDone.hxx"
+
+#include "../ifcparse/IfcTypes.h"
+#include "../ifcparse/IfcEnum.h"
+
+using namespace IfcSchema;
+
+#define IFC_PARSE_SOURCE
+#include "../ifcparse/IfcSchema.h"
+#undef IFC_PARSE_SOURCE
+
+bool IfcGeom::convert_shape(const IfcEntity L, TopoDS_Shape &result) {
+	if ( ! L ) return false;
+#define IFC_SHAPE_SRC
+#include "../ifcparse/IfcSchema.h"
+#undef IFC_SHAPE_SRC
+	std::cout << "[Error] Failed to interpret:" << std::endl << L->toString() << std::endl;
+	return false;
+}
+
+bool IfcGeom::convert_wire(const IfcEntity L, TopoDS_Wire &result) {
+	if ( ! L ) return false;
+#define IFC_WIRE_SRC
+#include "../ifcparse/IfcSchema.h"
+#undef IFC_WIRE_SRC
+	std::cout << "[Error] Failed to interpret:" << std::endl << L->toString() << std::endl;
+	return false;
+}
+
+bool IfcGeom::convert_face(const IfcEntity L, TopoDS_Face &result) {
+	if ( ! L ) return false;
+	TopoDS_Wire wire;
+#define IFC_FACE_SRC
+#include "../ifcparse/IfcSchema.h"
+#undef IFC_FACE_SRC
+	std::cout << "[Error] Failed to interpret:" << std::endl << L->toString() << std::endl;
+	return false;
+}

src/ifcparse/IfcTypes.h

@@ -0,0 +1,49 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCTYPES_H
+#define IFCTYPES_H
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Wire.hxx>
+
+#include "../ifcparse/IfcParse.h"
+
+namespace IfcSchema {	
+#define IFC_PARSE_HEADER
+#include "../ifcparse/IfcSchema.h"
+#undef IFC_PARSE_HEADER
+}
+
+namespace IfcGeom {
+#define IFC_GEOM_HEADER
+#include "../ifcparse/IfcSchema.h"
+#undef IFC_GEOM_HEADER
+	bool convert_wire_to_face(const TopoDS_Wire& wire, TopoDS_Face& face);
+	bool convert_shape(const IfcEntity L, TopoDS_Shape& result);
+	bool convert_wire(const IfcEntity L, TopoDS_Wire& result);
+	bool convert_face(const IfcEntity L, TopoDS_Face& result);
+	bool convert_openings(const IfcSchema::BuildingElement* IfcBuildingElement, const IfcEntities openings, TopoDS_Shape& result, const gp_Trsf& trsf);
+}
+
+#endif

src/ifcwrap/CMakeLists.txt

@@ -0,0 +1,13 @@
+FIND_PACKAGE(SWIG REQUIRED)
+INCLUDE(${SWIG_USE_FILE})  
+
+FIND_PACKAGE(PythonLibs REQUIRED)
+INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH})
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+
+SET(CMAKE_SWIG_FLAGS "")
+
+SET_SOURCE_FILES_PROPERTIES(IfcPython.i PROPERTIES CPLUSPLUS ON)
+SWIG_ADD_MODULE(IfcImport python IfcPython.i)
+SWIG_LINK_LIBRARIES(IfcImport ${PYTHON_LIBRARIES} IfcParse TKAdvTools TKMath TKernel TKBRep TKGeomBase TKGeomAlgo TKBool TKMesh TKShHealing)

src/ifcwrap/IfcImport.py

@@ -0,0 +1,310 @@
+# This file was automatically generated by SWIG (http://www.swig.org).
+# Version 2.0.3
+#
+# Do not make changes to this file unless you know what you are doing--modify
+# the SWIG interface file instead.
+# This file is compatible with both classic and new-style classes.
+
+from sys import version_info
+if version_info >= (2,6,0):
+    def swig_import_helper():
+        from os.path import dirname
+        import imp
+        fp = None
+        try:
+            fp, pathname, description = imp.find_module('_IfcImport', [dirname(__file__)])
+        except ImportError:
+            import _IfcImport
+            return _IfcImport
+        if fp is not None:
+            try:
+                _mod = imp.load_module('_IfcImport', fp, pathname, description)
+            finally:
+                fp.close()
+            return _mod
+    _IfcImport = swig_import_helper()
+    del swig_import_helper
+else:
+    import _IfcImport
+del version_info
+try:
+    _swig_property = property
+except NameError:
+    pass # Python < 2.2 doesn't have 'property'.
+def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
+    if (name == "thisown"): return self.this.own(value)
+    if (name == "this"):
+        if type(value).__name__ == 'SwigPyObject':
+            self.__dict__[name] = value
+            return
+    method = class_type.__swig_setmethods__.get(name,None)
+    if method: return method(self,value)
+    if (not static) or hasattr(self,name):
+        self.__dict__[name] = value
+    else:
+        raise AttributeError("You cannot add attributes to %s" % self)
+
+def _swig_setattr(self,class_type,name,value):
+    return _swig_setattr_nondynamic(self,class_type,name,value,0)
+
+def _swig_getattr(self,class_type,name):
+    if (name == "thisown"): return self.this.own()
+    method = class_type.__swig_getmethods__.get(name,None)
+    if method: return method(self)
+    raise AttributeError(name)
+
+def _swig_repr(self):
+    try: strthis = "proxy of " + self.this.__repr__()
+    except: strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+try:
+    _object = object
+    _newclass = 1
+except AttributeError:
+    class _object : pass
+    _newclass = 0
+
+
+class SwigPyIterator(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
+    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
+    __repr__ = _swig_repr
+    __swig_destroy__ = _IfcImport.delete_SwigPyIterator
+    __del__ = lambda self : None;
+    def value(self): return _IfcImport.SwigPyIterator_value(self)
+    def incr(self, n = 1): return _IfcImport.SwigPyIterator_incr(self, n)
+    def decr(self, n = 1): return _IfcImport.SwigPyIterator_decr(self, n)
+    def distance(self, *args): return _IfcImport.SwigPyIterator_distance(self, *args)
+    def equal(self, *args): return _IfcImport.SwigPyIterator_equal(self, *args)
+    def copy(self): return _IfcImport.SwigPyIterator_copy(self)
+    def next(self): return _IfcImport.SwigPyIterator_next(self)
+    def __next__(self): return _IfcImport.SwigPyIterator___next__(self)
+    def previous(self): return _IfcImport.SwigPyIterator_previous(self)
+    def advance(self, *args): return _IfcImport.SwigPyIterator_advance(self, *args)
+    def __eq__(self, *args): return _IfcImport.SwigPyIterator___eq__(self, *args)
+    def __ne__(self, *args): return _IfcImport.SwigPyIterator___ne__(self, *args)
+    def __iadd__(self, *args): return _IfcImport.SwigPyIterator___iadd__(self, *args)
+    def __isub__(self, *args): return _IfcImport.SwigPyIterator___isub__(self, *args)
+    def __add__(self, *args): return _IfcImport.SwigPyIterator___add__(self, *args)
+    def __sub__(self, *args): return _IfcImport.SwigPyIterator___sub__(self, *args)
+    def __iter__(self): return self
+SwigPyIterator_swigregister = _IfcImport.SwigPyIterator_swigregister
+SwigPyIterator_swigregister(SwigPyIterator)
+
+class IfcMesh(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, IfcMesh, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, IfcMesh, name)
+    __repr__ = _swig_repr
+    __swig_setmethods__["id"] = _IfcImport.IfcMesh_id_set
+    __swig_getmethods__["id"] = _IfcImport.IfcMesh_id_get
+    if _newclass:id = _swig_property(_IfcImport.IfcMesh_id_get, _IfcImport.IfcMesh_id_set)
+    __swig_setmethods__["verts"] = _IfcImport.IfcMesh_verts_set
+    __swig_getmethods__["verts"] = _IfcImport.IfcMesh_verts_get
+    if _newclass:verts = _swig_property(_IfcImport.IfcMesh_verts_get, _IfcImport.IfcMesh_verts_set)
+    __swig_setmethods__["faces"] = _IfcImport.IfcMesh_faces_set
+    __swig_getmethods__["faces"] = _IfcImport.IfcMesh_faces_get
+    if _newclass:faces = _swig_property(_IfcImport.IfcMesh_faces_get, _IfcImport.IfcMesh_faces_set)
+    __swig_setmethods__["edges"] = _IfcImport.IfcMesh_edges_set
+    __swig_getmethods__["edges"] = _IfcImport.IfcMesh_edges_get
+    if _newclass:edges = _swig_property(_IfcImport.IfcMesh_edges_get, _IfcImport.IfcMesh_edges_set)
+    def __init__(self): 
+        this = _IfcImport.new_IfcMesh()
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _IfcImport.delete_IfcMesh
+    __del__ = lambda self : None;
+IfcMesh_swigregister = _IfcImport.IfcMesh_swigregister
+IfcMesh_swigregister(IfcMesh)
+
+class IfcGeomObject(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, IfcGeomObject, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, IfcGeomObject, name)
+    __repr__ = _swig_repr
+    __swig_setmethods__["name"] = _IfcImport.IfcGeomObject_name_set
+    __swig_getmethods__["name"] = _IfcImport.IfcGeomObject_name_get
+    if _newclass:name = _swig_property(_IfcImport.IfcGeomObject_name_get, _IfcImport.IfcGeomObject_name_set)
+    __swig_setmethods__["type"] = _IfcImport.IfcGeomObject_type_set
+    __swig_getmethods__["type"] = _IfcImport.IfcGeomObject_type_get
+    if _newclass:type = _swig_property(_IfcImport.IfcGeomObject_type_get, _IfcImport.IfcGeomObject_type_set)
+    __swig_setmethods__["matrix"] = _IfcImport.IfcGeomObject_matrix_set
+    __swig_getmethods__["matrix"] = _IfcImport.IfcGeomObject_matrix_get
+    if _newclass:matrix = _swig_property(_IfcImport.IfcGeomObject_matrix_get, _IfcImport.IfcGeomObject_matrix_set)
+    __swig_setmethods__["mesh"] = _IfcImport.IfcGeomObject_mesh_set
+    __swig_getmethods__["mesh"] = _IfcImport.IfcGeomObject_mesh_get
+    if _newclass:mesh = _swig_property(_IfcImport.IfcGeomObject_mesh_get, _IfcImport.IfcGeomObject_mesh_set)
+    def __init__(self): 
+        this = _IfcImport.new_IfcGeomObject()
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _IfcImport.delete_IfcGeomObject
+    __del__ = lambda self : None;
+IfcGeomObject_swigregister = _IfcImport.IfcGeomObject_swigregister
+IfcGeomObject_swigregister(IfcGeomObject)
+
+
+def Next():
+  return _IfcImport.Next()
+Next = _IfcImport.Next
+
+def Get():
+  return _IfcImport.Get()
+Get = _IfcImport.Get
+
+def Progress():
+  return _IfcImport.Progress()
+Progress = _IfcImport.Progress
+class IntVector(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
+    __repr__ = _swig_repr
+    def iterator(self): return _IfcImport.IntVector_iterator(self)
+    def __iter__(self): return self.iterator()
+    def __nonzero__(self): return _IfcImport.IntVector___nonzero__(self)
+    def __bool__(self): return _IfcImport.IntVector___bool__(self)
+    def __len__(self): return _IfcImport.IntVector___len__(self)
+    def pop(self): return _IfcImport.IntVector_pop(self)
+    def __getslice__(self, *args): return _IfcImport.IntVector___getslice__(self, *args)
+    def __setslice__(self, *args): return _IfcImport.IntVector___setslice__(self, *args)
+    def __delslice__(self, *args): return _IfcImport.IntVector___delslice__(self, *args)
+    def __delitem__(self, *args): return _IfcImport.IntVector___delitem__(self, *args)
+    def __getitem__(self, *args): return _IfcImport.IntVector___getitem__(self, *args)
+    def __setitem__(self, *args): return _IfcImport.IntVector___setitem__(self, *args)
+    def append(self, *args): return _IfcImport.IntVector_append(self, *args)
+    def empty(self): return _IfcImport.IntVector_empty(self)
+    def size(self): return _IfcImport.IntVector_size(self)
+    def clear(self): return _IfcImport.IntVector_clear(self)
+    def swap(self, *args): return _IfcImport.IntVector_swap(self, *args)
+    def get_allocator(self): return _IfcImport.IntVector_get_allocator(self)
+    def begin(self): return _IfcImport.IntVector_begin(self)
+    def end(self): return _IfcImport.IntVector_end(self)
+    def rbegin(self): return _IfcImport.IntVector_rbegin(self)
+    def rend(self): return _IfcImport.IntVector_rend(self)
+    def pop_back(self): return _IfcImport.IntVector_pop_back(self)
+    def erase(self, *args): return _IfcImport.IntVector_erase(self, *args)
+    def __init__(self, *args): 
+        this = _IfcImport.new_IntVector(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def push_back(self, *args): return _IfcImport.IntVector_push_back(self, *args)
+    def front(self): return _IfcImport.IntVector_front(self)
+    def back(self): return _IfcImport.IntVector_back(self)
+    def assign(self, *args): return _IfcImport.IntVector_assign(self, *args)
+    def resize(self, *args): return _IfcImport.IntVector_resize(self, *args)
+    def insert(self, *args): return _IfcImport.IntVector_insert(self, *args)
+    def reserve(self, *args): return _IfcImport.IntVector_reserve(self, *args)
+    def capacity(self): return _IfcImport.IntVector_capacity(self)
+    __swig_destroy__ = _IfcImport.delete_IntVector
+    __del__ = lambda self : None;
+IntVector_swigregister = _IfcImport.IntVector_swigregister
+IntVector_swigregister(IntVector)
+
+def Init(*args):
+  return _IfcImport.Init(*args)
+Init = _IfcImport.Init
+
+class FloatVector(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatVector, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, FloatVector, name)
+    __repr__ = _swig_repr
+    def iterator(self): return _IfcImport.FloatVector_iterator(self)
+    def __iter__(self): return self.iterator()
+    def __nonzero__(self): return _IfcImport.FloatVector___nonzero__(self)
+    def __bool__(self): return _IfcImport.FloatVector___bool__(self)
+    def __len__(self): return _IfcImport.FloatVector___len__(self)
+    def pop(self): return _IfcImport.FloatVector_pop(self)
+    def __getslice__(self, *args): return _IfcImport.FloatVector___getslice__(self, *args)
+    def __setslice__(self, *args): return _IfcImport.FloatVector___setslice__(self, *args)
+    def __delslice__(self, *args): return _IfcImport.FloatVector___delslice__(self, *args)
+    def __delitem__(self, *args): return _IfcImport.FloatVector___delitem__(self, *args)
+    def __getitem__(self, *args): return _IfcImport.FloatVector___getitem__(self, *args)
+    def __setitem__(self, *args): return _IfcImport.FloatVector___setitem__(self, *args)
+    def append(self, *args): return _IfcImport.FloatVector_append(self, *args)
+    def empty(self): return _IfcImport.FloatVector_empty(self)
+    def size(self): return _IfcImport.FloatVector_size(self)
+    def clear(self): return _IfcImport.FloatVector_clear(self)
+    def swap(self, *args): return _IfcImport.FloatVector_swap(self, *args)
+    def get_allocator(self): return _IfcImport.FloatVector_get_allocator(self)
+    def begin(self): return _IfcImport.FloatVector_begin(self)
+    def end(self): return _IfcImport.FloatVector_end(self)
+    def rbegin(self): return _IfcImport.FloatVector_rbegin(self)
+    def rend(self): return _IfcImport.FloatVector_rend(self)
+    def pop_back(self): return _IfcImport.FloatVector_pop_back(self)
+    def erase(self, *args): return _IfcImport.FloatVector_erase(self, *args)
+    def __init__(self, *args): 
+        this = _IfcImport.new_FloatVector(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def push_back(self, *args): return _IfcImport.FloatVector_push_back(self, *args)
+    def front(self): return _IfcImport.FloatVector_front(self)
+    def back(self): return _IfcImport.FloatVector_back(self)
+    def assign(self, *args): return _IfcImport.FloatVector_assign(self, *args)
+    def resize(self, *args): return _IfcImport.FloatVector_resize(self, *args)
+    def insert(self, *args): return _IfcImport.FloatVector_insert(self, *args)
+    def reserve(self, *args): return _IfcImport.FloatVector_reserve(self, *args)
+    def capacity(self): return _IfcImport.FloatVector_capacity(self)
+    __swig_destroy__ = _IfcImport.delete_FloatVector
+    __del__ = lambda self : None;
+FloatVector_swigregister = _IfcImport.FloatVector_swigregister
+FloatVector_swigregister(FloatVector)
+
+class ObjVector(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ObjVector, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ObjVector, name)
+    __repr__ = _swig_repr
+    def iterator(self): return _IfcImport.ObjVector_iterator(self)
+    def __iter__(self): return self.iterator()
+    def __nonzero__(self): return _IfcImport.ObjVector___nonzero__(self)
+    def __bool__(self): return _IfcImport.ObjVector___bool__(self)
+    def __len__(self): return _IfcImport.ObjVector___len__(self)
+    def pop(self): return _IfcImport.ObjVector_pop(self)
+    def __getslice__(self, *args): return _IfcImport.ObjVector___getslice__(self, *args)
+    def __setslice__(self, *args): return _IfcImport.ObjVector___setslice__(self, *args)
+    def __delslice__(self, *args): return _IfcImport.ObjVector___delslice__(self, *args)
+    def __delitem__(self, *args): return _IfcImport.ObjVector___delitem__(self, *args)
+    def __getitem__(self, *args): return _IfcImport.ObjVector___getitem__(self, *args)
+    def __setitem__(self, *args): return _IfcImport.ObjVector___setitem__(self, *args)
+    def append(self, *args): return _IfcImport.ObjVector_append(self, *args)
+    def empty(self): return _IfcImport.ObjVector_empty(self)
+    def size(self): return _IfcImport.ObjVector_size(self)
+    def clear(self): return _IfcImport.ObjVector_clear(self)
+    def swap(self, *args): return _IfcImport.ObjVector_swap(self, *args)
+    def get_allocator(self): return _IfcImport.ObjVector_get_allocator(self)
+    def begin(self): return _IfcImport.ObjVector_begin(self)
+    def end(self): return _IfcImport.ObjVector_end(self)
+    def rbegin(self): return _IfcImport.ObjVector_rbegin(self)
+    def rend(self): return _IfcImport.ObjVector_rend(self)
+    def pop_back(self): return _IfcImport.ObjVector_pop_back(self)
+    def erase(self, *args): return _IfcImport.ObjVector_erase(self, *args)
+    def __init__(self, *args): 
+        this = _IfcImport.new_ObjVector(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def push_back(self, *args): return _IfcImport.ObjVector_push_back(self, *args)
+    def front(self): return _IfcImport.ObjVector_front(self)
+    def back(self): return _IfcImport.ObjVector_back(self)
+    def assign(self, *args): return _IfcImport.ObjVector_assign(self, *args)
+    def resize(self, *args): return _IfcImport.ObjVector_resize(self, *args)
+    def insert(self, *args): return _IfcImport.ObjVector_insert(self, *args)
+    def reserve(self, *args): return _IfcImport.ObjVector_reserve(self, *args)
+    def capacity(self): return _IfcImport.ObjVector_capacity(self)
+    __swig_destroy__ = _IfcImport.delete_ObjVector
+    __del__ = lambda self : None;
+ObjVector_swigregister = _IfcImport.ObjVector_swigregister
+ObjVector_swigregister(ObjVector)
+
+
+

src/ifcwrap/IfcPython.i

@@ -0,0 +1,34 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+%include "std_vector.i"
+%include "std_string.i"
+
+%include "Interface.h"
+
+%module IfcImport %{
+	#include "Interface.h"
+	using namespace IfcGeomObjects;
+%}
+
+namespace std {
+   %template(IntVector) vector<int>;
+   %template(FloatVector) vector<float>;
+   %template(ObjVector) vector<IfcGeomObject>;
+};

src/ifcwrap/Interface.h

@@ -0,0 +1,41 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+namespace IfcGeomObjects {
+	class IfcMesh {
+	public:
+		int id;
+		std::vector<float> verts;
+		std::vector<int> faces;
+		std::vector<int> edges;
+	};
+
+	class IfcGeomObject {
+	public:
+		std::string name;
+		std::string type;
+		std::vector<float> matrix;
+		IfcMesh* mesh;
+	};
+
+	extern bool Next();
+	extern const IfcGeomObject* Get();
+	extern bool Init(char* fn, bool world_coords = false);
+	extern int Progress();
+};