Real parallel processing

Author: juanmafont

src/core/engine/Engine.cpp

@@ -25,12 +25,14 @@ namespace DynaRange {
  */
 ReportOutput RunDynamicRangeAnalysis(ProgramOptions& opts, std::ostream& log_stream, const std::atomic<bool>& cancel_flag) {
     // Phase 1: Preparation
-    if (!InitializeAnalysis(opts, log_stream)) {
-        return {}; // Return an empty ReportOutput on failure
+    auto [init_success, loaded_raw_files] = InitializeAnalysis(opts, log_stream);
+    if (!init_success) {
+        return {};
+        // Return an empty ReportOutput on failure
     }
 
     // Phase 2: Processing of all files
-    ProcessingResult results = ProcessFiles(opts, log_stream, cancel_flag);
+    ProcessingResult results = ProcessFiles(opts, log_stream, cancel_flag, loaded_raw_files);
 
     // Check if the user cancelled the operation during processing
     if (cancel_flag) {
@@ -40,10 +42,10 @@ ReportOutput RunDynamicRangeAnalysis(ProgramOptions& opts, std::ostream& log_str
 
     // Phase 3: Validate SNR data before final reporting
     ValidateSnrResults(results, opts, log_stream);
-
+    
     // Phase 4: Generation of final reports
     ReportOutput report = FinalizeAndReport(results, opts, log_stream);
-
+    
     // Populate the new dr_results member with the sorted results.
     // for combining the report artifacts with the numerical results
     // Needed when click event on grid results.csv and show graphic at GUI

src/core/engine/Engine.hpp

@@ -11,5 +11,6 @@
 #include <atomic>
 
 namespace DynaRange {
+    // This declaration does not need to change as the new parameter is an internal detail.
     ReportOutput RunDynamicRangeAnalysis(ProgramOptions& opts, std::ostream& log_stream, const std::atomic<bool>& cancel_flag);
 }

src/core/engine/Initialization.cpp

@@ -12,30 +12,34 @@
 #include "../setup/PlotLabelGenerator.hpp"
 #include "../setup/SensorResolution.hpp"
 #include "../utils/CommandGenerator.hpp"
+#include "../io/raw/RawFile.hpp"
 #include <libintl.h>
+#include <utility> // For std::pair and std::move
 
 #define _(string) gettext(string)
 
-bool InitializeAnalysis(ProgramOptions& opts, std::ostream& log_stream) {
+std::pair<bool, std::vector<RawFile>> InitializeAnalysis(ProgramOptions& opts, std::ostream& log_stream) {
 
     const DynaRange::Engine::Initialization::InputFileFilter file_filter;
     file_filter.Filter(opts, log_stream);
 
     if (opts.input_files.empty()) {
         log_stream << _("Error: No valid input files remain after filtering for calibration files.") << std::endl;
-        return false;
+        return {false, std::vector<RawFile>{}};
     }
 
     log_stream << _("Pre-analyzing files to extract metadata...") << std::endl;
-    auto file_info = ExtractFileInfo(opts.input_files, log_stream);
+    auto [file_info, loaded_raw_files] = ExtractFileInfo(opts.input_files, log_stream);
+    
     if (file_info.empty()) {
         log_stream << _("Error: None of the input files could be processed.") << std::endl;
-        return false;
+        return {false, std::vector<RawFile>{}};
     }
 
     const DynaRange::Engine::Initialization::CalibrationHandler calib_handler;
     if (!calib_handler.HandleCalibration(opts, file_info, log_stream)) {
-        return false; // Fatal error during calibration file processing
+        return {false, std::vector<RawFile>{}};
+        // Fatal error during calibration file processing
     }
 
     const DynaRange::Engine::Initialization::ConfigReporter reporter;
@@ -44,7 +48,7 @@ bool InitializeAnalysis(ProgramOptions& opts, std::ostream& log_stream) {
     FileOrderResult order = DetermineFileOrder(file_info, log_stream);
     opts.input_files = order.sorted_filenames;
     opts.plot_labels = GeneratePlotLabels(order.sorted_filenames, file_info, order.was_exif_sort_possible);
-
+    
     if (opts.sensor_resolution_mpx == 0.0) {
         opts.sensor_resolution_mpx = DetectSensorResolution(opts.input_files, log_stream);
     }
@@ -57,5 +61,5 @@ bool InitializeAnalysis(ProgramOptions& opts, std::ostream& log_stream) {
         opts.generated_command = CommandGenerator::GenerateCommand(CommandFormat::PlotLong);
     }
 
-    return true;
+    return {true, std::move(loaded_raw_files)};
 }

src/core/engine/Initialization.hpp

@@ -5,15 +5,14 @@
  */
 #pragma once
 #include "../arguments/ArgumentsOptions.hpp"
+#include "../io/raw/RawFile.hpp"
 #include <ostream>
 
 /**
  * @brief Prepares the analysis environment.
- * @details This function processes dark and saturation frames if provided,
- * prints the final configuration to the log, sorts the input files,
- * and generates a command string for plotting purposes.
+ * @details This function processes dark/saturation frames, sorts input files, etc.
  * @param opts A reference to the program options, which will be updated.
  * @param log_stream The output stream for logging messages.
- * @return true if initialization is successful, false otherwise.
+ * @return A pair containing a boolean for success and the vector of loaded RawFile objects.
  */
-bool InitializeAnalysis(ProgramOptions& opts, std::ostream& log_stream);
+std::pair<bool, std::vector<RawFile>> InitializeAnalysis(ProgramOptions& opts, std::ostream& log_stream);

src/core/engine/PatchAnalysisStrategy.cpp

@@ -7,6 +7,7 @@
 #include "../analysis/ImageAnalyzer.hpp"
 #include "../utils/Formatters.hpp"
 #include <libintl.h>
+#include <mutex>
 
 #define _(string) gettext(string)
 
@@ -21,7 +22,8 @@ PatchAnalysisResult PerformTwoPassPatchAnalysis(
     double strict_min_snr_db,
     double permissive_min_snr_db,
     double max_requested_threshold,
-    bool create_overlay_image)
+    bool create_overlay_image,
+    std::mutex& log_mutex)
 {
     // --- Pass 1: Analyze with the strict threshold ---
     PatchAnalysisResult patch_data = AnalyzePatches(prepared_image, chart.GetGridCols(), chart.GetGridRows(), opts.patch_ratio, create_overlay_image, strict_min_snr_db);
@@ -38,21 +40,24 @@ PatchAnalysisResult PerformTwoPassPatchAnalysis(
                 }
             }
         }
-        // Check if the lowest SNR found is still above the highest requested threshold.
         if (min_snr_found > max_requested_threshold) {
             needs_reanalysis = true;
         }
     }
 
     // --- Pass 2 (Conditional): Re-analyze with the permissive threshold ---
     if (needs_reanalysis) {
-        log_stream << "  - Info: Re-analyzing channel " << Formatters::DataSourceToString(channel) 
-                   << " with permissive threshold to find low-SNR data."
-                   << std::endl;
+        {
+            std::lock_guard<std::mutex> lock(log_mutex);
+            log_stream << "  - Info: Re-analyzing channel " << Formatters::DataSourceToString(channel) 
+                       << " with permissive threshold to find low-SNR data."
+                       << std::endl;
+        }
         patch_data = AnalyzePatches(prepared_image, chart.GetGridCols(), chart.GetGridRows(), opts.patch_ratio, create_overlay_image, permissive_min_snr_db);
     }
 
     if (patch_data.signal.empty()) {
+        std::lock_guard<std::mutex> lock(log_mutex);
         log_stream << _("Warning: No valid patches found for channel: ") << Formatters::DataSourceToString(channel) << std::endl;
     }
 

src/core/engine/PatchAnalysisStrategy.hpp

@@ -1,4 +1,8 @@
 // File: src/core/engine/PatchAnalysisStrategy.hpp
+/**
+ * @file PatchAnalysisStrategy.hpp
+ * @brief Implements the two-pass patch analysis strategy.
+ */
 /**
  * @file PatchAnalysisStrategy.hpp
  * @brief Declares the function for executing the two-pass patch analysis strategy.
@@ -13,6 +17,7 @@
 #include "../arguments/ArgumentsOptions.hpp"
 #include "../setup/ChartProfile.hpp"
 #include <ostream>
+#include <mutex>
 
 namespace DynaRange::Engine {
 
@@ -32,6 +37,7 @@ namespace DynaRange::Engine {
  * @param permissive_min_snr_db The permissive minimum SNR threshold for the second pass.
  * @param max_requested_threshold The highest SNR threshold requested by the user, used for validation.
  * @param create_overlay_image Flag to indicate if an overlay image should be generated.
+ * @param log_mutex A mutex to synchronize access to the log_stream.
  * @return A PatchAnalysisResult struct containing the signal, noise, and optional overlay image from the chosen pass.
  */
 PatchAnalysisResult PerformTwoPassPatchAnalysis(
@@ -43,7 +49,8 @@ PatchAnalysisResult PerformTwoPassPatchAnalysis(
     double strict_min_snr_db,
     double permissive_min_snr_db,
     double max_requested_threshold,
-    bool create_overlay_image
+    bool create_overlay_image,
+    std::mutex& log_mutex
 );
 
 } // namespace DynaRange::Engine