Refactorizing all 2

Author: juanmafont

CMakeLists.txt

@@ -72,16 +72,26 @@ set(CORE_SOURCES
     src/core/arguments/parsing/OptionsConverter.cpp
     src/core/engine/Engine.cpp
     src/core/engine/Initialization.cpp
+    src/core/engine/initialization/CalibrationHandler.cpp
+    src/core/engine/initialization/ConfigReporter.cpp
+    src/core/engine/initialization/FileSorter.cpp
+    src/core/engine/initialization/InputFileFilter.cpp
     src/core/engine/PatchAnalysisStrategy.cpp
+    src/core/engine/processing/AnalysisLoopRunner.cpp
     src/core/engine/processing/CornerDetectionHandler.cpp
     src/core/engine/processing/Processing.cpp
     src/core/engine/processing/ResultAggregator.cpp
     src/core/engine/Reporting.cpp
     src/core/engine/Validation.cpp
     src/core/graphics/ChartGenerator.cpp
     src/core/graphics/detection/ChartCornerDetector.cpp
+    src/core/graphics/drawing/AxisDrawer.cpp
+    src/core/graphics/drawing/AxisLabelDrawer.cpp
     src/core/graphics/drawing/CurveDrawer.cpp
+    src/core/graphics/drawing/FooterDrawer.cpp
+    src/core/graphics/drawing/GridDrawer.cpp    
     src/core/graphics/drawing/LabelDrawer.cpp
+    src/core/graphics/drawing/TitleDrawer.cpp
     src/core/graphics/FontManager.cpp
     src/core/graphics/geometry/KeystoneCorrection.cpp
     src/core/graphics/ImageProcessing.cpp
@@ -92,11 +102,13 @@ set(CORE_SOURCES
     src/core/graphics/PlotOrchestrator.cpp
     src/core/graphics/Plotting.cpp
     src/core/io/OutputWriter.cpp
-    src/core/io/RawFile.cpp
+    src/core/io/raw/RawFile.cpp
+    src/core/io/raw/RawImageAccessor.cpp
+    src/core/io/raw/RawLoader.cpp
+    src/core/io/raw/RawMetadataExtractor.cpp
     src/core/math/Math.cpp
     src/core/setup/CalibrationEstimator.cpp
     src/core/setup/ChartProfile.cpp
-    src/core/setup/FileSorter.cpp
     src/core/setup/MetadataExtractor.cpp
     src/core/setup/PlotLabelGenerator.cpp
     src/core/setup/SensorResolution.cpp

src/core/analysis/RawProcessor.cpp

@@ -5,7 +5,7 @@
  * calibration.
  */
 #include "RawProcessor.hpp"
-#include "../io/RawFile.hpp"
+#include "../io/raw/RawFile.hpp"
 #include "../math/Math.hpp"
 #include <iomanip>
 #include <iostream>

src/core/engine/Initialization.cpp

@@ -1,214 +1,56 @@
 // File: src/core/engine/Initialization.cpp
 /**
  * @file src/core/engine/Initialization.cpp
- * @brief Implementation of the analysis initialization process.
+ * @brief Implementation of the analysis initialization process orchestration.
  */
 #include "Initialization.hpp"
-#include "../analysis/RawProcessor.hpp"
-#include "../setup/CalibrationEstimator.hpp"
-#include "../setup/FileSorter.hpp"
+#include "initialization/InputFileFilter.hpp"
+#include "initialization/CalibrationHandler.hpp"
+#include "initialization/ConfigReporter.hpp"
+#include "initialization/FileSorter.hpp"
 #include "../setup/MetadataExtractor.hpp"
 #include "../setup/PlotLabelGenerator.hpp"
 #include "../setup/SensorResolution.hpp"
 #include "../utils/CommandGenerator.hpp"
-#include <algorithm>
-#include <cstring>
-#include <filesystem>
-#include <iomanip>
 #include <libintl.h>
-#include <set> 
 
 #define _(string) gettext(string)
 
-namespace fs = std::filesystem;
-
 bool InitializeAnalysis(ProgramOptions& opts, std::ostream& log_stream) {
+    
+    const DynaRange::Engine::Initialization::InputFileFilter file_filter;
+    file_filter.Filter(opts, log_stream);
 
-    // --- 1. Exclude Calibration Files from Analysis ---
-    if (!opts.dark_file_path.empty() || !opts.sat_file_path.empty()) {
-        std::set<std::string> calibration_files;
-        if (!opts.dark_file_path.empty()) {
-            calibration_files.insert(opts.dark_file_path);
-        }
-        if (!opts.sat_file_path.empty()) {
-            calibration_files.insert(opts.sat_file_path);
-        }
-
-        std::vector<std::string> files_to_remove;
-        auto original_size = opts.input_files.size();
-
-        opts.input_files.erase(
-            std::remove_if(opts.input_files.begin(), opts.input_files.end(),
-                [&](const std::string& input_file) {
-                    if (calibration_files.count(input_file)) {
-                        files_to_remove.push_back(input_file);
-                        return true;
-                    }
-                    return false;
-                }),
-            opts.input_files.end()
-        );
-
-        if (!files_to_remove.empty()) {
-            log_stream << _("[INFO] The following files were excluded from the analysis because they are used for calibration:") << std::endl;
-            for (const auto& file : files_to_remove) {
-                log_stream << "  - " << fs::path(file).filename().string() << std::endl;
-            }
-        }
-    }
-
-    // --- 2. Deduplicate Input Files ---
-    if (!opts.input_files.empty()) {
-        std::vector<std::string> unique_files;
-        std::set<std::string> seen_files;
-        unique_files.reserve(opts.input_files.size());
-        for (const auto& file : opts.input_files) {
-            if (seen_files.insert(file).second) {
-                unique_files.push_back(file);
-            } else {
-                log_stream << _("Warning: Duplicate input file ignored: ") << file << std::endl;
-            }
-        }
-        opts.input_files = unique_files;
+    if (opts.input_files.empty()) {
+        log_stream << _("Error: No valid input files remain after filtering for calibration files.") << std::endl;
+        return false;
     }
 
-    // --- 3. Pre-analysis of all files to get metadata (moved to the beginning) ---
     log_stream << _("Pre-analyzing files to extract metadata...") << std::endl;
     auto file_info = 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;
     }
 
-    // --- 4. DEFAULT CALIBRATION ESTIMATION (now uses pre-analyzed data) ---
-    if (opts.dark_file_path.empty() && opts.black_level_is_default) {
-        log_stream << _("[INFO] Black level not specified. Attempting to estimate from RAW file...") << std::endl;
-        auto estimated_black = CalibrationEstimator::EstimateBlackLevel(opts, file_info, log_stream);
-        if (estimated_black) {
-            opts.dark_value = *estimated_black;
-        } else {
-            log_stream << _("[Warning] Could not estimate black level. Using fallback default value: ") 
-                       << opts.dark_value << std::endl;
-        }
-    }
-
-    if (opts.sat_file_path.empty() && opts.saturation_level_is_default) {
-        log_stream << _("[INFO] Saturation level not specified. Attempting to estimate from RAW file...") << std::endl;
-        auto estimated_sat = CalibrationEstimator::EstimateSaturationLevel(opts, file_info, log_stream);
-        if (estimated_sat) {
-            opts.saturation_value = *estimated_sat;
-        } else {
-            log_stream << _("[Warning] Could not estimate saturation level. Using fallback default value: ")
-                       << opts.saturation_value << std::endl;
-        }
-    }
-
-    // --- 5. CALIBRATION FROM EXPLICIT FILES ---
-    if (!opts.dark_file_path.empty()) {
-        auto dark_val_opt = ProcessDarkFrame(opts.dark_file_path, log_stream);
-        if (!dark_val_opt) { log_stream << _("Fatal error processing dark frame.") << std::endl; return false;
-        }
-        opts.dark_value = *dark_val_opt;
-    }
-    if (!opts.sat_file_path.empty()) {
-        auto sat_val_opt = ProcessSaturationFrame(opts.sat_file_path, log_stream);
-        if (!sat_val_opt) { log_stream << _("Fatal error processing saturation frame.") << std::endl; return false;
-        }
-        opts.saturation_value = *sat_val_opt;
-    }
-
-    // --- 6. SETUP PROCESS ORCHESTRATION (using already extracted metadata) ---
-    // --- Print table with dynamic widths ---
-    size_t max_file_width = strlen("File");
-    size_t max_bright_width = strlen("Brightness");
-    size_t max_iso_width = strlen("ISO");
-
-    for (const auto& info : file_info) {
-        max_file_width = std::max(max_file_width, fs::path(info.filename).filename().string().length());
-        std::stringstream bright_ss;
-        bright_ss << std::fixed << std::setprecision(2) << info.mean_brightness;
-        max_bright_width = std::max(max_bright_width, bright_ss.str().length());
-
-        std::stringstream iso_ss;
-        iso_ss << static_cast<int>(info.iso_speed);
-        max_iso_width = std::max(max_iso_width, iso_ss.str().length());
-    }
-
-    max_file_width += 2;
-    max_bright_width += 2;
-    max_iso_width += 2;
-    log_stream << "\n" << _("Sorting files based on pre-analyzed data:") << std::endl;
-    log_stream << "  " << std::left << std::setw(max_file_width) << "File"
-               << std::right << std::setw(max_bright_width) << "Brightness"
-               << std::right << std::setw(max_iso_width) << "ISO" << std::endl;
-    log_stream << "  " << std::string(max_file_width + max_bright_width + max_iso_width, '-') << std::endl;
-    for (const auto& info : file_info) {
-        log_stream << "  " << std::left << std::setw(max_file_width) << fs::path(info.filename).filename().string()
-                   << std::right << std::setw(max_bright_width) << std::fixed << std::setprecision(2) << info.mean_brightness
-                   << std::right << std::setw(max_iso_width) << static_cast<int>(info.iso_speed) << std::endl;
+    const DynaRange::Engine::Initialization::CalibrationHandler calib_handler;
+    if (!calib_handler.HandleCalibration(opts, file_info, log_stream)) {
+        return false; // Fatal error during calibration file processing
     }
 
+    const DynaRange::Engine::Initialization::ConfigReporter reporter;
+    reporter.PrintPreAnalysisTable(file_info, log_stream);
+
     FileOrderResult order = DetermineFileOrder(file_info, log_stream);
-    std::map<std::string, std::string> labels = GeneratePlotLabels(
-        order.sorted_filenames,
-        file_info,
-        order.was_exif_sort_possible
-    );
     opts.input_files = order.sorted_filenames;
-    opts.plot_labels = labels;
+    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);
     }
-
-    // --- 7. PRINT FINAL CONFIGURATION ---
-    log_stream << std::fixed << std::setprecision(2);
-    log_stream << "\n" << _("[Final configuration]") << std::endl;
-    log_stream << _("Black level: ") << opts.dark_value 
-               << (opts.black_level_is_default ? _(" (estimated)") : "") << std::endl;
-    log_stream << _("Saturation point: ") << opts.saturation_value 
-               << (opts.saturation_level_is_default ? _(" (estimated)") : "") << std::endl;
-    // New logic to dynamically build the list of channels to be analyzed.
-    std::vector<std::string> selected_channels;
-    if (opts.raw_channels.R) selected_channels.push_back("R");
-    if (opts.raw_channels.G1) selected_channels.push_back("G1");
-    if (opts.raw_channels.G2) selected_channels.push_back("G2");
-    if (opts.raw_channels.B) selected_channels.push_back("B");
-    if (opts.raw_channels.AVG) selected_channels.push_back("AVG");
-
-    std::stringstream channels_ss;
-    for(size_t i = 0; i < selected_channels.size(); ++i) {
-        channels_ss << selected_channels[i] << (i < selected_channels.size() - 1 ? ", " : "");
-    }
 
-    std::string channel_label = (selected_channels.size() > 1) ?
-_("Analysis channels: ") : _("Analysis channel: ");
-    log_stream << channel_label << channels_ss.str() << std::endl;
-    if (opts.sensor_resolution_mpx > 0.0) {
-        log_stream << _("Sensor resolution: ") << opts.sensor_resolution_mpx << _(" Mpx") << std::endl;
-    }
-    log_stream << _("SNR threshold(s): ");
-    for(size_t i = 0; i < opts.snr_thresholds_db.size(); ++i) {
-        log_stream << opts.snr_thresholds_db[i] << (i == opts.snr_thresholds_db.size() - 1 ? "" : ", ");
-    }
-    log_stream << _(" dB") << std::endl;
-    log_stream << _("DR normalization: ") << opts.dr_normalization_mpx << _(" Mpx") << std::endl;
-    log_stream << _("Polynomic order: ") << opts.poly_order << std::endl;
-    log_stream << _("Patch ratio: ") << opts.patch_ratio << std::endl;
-    log_stream << _("Plotting: ");
-    if (!opts.generate_plot) {
-        log_stream << _("No graphics") << std::endl;
-    } else {
-        switch (opts.plot_command_mode) {
-            case 1: log_stream << _("Graphics without command CLI") << std::endl;
-            break;
-            case 2: log_stream << _("Graphics with short command CLI") << std::endl; break;
-            case 3: log_stream << _("Graphics with long command CLI") << std::endl; break;
-            default: log_stream << _("Graphics enabled") << std::endl; break;
-        }
-    }
+    reporter.PrintFinalConfiguration(opts, log_stream);
 
-    log_stream << _("Output file: ") << opts.output_filename << "\n" << std::endl;
     if (opts.plot_command_mode == 2) {
         opts.generated_command = CommandGenerator::GenerateCommand(CommandFormat::PlotShort);
     } else if (opts.plot_command_mode == 3) {

src/core/engine/initialization/CalibrationHandler.cpp

@@ -0,0 +1,61 @@
+// File: src/core/engine/initialization/CalibrationHandler.cpp
+/**
+ * @file CalibrationHandler.cpp
+ * @brief Implements the sensor calibration logic.
+ */
+#include "CalibrationHandler.hpp"
+#include "../../analysis/RawProcessor.hpp"
+#include "../../setup/CalibrationEstimator.hpp"
+#include <libintl.h>
+
+#define _(string) gettext(string)
+
+namespace DynaRange::Engine::Initialization {
+
+bool CalibrationHandler::HandleCalibration(ProgramOptions& opts, const std::vector<FileInfo>& file_info, std::ostream& log_stream) const
+{
+    // --- 1. DEFAULT CALIBRATION ESTIMATION ---
+    if (opts.dark_file_path.empty() && opts.black_level_is_default) {
+        log_stream << _("[INFO] Black level not specified. Attempting to estimate from RAW file...") << std::endl;
+        auto estimated_black = CalibrationEstimator::EstimateBlackLevel(opts, file_info, log_stream);
+        if (estimated_black) {
+            opts.dark_value = *estimated_black;
+        } else {
+            log_stream << _("[Warning] Could not estimate black level. Using fallback default value: ") 
+                       << opts.dark_value << std::endl;
+        }
+    }
+
+    if (opts.sat_file_path.empty() && opts.saturation_level_is_default) {
+        log_stream << _("[INFO] Saturation level not specified. Attempting to estimate from RAW file...") << std::endl;
+        auto estimated_sat = CalibrationEstimator::EstimateSaturationLevel(opts, file_info, log_stream);
+        if (estimated_sat) {
+            opts.saturation_value = *estimated_sat;
+        } else {
+            log_stream << _("[Warning] Could not estimate saturation level. Using fallback default value: ")
+                       << opts.saturation_value << std::endl;
+        }
+    }
+
+    // --- 2. CALIBRATION FROM EXPLICIT FILES (overwrites estimates) ---
+    if (!opts.dark_file_path.empty()) {
+        auto dark_val_opt = ProcessDarkFrame(opts.dark_file_path, log_stream);
+        if (!dark_val_opt) { 
+            log_stream << _("Fatal error processing dark frame.") << std::endl; 
+            return false;
+        }
+        opts.dark_value = *dark_val_opt;
+    }
+    if (!opts.sat_file_path.empty()) {
+        auto sat_val_opt = ProcessSaturationFrame(opts.sat_file_path, log_stream);
+        if (!sat_val_opt) { 
+            log_stream << _("Fatal error processing saturation frame.") << std::endl; 
+            return false;
+        }
+        opts.saturation_value = *sat_val_opt;
+    }
+    
+    return true;
+}
+
+} // namespace DynaRange::Engine::Initialization

src/core/engine/initialization/CalibrationHandler.hpp

@@ -0,0 +1,38 @@
+// File: src/core/engine/initialization/CalibrationHandler.hpp
+/**
+ * @file CalibrationHandler.hpp
+ * @brief Declares a component for handling sensor calibration.
+ * @details This module adheres to SRP by encapsulating all logic related to
+ * determining the black and saturation levels, either by estimating them or by
+ * processing dedicated calibration files.
+ */
+#pragma once
+
+#include "../../arguments/ArgumentsOptions.hpp"
+#include "../../setup/MetadataExtractor.hpp" // For FileInfo
+#include <ostream>
+
+namespace DynaRange::Engine::Initialization {
+
+/**
+ * @class CalibrationHandler
+ * @brief Manages the determination of black and saturation levels.
+ */
+class CalibrationHandler {
+public:
+    /**
+     * @brief Determines the final black and saturation values.
+     * @details This function follows a clear priority:
+     * 1. If explicit calibration files are provided in `opts`, it processes them.
+     * 2. Otherwise, if default values are being used, it attempts to estimate them.
+     * 3. If estimation fails, it falls back to the hardcoded default values.
+     * The function modifies the ProgramOptions object directly.
+     * @param opts A reference to the program options, which will be updated.
+     * @param file_info A vector of pre-analyzed file metadata for estimation.
+     * @param log_stream The output stream for logging messages.
+     * @return true on success, false if a fatal error occurs during processing.
+     */
+    bool HandleCalibration(ProgramOptions& opts, const std::vector<FileInfo>& file_info, std::ostream& log_stream) const;
+};
+
+} // namespace DynaRange::Engine::Initialization