Performance (#4)

Author: ExternPointer

CMakeLists.txt

@@ -46,12 +46,24 @@ set( HEADERS
         include/ifcpp/Geometry/Extruder.h
         include/ifcpp/Geometry/Helpers.h
         include/ifcpp/Geometry/StyleConverter.h
+        include/ifcpp/Geometry/Style.h
+        include/ifcpp/Geometry/VisualObject.h
         ${IFC_HEADERS} )
 
 
-
-add_library( ${PROJECT_NAME} STATIC ${SOURCES} ${HEADERS} )
-target_include_directories( ${PROJECT_NAME} PUBLIC include )
+add_library( ifcpp_lib STATIC ${SOURCES} ${HEADERS} )
+target_include_directories( ifcpp_lib PUBLIC include )
 if( MSVC )
-    target_compile_options( ${PROJECT_NAME} PRIVATE "/bigobj" )
+    set_source_files_properties( src/Ifc/Factories/EntityFactory.cpp PROPERTIES COMPILE_FLAGS /bigobj )
+    set_source_files_properties( src/Ifc/Factories/TypeFactory.cpp PROPERTIES COMPILE_FLAGS /bigobj )
+endif()
+
+
+add_library( ${PROJECT_NAME} INTERFACE )
+target_link_libraries( ${PROJECT_NAME} INTERFACE ifcpp_lib )
+
+find_package( OpenMP )
+if( OpenMP_CXX_FOUND )
+    add_definitions( -DENABLE_OPENMP )
+    target_link_libraries( ${PROJECT_NAME} INTERFACE OpenMP::OpenMP_CXX )
 endif()

README.md

@@ -1,7 +1,5 @@
-It is fork off [IfcPlusPlus](https://github.com/ifcquery/ifcplusplus)
+Forked from [IfcPlusPlus](https://github.com/ifcquery/ifcplusplus)
 
-The approach to geometry generation has been redesigned, especially working with cycles (making holes without premature triangulation), as well as the "adapter" layer, with which it is possible to easily use different libraries for triangulation and CSG.
+The approach to geometry generation has been redesigned, especially working with loops (making holes without premature triangulation), as well as the "adapter" layer, with which it is possible to easily use different libraries for triangulation and CSG.
 
 Take a look into [usage example](https://github.com/ExternPointer/ifcpp-example)
-
-// TODO: Styles

include/ifcpp/Geometry/CAdapter.h

@@ -19,9 +19,11 @@ concept CAdapter = CVector<typename TAdapter::TVector> &&
               std::vector<typename TAdapter::TMesh> meshes, std::vector<typename TAdapter::TPolyline> polylines, Matrix<typename TAdapter::TVector> matrix,
               std::vector<typename TAdapter::TVector> loop, std::vector<typename TAdapter::TMesh> operand1, std::vector<typename TAdapter::TMesh> operand2,
               std::vector<std::shared_ptr<Style>> styles ) {
-        { adapter.CreatePolyline( vertices ) } -> std::same_as<typename TAdapter::TPolyline>;
         { adapter.CreateTriangle( vertices, indices ) } -> std::same_as<typename TAdapter::TTriangle>;
+        { adapter.CreatePolyline( vertices ) } -> std::same_as<typename TAdapter::TPolyline>;
         { adapter.CreateMesh( triangles ) } -> std::same_as<typename TAdapter::TMesh>;
+        { adapter.CreatePolyline( polylines[0] ) } -> std::same_as<typename TAdapter::TPolyline>;
+        { adapter.CreateMesh( meshes[0] ) } -> std::same_as<typename TAdapter::TMesh>;
         { adapter.CreateEntity( ifcObjectDifinition, meshes, polylines ) } -> std::same_as<typename TAdapter::TEntity>;
         { adapter.Transform( &meshes, matrix ) } -> std::same_as<void>;
         { adapter.Transform( &polylines, matrix ) } -> std::same_as<void>;

include/ifcpp/Geometry/CurveConverter.h

@@ -1,5 +1,9 @@
 #pragma once
 
+#include <map>
+
+#include "ifcpp/Model/OpenMPIncludes.h"
+
 #include "ifcpp/Geometry/CAdapter.h"
 #include "ifcpp/Geometry/GeomUtils.h"
 #include "ifcpp/Geometry/Matrix.h"
@@ -49,6 +53,11 @@ class CurveConverter {
     std::shared_ptr<SplineConverter<TVector>> m_splineConverter;
     std::shared_ptr<Parameters> m_parameters;
 
+    std::map<std::shared_ptr<IfcCurve>, TCurve> m_curveToPointsMap;
+#ifdef ENABLE_OPENMP
+    Mutex m_curveToPointsMapMutex;
+#endif
+
 public:
     CurveConverter( const std::shared_ptr<PrimitiveTypesConverter<TVector>>& primitivesConverter, const std::shared_ptr<GeomUtils<TVector>>& geomUtils,
                     const std::shared_ptr<SplineConverter<TVector>> splineConverter, const std::shared_ptr<Parameters>& parameters )
@@ -58,16 +67,33 @@ class CurveConverter {
         , m_parameters( parameters ) {
     }
 
+    void ResetCaches() {
+#ifdef ENABLE_OPENMP
+        ScopedLock lock( this->m_curveToPointsMapMutex );
+#endif
+        this->m_curveToPointsMap = {};
+    }
+
     TCurve ConvertCurve( const std::shared_ptr<IfcCurve>& curve ) {
         // ENTITY IfcCurve ABSTRACT SUPERTYPE OF (ONEOF(IfcBoundedCurve, IfcConic, IfcLine, IfcOffsetCurve2D, IfcOffsetCurve3D, IfcPCurve))
 
+        {
+#ifdef ENABLE_OPENMP
+            ScopedLock lock( this->m_curveToPointsMapMutex );
+#endif
+            if( this->m_curveToPointsMap.contains( curve ) ) {
+                return this->m_curveToPointsMap[ curve ];
+            }
+        }
+
+        TCurve result;
+
         const auto boundedCurve = dynamic_pointer_cast<IfcBoundedCurve>( curve );
         if( boundedCurve ) {
             // ENTITY IfcBoundedCurve ABSTRACT SUPERTYPE OF (ONEOF(IfcCompositeCurve, IfcPolyline, IfcTrimmedCurve, IfcBSplineCurve))
 
             const auto compositeCurve = dynamic_pointer_cast<IfcCompositeCurve>( boundedCurve );
             if( compositeCurve ) {
-                TCurve result;
                 for( const auto& segment: compositeCurve->m_Segments ) {
                     TCurve segmentPoints;
                     const auto compositeCurveSegment = dynamic_pointer_cast<IfcCompositeCurveSegment>( segment );
@@ -83,12 +109,12 @@ class CurveConverter {
                         // TODO: Log error
                     }
                 }
-                return this->m_geomUtils->SimplifyCurve( result );
+                result = this->m_geomUtils->SimplifyCurve( result );
             }
 
             const auto polyLine = dynamic_pointer_cast<IfcPolyline>( curve );
             if( polyLine ) {
-                return this->m_geomUtils->SimplifyCurve( this->m_primitivesConverter->ConvertPoints( polyLine->m_Points ) );
+                result = this->m_geomUtils->SimplifyCurve( this->m_primitivesConverter->ConvertPoints( polyLine->m_Points ) );
             }
 
             const auto trimmedCurve = dynamic_pointer_cast<IfcTrimmedCurve>( boundedCurve );
@@ -111,19 +137,17 @@ class CurveConverter {
                             radius1 = radius2 = (float)circle->m_Radius->m_value;
                         }
 
-                        TCurve result;
                         int n = this->m_parameters->m_numVerticesPerCircle; // TODO: should be calculated from radius
                         n = std::max( n, this->m_parameters->m_minNumVerticesPerArc );
                         bool senseAgreement = !trimmedCurve->m_SenseAgreement || trimmedCurve->m_SenseAgreement->m_value;
-                        auto [ startAngle, openingAngle ] =
-                            this->GetTrimmingsForCircle( trimmedCurve->m_Trim1, trimmedCurve->m_Trim2, placement.GetTransformed( AVector::New() ), senseAgreement );
+                        auto [ startAngle, openingAngle ] = this->GetTrimmingsForCircle( trimmedCurve->m_Trim1, trimmedCurve->m_Trim2,
+                                                                                         placement.GetTransformed( AVector::New() ), senseAgreement );
                         if( radius1 > this->m_parameters->m_epsilon && radius2 > this->m_parameters->m_epsilon ) {
                             result = this->m_geomUtils->BuildEllipse( radius1, radius2, startAngle, openingAngle, n );
                         } else {
                             result.push_back( AVector::New() );
                         }
                         placement.TransformLoop( &result );
-                        return result;
                     }
 
                     const auto line = dynamic_pointer_cast<IfcLine>( trimmedCurve->m_BasisCurve );
@@ -132,7 +156,7 @@ class CurveConverter {
                         const auto direction = AVector::Normalized( this->m_primitivesConverter->ConvertVector( line->m_Dir ) );
                         bool senseAgreement = !trimmedCurve->m_SenseAgreement || trimmedCurve->m_SenseAgreement->m_value;
                         const auto [ l, r ] = this->GetTrimmingsForLine( trimmedCurve->m_Trim1, trimmedCurve->m_Trim2, origin, direction, senseAgreement );
-                        return {
+                        result = {
                             origin + direction * l,
                             origin + direction * r,
                         };
@@ -142,13 +166,12 @@ class CurveConverter {
 
             const auto bsplineCurve = dynamic_pointer_cast<IfcBSplineCurve>( boundedCurve );
             if( bsplineCurve ) {
-                return this->m_splineConverter->ConvertBSplineCurve( bsplineCurve );
+                result = this->m_splineConverter->ConvertBSplineCurve( bsplineCurve );
             }
 
             const auto indexedPolyCurve = dynamic_pointer_cast<IfcIndexedPolyCurve>( boundedCurve );
             if( indexedPolyCurve ) {
                 std::vector<TVector> points;
-                TCurve result;
                 const auto pointList2d = dynamic_pointer_cast<IfcCartesianPointList2D>( indexedPolyCurve->m_Points );
                 if( pointList2d ) {
                     points = this->m_primitivesConverter->ConvertPoints( pointList2d->m_CoordList );
@@ -178,7 +201,6 @@ class CurveConverter {
                         }
                     }
                 }
-                return result;
             }
         }
 
@@ -199,7 +221,6 @@ class CurveConverter {
                 radius1 = radius2 = (float)circle->m_Radius->m_value;
             }
 
-            TCurve result;
             int n = this->m_parameters->m_numVerticesPerCircle; // TODO: should be calculated from radius
             n = std::max( n, this->m_parameters->m_minNumVerticesPerArc );
             if( radius1 > this->m_parameters->m_epsilon && radius2 > this->m_parameters->m_epsilon ) {
@@ -208,14 +229,13 @@ class CurveConverter {
                 result.push_back( AVector::New() );
             }
             placement.TransformLoop( &result );
-            return result;
         }
 
         const auto line = dynamic_pointer_cast<IfcLine>( curve );
         if( line && line->m_Pnt && line->m_Dir ) {
             const auto origin = this->m_primitivesConverter->ConvertPoint( line->m_Pnt );
             const auto direction = AVector::Normalized( this->m_primitivesConverter->ConvertVector( line->m_Dir ) );
-            return {
+            result = {
                 origin - direction * this->m_parameters->m_modelMaxSize * 0.5f,
                 origin + direction * this->m_parameters->m_modelMaxSize * 0.5f,
             };
@@ -224,23 +244,28 @@ class CurveConverter {
         const auto offset_curve_2d = dynamic_pointer_cast<IfcOffsetCurve2D>( curve );
         if( offset_curve_2d ) {
             // TODO: implement
-            return {};
+            result = {};
         }
 
         const auto offset_curve_3d = dynamic_pointer_cast<IfcOffsetCurve3D>( curve );
         if( offset_curve_3d ) {
             // TODO: implement
-            return {};
+            result = {};
         }
 
         const auto pcurve = dynamic_pointer_cast<IfcPcurve>( curve );
         if( pcurve ) {
             // TODO: implement
-            return {};
+            result = {};
         }
 
-        // TODO: Log error
-        return {};
+        {
+#ifdef ENABLE_OPENMP
+            ScopedLock lock( this->m_curveToPointsMapMutex );
+#endif
+            this->m_curveToPointsMap[ curve ] = result;
+        }
+        return result;
     }
 
     TCurve TrimCurve( const TCurve& curve, const TVector& t1, const TVector& t2 ) {
@@ -291,7 +316,7 @@ class CurveConverter {
             return { l, M_PI * 2 - l + r };
         }
         if( !senseAgreement && l < r ) {
-            return { l, -l - (M_PI * 2 - r)};
+            return { l, -l - ( M_PI * 2 - r ) };
         }
         if( !senseAgreement && l > r ) {
             return { l, l - r };

include/ifcpp/Geometry/Extruder.h

@@ -88,9 +88,9 @@ class Extruder {
         for( int i = 1; i < sweepPoints.size() - 1; i++ ) {
             fDirs.push_back( AVector::Normalized( AVector::Normalized( sweepPoints[ i ] - sweepPoints[ i - 1 ] ) +
                                                   AVector::Normalized( sweepPoints[ i + 1 ] - sweepPoints[ i ] ) ) );
-            float angle = std::acosf( AVector::Dot( AVector::Normalized( sweepPoints[ i ] - sweepPoints[ i - 1 ] ),
+            float angle = acosf( AVector::Dot( AVector::Normalized( sweepPoints[ i ] - sweepPoints[ i - 1 ] ),
                                                     AVector::Normalized( sweepPoints[ i ] - sweepPoints[ i + 1 ] ) ) );
-            k.push_back( 1.0f / std::sinf( angle / 2.0f ) );
+            k.push_back( 1.0f / sinf( angle / 2.0f ) );
         }
         fDirs.push_back( AVector::Normalized( sweepPoints[ sweepPoints.size() - 1 ] - sweepPoints[ sweepPoints.size() - 2 ] ) );
         k.push_back( 1.0f );

include/ifcpp/Geometry/GeomUtils.h

@@ -159,22 +159,21 @@ class GeomUtils {
         std::copy( std::begin( toAppend ), std::end( toAppend ), std::back_inserter( *loop ) );
     }
     std::vector<TVector> CombineLoops( std::vector<std::vector<TVector>> loops ) {
-        while( !loops.empty() && loops[ 0 ].size() < 3 ) {
-            loops.erase( std::begin( loops ) );
+        for( int i = 0; i < loops.size(); i++ ) {
+            if( loops[i].size() < 3 ) {
+                loops.erase( loops.begin() + i );
+                i--;
+            }
         }
-
         if( loops.empty() ) {
             return {};
         }
 
-        auto planeNormal = this->ComputePolygonNormal( loops[ 0 ] );
-        const Plane<TVector> p( loops[ 0 ][ 0 ], planeNormal );
-
-
-        for( auto& l: loops ) {
-            l = p.GetProjection( l );
-        }
-
+//        auto planeNormal = this->ComputePolygonNormal( loops[ 0 ] );
+//        const Plane<TVector> p( loops[ 0 ][ 0 ], planeNormal );
+//        for( auto& l: loops ) {
+//            l = p.GetProjection( l );
+//        }
 
         for( auto& l: loops ) {
             if( !l.empty() ) {
@@ -234,7 +233,7 @@ class GeomUtils {
             result.insert( std::begin( result ) + inResultIdx, result[ inResultIdx ] );
             result.insert( std::begin( result ) + inResultIdx + 1, std::begin( loopToInsert ), std::end( loopToInsert ) );
         }
-        result = p.GetUnProjected( result );
+        //result = p.GetUnProjected( result );
         return this->SimplifyLoop( result );
     }
     std::vector<TVector> IncorporateHoles( const std::vector<TVector>& outer, std::vector<std::vector<TVector>> inners ) {
@@ -339,7 +338,7 @@ class GeomUtils {
             const auto center_p0_normalized = AVector::Normalized( center_p0 );
             const auto center_p2_normalized = AVector::Normalized( center_p2 );
 
-            const float openingAngle = std::acos( AVector::Dot( center_p0_normalized, center_p2_normalized ) );
+            const float openingAngle = acosf( AVector::Dot( center_p0_normalized, center_p2_normalized ) );
             int n = (int)( this->m_parameters->m_numVerticesPerCircle * openingAngle / ( M_PI * 2.0f ) );
             n = std::max( n, this->m_parameters->m_minNumVerticesPerArc );
 
@@ -370,7 +369,7 @@ class GeomUtils {
                     if( AVector::Len2( normal ) > AVector::Len2( planeNormal ) ) {
                         planeNormal = normal;
                     }
-                    if( AVector::Len2( planeNormal ) > this->m_parameters->m_epsilon ) {
+                    if( AVector::Len2( planeNormal ) > this->m_parameters->m_epsilon * this->m_parameters->m_epsilon ) {
                         goto BREAK;
                     }
                 }
@@ -384,6 +383,11 @@ class GeomUtils {
         loop = p.GetProjection( loop );
         loop.push_back( loop[ 0 ] );
 
+        BoundingBox<TVector> bbox( loop );
+        for( auto& v: loop ) {
+            v = v - bbox.m_min;
+        }
+
         float s = 0.0f;
         for( int i = 1; i < loop.size(); i++ ) {
             const auto& v1 = loop[ i - 1 ];