ModelLoader and progress changed callback (#11)

Author: ExternPointer

include/ifcpp/Geometry/GeometryGenerator.h

@@ -3,6 +3,8 @@
 #include <map>
 #include <memory>
 #include <vector>
+#include <functional>
+#include <atomic>
 
 #include "ifcpp/Geometry/CAdapter.h"
 #include "ifcpp/Geometry/CurveConverter.h"
@@ -109,7 +111,7 @@ class GeometryGenerator {
         this->m_parameters->m_angleFactor = ifcModel->getUnitConverter()->getAngleInRadiantFactor();
     }
 
-    std::vector<TEntity> GenerateGeometry() {
+    std::vector<TEntity> GenerateGeometry( const std::function<void(double)>& onProgressChanged ) {
         this->ResetCaches();
         std::vector<TEntity> entities;
 
@@ -122,16 +124,24 @@ class GeometryGenerator {
         const auto ifcEntitiesPtr = &ifcEntities;
         const auto ifcEntitiesCount = ifcEntities.size();
         const auto entitiesPtr = &entities;
+        std::atomic<size_t> processedCount = 0;
 
 #ifdef ENABLE_OPENMP
         Mutex entitiesPtrMutex;
-#pragma omp parallel default( none ) shared( entitiesPtrMutex, ifcEntitiesCount, ifcEntitiesPtr, entitiesPtr )
+#pragma omp parallel default( none ) shared( entitiesPtrMutex, ifcEntitiesCount, ifcEntitiesPtr, entitiesPtr, onProgressChanged, processedCount )
         {
             std::vector<TEntity> entitiesPerThread;
             entitiesPerThread.reserve( 1000 );
 #pragma omp for schedule( dynamic, 1000 )
 #endif
             for( int i = 0; i < ifcEntitiesCount; i++ ) {
+                if( !(++processedCount % 100000) ) {
+                    auto progress = (double)processedCount / (double)ifcEntitiesCount;
+                    if( progress < 1 ) {
+                        onProgressChanged( (double)processedCount / (double)ifcEntitiesCount );
+                    }
+                }
+
                 const auto object = std::dynamic_pointer_cast<IfcObjectDefinition>( ifcEntitiesPtr->at( i ) );
                 if( !object ) {
                     continue;
@@ -156,6 +166,7 @@ class GeometryGenerator {
             }
         }
 #endif
+        onProgressChanged( 1 );
         return entities;
     }
 

include/ifcpp/ModelLoader.h

@@ -1,8 +1,46 @@
 #pragma once
 
+#include "ifcpp/Geometry/CAdapter.h"
+#include "ifcpp/Model/BuildingModel.h"
+#include "ifcpp/Reader/ReaderSTEP.h"
+#include <ifcpp/Geometry/GeometryGenerator.h>
 
 namespace ifcpp {
 
+template<CAdapter TAdapter>
+std::vector<typename TAdapter::TEntity> LoadModel( const std::string& filePath, const std::shared_ptr<Parameters>& parameters, const std::function<void(double)>& onProgressChanged ) {
 
+    auto readerMessageCallback = [onProgressChanged]( const std::shared_ptr<StatusCallback::Message>& message ) {
+        if( message->m_type == StatusCallback::PROGRESS_CHANGED ) {
+            onProgressChanged( message->m_progress * 0.5 );
+        }
+    };
+
+    auto geometryGeneratorProgressChangedCallback = [onProgressChanged]( double progress ) {
+        onProgressChanged( 0.5 + progress * 0.5 );
+    };
+
+    auto ifcModel = std::make_shared<BuildingModel>();
+    auto reader = std::make_shared<ReaderSTEP>();
+    reader->SetMessageCallBack( readerMessageCallback );
+    reader->loadModelFromFile( filePath, ifcModel );
+    auto adapter = std::make_shared<TAdapter>();
+    auto styleConverter = std::make_shared<ifcpp::StyleConverter>();
+    auto geomUtils = std::make_shared<ifcpp::GeomUtils<typename TAdapter::TVector>>( parameters );
+    auto primitivesConverter = std::make_shared<ifcpp::PrimitiveTypesConverter<typename TAdapter::TVector>>();
+    auto splineConverter = std::make_shared<ifcpp::SplineConverter<typename TAdapter::TVector>>( primitivesConverter, geomUtils, parameters );
+    auto curveConverter = std::make_shared<ifcpp::CurveConverter<typename TAdapter::TVector>>( primitivesConverter, geomUtils, splineConverter, parameters );
+    auto extruder = std::make_shared<ifcpp::Extruder<typename TAdapter::TVector>>( geomUtils, parameters );
+    auto profileConverter = std::make_shared<ifcpp::ProfileConverter<typename TAdapter::TVector>>( curveConverter, geomUtils, primitivesConverter, parameters );
+    auto geometryConverter = std::make_shared<ifcpp::GeometryConverter<typename TAdapter::TVector>>( curveConverter, primitivesConverter, splineConverter,
+                                                                                                     geomUtils, extruder, profileConverter, parameters );
+    auto solidConverter = std::make_shared<ifcpp::SolidConverter<TAdapter>>( primitivesConverter, curveConverter, profileConverter, extruder, geometryConverter,
+                                                                             adapter, geomUtils, styleConverter, parameters );
+    auto geometryGenerator =
+        std::make_shared<ifcpp::GeometryGenerator<TAdapter>>( ifcModel, adapter, curveConverter, extruder, geometryConverter, geomUtils, primitivesConverter,
+                                                              profileConverter, solidConverter, splineConverter, styleConverter, parameters );
+
+    return geometryGenerator->GenerateGeometry( geometryGeneratorProgressChangedCallback );
+}
 
 }