Merge fixes

cmake/CMakeLists.txt

@@ -308,7 +308,7 @@ get_filename_component(libTKernelExt ${libTKernel} EXT)
 if("${libTKernelExt}" STREQUAL ".a")
     find_package(Threads)
     # OPENCASCADE_LIBRARIES repeated three times below in order to fix cyclic dependencies - use --start-group ... --end-group instead?
-    set(OPENCASCADE_LIBRARIES ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+    set(OPENCASCADE_LIBRARIES -Wl,--start-group ${OPENCASCADE_LIBRARIES} -Wl,--end-group ${CMAKE_THREAD_LIBS_INIT})
     if (NOT APPLE AND NOT WIN32)
         set(OPENCASCADE_LIBRARIES ${OPENCASCADE_LIBRARIES} "rt")
     endif()

src/ifcgeom/kernels/cgal/CgalConversionFunctions.cpp

@@ -1,4 +1,7 @@
 #include "CgalKernel.h"
+#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
+
+#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
 
 bool IfcGeom::CgalKernel::convert_wire_to_face(const cgal_wire_t& wire, cgal_face_t& face) {
   face.outer = wire;
@@ -15,10 +18,10 @@ void IfcGeom::CgalKernel::remove_duplicate_points_from_loop(cgal_wire_t& polygon
   }
 }
 
-CGAL::Polyhedron_3<Kernel> IfcGeom::CgalKernel::create_polyhedron(std::list<cgal_face_t> &face_list) {
+CGAL::Polyhedron_3<Kernel_> IfcGeom::CgalKernel::create_polyhedron(std::list<cgal_face_t> &face_list) {
   
   // Naive creation
-  CGAL::Polyhedron_3<Kernel> polyhedron;
+  CGAL::Polyhedron_3<Kernel_> polyhedron;
   PolyhedronBuilder builder(&face_list);
   polyhedron.delegate(builder);
   
@@ -31,7 +34,7 @@ CGAL::Polyhedron_3<Kernel> IfcGeom::CgalKernel::create_polyhedron(std::list<cgal
     //    fresult.open("/Users/ken/Desktop/invalid.off");
     //    fresult << polyhedron << std::endl;
     //    fresult.close();
-    return CGAL::Polyhedron_3<Kernel>();
+    return CGAL::Polyhedron_3<Kernel_>();
   } if (polyhedron.is_closed()) {
     if (!CGAL::Polygon_mesh_processing::is_outward_oriented(polyhedron)) {
       CGAL::Polygon_mesh_processing::reverse_face_orientations(polyhedron);
@@ -43,61 +46,61 @@ CGAL::Polyhedron_3<Kernel> IfcGeom::CgalKernel::create_polyhedron(std::list<cgal
   return polyhedron;
 }
 
-CGAL::Polyhedron_3<Kernel> IfcGeom::CgalKernel::create_polyhedron(CGAL::Nef_polyhedron_3<Kernel> &nef_polyhedron) {
+CGAL::Polyhedron_3<Kernel_> IfcGeom::CgalKernel::create_polyhedron(CGAL::Nef_polyhedron_3<Kernel_> &nef_polyhedron) {
   if (nef_polyhedron.is_simple()) {
     try {
-      CGAL::Polyhedron_3<Kernel> polyhedron;
+      CGAL::Polyhedron_3<Kernel_> polyhedron;
       nef_polyhedron.convert_to_polyhedron(polyhedron);
       return polyhedron;
     } catch (...) {
       Logger::Message(Logger::LOG_ERROR, "Conversion from Nef to polyhedron failed!");
-      return CGAL::Polyhedron_3<Kernel>();
+      return CGAL::Polyhedron_3<Kernel_>();
     }
   } else {
     Logger::Message(Logger::LOG_ERROR, "Nef polyhedron not simple: cannot create polyhedron!");
-    return CGAL::Polyhedron_3<Kernel>();
+    return CGAL::Polyhedron_3<Kernel_>();
   }
 }
 
-CGAL::Nef_polyhedron_3<Kernel> IfcGeom::CgalKernel::create_nef_polyhedron(std::list<cgal_face_t> &face_list) {
+CGAL::Nef_polyhedron_3<Kernel_> IfcGeom::CgalKernel::create_nef_polyhedron(std::list<cgal_face_t> &face_list) {
-  CGAL::Polyhedron_3<Kernel> polyhedron = create_polyhedron(face_list);
+  CGAL::Polyhedron_3<Kernel_> polyhedron = create_polyhedron(face_list);
   CGAL::Polygon_mesh_processing::triangulate_faces(polyhedron);
-  CGAL::Nef_polyhedron_3<Kernel> nef_polyhedron;
+  CGAL::Nef_polyhedron_3<Kernel_> nef_polyhedron;
   try {
-    nef_polyhedron = CGAL::Nef_polyhedron_3<Kernel>(polyhedron);
+    nef_polyhedron = CGAL::Nef_polyhedron_3<Kernel_>(polyhedron);
   } catch (...) {
     Logger::Message(Logger::LOG_ERROR, "Conversion to Nef polyhedron failed!");
     return nef_polyhedron;
   } return nef_polyhedron;
 }
 
-CGAL::Nef_polyhedron_3<Kernel> IfcGeom::CgalKernel::create_nef_polyhedron(CGAL::Polyhedron_3<Kernel> &polyhedron) {
+CGAL::Nef_polyhedron_3<Kernel_> IfcGeom::CgalKernel::create_nef_polyhedron(CGAL::Polyhedron_3<Kernel_> &polyhedron) {
   if (polyhedron.is_valid()) {
     CGAL::Polygon_mesh_processing::triangulate_faces(polyhedron);
-    CGAL::Nef_polyhedron_3<Kernel> nef_polyhedron;
+    CGAL::Nef_polyhedron_3<Kernel_> nef_polyhedron;
     try {
-      nef_polyhedron = CGAL::Nef_polyhedron_3<Kernel>(polyhedron);
+      nef_polyhedron = CGAL::Nef_polyhedron_3<Kernel_>(polyhedron);
     } catch (...) {
       Logger::Message(Logger::LOG_ERROR, "Conversion to Nef polyhedron failed!");
       return nef_polyhedron;
     } return nef_polyhedron;
   } else {
     Logger::Message(Logger::LOG_ERROR, "Polyhedron not valid: cannot create Nef polyhedron!");
-    return CGAL::Nef_polyhedron_3<Kernel>();
+    return CGAL::Nef_polyhedron_3<Kernel_>();
   }
 }
 
-//CGAL::Polyhedron_3<Kernel> IfcGeom::CgalKernel::triangulate_faces(CGAL::Polyhedron_3<Kernel> &polyhedron) {
+//CGAL::Polyhedron_3<Kernel_> IfcGeom::CgalKernel::triangulate_faces(CGAL::Polyhedron_3<Kernel_> &polyhedron) {
 //  std::list<cgal_face_t> face_list;
 //  
-//  for (CGAL::Polyhedron_3<Kernel>::Facet_const_iterator current_facet = polyhedron.facets_begin();
+//  for (CGAL::Polyhedron_3<Kernel_>::Facet_const_iterator current_facet = polyhedron.facets_begin();
 //       current_facet != polyhedron.facets_end();
 //       ++current_facet) {
 //    
 //    // Triangle
 //    if (current_facet->is_triangle()) {
 //      face_list.push_back(cgal_face_t());
-//      CGAL::Polyhedron_3<Kernel>::Halfedge_around_facet_const_circulator current_halfedge = current_facet->facet_begin();
+//      CGAL::Polyhedron_3<Kernel_>::Halfedge_around_facet_const_circulator current_halfedge = current_facet->facet_begin();
 //      do {
 //        face_list.back().outer.push_back(current_halfedge->vertex()->point());
 //        ++current_halfedge;
@@ -106,7 +109,7 @@ CGAL::Nef_polyhedron_3<Kernel> IfcGeom::CgalKernel::create_nef_polyhedron(CGAL::
 //    
 //    // Polygon
 //    else {
-//      std::list<Kernel::Point_3> points_in_polygon;
+//      std::list<Kernel_::Point_3> points_in_polygon;
 //      
 //    }
 //  }

src/ifcgeom/kernels/cgal/CgalEntityMapping.cpp

@@ -17,28 +17,24 @@
 *                                                                              *
 ********************************************************************************/
 
-#include "../../../ifcgeom/IfcGeomShapeType.h"
-#include "../../../ifcgeom/IfcGeom.h"
-
 #include "CgalKernel.h"
-#include "CgalConversionResult.h"
 
-using namespace IfcSchema;
+#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
+
 using namespace IfcUtil;
 
-
 bool IfcGeom::CgalKernel::convert_shapes(const IfcBaseClass* l, ConversionResults& r) {
 	if (shape_type(l) != ST_SHAPELIST) {
 		cgal_shape_t shp;
 		if (convert_shape(l, shp)) {
-			r.push_back(IfcGeom::ConversionResult(new CgalShape(shp), get_style(l->as<IfcSchema::IfcRepresentationItem>())));
+			r.push_back(IfcGeom::ConversionResult(l->data().id(), new CgalShape(shp), get_style(l->as<IfcSchema::IfcRepresentationItem>())));
 			return true;
 		}
 		return false;
 	}
 
 #include "CgalEntityMappingShapes.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
 	return false;
 }
 
@@ -48,7 +44,7 @@ IfcGeom::ShapeType IfcGeom::CgalKernel::shape_type(const IfcBaseClass* l) {
 }
 
 bool IfcGeom::CgalKernel::convert_shape(const IfcBaseClass* l, cgal_shape_t& r) {
-	const unsigned int id = l->entity->id();
+	const unsigned int id = l->data().id();
 	bool success = false;
 	bool processed = false;
 	bool ignored = false;
@@ -76,25 +72,25 @@ bool IfcGeom::CgalKernel::convert_shape(const IfcBaseClass* l, cgal_shape_t& r)
 		const char* const msg = processed
 			? "Failed to convert:"
 			: "No operation defined for:";
-		Logger::Message(Logger::LOG_ERROR, msg, l->entity);
+		Logger::Message(Logger::LOG_ERROR, msg, l);
 	}
 	return success;
 }
 
 bool IfcGeom::CgalKernel::convert_wire(const IfcBaseClass* l, cgal_wire_t& r) {
 #include "CgalEntityMappingWire.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
 	return false;
 }
 
 bool IfcGeom::CgalKernel::convert_face(const IfcBaseClass* l, cgal_face_t& r) {
 #include "CgalEntityMappingFace.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
 	return false;
 }
 
 bool IfcGeom::CgalKernel::convert_curve(const IfcBaseClass* l, cgal_curve_t& r) {
 #include "CgalEntityMappingCurve.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
 	return false;
 }

src/ifcgeom/kernels/cgal/CgalIfcGeomCurves.cpp

@@ -1,14 +1,17 @@
 #include "CgalKernel.h"
+#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
+
+#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
 
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCircle* l, cgal_curve_t& curve) {
   const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
   if ( r < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l);
     return false;
   }
   cgal_placement_t trsf;
   IfcSchema::IfcAxis2Placement* placement = l->Position();
-  if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
+  if (placement->as<IfcSchema::IfcAxis2Placement3D>()) {
     IfcGeom::CgalKernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
   } else {
     cgal_placement_t trsf2d;
@@ -21,7 +24,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCircle* l, cgal_curve_t& c
   curve = cgal_curve_t();
   for (int current_segment = 0; current_segment < segments; ++current_segment) {
     double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    curve.push_back(Kernel::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
+    curve.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
   }
   
   for (auto &vertex: curve) {
@@ -35,12 +38,12 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcEllipse* l, cgal_curve_t&
   double x = l->SemiAxis1() * getValue(GV_LENGTH_UNIT);
   double y = l->SemiAxis2() * getValue(GV_LENGTH_UNIT);
   if (x < ALMOST_ZERO || y < ALMOST_ZERO) {
-    Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l);
     return false;
   }
   cgal_placement_t trsf;
   IfcSchema::IfcAxis2Placement* placement = l->Position();
-  if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
+  if (placement->as<IfcSchema::IfcAxis2Placement3D>()) {
     convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
   } else {
     cgal_placement_t trsf2d;
@@ -53,7 +56,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcEllipse* l, cgal_curve_t&
   curve = cgal_curve_t();
   for (int current_segment = 0; current_segment < segments; ++current_segment) {
     double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    curve.push_back(Kernel::Point_3(x*cos(current_angle), y*sin(current_angle), 0));
+    curve.push_back(Kernel_::Point_3(x*cos(current_angle), y*sin(current_angle), 0));
   }
   
   for (auto &vertex: curve) {

src/ifcgeom/kernels/cgal/CgalIfcGeomFaces.cpp

@@ -1,4 +1,7 @@
 #include "CgalKernel.h"
+#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
+
+#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
 
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcArbitraryClosedProfileDef* l, cgal_face_t& face) {
   cgal_wire_t wire;
@@ -30,7 +33,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRectangleProfileDef* l, cg
   const double y = l->YDim() / 2.0f * getValue(GV_LENGTH_UNIT);
   
   if ( x < ALMOST_ZERO || y < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -41,10 +44,10 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRectangleProfileDef* l, cg
 #endif
   
   face = cgal_face_t();
-  face.outer.push_back(Kernel::Point_3(-x, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-  face.outer.push_back(Kernel::Point_3( x, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3( x, -y, 0.0));
-  face.outer.push_back(Kernel::Point_3( x,  y, 0.0));
+  face.outer.push_back(Kernel_::Point_3( x,  y, 0.0));
-  face.outer.push_back(Kernel::Point_3(-x,  y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x,  y, 0.0));
   
   if (has_position) {
     IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
@@ -62,7 +65,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRoundedRectangleProfileDef
   const double r = l->RoundingRadius() * getValue(GV_LENGTH_UNIT);
   
   if ( x < ALMOST_ZERO || y < ALMOST_ZERO || r < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -76,29 +79,29 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRoundedRectangleProfileDef
   
   if (r == 0.0) {
     face = cgal_face_t();
-    face.outer.push_back(Kernel::Point_3(-x, -y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-    face.outer.push_back(Kernel::Point_3( x, -y, 0.0));
+    face.outer.push_back(Kernel_::Point_3( x, -y, 0.0));
-    face.outer.push_back(Kernel::Point_3( x,  y, 0.0));
+    face.outer.push_back(Kernel_::Point_3( x,  y, 0.0));
-    face.outer.push_back(Kernel::Point_3(-x,  y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x,  y, 0.0));
   }
   
   else {
     face = cgal_face_t();
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-r+r*cos(current_angle), y-r+r*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-r+r*cos(current_angle), y-r+r*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+r+r*cos(current_angle), y-r+r*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+r+r*cos(current_angle), y-r+r*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+r+r*cos(current_angle), -y+r+r*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+r+r*cos(current_angle), -y+r+r*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-r+r*cos(current_angle), -y+r+r*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-r+r*cos(current_angle), -y+r+r*sin(current_angle), 0));
     }
   }
   
@@ -124,7 +127,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRectangleHollowProfileDef*
   const double r2 = fr2 ? l->InnerFilletRadius() * getValue(GV_LENGTH_UNIT) : 0.;
   
   if ( x < ALMOST_ZERO || y < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -138,57 +141,57 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRectangleHollowProfileDef*
   
   if (!fr1 || r1 == 0.0) {
     face = cgal_face_t();
-    face.outer.push_back(Kernel::Point_3(-x, -y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-    face.outer.push_back(Kernel::Point_3( x, -y, 0.0));
+    face.outer.push_back(Kernel_::Point_3( x, -y, 0.0));
-    face.outer.push_back(Kernel::Point_3( x,  y, 0.0));
+    face.outer.push_back(Kernel_::Point_3( x,  y, 0.0));
-    face.outer.push_back(Kernel::Point_3(-x,  y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x,  y, 0.0));
   }
   
   else {
     face = cgal_face_t();
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-r1+r1*cos(current_angle), y-r1+r1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-r1+r1*cos(current_angle), y-r1+r1*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+r1+r1*cos(current_angle), y-r1+r1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+r1+r1*cos(current_angle), y-r1+r1*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+r1+r1*cos(current_angle), -y+r1+r1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+r1+r1*cos(current_angle), -y+r1+r1*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-r1+r1*cos(current_angle), -y+r1+r1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-r1+r1*cos(current_angle), -y+r1+r1*sin(current_angle), 0));
     }
   }
   
   if (!fr2 || r2 == 0.0) {
     face.inner.push_back(cgal_wire_t());
-    face.inner.back().push_back(Kernel::Point_3(-x+d, -y+d, 0.0));
+    face.inner.back().push_back(Kernel_::Point_3(-x+d, -y+d, 0.0));
-    face.inner.back().push_back(Kernel::Point_3( x-d, -y+d, 0.0));
+    face.inner.back().push_back(Kernel_::Point_3( x-d, -y+d, 0.0));
-    face.inner.back().push_back(Kernel::Point_3( x-d,  y-d, 0.0));
+    face.inner.back().push_back(Kernel_::Point_3( x-d,  y-d, 0.0));
-    face.inner.back().push_back(Kernel::Point_3(-x+d,  y-d, 0.0));
+    face.inner.back().push_back(Kernel_::Point_3(-x+d,  y-d, 0.0));
   }
   
   else {
     face.inner.push_back(cgal_wire_t());
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.inner.back().push_back(Kernel::Point_3(x-d-r1+r1*cos(current_angle), y-d-r1+r1*sin(current_angle), 0));
+      face.inner.back().push_back(Kernel_::Point_3(x-d-r1+r1*cos(current_angle), y-d-r1+r1*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.inner.back().push_back(Kernel::Point_3(-x+d+r1+r1*cos(current_angle), y-d-r1+r1*sin(current_angle), 0));
+      face.inner.back().push_back(Kernel_::Point_3(-x+d+r1+r1*cos(current_angle), y-d-r1+r1*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.inner.back().push_back(Kernel::Point_3(-x+d+r1+r1*cos(current_angle), -y+d+r1+r1*sin(current_angle), 0));
+      face.inner.back().push_back(Kernel_::Point_3(-x+d+r1+r1*cos(current_angle), -y+d+r1+r1*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.inner.back().push_back(Kernel::Point_3(x-d-r1+r1*cos(current_angle), -y+d+r1+r1*sin(current_angle), 0));
+      face.inner.back().push_back(Kernel_::Point_3(x-d-r1+r1*cos(current_angle), -y+d+r1+r1*sin(current_angle), 0));
     }
   }
   
@@ -213,7 +216,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrapeziumProfileDef* l, cg
   const double y = l->YDim() / 2.0f  * getValue(GV_LENGTH_UNIT);
   
   if ( x1 < ALMOST_ZERO || w < ALMOST_ZERO || y < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -224,10 +227,10 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrapeziumProfileDef* l, cg
 #endif
   
   face = cgal_face_t();
-  face.outer.push_back(Kernel::Point_3(-x1, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x1, -y, 0.0));
-  face.outer.push_back(Kernel::Point_3(x1, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(x1, -y, 0.0));
-  face.outer.push_back(Kernel::Point_3(dx+w-x1, y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(dx+w-x1, y, 0.0));
-  face.outer.push_back(Kernel::Point_3(dx-x1, y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(dx-x1, y, 0.0));
   
   if (has_position) {
     IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
@@ -242,7 +245,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrapeziumProfileDef* l, cg
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCircleProfileDef* l, cgal_face_t& face) {
   const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
   if ( r == 0.0f ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -257,7 +260,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCircleProfileDef* l, cgal_
   face = cgal_face_t();
   for (int current_segment = 0; current_segment < segments; ++current_segment) {
     double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face.outer.push_back(Kernel::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
+    face.outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
   }
   
   if (has_position) {
@@ -275,7 +278,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCircleHollowProfileDef* l,
   const double t = l->WallThickness() * getValue(GV_LENGTH_UNIT);
   
   if ( r == 0.0f || t == 0.0f ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -290,13 +293,13 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCircleHollowProfileDef* l,
   face = cgal_face_t();
   for (int current_segment = 0; current_segment < segments; ++current_segment) {
     double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face.outer.push_back(Kernel::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
+    face.outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
   }
   
   face.inner.push_back(cgal_wire_t());
   for (int current_segment = 0; current_segment < segments; ++current_segment) {
     double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face.inner.back().push_back(Kernel::Point_3((r-t)*cos(current_angle), (r-t)*sin(current_angle), 0));
+    face.inner.back().push_back(Kernel_::Point_3((r-t)*cos(current_angle), (r-t)*sin(current_angle), 0));
   }
   
   if (has_position) {
@@ -318,7 +321,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcEllipseProfileDef* l, cgal
   double ry = l->SemiAxis2() * getValue(GV_LENGTH_UNIT);
   
   if ( rx < ALMOST_ZERO || ry < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -333,7 +336,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcEllipseProfileDef* l, cgal
   face = cgal_face_t();
   for (int current_segment = 0; current_segment < segments; ++current_segment) {
     double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face.outer.push_back(Kernel::Point_3(rx*cos(current_angle), ry*sin(current_angle), 0));
+    face.outer.push_back(Kernel_::Point_3(rx*cos(current_angle), ry*sin(current_angle), 0));
   }
   
   if (has_position) {
@@ -353,11 +356,11 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcFace* l, cgal_face_t& face
   
   for (IfcSchema::IfcFaceBound::list::it it = bounds->begin(); it != bounds->end(); ++it) {
     IfcSchema::IfcFaceBound* bound = *it;
-    if (bound->is(IfcSchema::Type::IfcFaceOuterBound)) num_outer_bounds ++;
+    if (bound->as<IfcSchema::IfcFaceOuterBound>()) num_outer_bounds ++;
   }
   
   if (num_outer_bounds != 1) {
-    Logger::Message(Logger::LOG_ERROR, "Invalid configuration of boundaries for:", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "Invalid configuration of boundaries for:", l);
     return false;
   }
   
@@ -367,11 +370,11 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcFace* l, cgal_face_t& face
     IfcSchema::IfcFaceBound* bound = *it;
     IfcSchema::IfcLoop* loop = bound->Bound();
     
-    const bool is_interior = !bound->is(IfcSchema::Type::IfcFaceOuterBound);
+    const bool is_interior = !bound->as<IfcSchema::IfcFaceOuterBound>();
     
     cgal_wire_t wire;
     if (!convert_wire(loop, wire)) {
-      Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary loop", loop->entity);
+      Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary loop", loop);
       return false;
     }
     
@@ -406,7 +409,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCShapeProfileDef* l, cgal_
   }
   
   if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -420,57 +423,57 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCShapeProfileDef* l, cgal_
   
   if (!doFillet || f1 == 0.0) {
     face = cgal_face_t();
-    face.outer.push_back(Kernel::Point_3(-x, -y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-    face.outer.push_back(Kernel::Point_3(x, -y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x, -y, 0.0));
-    face.outer.push_back(Kernel::Point_3(x, -y+d2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x, -y+d2, 0.0));
-    face.outer.push_back(Kernel::Point_3(x-d1, -y+d2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x-d1, -y+d2, 0.0));
-    face.outer.push_back(Kernel::Point_3(x-d1, -y+d1, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x-d1, -y+d1, 0.0));
-    face.outer.push_back(Kernel::Point_3(-x+d1, -y+d1, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x+d1, -y+d1, 0.0));
-    face.outer.push_back(Kernel::Point_3(-x+d1, y-d1, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x+d1, y-d1, 0.0));
-    face.outer.push_back(Kernel::Point_3(x-d1, y-d1, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x-d1, y-d1, 0.0));
-    face.outer.push_back(Kernel::Point_3(x-d1, y-d2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x-d1, y-d2, 0.0));
-    face.outer.push_back(Kernel::Point_3(x, y-d2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x, y-d2, 0.0));
-    face.outer.push_back(Kernel::Point_3(x, y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x, y, 0.0));
-    face.outer.push_back(Kernel::Point_3(-x, y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x, y, 0.0));
   }
   
   else {
     face = cgal_face_t();
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
     }
-    face.outer.push_back(Kernel::Point_3(x, -y+d2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x, -y+d2, 0.0));
-    face.outer.push_back(Kernel::Point_3(x-d1, -y+d2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x-d1, -y+d2, 0.0));
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-f2+f1*cos(current_angle), -y+f2+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-f2+f1*cos(current_angle), -y+f2+f1*sin(current_angle), 0));
     }
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+f2+f1*cos(current_angle), -y+f2+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+f2+f1*cos(current_angle), -y+f2+f1*sin(current_angle), 0));
     }
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+f2+f1*cos(current_angle), y-f2+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+f2+f1*cos(current_angle), y-f2+f1*sin(current_angle), 0));
     }
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-f2+f1*cos(current_angle), y-f2+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-f2+f1*cos(current_angle), y-f2+f1*sin(current_angle), 0));
     }
-    face.outer.push_back(Kernel::Point_3(x-d1, y-d2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x-d1, y-d2, 0.0));
-    face.outer.push_back(Kernel::Point_3(x, y-d2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x, y-d2, 0.0));
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-f2+f2*cos(current_angle), y-f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), y-f2+f2*sin(current_angle), 0));
     }
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+f2+f2*cos(current_angle), y-f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+f2+f2*cos(current_angle), y-f2+f2*sin(current_angle), 0));
     }
   }
   
@@ -504,7 +507,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcLShapeProfileDef* l, cgal_
   }
   
   if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -536,7 +539,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcLShapeProfileDef* l, cgal_
     const double det = a1*b2 - a2*b1;
     
     if (ALMOST_THE_SAME(det, 0.)) {
-      Logger::Message(Logger::LOG_NOTICE, "Legs do not intersect for:",l->entity);
+      Logger::Message(Logger::LOG_NOTICE, "Legs do not intersect for:",l);
       return false;
     }
     
@@ -553,30 +556,30 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcLShapeProfileDef* l, cgal_
   const int segments = 3;
   
   face = cgal_face_t();
-  face.outer.push_back(Kernel::Point_3(-x, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-  face.outer.push_back(Kernel::Point_3(x, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(x, -y, 0.0));
   if (f2 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(x, -y+d-dy1, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x, -y+d-dy1, 0.0));
   } else {
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-f2+f2*cos(current_angle), -y+d-dy1-f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), -y+d-dy1-f2+f2*sin(current_angle), 0));
     }
   } if (f1 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(xx, xy, 0.0));
+    face.outer.push_back(Kernel_::Point_3(xx, xy, 0.0));
   } else {
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(xx+f1+f1*cos(current_angle), xy+f1+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(xx+f1+f1*cos(current_angle), xy+f1+f1*sin(current_angle), 0));
     }
   } if (f2 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(-x+d-dx1, y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x+d-dx1, y, 0.0));
   } else {
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+d-dx1-f2+f2*cos(current_angle), y-f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+d-dx1-f2+f2*cos(current_angle), y-f2+f2*sin(current_angle), 0));
     }
-  } face.outer.push_back(Kernel::Point_3(-x, y, 0.0));
+  } face.outer.push_back(Kernel_::Point_3(-x, y, 0.0));
   
   if (has_position) {
     IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
@@ -604,7 +607,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcIShapeProfileDef* l, cgal_
   bool doFillet2 = doFillet1;
   double x2 = x1, dy2 = dy1, f2 = f1;
   
-  if (l->is(IfcSchema::Type::IfcAsymmetricIShapeProfileDef)) {
+  if (l->as<IfcSchema::IfcAsymmetricIShapeProfileDef>()) {
     IfcSchema::IfcAsymmetricIShapeProfileDef* assym = (IfcSchema::IfcAsymmetricIShapeProfileDef*) l;
     x2 = assym->TopFlangeWidth() / 2. * getValue(GV_LENGTH_UNIT);
     doFillet2 = assym->hasTopFlangeFilletRadius();
@@ -617,7 +620,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcIShapeProfileDef* l, cgal_
   }
   
   if ( x1 < ALMOST_ZERO || x2 < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || dy1 < ALMOST_ZERO || dy2 < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -630,36 +633,36 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcIShapeProfileDef* l, cgal_
   const int segments = 3;
   
   face = cgal_face_t();
-  face.outer.push_back(Kernel::Point_3(-x1, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x1, -y, 0.0));
-  face.outer.push_back(Kernel::Point_3(x1, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(x1, -y, 0.0));
-  face.outer.push_back(Kernel::Point_3(x1, -y+dy1, 0.0));
+  face.outer.push_back(Kernel_::Point_3(x1, -y+dy1, 0.0));
   if (f1 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(d1, -y+dy1, 0.0));
+    face.outer.push_back(Kernel_::Point_3(d1, -y+dy1, 0.0));
-    face.outer.push_back(Kernel::Point_3(d1, y-dy2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(d1, y-dy2, 0.0));
   } else {
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(d1+f1+f1*cos(current_angle), -y+dy1+f1+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(d1+f1+f1*cos(current_angle), -y+dy1+f1+f1*sin(current_angle), 0));
     } for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(d1+f1+f1*cos(current_angle), y-dy2-f1+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(d1+f1+f1*cos(current_angle), y-dy2-f1+f1*sin(current_angle), 0));
     }
-  } face.outer.push_back(Kernel::Point_3(x2, y-dy2, 0.0));
+  } face.outer.push_back(Kernel_::Point_3(x2, y-dy2, 0.0));
-  face.outer.push_back(Kernel::Point_3(x2, y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(x2, y, 0.0));
-  face.outer.push_back(Kernel::Point_3(-x2, y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x2, y, 0.0));
-  face.outer.push_back(Kernel::Point_3(-x2, y-dy2, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x2, y-dy2, 0.0));
   if (f2 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(-d1, y-dy2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-d1, y-dy2, 0.0));
-    face.outer.push_back(Kernel::Point_3(-d1, -y+dy1, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-d1, -y+dy1, 0.0));
   } else {
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-d1-f2+f2*cos(current_angle), y-dy2-f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-d1-f2+f2*cos(current_angle), y-dy2-f2+f2*sin(current_angle), 0));
     } for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-d1-f2+f2*cos(current_angle), -y+dy1+f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-d1-f2+f2*cos(current_angle), -y+dy1+f2+f2*sin(current_angle), 0));
     }
-  } face.outer.push_back(Kernel::Point_3(-x1, -y+dy1, 0.0));
+  } face.outer.push_back(Kernel_::Point_3(-x1, -y+dy1, 0.0));
   
   if (has_position) {
     IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
@@ -686,7 +689,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTShapeProfileDef* l, cgal_
   const double webSlope = hasWebSlope ? (l->WebSlope() * getValue(GV_PLANEANGLE_UNIT)) : 0.;
   
   if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -734,7 +737,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTShapeProfileDef* l, cgal_
     const double det = a1*b2 - a2*b1;
     
     if (ALMOST_THE_SAME(det, 0.)) {
-      Logger::Message(Logger::LOG_NOTICE, "Web and flange do not intersect for:",l->entity);
+      Logger::Message(Logger::LOG_NOTICE, "Web and flange do not intersect for:",l);
       return false;
     }
     
@@ -755,48 +758,48 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTShapeProfileDef* l, cgal_
   
   face = cgal_face_t();
   if (f2 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(d1/2.-dx2, -y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(d1/2.-dx2, -y, 0.0));
   } else {
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(d1/2.-dx2-f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(d1/2.-dx2-f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
     }
   } if (f1 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(xx, xy, 0.0));
+    face.outer.push_back(Kernel_::Point_3(xx, xy, 0.0));
   } else {
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(xx+f1+f1*cos(current_angle), xy-f1+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(xx+f1+f1*cos(current_angle), xy-f1+f1*sin(current_angle), 0));
     }
   } if (f3 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(x, y-d2+dy2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x, y-d2+dy2, 0.0));
   } else {
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-f3+f3*cos(current_angle), y-d2+dy2+f3+f3*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-f3+f3*cos(current_angle), y-d2+dy2+f3+f3*sin(current_angle), 0));
     }
-  } face.outer.push_back(Kernel::Point_3(x, y, 0.0));
+  } face.outer.push_back(Kernel_::Point_3(x, y, 0.0));
-  face.outer.push_back(Kernel::Point_3(-x, y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x, y, 0.0));
   if (f3 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(-x, y-d2+dy2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x, y-d2+dy2, 0.0));
   } else {
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+f3+f3*cos(current_angle), y-d2+dy2+f3+f3*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+f3+f3*cos(current_angle), y-d2+dy2+f3+f3*sin(current_angle), 0));
     }
   } if (f1 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(-xx, xy, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-xx, xy, 0.0));
   } else {
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-xx-f1+f1*cos(current_angle), xy-f1+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-xx-f1+f1*cos(current_angle), xy-f1+f1*sin(current_angle), 0));
     }
   } if (f2 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(-d1/2.+dx2, -y, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-d1/2.+dx2, -y, 0.0));
   } else {
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-d1/2.+dx2+f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-d1/2.+dx2+f2+f2*cos(current_angle), -y+f2+f2*sin(current_angle), 0));
     }
   }
   
@@ -839,7 +842,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcUShapeProfileDef* l, cgal_
   }
   
   if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -852,38 +855,38 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcUShapeProfileDef* l, cgal_
   const int segments = 3;
   
   face = cgal_face_t();
-  face.outer.push_back(Kernel::Point_3(-x, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x, -y, 0.0));
-  face.outer.push_back(Kernel::Point_3(x, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(x, -y, 0.0));
   if (f2 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(x, -y+d2-dy2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x, -y+d2-dy2, 0.0));
   } else {
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-f2+f2*cos(current_angle), -y+d2-dy2-f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), -y+d2-dy2-f2+f2*sin(current_angle), 0));
     }
   } if (f1 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(-x+d1, -y+d2+dy1, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x+d1, -y+d2+dy1, 0.0));
   } else {
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+d1+f1+f1*cos(current_angle), -y+d2+dy1+f1+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+d1+f1+f1*cos(current_angle), -y+d2+dy1+f1+f1*sin(current_angle), 0));
     }
   } if (f1 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(-x+d1, y-d2-dy1, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x+d1, y-d2-dy1, 0.0));
   } else {
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 0.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+d1+f1+f1*cos(current_angle), y-d2-dy1-f1+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+d1+f1+f1*cos(current_angle), y-d2-dy1-f1+f1*sin(current_angle), 0));
     }
   } if (f2 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(x,y-d2+dy2, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x,y-d2+dy2, 0.0));
   } else {
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.5*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-f2+f2*cos(current_angle), y-d2+dy2+f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), y-d2+dy2+f2+f2*sin(current_angle), 0));
     }
-  } face.outer.push_back(Kernel::Point_3(x,y, 0.0));
+  } face.outer.push_back(Kernel_::Point_3(x,y, 0.0));
-  face.outer.push_back(Kernel::Point_3(-x,y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x,y, 0.0));
   
   if (has_position) {
     IfcGeom::CgalKernel::convert(l->Position(), trsf2d);
@@ -915,7 +918,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcZShapeProfileDef* l, cgal_
   }
   
   if ( x == 0.0f || y == 0.0f || dx == 0.0f || dy == 0.0f ) {
-    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+    Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
     return false;
   }
   
@@ -928,37 +931,37 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcZShapeProfileDef* l, cgal_
   const int segments = 3;
   
   face = cgal_face_t();
-  face.outer.push_back(Kernel::Point_3(-dx, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-dx, -y, 0.0));
-  face.outer.push_back(Kernel::Point_3(x, -y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(x, -y, 0.0));
   if (f2 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(x, -y+dy, 0.0));
+    face.outer.push_back(Kernel_::Point_3(x, -y+dy, 0.0));
   } else {
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(x-f2+f2*cos(current_angle), -y+dy-f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(x-f2+f2*cos(current_angle), -y+dy-f2+f2*sin(current_angle), 0));
     }
   } if (f1 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(dx, -y+dy, 0.0));
+    face.outer.push_back(Kernel_::Point_3(dx, -y+dy, 0.0));
   } else {
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(dx+f1+f1*cos(current_angle), -y+dy+f1+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(dx+f1+f1*cos(current_angle), -y+dy+f1+f1*sin(current_angle), 0));
     }
-  } face.outer.push_back(Kernel::Point_3(dx, y, 0.0));
+  } face.outer.push_back(Kernel_::Point_3(dx, y, 0.0));
-  face.outer.push_back(Kernel::Point_3(-x, y, 0.0));
+  face.outer.push_back(Kernel_::Point_3(-x, y, 0.0));
   if (f2 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(-x, y-dy, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-x, y-dy, 0.0));
   } else {
     for (int current_segment = 0; current_segment <= segments; ++current_segment) {
       double current_angle = 1.0*3.141592653589793+current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-x+f2+f2*cos(current_angle), y-dy+f2+f2*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-x+f2+f2*cos(current_angle), y-dy+f2+f2*sin(current_angle), 0));
     }
   } if (f1 == 0.0) {
-    face.outer.push_back(Kernel::Point_3(-dx, y-dy, 0.0));
+    face.outer.push_back(Kernel_::Point_3(-dx, y-dy, 0.0));
   } else {
     for (int current_segment = segments; current_segment >= 0; --current_segment) {
       double current_angle = current_segment*0.5*3.141592653589793/((double)segments);
-      face.outer.push_back(Kernel::Point_3(-dx-f1+f1*cos(current_angle), y-dy-f1+f1*sin(current_angle), 0));
+      face.outer.push_back(Kernel_::Point_3(-dx-f1+f1*cos(current_angle), y-dy-f1+f1*sin(current_angle), 0));
     }
   }
   

src/ifcgeom/kernels/cgal/CgalIfcGeomPrimitives.cpp

@@ -1,8 +1,11 @@
 #include "CgalKernel.h"
+#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
+
+#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
 
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianPoint* l, cgal_point_t& point) {
   std::vector<double> xyz = l->Coordinates();
-  point = Kernel::Point_3(xyz.size()     ? (xyz[0]*getValue(GV_LENGTH_UNIT)) : 0.0f,
+  point = Kernel_::Point_3(xyz.size()     ? (xyz[0]*getValue(GV_LENGTH_UNIT)) : 0.0f,
                           xyz.size() > 1 ? (xyz[1]*getValue(GV_LENGTH_UNIT)) : 0.0f,
                           xyz.size() > 2 ? (xyz[2]*getValue(GV_LENGTH_UNIT)) : 0.0f);
   //  std::cout << "Converted Point(" << point << ")" << std::endl;
@@ -12,7 +15,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianPoint* l, cgal_po
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcDirection* l, cgal_direction_t& dir) {
   //  IN_CACHE(IfcDirection,l,cgal_direction_t,dir)
   std::vector<double> xyz = l->DirectionRatios();
-  dir = Kernel::Vector_3(xyz.size()     ? xyz[0] : 0.0f,
+  dir = Kernel_::Vector_3(xyz.size()     ? xyz[0] : 0.0f,
                          xyz.size() > 1 ? xyz[1] : 0.0f,
                          xyz.size() > 2 ? xyz[2] : 0.0f);
   //  CACHE(IfcDirection,l,dir)
@@ -32,18 +35,18 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcPlane* pln, cgal_plane_t&
   //  IN_CACHE(IfcPlane,pln,gp_Pln,plane)
   IfcSchema::IfcAxis2Placement3D* l = pln->Position();
   cgal_point_t o;
-  cgal_direction_t axis = Kernel::Vector_3(0,0,1);
+  cgal_direction_t axis = Kernel_::Vector_3(0,0,1);
-  cgal_direction_t refDirection = Kernel::Vector_3(1,0,0);
+  cgal_direction_t refDirection = Kernel_::Vector_3(1,0,0);
   IfcGeom::CgalKernel::convert(l->Location(),o);
   bool hasRef = l->hasRefDirection();
   if ( l->hasAxis() ) IfcGeom::CgalKernel::convert(l->Axis(),axis);
   if ( hasRef ) IfcGeom::CgalKernel::convert(l->RefDirection(),refDirection);
-  Kernel::Vector_3 y = CGAL::cross_product(axis, refDirection);
+  Kernel_::Vector_3 y = CGAL::cross_product(axis, refDirection);
-  Kernel::Vector_3 x = CGAL::cross_product(y, axis);
+  Kernel_::Vector_3 x = CGAL::cross_product(y, axis);
   
   cgal_plane_t ax3;
-  if ( hasRef ) ax3 = Kernel::Plane_3(o,o+x,o+y);
+  if ( hasRef ) ax3 = Kernel_::Plane_3(o,o+x,o+y);
-  else ax3 = Kernel::Plane_3(o,axis);
+  else ax3 = Kernel_::Plane_3(o,axis);
   plane = ax3;
   
   //  std::cout << "IfcPlane C = " << o << std::endl;
@@ -80,11 +83,11 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcPlane* pln, cgal_plane_t&
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis2Placement2D* l, cgal_placement_t& trsf) {
   //  IN_CACHE(IfcAxis2Placement3D,l,gp_Trsf,trsf)
   cgal_point_t o;
-  cgal_direction_t refDirection = Kernel::Vector_3(1,0,0);
+  cgal_direction_t refDirection = Kernel_::Vector_3(1,0,0);
   IfcGeom::CgalKernel::convert(l->Location(),o);
   bool hasRef = l->hasRefDirection();
   if ( hasRef ) IfcGeom::CgalKernel::convert(l->RefDirection(),refDirection);
-  cgal_direction_t y = Kernel::Vector_3(-refDirection.y(), refDirection.x(), 0.0);
+  cgal_direction_t y = Kernel_::Vector_3(-refDirection.y(), refDirection.x(), 0.0);
   
   const double tolerance = 0.01;
   if (refDirection.squared_length() < 1.0-tolerance || refDirection.squared_length() > 1.0+tolerance ||
@@ -95,7 +98,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis2Placement2D* l, cgal_
   }
   
   // TODO: Should be checked.
-  trsf = Kernel::Aff_transformation_3(refDirection.cartesian(0), y.cartesian(0), 0.0, o.cartesian(0),
+  trsf = Kernel_::Aff_transformation_3(refDirection.cartesian(0), y.cartesian(0), 0.0, o.cartesian(0),
                                       refDirection.cartesian(1), y.cartesian(1), 0.0, o.cartesian(1),
                                       0.0, 0.0, 1.0, 0.0);
   
@@ -106,14 +109,14 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis2Placement2D* l, cgal_
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis2Placement3D* l, cgal_placement_t& trsf) {
   //  IN_CACHE(IfcAxis2Placement3D,l,gp_Trsf,trsf)
   cgal_point_t o;
-  cgal_direction_t axis = Kernel::Vector_3(0,0,1);
+  cgal_direction_t axis = Kernel_::Vector_3(0,0,1);
-  cgal_direction_t refDirection = Kernel::Vector_3(1,0,0);
+  cgal_direction_t refDirection = Kernel_::Vector_3(1,0,0);
   IfcGeom::CgalKernel::convert(l->Location(),o);
   bool hasRef = l->hasRefDirection();
   if ( l->hasAxis() ) IfcGeom::CgalKernel::convert(l->Axis(),axis);
   if ( hasRef ) IfcGeom::CgalKernel::convert(l->RefDirection(),refDirection);
-  Kernel::Vector_3 y = CGAL::cross_product(axis, refDirection);
+  Kernel_::Vector_3 y = CGAL::cross_product(axis, refDirection);
-  Kernel::Vector_3 x = CGAL::cross_product(y, axis);
+  Kernel_::Vector_3 x = CGAL::cross_product(y, axis);
   
   const double tolerance = 0.01;
   if (x.squared_length() < 1.0-tolerance || x.squared_length() > 1.0+tolerance ||
@@ -127,7 +130,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis2Placement3D* l, cgal_
   }
   
   // TODO: Should be checked.
-  trsf = Kernel::Aff_transformation_3(x.cartesian(0), y.cartesian(0), axis.cartesian(0), o.cartesian(0),
+  trsf = Kernel_::Aff_transformation_3(x.cartesian(0), y.cartesian(0), axis.cartesian(0), o.cartesian(0),
                                       x.cartesian(1), y.cartesian(1), axis.cartesian(1), o.cartesian(1),
                                       x.cartesian(2), y.cartesian(2), axis.cartesian(2), o.cartesian(2));
   
@@ -144,7 +147,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis2Placement3D* l, cgal_
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis1Placement* l, cgal_placement_t& ax) {
 //  IN_CACHE(IfcAxis1Placement,l,gp_Ax1,ax)
   cgal_point_t o;
-  cgal_direction_t axis = Kernel::Vector_3(0,0,1);
+  cgal_direction_t axis = Kernel_::Vector_3(0,0,1);
   IfcGeom::CgalKernel::convert(l->Location(),o);
   if ( l->hasAxis() ) IfcGeom::CgalKernel::convert(l->Axis(), axis);
   
@@ -155,7 +158,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis1Placement* l, cgal_pl
   }
   
   // TODO: Should be checked.
-  ax = Kernel::Aff_transformation_3(1.0, 0.0, axis.cartesian(0), o.cartesian(0),
+  ax = Kernel_::Aff_transformation_3(1.0, 0.0, axis.cartesian(0), o.cartesian(0),
                                     0.0, 1.0, axis.cartesian(1), o.cartesian(1),
                                     0.0, 0.0, axis.cartesian(2), o.cartesian(2));
   
@@ -165,8 +168,8 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcAxis1Placement* l, cgal_pl
 
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcObjectPlacement* l, cgal_placement_t& trsf) {
   //  IN_CACHE(IfcObjectPlacement,l,cgal_placement_t,trsf)
-  if ( ! l->is(IfcSchema::Type::IfcLocalPlacement) ) {
+  if ( ! l->as<IfcSchema::IfcLocalPlacement>() ) {
-    Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l);
     return false;
   }
   
@@ -182,7 +185,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcObjectPlacement* l, cgal_p
     cgal_placement_t trsf2;
     
     IfcSchema::IfcAxis2Placement* relplacement = current->RelativePlacement();
-    if ( relplacement->is(IfcSchema::Type::IfcAxis2Placement3D) ) {
+    if ( relplacement->as<IfcSchema::IfcAxis2Placement3D>() ) {
       IfcGeom::CgalKernel::convert((IfcSchema::IfcAxis2Placement3D*)relplacement,trsf2);
       
       //      std::cout << "trsf2" << std::endl;
@@ -203,7 +206,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcObjectPlacement* l, cgal_p
     }
     if ( current->hasPlacementRelTo() ) {
       IfcSchema::IfcObjectPlacement* relto = current->PlacementRelTo();
-      if ( relto->is(IfcSchema::Type::IfcLocalPlacement) )
+      if ( relto->as<IfcSchema::IfcLocalPlacement>() )
         current = (IfcSchema::IfcLocalPlacement*)current->PlacementRelTo();
       else break;
     } else break;
@@ -228,7 +231,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianTransformationOpe
   }
   
   // TODO: Untested
-  trsf = Kernel::Aff_transformation_3(scale*axis1.cartesian(0), axis2.cartesian(0), 0.0, origin.cartesian(0),
+  trsf = Kernel_::Aff_transformation_3(scale*axis1.cartesian(0), axis2.cartesian(0), 0.0, origin.cartesian(0),
                                       axis1.cartesian(1), scale*axis2.cartesian(1), 0.0, origin.cartesian(1),
                                       0.0, 0.0, 1.0, 0.0);
   
@@ -251,7 +254,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianTransformationOpe
   const double scale2 = l->hasScale2() ? l->Scale2() : scale1;
   
   // TODO: Untested
-  trsf = Kernel::Aff_transformation_3(scale1*axis1.cartesian(0), axis2.cartesian(0), 0.0, origin.cartesian(0),
+  trsf = Kernel_::Aff_transformation_3(scale1*axis1.cartesian(0), axis2.cartesian(0), 0.0, origin.cartesian(0),
                                       axis1.cartesian(1), scale2*axis2.cartesian(1), 0.0, origin.cartesian(1),
                                       0.0, 0.0, 1.0, 0.0);
   
@@ -275,7 +278,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianTransformationOpe
   }
   
   // TODO: Untested
-  trsf = Kernel::Aff_transformation_3(scale*axis1.cartesian(0), axis2.cartesian(0), axis3.cartesian(0), origin.cartesian(0),
+  trsf = Kernel_::Aff_transformation_3(scale*axis1.cartesian(0), axis2.cartesian(0), axis3.cartesian(0), origin.cartesian(0),
                                       axis1.cartesian(1), scale*axis2.cartesian(1), axis3.cartesian(1), origin.cartesian(1),
                                       axis1.cartesian(2), axis2.cartesian(2), scale*axis3.cartesian(2), origin.cartesian(2));
   
@@ -305,7 +308,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCartesianTransformationOpe
   const double scale3 = l->hasScale3() ? l->Scale3() : scale1;
   
   // TODO: Untested
-  gtrsf = Kernel::Aff_transformation_3(scale1*axis1.cartesian(0), axis2.cartesian(0), axis3.cartesian(0), origin.cartesian(0),
+  gtrsf = Kernel_::Aff_transformation_3(scale1*axis1.cartesian(0), axis2.cartesian(0), axis3.cartesian(0), origin.cartesian(0),
                                        axis1.cartesian(1), scale2*axis2.cartesian(1), axis3.cartesian(1), origin.cartesian(1),
                                        axis1.cartesian(2), axis2.cartesian(2), scale3*axis3.cartesian(2), origin.cartesian(2));
   

src/ifcgeom/kernels/cgal/CgalIfcGeomShapes.cpp

@@ -1,9 +1,12 @@
 #include "CgalKernel.h"
+#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
+
+#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
 
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolid *l, cgal_shape_t &shape) {
   const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
   if (height < getValue(GV_PRECISION)) {
-    Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l);
     return false;
   }
   
@@ -28,10 +31,10 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolid *l, cgal
   std::list<cgal_face_t> face_list;
   face_list.push_back(bottom_face);
   
-  for (std::vector<Kernel::Point_3>::const_iterator current_vertex = bottom_face.outer.begin();
+  for (std::vector<Kernel_::Point_3>::const_iterator current_vertex = bottom_face.outer.begin();
        current_vertex != bottom_face.outer.end();
        ++current_vertex) {
-    std::vector<Kernel::Point_3>::const_iterator next_vertex = current_vertex;
+    std::vector<Kernel_::Point_3>::const_iterator next_vertex = current_vertex;
     ++next_vertex;
     if (next_vertex == bottom_face.outer.end()) {
       next_vertex = bottom_face.outer.begin();
@@ -44,7 +47,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolid *l, cgal
   }
   
   cgal_face_t top_face;
-  for (std::vector<Kernel::Point_3>::const_reverse_iterator vertex = bottom_face.outer.rbegin();
+  for (std::vector<Kernel_::Point_3>::const_reverse_iterator vertex = bottom_face.outer.rbegin();
        vertex != bottom_face.outer.rend();
        ++vertex) {
     top_face.outer.push_back(*vertex+height*dir);
@@ -56,7 +59,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolid *l, cgal
     return true;
   }
   
-  CGAL::Nef_polyhedron_3<Kernel> nef_shape = create_nef_polyhedron(face_list);
+  CGAL::Nef_polyhedron_3<Kernel_> nef_shape = create_nef_polyhedron(face_list);
   
   // Inner
   // TODO: Would be faster to triangulate top/bottom face template rather than use Nef polyhedra for subtraction
@@ -69,10 +72,10 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolid *l, cgal
     remove_duplicate_points_from_loop(hole_bottom_face.outer);
     face_list.push_back(hole_bottom_face);
     
-    for (std::vector<Kernel::Point_3>::const_iterator current_vertex = inner.begin();
+    for (std::vector<Kernel_::Point_3>::const_iterator current_vertex = inner.begin();
          current_vertex != inner.end();
          ++current_vertex) {
-      std::vector<Kernel::Point_3>::const_iterator next_vertex = current_vertex;
+      std::vector<Kernel_::Point_3>::const_iterator next_vertex = current_vertex;
       ++next_vertex;
       if (next_vertex == inner.end()) {
         next_vertex = inner.begin();
@@ -85,7 +88,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolid *l, cgal
     }
     
     cgal_face_t hole_top_face;
-    for (std::vector<Kernel::Point_3>::const_reverse_iterator vertex = inner.rbegin();
+    for (std::vector<Kernel_::Point_3>::const_reverse_iterator vertex = inner.rbegin();
          vertex != inner.rend();
          ++vertex) {
       hole_top_face.outer.push_back(*vertex+height*dir);
@@ -94,7 +97,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolid *l, cgal
     try {
       nef_shape -= create_nef_polyhedron(face_list);
     } catch (...) {
-      Logger::Message(Logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot subtract opening for:", l->entity);
+      Logger::Message(Logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot subtract opening for:", l);
       return false;
     }
   }
@@ -109,7 +112,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolid *l, cgal
     nef_shape.convert_to_polyhedron(shape);
     return true;
   } catch (...) {
-    Logger::Message(Logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot convert Nef to polyhedron for:", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot convert Nef to polyhedron for:", l);
     return false;
   }
   
@@ -119,7 +122,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolid *l, cgal
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered* l, cgal_shape_t& shape) {
   const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
   if (height < getValue(GV_PRECISION)) {
-    Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l);
     return false;
   }
   
@@ -148,12 +151,12 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered*
   std::list<cgal_face_t> face_list;
   face_list.push_back(face1);
   
-  std::vector<Kernel::Point_3>::const_iterator current_face1_vertex = face1.outer.begin();
+  std::vector<Kernel_::Point_3>::const_iterator current_face1_vertex = face1.outer.begin();
-  std::vector<Kernel::Point_3>::const_iterator current_face2_vertex = face2.outer.begin();
+  std::vector<Kernel_::Point_3>::const_iterator current_face2_vertex = face2.outer.begin();
   while (current_face1_vertex != face1.outer.end() &&
          current_face2_vertex != face2.outer.end()) {
-    std::vector<Kernel::Point_3>::const_iterator next_face1_vertex = current_face1_vertex;
+    std::vector<Kernel_::Point_3>::const_iterator next_face1_vertex = current_face1_vertex;
-    std::vector<Kernel::Point_3>::const_iterator next_face2_vertex = current_face2_vertex;
+    std::vector<Kernel_::Point_3>::const_iterator next_face2_vertex = current_face2_vertex;
     ++next_face1_vertex;
     ++next_face2_vertex;
     if (next_face1_vertex == face1.outer.end()) next_face1_vertex = face1.outer.begin();
@@ -169,7 +172,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered*
   }
   
   cgal_face_t top_face;
-  for (std::vector<Kernel::Point_3>::const_reverse_iterator vertex = face2.outer.rbegin();
+  for (std::vector<Kernel_::Point_3>::const_reverse_iterator vertex = face2.outer.rbegin();
        vertex != face2.outer.rend();
        ++vertex) {
     top_face.outer.push_back(*vertex);
@@ -182,14 +185,14 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered*
   }
   
 //  std::ofstream f1;
-//  CGAL::Polyhedron_3<Kernel> outer_polyhedron;
+//  CGAL::Polyhedron_3<Kernel_> outer_polyhedron;
 //  PolyhedronBuilder builder(&face_list);
 //  outer_polyhedron.delegate(builder);
 //  f1.open("/Users/ken/Desktop/outer.off");
 //  f1 << outer_polyhedron << std::endl;
 //  f1.close();
   
-  CGAL::Nef_polyhedron_3<Kernel> nef_shape = create_nef_polyhedron(face_list);
+  CGAL::Nef_polyhedron_3<Kernel_> nef_shape = create_nef_polyhedron(face_list);
   
   // Inner
   // TODO: Would be faster to triangulate top/bottom face template rather than use Nef polyhedra for subtraction
@@ -212,8 +215,8 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered*
     current_face2_vertex = hole_face2.outer.begin();
     while (current_face1_vertex != hole_face1.outer.end() &&
            current_face2_vertex != hole_face2.outer.end()) {
-      std::vector<Kernel::Point_3>::const_iterator next_face1_vertex = current_face1_vertex;
+      std::vector<Kernel_::Point_3>::const_iterator next_face1_vertex = current_face1_vertex;
-      std::vector<Kernel::Point_3>::const_iterator next_face2_vertex = current_face2_vertex;
+      std::vector<Kernel_::Point_3>::const_iterator next_face2_vertex = current_face2_vertex;
       ++next_face1_vertex;
       ++next_face2_vertex;
       if (next_face1_vertex == hole_face1.outer.end()) next_face1_vertex = hole_face1.outer.begin();
@@ -229,14 +232,14 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered*
     }
     
     cgal_face_t top_hole_face;
-    for (std::vector<Kernel::Point_3>::const_reverse_iterator vertex = hole_face2.outer.rbegin();
+    for (std::vector<Kernel_::Point_3>::const_reverse_iterator vertex = hole_face2.outer.rbegin();
          vertex != hole_face2.outer.rend();
          ++vertex) {
       top_hole_face.outer.push_back(*vertex);
     } face_list.push_back(top_hole_face);
     
 //    std::ofstream f2;
-//    CGAL::Polyhedron_3<Kernel> inner_polyhedron;
+//    CGAL::Polyhedron_3<Kernel_> inner_polyhedron;
 //    PolyhedronBuilder builder(&face_list);
 //    inner_polyhedron.delegate(builder);
 //    f2.open("/Users/ken/Desktop/inner.off");
@@ -283,7 +286,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcConnectedFaceSet* l, cgal_
     } catch (...) {}
     
     if (!success) {
-      Logger::Message(Logger::LOG_WARNING, "Failed to convert face:", (*it)->entity);
+      Logger::Message(Logger::LOG_WARNING, "Failed to convert face:", (*it));
       continue;
     }
     
@@ -312,45 +315,45 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcBlock* l, cgal_shape_t& sh
   
   // x = 0
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(0, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0, dy, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, dz));
-  face_list.back().outer.push_back(Kernel::Point_3(0, 0, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, dz));
   
   // x = dx
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(dx, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, 0, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, dz));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, dy, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, dz));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
   
   // y = 0
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(0, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0, 0, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, dz));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, 0, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, dz));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
   
   // y = dy
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(0, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, dy, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, dz));
-  face_list.back().outer.push_back(Kernel::Point_3(0, dy, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, dz));
   
   // z = 0
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(0, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
   
   // z = dz
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(0, 0, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, dz));
-  face_list.back().outer.push_back(Kernel::Point_3(0, dy, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, dz));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, dy, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, dz));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, 0, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, dz));
   
   cgal_placement_t trsf;
   IfcGeom::CgalKernel::convert(l->Position(),trsf);
@@ -367,10 +370,10 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcBooleanResult* l, cgal_sha
   cgal_wire_t boundary_wire;
   IfcSchema::IfcBooleanOperand* operand1 = l->FirstOperand();
   IfcSchema::IfcBooleanOperand* operand2 = l->SecondOperand();
-  bool is_halfspace = operand2->is(IfcSchema::Type::IfcHalfSpaceSolid);
+  bool is_halfspace = operand2->as<IfcSchema::IfcHalfSpaceSolid>();
   
   if ( shape_type(operand1) == ST_SHAPELIST ) {
-    Logger::Message(Logger::LOG_ERROR, "s1: ST_SHAPELIST Unsupported", operand1->entity);
+    Logger::Message(Logger::LOG_ERROR, "s1: ST_SHAPELIST Unsupported", operand1);
 //    if (!(convert_shapes(operand1, items1) && flatten_shape_list(items1, s1, true))) {
       return false;
 //    }
@@ -379,44 +382,44 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcBooleanResult* l, cgal_sha
       return false;
     }
   } else {
-    Logger::Message(Logger::LOG_ERROR, "s1: Invalid representation item for boolean operation", operand1->entity);
+    Logger::Message(Logger::LOG_ERROR, "s1: Invalid representation item for boolean operation", operand1);
     return false;
   }
 
 //  const double first_operand_volume = shape_volume(s1);
 //  if ( first_operand_volume <= ALMOST_ZERO )
-//    Logger::Message(Logger::LOG_WARNING,"Empty solid for:",l->FirstOperand()->entity);
+//    Logger::Message(Logger::LOG_WARNING,"Empty solid for:",l->FirstOperand());
   
   bool shape2_processed = false;
   if ( shape_type(operand2) == ST_SHAPELIST ) {
-    Logger::Message(Logger::LOG_ERROR, "s2: ST_SHAPELIST Unsupported", operand1->entity);
+    Logger::Message(Logger::LOG_ERROR, "s2: ST_SHAPELIST Unsupported", operand1);
 //    shape2_processed = convert_shapes(operand2, items2) && flatten_shape_list(items2, s2, true);
   } else if ( shape_type(operand2) == ST_SHAPE ) {
     shape2_processed = convert_shape(operand2,s2);
   } else {
-    Logger::Message(Logger::LOG_ERROR, "s2: Invalid representation item for boolean operation", operand2->entity);
+    Logger::Message(Logger::LOG_ERROR, "s2: Invalid representation item for boolean operation", operand2);
   }
 
   if (!shape2_processed) {
     shape = s1;
-    Logger::Message(Logger::LOG_ERROR,"Failed to convert SecondOperand of:",l->entity);
+    Logger::Message(Logger::LOG_ERROR,"Failed to convert SecondOperand of:",l);
     return true;
   }
 
 //  if (!is_halfspace) {
 //    const double second_operand_volume = shape_volume(s2);
 //    if ( second_operand_volume <= ALMOST_ZERO )
-//      Logger::Message(Logger::LOG_WARNING,"Empty solid for:",operand2->entity);
+//      Logger::Message(Logger::LOG_WARNING,"Empty solid for:",operand2);
 //  }
   
-  const IfcSchema::IfcBooleanOperator::IfcBooleanOperator op = l->Operator();
+  const IfcSchema::IfcBooleanOperator::Value op = l->Operator();
   
   if (!s1.is_valid()) {
-    Logger::Message(Logger::LOG_ERROR, "s1: Not valid?", operand1->entity);
+    Logger::Message(Logger::LOG_ERROR, "s1: Not valid?", operand1);
     return false;
   } else {
 //    std::ofstream f1;
-//    CGAL::Polyhedron_3<Kernel> p1;
+//    CGAL::Polyhedron_3<Kernel_> p1;
 //    s1.convert_to_Polyhedron(p1);
 //    f1.open("/Users/ken/Desktop/s1.off");
 //    f1 << p1 << std::endl;
@@ -426,13 +429,13 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcBooleanResult* l, cgal_sha
   bool is_plane = false;
   cgal_plane_t plane;
   if (!s2.is_valid()) {
-    Logger::Message(Logger::LOG_ERROR, "s2: Not valid?", operand2->entity);
+    Logger::Message(Logger::LOG_ERROR, "s2: Not valid?", operand2);
     return false;
   } else if (is_halfspace) {
     //    std::cout << "s2: halfspace" << std::endl;
     IfcSchema::IfcHalfSpaceSolid *hss = static_cast<IfcSchema::IfcHalfSpaceSolid *>(operand2);
     IfcSchema::IfcSurface* surface = hss->BaseSurface();
-    if (surface->is(IfcSchema::Type::IfcPlane) ) {
+    if (surface->as<IfcSchema::IfcPlane>() ) {
       is_plane = true;
       IfcGeom::CgalKernel::convert((IfcSchema::IfcPlane *)surface, plane);
       if (hss->AgreementFlag()) plane = plane.opposite();
@@ -453,7 +456,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcBooleanResult* l, cgal_sha
     }
   } else {
 //    std::ofstream f2;
-//    CGAL::Polyhedron_3<Kernel> p2;
+//    CGAL::Polyhedron_3<Kernel_> p2;
 //    s2.convert_to_Polyhedron(p2);
 //    f2.open("/Users/ken/Desktop/s2.off");
 //    f2 << p2 << std::endl;
@@ -463,27 +466,27 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcBooleanResult* l, cgal_sha
   if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_DIFFERENCE) {
     
 //    std::cout << "Difference" << std::endl;
-    CGAL::Nef_polyhedron_3<Kernel> nef_result;
+    CGAL::Nef_polyhedron_3<Kernel_> nef_result;
     try {
-      nef_result = CGAL::Nef_polyhedron_3<Kernel>(s1);
+      nef_result = CGAL::Nef_polyhedron_3<Kernel_>(s1);
     } catch (...) {
-      Logger::Message(Logger::LOG_ERROR, "s1: cannot convert to Nef?", operand1->entity);
+      Logger::Message(Logger::LOG_ERROR, "s1: cannot convert to Nef?", operand1);
       return false;
     } if (is_halfspace) {
-      if (is_plane) nef_result = nef_result.intersection(plane, CGAL::Nef_polyhedron_3<Kernel>::Intersection_mode::CLOSED_HALFSPACE);
+      if (is_plane) nef_result = nef_result.intersection(plane, CGAL::Nef_polyhedron_3<Kernel_>::Intersection_mode::CLOSED_HALFSPACE);
     } else {
-      CGAL::Nef_polyhedron_3<Kernel> nef_s2;
+      CGAL::Nef_polyhedron_3<Kernel_> nef_s2;
       try {
-        nef_s2 = CGAL::Nef_polyhedron_3<Kernel>(s2);
+        nef_s2 = CGAL::Nef_polyhedron_3<Kernel_>(s2);
       } catch (...) {
-        Logger::Message(Logger::LOG_ERROR, "s2: cannot convert to Nef?", operand2->entity);
+        Logger::Message(Logger::LOG_ERROR, "s2: cannot convert to Nef?", operand2);
       } nef_result -= nef_s2;
     }
     if (!nef_result.is_simple()) {
-      Logger::Message(Logger::LOG_ERROR, "s2: not simple?", operand2->entity);
+      Logger::Message(Logger::LOG_ERROR, "s2: not simple?", operand2);
       return false;
     } else {
-//      CGAL::Polyhedron_3<Kernel> result;
+//      CGAL::Polyhedron_3<Kernel_> result;
 //      nef_result.convert_to_polyhedron(result);
 //      std::ofstream fresult;
 //      fresult.open("/Users/ken/Desktop/result.off");
@@ -500,12 +503,12 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcBooleanResult* l, cgal_sha
   } else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_UNION) {
 
 //    std::cout << "Union" << std::endl;
-    CGAL::Nef_polyhedron_3<Kernel> nef_result = CGAL::Nef_polyhedron_3<Kernel>(s1)+CGAL::Nef_polyhedron_3<Kernel>(s2);
+    CGAL::Nef_polyhedron_3<Kernel_> nef_result = CGAL::Nef_polyhedron_3<Kernel_>(s1)+CGAL::Nef_polyhedron_3<Kernel_>(s2);
     if (!nef_result.is_simple()) {
       std::cout << "Not simple: " << nef_result.number_of_volumes() << " volumes" << std::endl;
       return false;
     } else {
-//      CGAL::Polyhedron_3<Kernel> result;
+//      CGAL::Polyhedron_3<Kernel_> result;
 //      nef_result.convert_to_polyhedron(result);
 //      std::ofstream fresult;
 //      fresult.open("/Users/ken/Desktop/result.off");
@@ -522,12 +525,12 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcBooleanResult* l, cgal_sha
   } else if (op == IfcSchema::IfcBooleanOperator::IfcBooleanOperator_INTERSECTION) {
 
 //    std::cout << "Intersection" << std::endl;
-    CGAL::Nef_polyhedron_3<Kernel> nef_result = CGAL::Nef_polyhedron_3<Kernel>(s1)*CGAL::Nef_polyhedron_3<Kernel>(s2);
+    CGAL::Nef_polyhedron_3<Kernel_> nef_result = CGAL::Nef_polyhedron_3<Kernel_>(s1)*CGAL::Nef_polyhedron_3<Kernel_>(s2);
     if (!nef_result.is_simple()) {
       std::cout << "Not simple: " << nef_result.number_of_volumes() << " volumes" << std::endl;
       return false;
     } else {
-//      CGAL::Polyhedron_3<Kernel> result;
+//      CGAL::Polyhedron_3<Kernel_> result;
 //      nef_result.convert_to_polyhedron(result);
 //      std::ofstream fresult;
 //      fresult.open("/Users/ken/Desktop/result.off");
@@ -549,19 +552,19 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcSphere* l, cgal_shape_t& s
   // Make icosahedron
   float golden_ratio = (1.0+sqrtf(5.0))/2.0;
   float normalising_factor = sqrtf(golden_ratio*golden_ratio+1.0);
-  std::vector<Kernel::Point_3> icosahedron_vertices;
+  std::vector<Kernel_::Point_3> icosahedron_vertices;
-  icosahedron_vertices.push_back(Kernel::Point_3(-1.0/normalising_factor,  golden_ratio/normalising_factor, 0.0));
+  icosahedron_vertices.push_back(Kernel_::Point_3(-1.0/normalising_factor,  golden_ratio/normalising_factor, 0.0));
-  icosahedron_vertices.push_back(Kernel::Point_3( 1.0/normalising_factor,  golden_ratio/normalising_factor, 0.0));
+  icosahedron_vertices.push_back(Kernel_::Point_3( 1.0/normalising_factor,  golden_ratio/normalising_factor, 0.0));
-  icosahedron_vertices.push_back(Kernel::Point_3(-1.0/normalising_factor, -golden_ratio/normalising_factor, 0.0));
+  icosahedron_vertices.push_back(Kernel_::Point_3(-1.0/normalising_factor, -golden_ratio/normalising_factor, 0.0));
-  icosahedron_vertices.push_back(Kernel::Point_3( 1.0/normalising_factor, -golden_ratio/normalising_factor, 0.0));
+  icosahedron_vertices.push_back(Kernel_::Point_3( 1.0/normalising_factor, -golden_ratio/normalising_factor, 0.0));
-  icosahedron_vertices.push_back(Kernel::Point_3(0.0, -1.0/normalising_factor,  golden_ratio/normalising_factor));
+  icosahedron_vertices.push_back(Kernel_::Point_3(0.0, -1.0/normalising_factor,  golden_ratio/normalising_factor));
-  icosahedron_vertices.push_back(Kernel::Point_3(0.0,  1.0/normalising_factor,  golden_ratio/normalising_factor));
+  icosahedron_vertices.push_back(Kernel_::Point_3(0.0,  1.0/normalising_factor,  golden_ratio/normalising_factor));
-  icosahedron_vertices.push_back(Kernel::Point_3(0.0, -1.0/normalising_factor, -golden_ratio/normalising_factor));
+  icosahedron_vertices.push_back(Kernel_::Point_3(0.0, -1.0/normalising_factor, -golden_ratio/normalising_factor));
-  icosahedron_vertices.push_back(Kernel::Point_3(0.0,  1.0/normalising_factor, -golden_ratio/normalising_factor));
+  icosahedron_vertices.push_back(Kernel_::Point_3(0.0,  1.0/normalising_factor, -golden_ratio/normalising_factor));
-  icosahedron_vertices.push_back(Kernel::Point_3( golden_ratio/normalising_factor, 0.0, -1.0/normalising_factor));
+  icosahedron_vertices.push_back(Kernel_::Point_3( golden_ratio/normalising_factor, 0.0, -1.0/normalising_factor));
-  icosahedron_vertices.push_back(Kernel::Point_3( golden_ratio/normalising_factor, 0.0,  1.0/normalising_factor));
+  icosahedron_vertices.push_back(Kernel_::Point_3( golden_ratio/normalising_factor, 0.0,  1.0/normalising_factor));
-  icosahedron_vertices.push_back(Kernel::Point_3(-golden_ratio/normalising_factor, 0.0, -1.0/normalising_factor));
+  icosahedron_vertices.push_back(Kernel_::Point_3(-golden_ratio/normalising_factor, 0.0, -1.0/normalising_factor));
-  icosahedron_vertices.push_back(Kernel::Point_3(-golden_ratio/normalising_factor, 0.0,  1.0/normalising_factor));
+  icosahedron_vertices.push_back(Kernel_::Point_3(-golden_ratio/normalising_factor, 0.0,  1.0/normalising_factor));
   
   std::list<cgal_face_t> face_list;
   
@@ -669,24 +672,24 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcSphere* l, cgal_shape_t& s
   for (unsigned int current_refinement = 0; current_refinement < refinements; ++current_refinement) {
     std::list<cgal_face_t> refined_face_list;
     for (auto &face: face_list) {
-      Kernel::Point_3 vertex0 = face.outer[0];
+      Kernel_::Point_3 vertex0 = face.outer[0];
-      Kernel::Point_3 vertex1 = face.outer[1];
+      Kernel_::Point_3 vertex1 = face.outer[1];
-      Kernel::Point_3 vertex2 = face.outer[2];
+      Kernel_::Point_3 vertex2 = face.outer[2];
       
-      Kernel::Point_3 midpoint01 = CGAL::midpoint(vertex0, vertex1);
+      Kernel_::Point_3 midpoint01 = CGAL::midpoint(vertex0, vertex1);
-      Kernel::Point_3 midpoint12 = CGAL::midpoint(vertex1, vertex2);
+      Kernel_::Point_3 midpoint12 = CGAL::midpoint(vertex1, vertex2);
-      Kernel::Point_3 midpoint20 = CGAL::midpoint(vertex2, vertex0);
+      Kernel_::Point_3 midpoint20 = CGAL::midpoint(vertex2, vertex0);
       
-      double midpoint01_distance_to_origin = sqrt(CGAL::to_double(CGAL::squared_distance(midpoint01, Kernel::Point_3(0, 0, 0))));
+      double midpoint01_distance_to_origin = sqrt(CGAL::to_double(CGAL::squared_distance(midpoint01, Kernel_::Point_3(0, 0, 0))));
-      midpoint01 = Kernel::Point_3(midpoint01.x()/midpoint01_distance_to_origin,
+      midpoint01 = Kernel_::Point_3(midpoint01.x()/midpoint01_distance_to_origin,
                                    midpoint01.y()/midpoint01_distance_to_origin,
                                    midpoint01.z()/midpoint01_distance_to_origin);
-      double midpoint12_distance_to_origin = sqrt(CGAL::to_double(CGAL::squared_distance(midpoint12, Kernel::Point_3(0, 0, 0))));
+      double midpoint12_distance_to_origin = sqrt(CGAL::to_double(CGAL::squared_distance(midpoint12, Kernel_::Point_3(0, 0, 0))));
-      midpoint12 = Kernel::Point_3(midpoint12.x()/midpoint12_distance_to_origin,
+      midpoint12 = Kernel_::Point_3(midpoint12.x()/midpoint12_distance_to_origin,
                                    midpoint12.y()/midpoint12_distance_to_origin,
                                    midpoint12.z()/midpoint12_distance_to_origin);
-      double midpoint20_distance_to_origin = sqrt(CGAL::to_double(CGAL::squared_distance(midpoint20, Kernel::Point_3(0, 0, 0))));
+      double midpoint20_distance_to_origin = sqrt(CGAL::to_double(CGAL::squared_distance(midpoint20, Kernel_::Point_3(0, 0, 0))));
-      midpoint20 = Kernel::Point_3(midpoint20.x()/midpoint20_distance_to_origin,
+      midpoint20 = Kernel_::Point_3(midpoint20.x()/midpoint20_distance_to_origin,
                                    midpoint20.y()/midpoint20_distance_to_origin,
                                    midpoint20.z()/midpoint20_distance_to_origin);
       
@@ -717,7 +720,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcSphere* l, cgal_shape_t& s
   
   shape = create_polyhedron(face_list);
   for (auto &vertex: vertices(shape)) {
-    vertex->point() = Kernel::Point_3(r*vertex->point().x(),
+    vertex->point() = Kernel_::Point_3(r*vertex->point().x(),
                                       r*vertex->point().y(),
                                       r*vertex->point().z());
     vertex->point() = vertex->point().transform(trsf);
@@ -734,31 +737,31 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRectangularPyramid* l, cga
   
   // Base
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(0, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
   
   // Lateral faces
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(0, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0.5*dx, 0.5*dy, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(0.5*dx, 0.5*dy, dz));
   
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(0, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, dy, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0.5*dx, 0.5*dy, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(0.5*dx, 0.5*dy, dz));
   
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(dx, dy, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, dy, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(dx, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0.5*dx, 0.5*dy, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(0.5*dx, 0.5*dy, dz));
   
   face_list.push_back(cgal_face_t());
-  face_list.back().outer.push_back(Kernel::Point_3(dx, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(dx, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0, 0, 0));
+  face_list.back().outer.push_back(Kernel_::Point_3(0, 0, 0));
-  face_list.back().outer.push_back(Kernel::Point_3(0.5*dx, 0.5*dy, dz));
+  face_list.back().outer.push_back(Kernel_::Point_3(0.5*dx, 0.5*dy, dz));
   
   cgal_placement_t trsf;
   IfcGeom::CgalKernel::convert(l->Position(),trsf);
@@ -780,7 +783,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRightCircularCylinder* l,
   face_list.push_back(cgal_face_t());
   for (int current_segment = 0; current_segment < segments; ++current_segment) {
     double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face_list.back().outer.push_back(Kernel::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
+    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
   }
   
   // Side faces
@@ -789,17 +792,17 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRightCircularCylinder* l,
     int next_segment = (current_segment+1)%segments;
     double next_angle = next_segment*2.0*3.141592653589793/((double)segments);
     face_list.push_back(cgal_face_t());
-    face_list.back().outer.push_back(Kernel::Point_3(r*cos(next_angle), r*sin(next_angle), 0));
+    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(next_angle), r*sin(next_angle), 0));
-    face_list.back().outer.push_back(Kernel::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
+    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-    face_list.back().outer.push_back(Kernel::Point_3(r*cos(current_angle), r*sin(current_angle), h));
+    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), h));
-    face_list.back().outer.push_back(Kernel::Point_3(r*cos(next_angle), r*sin(next_angle), h));
+    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(next_angle), r*sin(next_angle), h));
   }
   
   // Top
   face_list.push_back(cgal_face_t());
   for (int current_segment = segments-1; current_segment >= 0; --current_segment) {
     double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face_list.back().outer.push_back(Kernel::Point_3(r*cos(current_angle), r*sin(current_angle), h));
+    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), h));
   }
   
   cgal_placement_t trsf;
@@ -822,7 +825,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRightCircularCone* l, cgal
   face_list.push_back(cgal_face_t());
   for (int current_segment = 0; current_segment < segments; ++current_segment) {
     double current_angle = current_segment*2.0*3.141592653589793/((double)segments);
-    face_list.back().outer.push_back(Kernel::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
+    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
   }
   
   // Side faces
@@ -831,9 +834,9 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRightCircularCone* l, cgal
     int next_segment = (current_segment+1)%segments;
     double next_angle = next_segment*2.0*3.141592653589793/((double)segments);
     face_list.push_back(cgal_face_t());
-    face_list.back().outer.push_back(Kernel::Point_3(r*cos(next_angle), r*sin(next_angle), 0));
+    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(next_angle), r*sin(next_angle), 0));
-    face_list.back().outer.push_back(Kernel::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
+    face_list.back().outer.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-    face_list.back().outer.push_back(Kernel::Point_3(0, 0, h));
+    face_list.back().outer.push_back(Kernel_::Point_3(0, 0, h));
   }
   
   cgal_placement_t trsf;
@@ -853,10 +856,10 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, cg
   for (std::vector< std::vector<double> >::const_iterator it = coordinates.begin(); it != coordinates.end(); ++it) {
     const std::vector<double>& coords = *it;
     if (coords.size() != 3) {
-      Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on Coordinates", l->entity);
+      Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on Coordinates", l);
       return false;
     }
-    points.push_back(Kernel::Point_3(coords[0] * getValue(GV_LENGTH_UNIT),
+    points.push_back(Kernel_::Point_3(coords[0] * getValue(GV_LENGTH_UNIT),
                                      coords[1] * getValue(GV_LENGTH_UNIT),
                                      coords[2] * getValue(GV_LENGTH_UNIT)));
   }
@@ -868,7 +871,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, cg
   for(std::vector< std::vector<int> >::const_iterator it = indices.begin(); it != indices.end(); ++ it) {
     const std::vector<int>& tri = *it;
     if (tri.size() != 3) {
-      Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on CoordIndex", l->entity);
+      Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on CoordIndex", l);
       return false;
     }
     
@@ -876,13 +879,13 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, cg
     const int max_index = *std::max_element(tri.begin(), tri.end());
     
     if (min_index < 1 || max_index > (int) points.size()) {
-      Logger::Message(Logger::LOG_ERROR, "Contents of CoordIndex out of bounds", l->entity);
+      Logger::Message(Logger::LOG_ERROR, "Contents of CoordIndex out of bounds", l);
       return false;
     }
     
-    const Kernel::Point_3& a = points[tri[0] - 1]; // account for zero- vs
+    const Kernel_::Point_3& a = points[tri[0] - 1]; // account for zero- vs
-    const Kernel::Point_3& b = points[tri[1] - 1]; // one-based indices in
+    const Kernel_::Point_3& b = points[tri[1] - 1]; // one-based indices in
-    const Kernel::Point_3& c = points[tri[2] - 1]; // c++ and express
+    const Kernel_::Point_3& c = points[tri[2] - 1]; // c++ and express
     
     face_list.push_back(cgal_face_t());
     face_list.back().outer.push_back(a);
@@ -897,8 +900,8 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, cg
 
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcHalfSpaceSolid* l, cgal_shape_t& shape) {
   IfcSchema::IfcSurface* surface = l->BaseSurface();
-  if ( ! surface->is(IfcSchema::Type::IfcPlane) ) {
+  if ( ! surface->as<IfcSchema::IfcPlane>() ) {
-    Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface->entity);
+    Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface);
     return false;
   }
   cgal_plane_t pln;
@@ -911,6 +914,6 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcHalfSpaceSolid* l, cgal_sh
   
   // TODO: For now we do nothing and process halfspaces in IfcBooleanResult, which likely doesn't capture all cases.
   // Find a better solution later (with an abstract shape class?)
-  shape = CGAL::Polyhedron_3<Kernel>();
+  shape = CGAL::Polyhedron_3<Kernel_>();
   return true;
 }

src/ifcgeom/kernels/cgal/CgalIfcGeomShapesWithStyles.cpp

@@ -1,5 +1,7 @@
 #include "CgalKernel.h"
-#include "CgalConversionResult.h"
+#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
+
+#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
 
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRepresentation* l, ConversionResults& shapes) {
   IfcSchema::IfcRepresentationItem::list::ptr items = l->Items();
@@ -12,7 +14,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcRepresentation* l, Convers
       } else {
         cgal_shape_t s;
         if (convert_shape(representation_item, s)) {
-          shapes.push_back(ConversionResult(new CgalShape(s), get_style(representation_item)));
+          shapes.push_back(ConversionResult(representation_item->data().id(), new CgalShape(s), get_style(representation_item)));
           part_succes |= true;
         }
       }
@@ -32,14 +34,14 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcGeometricSet* l, Conversio
     if (convert_shape(element, s)) {
       part_succes = true;
       const IfcGeom::SurfaceStyle* style = 0;
-      if (element->is(IfcSchema::Type::IfcPoint)) {
+      if (element->as<IfcSchema::IfcPoint>()) {
         style = get_style((IfcSchema::IfcPoint*) element);
-      } else if (element->is(IfcSchema::Type::IfcCurve)) {
+      } else if (element->as<IfcSchema::IfcCurve>()) {
         style = get_style((IfcSchema::IfcCurve*) element);
-      } else if (element->is(IfcSchema::Type::IfcSurface)) {
+      } else if (element->as<IfcSchema::IfcSurface>()) {
         style = get_style((IfcSchema::IfcSurface*) element);
       }
-      shapes.push_back(ConversionResult(new CgalShape(s), style ? style : parent_style));
+      shapes.push_back(ConversionResult(element->data().id(), new CgalShape(s), style ? style : parent_style));
     }
   }
   return part_succes;
@@ -51,11 +53,11 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l,
   for( IfcEntityList::it it = shells->begin(); it != shells->end(); ++ it ) {
     cgal_shape_t s;
     const SurfaceStyle* shell_style = 0;
-    if ((*it)->is(IfcSchema::Type::IfcRepresentationItem)) {
+    if ((*it)->as<IfcSchema::IfcRepresentationItem>()) {
       shell_style = get_style((IfcSchema::IfcRepresentationItem*)*it);
     }
     if (convert_shape(*it,s)) {
-      shapes.push_back(ConversionResult(new CgalShape(s), shell_style ? shell_style : collective_style));
+      shapes.push_back(ConversionResult((*it)->data().id(), new CgalShape(s), shell_style ? shell_style : collective_style));
     }
   }
   return true;
@@ -65,31 +67,28 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, Conv
   cgal_shape_t s;
   const SurfaceStyle* collective_style = get_style(l);
   if (convert_shape(l->Outer(),s) ) {
-    CGAL::Nef_polyhedron_3<Kernel> nef_s = create_nef_polyhedron(s);
+    CGAL::Nef_polyhedron_3<Kernel_> nef_s = create_nef_polyhedron(s);
     const SurfaceStyle* indiv_style = get_style(l->Outer());
     
     IfcSchema::IfcClosedShell::list::ptr voids(new IfcSchema::IfcClosedShell::list);
-    if (l->is(IfcSchema::Type::IfcFacetedBrepWithVoids)) {
+    if (l->as<IfcSchema::IfcFacetedBrepWithVoids>()) {
       voids = l->as<IfcSchema::IfcFacetedBrepWithVoids>()->Voids();
     }
 #ifdef USE_IFC4
-    if (l->is(IfcSchema::Type::IfcAdvancedBrepWithVoids)) {
+    if (l->as<IfcSchema::IfcAdvancedBrepWithVoids>()) {
       voids = l->as<IfcSchema::IfcAdvancedBrepWithVoids>()->Voids();
     }
 #endif
     
     for (IfcSchema::IfcClosedShell::list::it it = voids->begin(); it != voids->end(); ++it) {
       cgal_shape_t s2;
-      // TODO: This looks weird. Aren't we removing the outer shell again and again?
+      if (convert_shape(*it, s2)) {
-      // Maybe it should be
+        nef_s -= CGAL::Nef_polyhedron_3<Kernel_>(s2);
-      // if (convert_shape(*it, s2)) {
-      if (convert_shape(l->Outer(), s2)) {
-        nef_s -= CGAL::Nef_polyhedron_3<Kernel>(s2);
       }
     }
     
     s = create_polyhedron(nef_s);
-    shape.push_back(ConversionResult(new CgalShape(s), indiv_style ? indiv_style : collective_style));
+    shape.push_back(ConversionResult(l->data().id(), new CgalShape(s), indiv_style ? indiv_style : collective_style));
     return true;
   }
   return false;
@@ -98,19 +97,19 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, Conv
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcMappedItem* l, ConversionResults& shapes) {
   cgal_placement_t gtrsf;
   IfcSchema::IfcCartesianTransformationOperator* transform = l->MappingTarget();
-  if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3DnonUniform) ) {
+  if ( transform->as<IfcSchema::IfcCartesianTransformationOperator3DnonUniform>() ) {
     IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator3DnonUniform*)transform,gtrsf);
-  } else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform) ) {
+  } else if ( transform->as<IfcSchema::IfcCartesianTransformationOperator2DnonUniform>() ) {
     IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator2DnonUniform*)transform,gtrsf);
-  } else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3D) ) {
+  } else if ( transform->as<IfcSchema::IfcCartesianTransformationOperator3D>() ) {
     IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator3D*)transform,gtrsf);
-  } else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2D) ) {
+  } else if ( transform->as<IfcSchema::IfcCartesianTransformationOperator2D>() ) {
     IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator2D*)transform,gtrsf);
   }
   IfcSchema::IfcRepresentationMap* map = l->MappingSource();
   IfcSchema::IfcAxis2Placement* placement = map->MappingOrigin();
   cgal_placement_t trsf;
-  if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
+  if (placement->as<IfcSchema::IfcAxis2Placement3D>()) {
     IfcGeom::CgalKernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
   } else {
     cgal_placement_t trsf_2d;
@@ -155,7 +154,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcFaceBasedSurfaceModel* l,
     cgal_shape_t s;
     const SurfaceStyle* shell_style = get_style(*it);
     if (convert_shape(*it,s)) {
-      shapes.push_back(ConversionResult(new CgalShape(s), shell_style ? shell_style : collective_style));
+      shapes.push_back(ConversionResult((*it)->data().id(), new CgalShape(s), shell_style ? shell_style : collective_style));
       part_success |= true;
     }
   }

src/ifcgeom/kernels/cgal/CgalIfcGeomWires.cpp

@@ -1,14 +1,17 @@
+#include "CgalKernel.h"
+#include "../../../ifcgeom/schema_agnostic/cgal/CgalConversionResult.h"
+
+#define CgalKernel MAKE_TYPE_NAME(CgalKernel)
+
 // For MSVC to have M_PI
 #define _USE_MATH_DEFINES
 #include <cmath>
 
-#include "CgalKernel.h"
-
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcPolyLoop* l, cgal_wire_t& result) {
   IfcSchema::IfcCartesianPoint::list::ptr points = l->Polygon();
   
   // Parse and store the points in a sequence
-  cgal_wire_t polygon = std::vector<Kernel::Point_3>();
+  cgal_wire_t polygon = std::vector<Kernel_::Point_3>();
   for(IfcSchema::IfcCartesianPoint::list::it it = points->begin(); it != points->end(); ++ it) {
     cgal_point_t pnt;
     IfcGeom::CgalKernel::convert(*it, pnt);
@@ -18,7 +21,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcPolyLoop* l, cgal_wire_t&
   // A loop should consist of at least three vertices
   std::size_t original_count = polygon.size();
   if (original_count < 3) {
-    Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l);
     return false;
   }
   
@@ -28,11 +31,11 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcPolyLoop* l, cgal_wire_t&
   std::size_t count = polygon.size();
   if (original_count - count != 0) {
     std::stringstream ss; ss << (original_count - count) << " edges removed for:";
-    Logger::Message(Logger::LOG_WARNING, ss.str(), l->entity);
+    Logger::Message(Logger::LOG_WARNING, ss.str(), l);
   }
   
   if (count < 3) {
-    Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l);
     return false;
   }
   
@@ -50,7 +53,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcPolyline* l, cgal_wire_t&
   IfcSchema::IfcCartesianPoint::list::ptr points = l->Points();
   
   // Parse and store the points in a sequence
-  cgal_wire_t polygon = std::vector<Kernel::Point_3>();
+  cgal_wire_t polygon = std::vector<Kernel_::Point_3>();
   for(IfcSchema::IfcCartesianPoint::list::it it = points->begin(); it != points->end(); ++ it) {
     cgal_point_t pnt;
     IfcGeom::CgalKernel::convert(*it, pnt);
@@ -91,15 +94,15 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcOrientedEdge* l, cgal_wire
 }
 
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcEdge* l, cgal_wire_t& result) {
-  if (!l->EdgeStart()->is(IfcSchema::Type::IfcVertexPoint) || !l->EdgeEnd()->is(IfcSchema::Type::IfcVertexPoint)) {
+  if (!l->EdgeStart()->as<IfcSchema::IfcVertexPoint>() || !l->EdgeEnd()->as<IfcSchema::IfcVertexPoint>()) {
-    Logger::Message(Logger::LOG_ERROR, "Only IfcVertexPoints are supported for EdgeStart and -End", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "Only IfcVertexPoints are supported for EdgeStart and -End", l);
     return false;
   }
   
   IfcSchema::IfcPoint* pnt1 = ((IfcSchema::IfcVertexPoint*) l->EdgeStart())->VertexGeometry();
   IfcSchema::IfcPoint* pnt2 = ((IfcSchema::IfcVertexPoint*) l->EdgeEnd())->VertexGeometry();
-  if (!pnt1->is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->is(IfcSchema::Type::IfcCartesianPoint)) {
+  if (!pnt1->as<IfcSchema::IfcCartesianPoint>() || !pnt2->as<IfcSchema::IfcCartesianPoint>()) {
-    Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l->entity);
+    Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l);
     return false;
   }
   
@@ -120,7 +123,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcEdge* l, cgal_wire_t& resu
 
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCompositeCurve* l, cgal_wire_t& wire) {
   if ( getValue(GV_PLANEANGLE_UNIT)<0 ) {
-    Logger::Message(Logger::LOG_WARNING,"Creating a composite curve without unit information:",l->entity);
+    Logger::Message(Logger::LOG_WARNING,"Creating a composite curve without unit information:",l);
     
     // Temporarily pretend we do have unit information
     setValue(GV_PLANEANGLE_UNIT,1.0);
@@ -181,7 +184,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCompositeCurve* l, cgal_wi
     IfcSchema::IfcCurve* curve = (*it)->ParentCurve();
     cgal_wire_t wire2;
     if ( !convert_wire(curve,wire2) ) {
-      Logger::Message(Logger::LOG_ERROR,"Failed to convert curve:",curve->entity);
+      Logger::Message(Logger::LOG_ERROR,"Failed to convert curve:",curve);
       continue;
     }
     if ( ! (*it)->SameSense() ) std::reverse(wire2.begin(),wire2.end());
@@ -191,7 +194,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCompositeCurve* l, cgal_wi
     } else if (w.empty()) {
       w = wire2;
     } else if (w.back() == w.front()) {
-      std::vector<Kernel::Point_3>::const_iterator vertex = wire2.begin();
+      std::vector<Kernel_::Point_3>::const_iterator vertex = wire2.begin();
       ++vertex;
       while (vertex != wire2.end()) {
         w.push_back(*vertex);
@@ -210,7 +213,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcCompositeCurve* l, cgal_wi
 
 bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrimmedCurve* l, cgal_wire_t& wire) {
   IfcSchema::IfcCurve* basis_curve = l->BasisCurve();
-  bool isConic = basis_curve->is(IfcSchema::Type::IfcConic);
+  bool isConic = basis_curve->as<IfcSchema::IfcConic>();
   double parameterFactor = isConic ? getValue(GV_PLANEANGLE_UNIT) : getValue(GV_LENGTH_UNIT);
   cgal_curve_t curve;
   if ( !convert_curve(basis_curve,curve) ) return false;
@@ -225,10 +228,10 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrimmedCurve* l, cgal_wire
   cgal_wire_t w;
   for ( IfcEntityList::it it = trims1->begin(); it != trims1->end(); it ++ ) {
     IfcUtil::IfcBaseClass* i = *it;
-    if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) {
+    if ( i->as<IfcSchema::IfcCartesianPoint>() ) {
       IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[sense_agreement] );
       has_pnts[sense_agreement] = true;
-    } else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
+    } else if ( i->as<IfcSchema::IfcParameterValue>() ) {
       const double value = *((IfcSchema::IfcParameterValue*)i);
       flts[sense_agreement] = value * parameterFactor;
       has_flts[sense_agreement] = true;
@@ -236,10 +239,10 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrimmedCurve* l, cgal_wire
   }
   for ( IfcEntityList::it it = trims2->begin(); it != trims2->end(); it ++ ) {
     IfcUtil::IfcBaseClass* i = *it;
-    if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) {
+    if ( i->as<IfcSchema::IfcCartesianPoint>() ) {
       IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[1-sense_agreement] );
       has_pnts[1-sense_agreement] = true;
-    } else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
+    } else if ( i->as<IfcSchema::IfcParameterValue>() ) {
       const double value = *((IfcSchema::IfcParameterValue*)i);
       flts[1-sense_agreement] = value * parameterFactor;
       has_flts[1-sense_agreement] = true;
@@ -250,13 +253,13 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrimmedCurve* l, cgal_wire
   if ( trim_cartesian ) {
     // TODO: Project points to closest point in curve?
     if ( CGAL::squared_distance(pnts[0], pnts[1]) < getValue(GV_WIRE_CREATION_TOLERANCE)*getValue(GV_WIRE_CREATION_TOLERANCE) ) {
-      Logger::Message(Logger::LOG_WARNING,"Skipping segment with length below tolerance level:",l->entity);
+      Logger::Message(Logger::LOG_WARNING,"Skipping segment with length below tolerance level:",l);
       return false;
     }
     if (l->SenseAgreement()) {
       bool found = false;
       int loops_to_go = 2;
-      std::vector<Kernel::Point_3>::const_iterator point = curve.begin();
+      std::vector<Kernel_::Point_3>::const_iterator point = curve.begin();
       do {
         if (!found) {
           if (CGAL::squared_distance(*point, pnts[0]) < getValue(GV_WIRE_CREATION_TOLERANCE)*getValue(GV_WIRE_CREATION_TOLERANCE)) {
@@ -277,7 +280,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrimmedCurve* l, cgal_wire
     } else {
       bool found = false;
       int loops_to_go = 2;
-      std::vector<Kernel::Point_3>::const_reverse_iterator point = curve.rbegin();
+      std::vector<Kernel_::Point_3>::const_reverse_iterator point = curve.rbegin();
       do {
         if (!found) {
           if (CGAL::squared_distance(*point, pnts[0]) < getValue(GV_WIRE_CREATION_TOLERANCE)*getValue(GV_WIRE_CREATION_TOLERANCE)) {
@@ -299,7 +302,7 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrimmedCurve* l, cgal_wire
     // is defined by an IfcCartesianPoint and an IfcVector with Magnitude. Because
     // the vector is normalised when passed to Geom_Line constructor the magnitude
     // needs to be factored in with the IfcParameterValue here.
-    if ( basis_curve->is(IfcSchema::Type::IfcLine) ) {
+    if ( basis_curve->as<IfcSchema::IfcLine>() ) {
       IfcSchema::IfcLine* line = static_cast<IfcSchema::IfcLine*>(basis_curve);
       const double magnitude = line->Dir()->Magnitude();
       flts[0] *= magnitude; flts[1] *= magnitude;
@@ -309,19 +312,19 @@ bool IfcGeom::CgalKernel::convert(const IfcSchema::IfcTrimmedCurve* l, cgal_wire
     } else {
       const int segments_of_full_curve = 12;
       double segment_angle = 2.0*3.141592653589793/segments_of_full_curve;
-      if ( basis_curve->is(IfcSchema::Type::IfcEllipse) ) {
+      if ( basis_curve->as<IfcSchema::IfcEllipse>() ) {
         IfcSchema::IfcEllipse* ellipse = static_cast<IfcSchema::IfcEllipse*>(basis_curve);
         double x = ellipse->SemiAxis1() * getValue(GV_LENGTH_UNIT);
         double y = ellipse->SemiAxis2() * getValue(GV_LENGTH_UNIT);
         for (double current_angle = flts[0]; current_angle < flts[1]; current_angle += segment_angle) {
-          w.push_back(Kernel::Point_3(x*cos(current_angle), y*sin(current_angle), 0));
+          w.push_back(Kernel_::Point_3(x*cos(current_angle), y*sin(current_angle), 0));
-        } w.push_back(Kernel::Point_3(x*cos(flts[1]), y*sin(flts[1]), 0));
+        } w.push_back(Kernel_::Point_3(x*cos(flts[1]), y*sin(flts[1]), 0));
-      } if ( basis_curve->is(IfcSchema::Type::IfcCircle) ) {
+      } if ( basis_curve->as<IfcSchema::IfcCircle>() ) {
         IfcSchema::IfcCircle* circle = static_cast<IfcSchema::IfcCircle*>(basis_curve);
         double r = circle->Radius() * getValue(GV_LENGTH_UNIT);
         for (double current_angle = flts[0]; current_angle < flts[1]; current_angle += segment_angle) {
-          w.push_back(Kernel::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
+          w.push_back(Kernel_::Point_3(r*cos(current_angle), r*sin(current_angle), 0));
-        } w.push_back(Kernel::Point_3(r*cos(flts[1]), r*sin(flts[1]), 0));
+        } w.push_back(Kernel_::Point_3(r*cos(flts[1]), r*sin(flts[1]), 0));
       }
     }
   } else if ( trim_cartesian_failed && (has_pnts[0] && has_pnts[1]) ) {

src/ifcgeom/kernels/cgal/CgalKernel.cpp

@@ -88,13 +88,14 @@ bool IfcGeom::CgalKernel::validate_quantities(const IfcSchema::IfcProduct* produ
 	throw std::runtime_error("not implemented");
 }
 
-bool IfcGeom::CgalKernel::convert_openings(const IfcSchema::IfcProduct* product, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const IfcGeom::ConversionResults& shapes, const IfcGeom::ConversionResultPlacement* trsf, IfcGeom::ConversionResults& opened_shapes) {
+bool IfcGeom::CgalKernel::convert_openings(const IfcSchema::IfcProduct* product, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const IfcGeom::ConversionResults& entity_shapes, const IfcGeom::ConversionResultPlacement* trsf, IfcGeom::ConversionResults& opened_shapes) {
+  const cgal_placement_t& entity_trsf = ((CgalPlacement*) trsf)->trsf();
   std::list<cgal_shape_t> opening_shapelist;
   
   for ( IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++ it ) {
     IfcSchema::IfcRelVoidsElement* v = *it;
     IfcSchema::IfcFeatureElementSubtraction* fes = v->RelatedOpeningElement();
-    if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {
+    if ( fes->as<IfcSchema::IfcOpeningElement>() ) {
       if (!fes->hasRepresentation()) continue;
       
       // Convert the IfcRepresentation of the IfcOpeningElement
@@ -143,13 +144,13 @@ bool IfcGeom::CgalKernel::convert_openings(const IfcSchema::IfcProduct* product,
     cgal_shape_t original_entity_shape(entity_shape);
     
     if (!entity_shape.is_valid()) {
-      Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Invalid entity:", entity->entity);
+      Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Invalid geometry:", product);
       return false;
     }
     
     if (!entity_shape.is_closed()) {
       // TODO: There can be substractions to remove parts of non-volumetric objects. Maybe iterate over all faces of an entity and put them in a Nef_polyhedron_3 through Boolean union? Highly inefficient but maybe desirable...
-      Logger::Message(Logger::LOG_ERROR, "Subtraction of openings not supported for non-closed entity:", entity->entity);
+      Logger::Message(Logger::LOG_ERROR, "Subtraction of openings not supported for non-closed geometry:", product);
       return false;
     }
     
@@ -158,26 +159,26 @@ bool IfcGeom::CgalKernel::convert_openings(const IfcSchema::IfcProduct* product,
     try {
       success = CGAL::Polygon_mesh_processing::triangulate_faces(entity_shape);
     } catch (...) {
-      Logger::Message(Logger::LOG_ERROR, "Triangulation of entity crashed:", entity->entity);
+      Logger::Message(Logger::LOG_ERROR, "Triangulation of geometry crashed:", product);
       return false;
     }
     
     if (!success) {
-      Logger::Message(Logger::LOG_ERROR, "Triangulation of entity failed:", entity->entity);
+      Logger::Message(Logger::LOG_ERROR, "Triangulation of geometry failed:", product);
       return false;
     }
     
     if (CGAL::Polygon_mesh_processing::does_self_intersect(entity_shape)) {
-      Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Self-intersecting entity:", entity->entity);
+      Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Self-intersecting geometry:", product);
       return false;
     }
     
-    CGAL::Nef_polyhedron_3<Kernel> nef_brep_cut_result;
+    CGAL::Nef_polyhedron_3<Kernel_> nef_brep_cut_result;
     
     try {
-      nef_brep_cut_result = CGAL::Nef_polyhedron_3<Kernel>(entity_shape);
+      nef_brep_cut_result = CGAL::Nef_polyhedron_3<Kernel_>(entity_shape);
     } catch (...) {
-      Logger::Message(Logger::LOG_ERROR, "Could not convert entity to Nef:", entity->entity);
+      Logger::Message(Logger::LOG_ERROR, "Could not convert geometry to Nef:", product);
       return false;
     }
     
@@ -185,17 +186,17 @@ bool IfcGeom::CgalKernel::convert_openings(const IfcSchema::IfcProduct* product,
       cgal_shape_t brep_cut_result;
       nef_brep_cut_result.convert_to_polyhedron(brep_cut_result);
     } catch (...) {
-      Logger::Message(Logger::LOG_WARNING, "Final conversion will likely fail. Could not convert entity from Nef:", entity->entity);
+      Logger::Message(Logger::LOG_WARNING, "Final conversion will likely fail. Could not convert geometry from Nef:", product);
     }
     
     for (auto &opening: opening_shapelist) {
       
       cgal_shape_t original_opening_shape(opening);
       if (!opening.is_valid()) {
-        Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Invalid opening in entity:", entity->entity);
+        Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Invalid opening in geometry:", product);
         return false;
       } if (!opening.is_closed()) {
-        Logger::Message(Logger::LOG_ERROR, "Subtraction of opening makes no sense. Not closed opening in entity:", entity->entity);
+        Logger::Message(Logger::LOG_ERROR, "Subtraction of opening makes no sense. Not closed opening in geometry:", product);
         return false;
       }
       
@@ -204,25 +205,25 @@ bool IfcGeom::CgalKernel::convert_openings(const IfcSchema::IfcProduct* product,
       try {
         success = CGAL::Polygon_mesh_processing::triangulate_faces(opening);
       } catch (...) {
-        Logger::Message(Logger::LOG_ERROR, "Triangulation of opening of entity crashed:", entity->entity);
+        Logger::Message(Logger::LOG_ERROR, "Triangulation of opening of geometry crashed:", product);
         return false;
       }
       
       if (!success) {
-        Logger::Message(Logger::LOG_ERROR, "Triangulation of opening of entity failed:", entity->entity);
+        Logger::Message(Logger::LOG_ERROR, "Triangulation of opening of geometry failed:", product);
         return false;
       }
       
       if (CGAL::Polygon_mesh_processing::does_self_intersect(entity_shape)) {
-        Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Self-intersecting opening of entity:", entity->entity);
+        Logger::Message(Logger::LOG_ERROR, "Conversion to Nef will fail. Self-intersecting opening of geometry:", product);
       }
       
-      CGAL::Nef_polyhedron_3<Kernel> nef_opening;
+      CGAL::Nef_polyhedron_3<Kernel_> nef_opening;
       
       try {
-        nef_opening = CGAL::Nef_polyhedron_3<Kernel>(opening);
+        nef_opening = CGAL::Nef_polyhedron_3<Kernel_>(opening);
       } catch (...) {
-        Logger::Message(Logger::LOG_ERROR, "Could not convert opening of entity to Nef:", entity->entity);
+        Logger::Message(Logger::LOG_ERROR, "Could not convert opening of geometry to Nef:", product);
         return false;
       }
       
@@ -230,14 +231,14 @@ bool IfcGeom::CgalKernel::convert_openings(const IfcSchema::IfcProduct* product,
         cgal_shape_t opening_shape;
         nef_opening.convert_to_polyhedron(opening_shape);
       } catch (...) {
-        Logger::Message(Logger::LOG_WARNING, "Final conversion will likely fail. Could not convert opening of entity from Nef:", entity->entity);
+        Logger::Message(Logger::LOG_WARNING, "Final conversion will likely fail. Could not convert opening of geometry from Nef:", product);
         // return false;
       }
       
       try {
         nef_brep_cut_result -= nef_opening;
       } catch (...) {
-        Logger::Message(Logger::LOG_ERROR, "Could not subtract Nef opening of entity:", entity->entity);
+        Logger::Message(Logger::LOG_ERROR, "Could not subtract Nef opening of geometry:", product);
         return false;
       }
     }
@@ -245,11 +246,11 @@ bool IfcGeom::CgalKernel::convert_openings(const IfcSchema::IfcProduct* product,
     try {
       nef_brep_cut_result.convert_to_polyhedron(entity_shape);
     } catch (...) {
-      Logger::Message(Logger::LOG_ERROR, "Could not convert entity with openings from Nef:", entity->entity);
+      Logger::Message(Logger::LOG_ERROR, "Could not convert geometry with openings from Nef:", product);
       return false;
     }
     
-    cut_shapes.push_back(IfcGeom::ConversionResult(new CgalShape(entity_shape), &it3->Style()));
+    opened_shapes.push_back(IfcGeom::ConversionResult(it3->ItemId(), new CgalShape(entity_shape), &it3->Style()));
     
   } return true;
 }

src/ifcgeom/kernels/cgal/CgalKernel.h

@@ -35,8 +35,15 @@ if ( it != cache.T.end() ) { e = it->second; return true; }
 #endif
 */
 
+#include <cmath>
+
 #define ALMOST_ZERO 1.e-9
 
+template <typename T>
+inline static bool ALMOST_THE_SAME(const T& a, const T& b, double tolerance=ALMOST_ZERO) {
+        return fabs(a-b) < tolerance;
+}
+
 #include "../../../ifcparse/macros.h"
 
 #include "../../../ifcgeom/kernel_agnostic/AbstractKernel.h"
@@ -52,7 +59,7 @@ if ( it != cache.T.end() ) { e = it->second; return true; }
 #include INCLUDE_SCHEMA(IfcSchema)
 #undef INCLUDE_SCHEMA
 
-struct PolyhedronBuilder : public CGAL::Modifier_base<CGAL::Polyhedron_3<Kernel>::HalfedgeDS> {
+struct PolyhedronBuilder : public CGAL::Modifier_base<CGAL::Polyhedron_3<Kernel_>::HalfedgeDS> {
 private:
   std::list<cgal_face_t> *face_list;
 public:
@@ -60,10 +67,10 @@ public:
     this->face_list = face_list;
   }
   
-  void operator()(CGAL::Polyhedron_3<Kernel>::HalfedgeDS &hds) {
+  void operator()(CGAL::Polyhedron_3<Kernel_>::HalfedgeDS &hds) {
-    std::list<Kernel::Point_3> points;
+    std::list<Kernel_::Point_3> points;
     std::list<std::list<std::size_t>> facet_vertices;
-    CGAL::Polyhedron_incremental_builder_3<CGAL::Polyhedron_3<Kernel>::HalfedgeDS> builder(hds, true);
+    CGAL::Polyhedron_incremental_builder_3<CGAL::Polyhedron_3<Kernel_>::HalfedgeDS> builder(hds, true);
     
     for (auto &face: *face_list) {
       facet_vertices.push_back(std::list<std::size_t>());
@@ -127,11 +134,11 @@ namespace IfcGeom {
 
     bool convert_openings(const IfcSchema::IfcProduct* entity, const IfcSchema::IfcRelVoidsElement::list::ptr& openings, const ConversionResults& entity_shapes, const cgal_placement_t& entity_trsf, ConversionResults& cut_shapes);
     
-//    CGAL::Polyhedron_3<Kernel> triangulate_faces(CGAL::Polyhedron_3<Kernel> &polyhedron);
+//    CGAL::Polyhedron_3<Kernel_> triangulate_faces(CGAL::Polyhedron_3<Kernel_> &polyhedron);
-    CGAL::Polyhedron_3<Kernel> create_polyhedron(std::list<cgal_face_t> &face_list);
+    CGAL::Polyhedron_3<Kernel_> create_polyhedron(std::list<cgal_face_t> &face_list);
-    CGAL::Polyhedron_3<Kernel> create_polyhedron(CGAL::Nef_polyhedron_3<Kernel> &nef_polyhedron);
+    CGAL::Polyhedron_3<Kernel_> create_polyhedron(CGAL::Nef_polyhedron_3<Kernel_> &nef_polyhedron);
-    CGAL::Nef_polyhedron_3<Kernel> create_nef_polyhedron(std::list<cgal_face_t> &face_list);
+    CGAL::Nef_polyhedron_3<Kernel_> create_nef_polyhedron(std::list<cgal_face_t> &face_list);
-    CGAL::Nef_polyhedron_3<Kernel> create_nef_polyhedron(CGAL::Polyhedron_3<Kernel> &polyhedron);
+    CGAL::Nef_polyhedron_3<Kernel_> create_nef_polyhedron(CGAL::Polyhedron_3<Kernel_> &polyhedron);
 
 		void purge_cache() {
 			// Rather hack-ish, but a stopgap solution to keep memory under control

src/ifcgeom/schema_agnostic/Kernel.cpp

@@ -183,7 +183,7 @@ namespace {
 		std::map<std::string, IfcUtil::IfcBaseEntity*> layers;
 		if (prod->hasRepresentation()) {
 			IfcEntityList::ptr r = IfcParse::traverse(prod->Representation());
-			typename Schema::IfcRepresentation::list::ptr representations = r->as<typename Schema::IfcRepresentation>();
+			typename Schema::IfcRepresentation::list::ptr representations = r->template as<typename Schema::IfcRepresentation>();
 			for (typename Schema::IfcRepresentation::list::it it = representations->begin(); it != representations->end(); ++it) {
 				typename Schema::IfcPresentationLayerAssignment::list::ptr a = (*it)->LayerAssignments();
 				for (typename Schema::IfcPresentationLayerAssignment::list::it jt = a->begin(); jt != a->end(); ++jt) {
@@ -191,7 +191,7 @@ namespace {
 				}
 			}
 
-			typename Schema::IfcRepresentationItem::list::ptr items = r->as<typename Schema::IfcRepresentationItem>();
+			typename Schema::IfcRepresentationItem::list::ptr items = r->template as<typename Schema::IfcRepresentationItem>();
 			for (typename Schema::IfcRepresentationItem::list::it it = items->begin(); it != items->end(); ++it) {
 				typename Schema::IfcPresentationLayerAssignment::list::ptr a = getLayerAssignments(*it)->template as<typename Schema::IfcPresentationLayerAssignment>();
 				for (typename Schema::IfcPresentationLayerAssignment::list::it jt = a->begin(); jt != a->end(); ++jt) {
@@ -251,11 +251,11 @@ namespace {
 		}
 
 		// Is the IfcElement a decomposition of an IfcElement with any IfcOpeningElements?
-		typename Schema::IfcObjectDefinition* obdef = product->as<typename Schema::IfcObjectDefinition>();
+		typename Schema::IfcObjectDefinition* obdef = product->template as<typename Schema::IfcObjectDefinition>();
 		for (;;) {
 			auto decomposes = obdef->Decomposes()->generalize();
 			if (decomposes->size() != 1) break;
-			typename Schema::IfcObjectDefinition* rel_obdef = (*decomposes->begin())->as<typename Schema::IfcRelAggregates>()->RelatingObject();
+			typename Schema::IfcObjectDefinition* rel_obdef = (*decomposes->begin())->template as<typename Schema::IfcRelAggregates>()->RelatingObject();
 			if (rel_obdef->declaration().is(Schema::IfcElement::Class()) && !rel_obdef->declaration().is(Schema::IfcOpeningElement::Class())) {
 				typename Schema::IfcElement* element = (typename Schema::IfcElement*)rel_obdef;
 				openings->push(element->HasOpenings()->generalize());

src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.cpp

@@ -23,10 +23,10 @@ void triangulate_helper(const cgal_shape_t& shape_const, const IfcGeom::Iterator
   }
   
   // Triangulate the shape and compute the normals
-//  std::map<cgal_vertex_descriptor_t, Kernel::Vector_3> vertex_normals;
+//  std::map<cgal_vertex_descriptor_t, Kernel_::Vector_3> vertex_normals;
-//  boost::associative_property_map<std::map<cgal_vertex_descriptor_t, Kernel::Vector_3>> vertex_normals_map(vertex_normals);
+//  boost::associative_property_map<std::map<cgal_vertex_descriptor_t, Kernel_::Vector_3>> vertex_normals_map(vertex_normals);
-  std::map<cgal_face_descriptor_t, Kernel::Vector_3> face_normals;
+  std::map<cgal_face_descriptor_t, Kernel_::Vector_3> face_normals;
-  boost::associative_property_map<std::map<cgal_face_descriptor_t, Kernel::Vector_3>> face_normals_map(face_normals);
+  boost::associative_property_map<std::map<cgal_face_descriptor_t, Kernel_::Vector_3>> face_normals_map(face_normals);
 
   bool success = false;
   try {
@@ -37,8 +37,8 @@ void triangulate_helper(const cgal_shape_t& shape_const, const IfcGeom::Iterator
   }
   
   if (!success) {
-    Logger::Message(Logger::LOG_ERROR,     return;
+    Logger::Message(Logger::LOG_ERROR, "Triangulation failed");
-"Triangulation failed");
+    return;
   }
   //    std::cout << "Triangulated model: " << s.size_of_facets() << " facets and " << s.size_of_vertices() << " vertices" << std::endl;
   
@@ -50,12 +50,13 @@ void triangulate_helper(const cgal_shape_t& shape_const, const IfcGeom::Iterator
 //  CGAL::Polygon_mesh_processing::compute_normals(s, vertex_normals_map, face_normals_map);
   CGAL::Polygon_mesh_processing::compute_face_normals(s, face_normals_map);
   
+  int num_faces = 0, num_vertices = 0;
   for (auto &face: faces(s)) {
     if (!face->is_triangle()) {
       std::cout << "Warning: non-triangular face!" << std::endl;
       continue;
     }
-    CGAL::Polyhedron_3<Kernel>::Halfedge_around_facet_const_circulator current_halfedge = face->facet_begin();
+    CGAL::Polyhedron_3<Kernel_>::Halfedge_around_facet_const_circulator current_halfedge = face->facet_begin();
     do {
       t->addVertex(surface_style_id,
                    CGAL::to_double(current_halfedge->vertex()->point().cartesian(0)),

src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.h

@@ -38,24 +38,24 @@
 #include <CGAL/Polygon_mesh_processing/self_intersections.h>
 #include <CGAL/Nef_polyhedron_3.h>
 
-typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel;
+typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel_;
 
-typedef Kernel::Aff_transformation_3 cgal_placement_t;
+typedef Kernel_::Aff_transformation_3 cgal_placement_t;
-typedef Kernel::Point_3 cgal_point_t;
+typedef Kernel_::Point_3 cgal_point_t;
-typedef Kernel::Vector_3 cgal_direction_t;
+typedef Kernel_::Vector_3 cgal_direction_t;
-typedef Kernel::Vector_3 cgal_vector_t;
+typedef Kernel_::Vector_3 cgal_vector_t;
-typedef Kernel::Plane_3 cgal_plane_t;
+typedef Kernel_::Plane_3 cgal_plane_t;
-typedef std::vector<Kernel::Point_3> cgal_curve_t;
+typedef std::vector<Kernel_::Point_3> cgal_curve_t;
-typedef std::vector<Kernel::Point_3> cgal_wire_t;
+typedef std::vector<Kernel_::Point_3> cgal_wire_t;
 
 struct cgal_face_t {
   cgal_wire_t outer;
   std::vector<cgal_wire_t> inner;
 };
 
-typedef CGAL::Polyhedron_3<Kernel> cgal_shape_t;
+typedef CGAL::Polyhedron_3<Kernel_> cgal_shape_t;
-typedef boost::graph_traits<CGAL::Polyhedron_3<Kernel>>::vertex_descriptor cgal_vertex_descriptor_t;
+typedef boost::graph_traits<CGAL::Polyhedron_3<Kernel_>>::vertex_descriptor cgal_vertex_descriptor_t;
-typedef boost::graph_traits<CGAL::Polyhedron_3<Kernel>>::face_descriptor cgal_face_descriptor_t;
+typedef boost::graph_traits<CGAL::Polyhedron_3<Kernel_>>::face_descriptor cgal_face_descriptor_t;
 
 #include "../../../ifcgeom/schema_agnostic/ConversionResult.h"