From 24b552a822d2d4515927d867e276c6eb9bb6f36d Mon Sep 17 00:00:00 2001 From: Thomas Krijnen Date: Wed, 23 Jan 2019 17:27:13 +0100 Subject: [PATCH] Merge fixes --- cmake/CMakeLists.txt | 2 +- .../kernels/cgal/CgalConversionFunctions.cpp | 41 +-- .../kernels/cgal/CgalEntityMapping.cpp | 22 +- .../kernels/cgal/CgalIfcGeomCurves.cpp | 15 +- src/ifcgeom/kernels/cgal/CgalIfcGeomFaces.cpp | 289 +++++++++--------- .../kernels/cgal/CgalIfcGeomPrimitives.cpp | 55 ++-- .../kernels/cgal/CgalIfcGeomShapes.cpp | 275 ++++++++--------- .../cgal/CgalIfcGeomShapesWithStyles.cpp | 45 ++- src/ifcgeom/kernels/cgal/CgalIfcGeomWires.cpp | 61 ++-- src/ifcgeom/kernels/cgal/CgalKernel.cpp | 47 +-- src/ifcgeom/kernels/cgal/CgalKernel.h | 25 +- src/ifcgeom/schema_agnostic/Kernel.cpp | 8 +- .../cgal/CgalConversionResult.cpp | 15 +- .../cgal/CgalConversionResult.h | 22 +- 14 files changed, 472 insertions(+), 450 deletions(-) diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt index 7a31f62eff..8f6dd2516d 100644 --- a/cmake/CMakeLists.txt +++ b/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() diff --git a/src/ifcgeom/kernels/cgal/CgalConversionFunctions.cpp b/src/ifcgeom/kernels/cgal/CgalConversionFunctions.cpp index 026b491b88..dfa70275c8 100644 --- a/src/ifcgeom/kernels/cgal/CgalConversionFunctions.cpp +++ b/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 IfcGeom::CgalKernel::create_polyhedron(std::list &face_list) { +CGAL::Polyhedron_3 IfcGeom::CgalKernel::create_polyhedron(std::list &face_list) { // Naive creation - CGAL::Polyhedron_3 polyhedron; + CGAL::Polyhedron_3 polyhedron; PolyhedronBuilder builder(&face_list); polyhedron.delegate(builder); @@ -31,7 +34,7 @@ CGAL::Polyhedron_3 IfcGeom::CgalKernel::create_polyhedron(std::list(); + return CGAL::Polyhedron_3(); } 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 IfcGeom::CgalKernel::create_polyhedron(std::list IfcGeom::CgalKernel::create_polyhedron(CGAL::Nef_polyhedron_3 &nef_polyhedron) { +CGAL::Polyhedron_3 IfcGeom::CgalKernel::create_polyhedron(CGAL::Nef_polyhedron_3 &nef_polyhedron) { if (nef_polyhedron.is_simple()) { try { - CGAL::Polyhedron_3 polyhedron; + CGAL::Polyhedron_3 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(); + return CGAL::Polyhedron_3(); } } else { Logger::Message(Logger::LOG_ERROR, "Nef polyhedron not simple: cannot create polyhedron!"); - return CGAL::Polyhedron_3(); + return CGAL::Polyhedron_3(); } } -CGAL::Nef_polyhedron_3 IfcGeom::CgalKernel::create_nef_polyhedron(std::list &face_list) { - CGAL::Polyhedron_3 polyhedron = create_polyhedron(face_list); +CGAL::Nef_polyhedron_3 IfcGeom::CgalKernel::create_nef_polyhedron(std::list &face_list) { + CGAL::Polyhedron_3 polyhedron = create_polyhedron(face_list); CGAL::Polygon_mesh_processing::triangulate_faces(polyhedron); - CGAL::Nef_polyhedron_3 nef_polyhedron; + CGAL::Nef_polyhedron_3 nef_polyhedron; try { - nef_polyhedron = CGAL::Nef_polyhedron_3(polyhedron); + nef_polyhedron = CGAL::Nef_polyhedron_3(polyhedron); } catch (...) { Logger::Message(Logger::LOG_ERROR, "Conversion to Nef polyhedron failed!"); return nef_polyhedron; } return nef_polyhedron; } -CGAL::Nef_polyhedron_3 IfcGeom::CgalKernel::create_nef_polyhedron(CGAL::Polyhedron_3 &polyhedron) { +CGAL::Nef_polyhedron_3 IfcGeom::CgalKernel::create_nef_polyhedron(CGAL::Polyhedron_3 &polyhedron) { if (polyhedron.is_valid()) { CGAL::Polygon_mesh_processing::triangulate_faces(polyhedron); - CGAL::Nef_polyhedron_3 nef_polyhedron; + CGAL::Nef_polyhedron_3 nef_polyhedron; try { - nef_polyhedron = CGAL::Nef_polyhedron_3(polyhedron); + nef_polyhedron = CGAL::Nef_polyhedron_3(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(); + return CGAL::Nef_polyhedron_3(); } } -//CGAL::Polyhedron_3 IfcGeom::CgalKernel::triangulate_faces(CGAL::Polyhedron_3 &polyhedron) { +//CGAL::Polyhedron_3 IfcGeom::CgalKernel::triangulate_faces(CGAL::Polyhedron_3 &polyhedron) { // std::list face_list; // -// for (CGAL::Polyhedron_3::Facet_const_iterator current_facet = polyhedron.facets_begin(); +// for (CGAL::Polyhedron_3::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::Halfedge_around_facet_const_circulator current_halfedge = current_facet->facet_begin(); +// CGAL::Polyhedron_3::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 IfcGeom::CgalKernel::create_nef_polyhedron(CGAL:: // // // Polygon // else { -// std::list points_in_polygon; +// std::list points_in_polygon; // // } // } diff --git a/src/ifcgeom/kernels/cgal/CgalEntityMapping.cpp b/src/ifcgeom/kernels/cgal/CgalEntityMapping.cpp index 26d5f819c1..a604069f8b 100644 --- a/src/ifcgeom/kernels/cgal/CgalEntityMapping.cpp +++ b/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()))); + r.push_back(IfcGeom::ConversionResult(l->data().id(), new CgalShape(shp), get_style(l->as()))); 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; } diff --git a/src/ifcgeom/kernels/cgal/CgalIfcGeomCurves.cpp b/src/ifcgeom/kernels/cgal/CgalIfcGeomCurves.cpp index 536bc74b66..1653a496f5 100644 --- a/src/ifcgeom/kernels/cgal/CgalIfcGeomCurves.cpp +++ b/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()) { 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()) { 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) { diff --git a/src/ifcgeom/kernels/cgal/CgalIfcGeomFaces.cpp b/src/ifcgeom/kernels/cgal/CgalIfcGeomFaces.cpp index e1a4383dc4..8fde4c292a 100644 --- a/src/ifcgeom/kernels/cgal/CgalIfcGeomFaces.cpp +++ b/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(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(-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-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()) 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(); 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+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-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)); + 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+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, 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)); } 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-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-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, 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)); 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* 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+dy1, 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)); 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-dy2, 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)); } 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, 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)); + 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)); 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+dy1, 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)); } 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(x, -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)); 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(-x, 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)); 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)); } } diff --git a/src/ifcgeom/kernels/cgal/CgalIfcGeomPrimitives.cpp b/src/ifcgeom/kernels/cgal/CgalIfcGeomPrimitives.cpp index f91617f8f3..6e630578e8 100644 --- a/src/ifcgeom/kernels/cgal/CgalIfcGeomPrimitives.cpp +++ b/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 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 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 refDirection = Kernel::Vector_3(1,0,0); + cgal_direction_t axis = Kernel_::Vector_3(0,0,1); + 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 x = CGAL::cross_product(y, axis); + Kernel_::Vector_3 y = CGAL::cross_product(axis, refDirection); + Kernel_::Vector_3 x = CGAL::cross_product(y, axis); cgal_plane_t ax3; - if ( hasRef ) ax3 = Kernel::Plane_3(o,o+x,o+y); - else ax3 = Kernel::Plane_3(o,axis); + if ( hasRef ) ax3 = Kernel_::Plane_3(o,o+x,o+y); + 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 refDirection = Kernel::Vector_3(1,0,0); + cgal_direction_t axis = Kernel_::Vector_3(0,0,1); + 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 x = CGAL::cross_product(y, axis); + Kernel_::Vector_3 y = CGAL::cross_product(axis, refDirection); + 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) ) { - Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l->entity); + if ( ! l->as() ) { + 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() ) { 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() ) 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)); diff --git a/src/ifcgeom/kernels/cgal/CgalIfcGeomShapes.cpp b/src/ifcgeom/kernels/cgal/CgalIfcGeomShapes.cpp index f6af7fc884..80d4a83a7b 100644 --- a/src/ifcgeom/kernels/cgal/CgalIfcGeomShapes.cpp +++ b/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 face_list; face_list.push_back(bottom_face); - for (std::vector::const_iterator current_vertex = bottom_face.outer.begin(); + for (std::vector::const_iterator current_vertex = bottom_face.outer.begin(); current_vertex != bottom_face.outer.end(); ++current_vertex) { - std::vector::const_iterator next_vertex = current_vertex; + std::vector::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::const_reverse_iterator vertex = bottom_face.outer.rbegin(); + for (std::vector::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 nef_shape = create_nef_polyhedron(face_list); + CGAL::Nef_polyhedron_3 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::const_iterator current_vertex = inner.begin(); + for (std::vector::const_iterator current_vertex = inner.begin(); current_vertex != inner.end(); ++current_vertex) { - std::vector::const_iterator next_vertex = current_vertex; + std::vector::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::const_reverse_iterator vertex = inner.rbegin(); + for (std::vector::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 face_list; face_list.push_back(face1); - std::vector::const_iterator current_face1_vertex = face1.outer.begin(); - std::vector::const_iterator current_face2_vertex = face2.outer.begin(); + std::vector::const_iterator current_face1_vertex = face1.outer.begin(); + std::vector::const_iterator current_face2_vertex = face2.outer.begin(); while (current_face1_vertex != face1.outer.end() && current_face2_vertex != face2.outer.end()) { - std::vector::const_iterator next_face1_vertex = current_face1_vertex; - std::vector::const_iterator next_face2_vertex = current_face2_vertex; + std::vector::const_iterator next_face1_vertex = current_face1_vertex; + std::vector::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::const_reverse_iterator vertex = face2.outer.rbegin(); + for (std::vector::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 outer_polyhedron; +// CGAL::Polyhedron_3 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 nef_shape = create_nef_polyhedron(face_list); + CGAL::Nef_polyhedron_3 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::const_iterator next_face1_vertex = current_face1_vertex; - std::vector::const_iterator next_face2_vertex = current_face2_vertex; + std::vector::const_iterator next_face1_vertex = current_face1_vertex; + std::vector::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::const_reverse_iterator vertex = hole_face2.outer.rbegin(); + for (std::vector::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 inner_polyhedron; +// CGAL::Polyhedron_3 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, dy, 0)); - 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, 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, 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, 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, 0, 0)); + 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, 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, 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(0, 0, 0)); + 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, 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(dx, dy, 0)); - 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, 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(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(dx, 0, 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, 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(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, 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(0, 0, 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, 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(); 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 p1; +// CGAL::Polyhedron_3 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(operand2); IfcSchema::IfcSurface* surface = hss->BaseSurface(); - if (surface->is(IfcSchema::Type::IfcPlane) ) { + if (surface->as() ) { 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 p2; +// CGAL::Polyhedron_3 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 nef_result; + CGAL::Nef_polyhedron_3 nef_result; try { - nef_result = CGAL::Nef_polyhedron_3(s1); + nef_result = CGAL::Nef_polyhedron_3(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::Intersection_mode::CLOSED_HALFSPACE); + if (is_plane) nef_result = nef_result.intersection(plane, CGAL::Nef_polyhedron_3::Intersection_mode::CLOSED_HALFSPACE); } else { - CGAL::Nef_polyhedron_3 nef_s2; + CGAL::Nef_polyhedron_3 nef_s2; try { - nef_s2 = CGAL::Nef_polyhedron_3(s2); + nef_s2 = CGAL::Nef_polyhedron_3(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 result; +// CGAL::Polyhedron_3 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 nef_result = CGAL::Nef_polyhedron_3(s1)+CGAL::Nef_polyhedron_3(s2); + CGAL::Nef_polyhedron_3 nef_result = CGAL::Nef_polyhedron_3(s1)+CGAL::Nef_polyhedron_3(s2); if (!nef_result.is_simple()) { std::cout << "Not simple: " << nef_result.number_of_volumes() << " volumes" << std::endl; return false; } else { -// CGAL::Polyhedron_3 result; +// CGAL::Polyhedron_3 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 nef_result = CGAL::Nef_polyhedron_3(s1)*CGAL::Nef_polyhedron_3(s2); + CGAL::Nef_polyhedron_3 nef_result = CGAL::Nef_polyhedron_3(s1)*CGAL::Nef_polyhedron_3(s2); if (!nef_result.is_simple()) { std::cout << "Not simple: " << nef_result.number_of_volumes() << " volumes" << std::endl; return false; } else { -// CGAL::Polyhedron_3 result; +// CGAL::Polyhedron_3 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 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(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)); + std::vector 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(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)); std::list 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 refined_face_list; for (auto &face: face_list) { - Kernel::Point_3 vertex0 = face.outer[0]; - Kernel::Point_3 vertex1 = face.outer[1]; - Kernel::Point_3 vertex2 = face.outer[2]; + Kernel_::Point_3 vertex0 = face.outer[0]; + Kernel_::Point_3 vertex1 = face.outer[1]; + Kernel_::Point_3 vertex2 = face.outer[2]; - Kernel::Point_3 midpoint01 = CGAL::midpoint(vertex0, vertex1); - Kernel::Point_3 midpoint12 = CGAL::midpoint(vertex1, vertex2); - Kernel::Point_3 midpoint20 = CGAL::midpoint(vertex2, vertex0); + Kernel_::Point_3 midpoint01 = CGAL::midpoint(vertex0, vertex1); + Kernel_::Point_3 midpoint12 = CGAL::midpoint(vertex1, vertex2); + 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)))); - midpoint01 = Kernel::Point_3(midpoint01.x()/midpoint01_distance_to_origin, + 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.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)))); - midpoint12 = Kernel::Point_3(midpoint12.x()/midpoint12_distance_to_origin, + 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.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)))); - midpoint20 = Kernel::Point_3(midpoint20.x()/midpoint20_distance_to_origin, + 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.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(dx, 0, 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, 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(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, 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, 0, 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.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(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, 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.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, 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(dx, dy, 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.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(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(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.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(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(next_angle), r*sin(next_angle), h)); + 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), 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(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(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(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 >::const_iterator it = coordinates.begin(); it != coordinates.end(); ++it) { const std::vector& 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 >::const_iterator it = indices.begin(); it != indices.end(); ++ it) { const std::vector& 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& 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& 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& 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) ) { - Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface->entity); + if ( ! surface->as() ) { + 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(); + shape = CGAL::Polyhedron_3(); return true; } diff --git a/src/ifcgeom/kernels/cgal/CgalIfcGeomShapesWithStyles.cpp b/src/ifcgeom/kernels/cgal/CgalIfcGeomShapesWithStyles.cpp index c28d6ee8e2..ef3adc858f 100644 --- a/src/ifcgeom/kernels/cgal/CgalIfcGeomShapesWithStyles.cpp +++ b/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()) { style = get_style((IfcSchema::IfcPoint*) element); - } else if (element->is(IfcSchema::Type::IfcCurve)) { + } else if (element->as()) { style = get_style((IfcSchema::IfcCurve*) element); - } else if (element->is(IfcSchema::Type::IfcSurface)) { + } else if (element->as()) { 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()) { 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 nef_s = create_nef_polyhedron(s); + CGAL::Nef_polyhedron_3 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()) { voids = l->as()->Voids(); } #ifdef USE_IFC4 - if (l->is(IfcSchema::Type::IfcAdvancedBrepWithVoids)) { + if (l->as()) { voids = l->as()->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? - // Maybe it should be - // if (convert_shape(*it, s2)) { - if (convert_shape(l->Outer(), s2)) { - nef_s -= CGAL::Nef_polyhedron_3(s2); + if (convert_shape(*it, s2)) { + nef_s -= CGAL::Nef_polyhedron_3(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() ) { IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator3DnonUniform*)transform,gtrsf); - } else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform) ) { + } else if ( transform->as() ) { IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator2DnonUniform*)transform,gtrsf); - } else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3D) ) { + } else if ( transform->as() ) { IfcGeom::CgalKernel::convert((IfcSchema::IfcCartesianTransformationOperator3D*)transform,gtrsf); - } else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2D) ) { + } else if ( transform->as() ) { 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()) { 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; } } diff --git a/src/ifcgeom/kernels/cgal/CgalIfcGeomWires.cpp b/src/ifcgeom/kernels/cgal/CgalIfcGeomWires.cpp index 08a947efd6..70d4fbee0a 100644 --- a/src/ifcgeom/kernels/cgal/CgalIfcGeomWires.cpp +++ b/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 -#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(); + cgal_wire_t polygon = std::vector(); 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(); + cgal_wire_t polygon = std::vector(); 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)) { - Logger::Message(Logger::LOG_ERROR, "Only IfcVertexPoints are supported for EdgeStart and -End", l->entity); + if (!l->EdgeStart()->as() || !l->EdgeEnd()->as()) { + 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)) { - Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l->entity); + if (!pnt1->as() || !pnt2->as()) { + 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::const_iterator vertex = wire2.begin(); + std::vector::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(); 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() ) { 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() ) { 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() ) { 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() ) { 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::const_iterator point = curve.begin(); + std::vector::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::const_reverse_iterator point = curve.rbegin(); + std::vector::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* line = static_cast(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* ellipse = static_cast(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(flts[1]), y*sin(flts[1]), 0)); - } if ( basis_curve->is(IfcSchema::Type::IfcCircle) ) { + 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)); + } if ( basis_curve->as() ) { IfcSchema::IfcCircle* circle = static_cast(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(flts[1]), r*sin(flts[1]), 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)); } } } else if ( trim_cartesian_failed && (has_pnts[0] && has_pnts[1]) ) { diff --git a/src/ifcgeom/kernels/cgal/CgalKernel.cpp b/src/ifcgeom/kernels/cgal/CgalKernel.cpp index e1f149dd85..2a36bc2adf 100644 --- a/src/ifcgeom/kernels/cgal/CgalKernel.cpp +++ b/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 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() ) { 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 nef_brep_cut_result; + CGAL::Nef_polyhedron_3 nef_brep_cut_result; try { - nef_brep_cut_result = CGAL::Nef_polyhedron_3(entity_shape); + nef_brep_cut_result = CGAL::Nef_polyhedron_3(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 nef_opening; + CGAL::Nef_polyhedron_3 nef_opening; try { - nef_opening = CGAL::Nef_polyhedron_3(opening); + nef_opening = CGAL::Nef_polyhedron_3(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; } diff --git a/src/ifcgeom/kernels/cgal/CgalKernel.h b/src/ifcgeom/kernels/cgal/CgalKernel.h index fdd2b020d5..34f0e3c900 100644 --- a/src/ifcgeom/kernels/cgal/CgalKernel.h +++ b/src/ifcgeom/kernels/cgal/CgalKernel.h @@ -35,8 +35,15 @@ if ( it != cache.T.end() ) { e = it->second; return true; } #endif */ +#include + #define ALMOST_ZERO 1.e-9 +template +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::HalfedgeDS> { +struct PolyhedronBuilder : public CGAL::Modifier_base::HalfedgeDS> { private: std::list *face_list; public: @@ -60,10 +67,10 @@ public: this->face_list = face_list; } - void operator()(CGAL::Polyhedron_3::HalfedgeDS &hds) { - std::list points; + void operator()(CGAL::Polyhedron_3::HalfedgeDS &hds) { + std::list points; std::list> facet_vertices; - CGAL::Polyhedron_incremental_builder_3::HalfedgeDS> builder(hds, true); + CGAL::Polyhedron_incremental_builder_3::HalfedgeDS> builder(hds, true); for (auto &face: *face_list) { facet_vertices.push_back(std::list()); @@ -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 triangulate_faces(CGAL::Polyhedron_3 &polyhedron); - CGAL::Polyhedron_3 create_polyhedron(std::list &face_list); - CGAL::Polyhedron_3 create_polyhedron(CGAL::Nef_polyhedron_3 &nef_polyhedron); - CGAL::Nef_polyhedron_3 create_nef_polyhedron(std::list &face_list); - CGAL::Nef_polyhedron_3 create_nef_polyhedron(CGAL::Polyhedron_3 &polyhedron); +// CGAL::Polyhedron_3 triangulate_faces(CGAL::Polyhedron_3 &polyhedron); + CGAL::Polyhedron_3 create_polyhedron(std::list &face_list); + CGAL::Polyhedron_3 create_polyhedron(CGAL::Nef_polyhedron_3 &nef_polyhedron); + CGAL::Nef_polyhedron_3 create_nef_polyhedron(std::list &face_list); + CGAL::Nef_polyhedron_3 create_nef_polyhedron(CGAL::Polyhedron_3 &polyhedron); void purge_cache() { // Rather hack-ish, but a stopgap solution to keep memory under control diff --git a/src/ifcgeom/schema_agnostic/Kernel.cpp b/src/ifcgeom/schema_agnostic/Kernel.cpp index a75f04053a..64ee0ce269 100644 --- a/src/ifcgeom/schema_agnostic/Kernel.cpp +++ b/src/ifcgeom/schema_agnostic/Kernel.cpp @@ -183,7 +183,7 @@ namespace { std::map layers; if (prod->hasRepresentation()) { IfcEntityList::ptr r = IfcParse::traverse(prod->Representation()); - typename Schema::IfcRepresentation::list::ptr representations = r->as(); + typename Schema::IfcRepresentation::list::ptr representations = r->template as(); 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::list::ptr items = r->template as(); for (typename Schema::IfcRepresentationItem::list::it it = items->begin(); it != items->end(); ++it) { typename Schema::IfcPresentationLayerAssignment::list::ptr a = getLayerAssignments(*it)->template as(); 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* obdef = product->template as(); for (;;) { auto decomposes = obdef->Decomposes()->generalize(); if (decomposes->size() != 1) break; - typename Schema::IfcObjectDefinition* rel_obdef = (*decomposes->begin())->as()->RelatingObject(); + typename Schema::IfcObjectDefinition* rel_obdef = (*decomposes->begin())->template as()->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()); diff --git a/src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.cpp b/src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.cpp index 24d3ed83c6..cd59ecd70a 100644 --- a/src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.cpp +++ b/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 vertex_normals; -// boost::associative_property_map> vertex_normals_map(vertex_normals); - std::map face_normals; - boost::associative_property_map> face_normals_map(face_normals); +// std::map vertex_normals; +// boost::associative_property_map> vertex_normals_map(vertex_normals); + std::map face_normals; + boost::associative_property_map> 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; -"Triangulation failed"); + Logger::Message(Logger::LOG_ERROR, "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::Halfedge_around_facet_const_circulator current_halfedge = face->facet_begin(); + CGAL::Polyhedron_3::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)), diff --git a/src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.h b/src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.h index 38a3bc87d5..df085e0c8d 100644 --- a/src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.h +++ b/src/ifcgeom/schema_agnostic/cgal/CgalConversionResult.h @@ -38,24 +38,24 @@ #include #include -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::Point_3 cgal_point_t; -typedef Kernel::Vector_3 cgal_direction_t; -typedef Kernel::Vector_3 cgal_vector_t; -typedef Kernel::Plane_3 cgal_plane_t; -typedef std::vector cgal_curve_t; -typedef std::vector cgal_wire_t; +typedef Kernel_::Aff_transformation_3 cgal_placement_t; +typedef Kernel_::Point_3 cgal_point_t; +typedef Kernel_::Vector_3 cgal_direction_t; +typedef Kernel_::Vector_3 cgal_vector_t; +typedef Kernel_::Plane_3 cgal_plane_t; +typedef std::vector cgal_curve_t; +typedef std::vector cgal_wire_t; struct cgal_face_t { cgal_wire_t outer; std::vector inner; }; -typedef CGAL::Polyhedron_3 cgal_shape_t; -typedef boost::graph_traits>::vertex_descriptor cgal_vertex_descriptor_t; -typedef boost::graph_traits>::face_descriptor cgal_face_descriptor_t; +typedef CGAL::Polyhedron_3 cgal_shape_t; +typedef boost::graph_traits>::vertex_descriptor cgal_vertex_descriptor_t; +typedef boost::graph_traits>::face_descriptor cgal_face_descriptor_t; #include "../../../ifcgeom/schema_agnostic/ConversionResult.h"