Add ISO to dataframe

Author: juanmafont

src/core/analysis/Analysis.hpp

@@ -14,7 +14,6 @@
 // --- STRUCTURE DEFINITIONS ---
 
 enum class DataSource { R, G1, G2, B, AVG };
-
 /**
  * @struct PointData
  * @brief Holds the data for a single plotted point, including its source channel.
@@ -28,6 +27,7 @@ struct PointData {
 struct DynamicRangeResult {
     std::string filename;
     DataSource channel;
+    float iso_speed = 0.0f;
     std::map<double, double> dr_values_ev;
     int samples_R = 0;
     int samples_G1 = 0;
@@ -57,7 +57,8 @@ struct CurveData {
 };
 
 struct SnrCurve {
-    std::vector<PointData> points; // Replaced separate signal_ev and snr_db vectors
+    std::vector<PointData> points;
+    // Replaced separate signal_ev and snr_db vectors
     cv::Mat poly_coeffs;
 };
 

src/core/arguments/ArgumentManager.cpp

@@ -0,0 +1,43 @@
+// File: src/core/arguments/Constants.hpp
+/**
+ * @file src/core/arguments/Constants.hpp
+ * @brief Centralizes all command-line argument name constants.
+ * @details Using constants for argument names avoids magic strings and ensures
+ * consistency across the application. A change here propagates everywhere.
+ */
+#pragma once
+
+namespace DynaRange::Arguments::Constants {
+
+    // --- Core Analysis Arguments ---
+    constexpr const char* BlackLevel = "black-level";
+    constexpr const char* BlackFile = "black-file";
+    constexpr const char* SaturationLevel = "saturation-level";
+    constexpr const char* SaturationFile = "saturation-file";
+    constexpr const char* InputFiles = "input-files";
+    constexpr const char* PatchRatio = "patch-ratio";
+    constexpr const char* SnrThresholdDb = "snrthreshold-db";
+    constexpr const char* DrNormalizationMpx = "drnormalization-mpx";
+    constexpr const char* RawChannels = "raw-channels";
+    constexpr const char* PolyFit = "poly-fit";
+
+    // --- Output and Plotting Arguments ---
+    constexpr const char* OutputFile = "output-file";
+    constexpr const char* PlotFormat = "plot-format";
+    constexpr const char* PlotParams = "plot-params";
+    constexpr const char* PrintPatches = "print-patches";
+
+    // --- Chart Generation Arguments ---
+    constexpr const char* Chart = "chart";
+    constexpr const char* ChartColour = "chart-colour";
+    constexpr const char* ChartPatches = "chart-patches";
+    constexpr const char* ChartCoords = "chart-coords";
+
+    // --- Internal Flags (no user-facing CLI equivalent) ---
+    constexpr const char* GeneratePlot = "generate-plot";
+    constexpr const char* CreateChartMode = "create-chart-mode";
+    constexpr const char* SnrThresholdIsDefault = "snr-threshold-is-default";
+    constexpr const char* BlackLevelIsDefault = "black-level-is-default";
+    constexpr const char* SaturationLevelIsDefault = "saturation-level-is-default";
+
+} // namespace DynaRange::Arguments::Constants

src/core/arguments/Constants.hpp

@@ -99,7 +99,6 @@ std::vector<SingleFileResult> AnalyzeSingleRawFile(
     }
     const double strict_min_snr_db = -10.0 - norm_adjustment;
     const double permissive_min_snr_db = DynaRange::Analysis::Constants::MIN_SNR_DB_THRESHOLD - norm_adjustment;
-
     // Find the highest SNR threshold requested by the user for the validation check.
     double max_requested_threshold = 0.0;
     if (!opts.snr_thresholds_db.empty()) {
@@ -126,10 +125,8 @@ std::vector<SingleFileResult> AnalyzeSingleRawFile(
         }
 
         bool should_draw_overlay = generate_debug_image && (channel == DataSource::R);
-
         // --- Pass 1: Analyze with the strict threshold ---
         PatchAnalysisResult patch_data = AnalyzePatches(img_prepared, chart.GetGridCols(), chart.GetGridRows(), opts.patch_ratio, should_draw_overlay, strict_min_snr_db);
-
         // --- Validation Step ---
         bool needs_reanalysis = false;
         if (!patch_data.signal.empty()) {
@@ -151,7 +148,8 @@ std::vector<SingleFileResult> AnalyzeSingleRawFile(
         // --- 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;
+                       << " with permissive threshold to find low-SNR data."
+                       << std::endl;
             patch_data = AnalyzePatches(img_prepared, chart.GetGridCols(), chart.GetGridRows(), opts.patch_ratio, should_draw_overlay, permissive_min_snr_db);
         }
 
@@ -187,14 +185,16 @@ std::vector<SingleFileResult> AnalyzeSingleRawFile(
         }
 
         if (final_patch_data.signal.empty()) continue;
-
+        
         auto [dr_result, curve_data] = CalculateResultsFromPatches(final_patch_data, opts, raw_file.GetFilename(), camera_resolution_mpx, final_channel);
 
+        dr_result.iso_speed = raw_file.GetIsoSpeed(); // Populate the new ISO field
         dr_result.samples_R = individual_channel_patches.count(DataSource::R) ? individual_channel_patches.at(DataSource::R).signal.size() : 0;
-        dr_result.samples_G1 = individual_channel_patches.count(DataSource::G1) ? individual_channel_patches.at(DataSource::G1).signal.size() : 0;
+        dr_result.samples_G1 = individual_channel_patches.count(DataSource::G1) ?
+        individual_channel_patches.at(DataSource::G1).signal.size() : 0;
         dr_result.samples_G2 = individual_channel_patches.count(DataSource::G2) ? individual_channel_patches.at(DataSource::G2).signal.size() : 0;
         dr_result.samples_B = individual_channel_patches.count(DataSource::B) ? individual_channel_patches.at(DataSource::B).signal.size() : 0;
-
+        
         if(opts.plot_labels.count(raw_file.GetFilename())) {
             curve_data.plot_label = opts.plot_labels.at(raw_file.GetFilename());
         } else {

src/core/engine/Processing.cpp

@@ -46,13 +46,16 @@ ReportOutput FinalizeAndReport(
     PathManager paths(opts);
     ReportOutput output;
 
+    // Flatten and sort the results before any output is generated.
+    auto sorted_rows = Formatters::FlattenAndSortResults(results.dr_results);
+
     output.final_csv_path = paths.GetCsvOutputPath().string();
     output.individual_plot_paths = GenerateIndividualPlots(results.curve_data, results.dr_results, opts, paths, log_stream);
 
     log_stream << "\n--- " << _("Dynamic Range Results") << " ---" << std::endl;
-    log_stream << Formatters::FormatResultsTable(results.dr_results, opts);
+    log_stream << Formatters::FormatResultsTable(sorted_rows);
 
-    OutputWriter::WriteCsv(results.dr_results, opts, paths.GetCsvOutputPath(), log_stream);
+    OutputWriter::WriteCsv(sorted_rows, paths.GetCsvOutputPath(), log_stream);
 
     output.summary_plot_path = GenerateSummaryPlotReport(results.curve_data, results.dr_results, opts, paths, log_stream);
 

src/core/engine/Reporting.cpp

@@ -28,8 +28,7 @@ bool WritePng(cairo_surface_t* surface, const fs::path& path, std::ostream& log_
 }
 
 bool WriteCsv(
-    const std::vector<DynamicRangeResult>& all_results,
-    const ProgramOptions& opts,
+    const std::vector<Formatters::FlatResultRow>& sorted_rows,
     const fs::path& path,
     std::ostream& log_stream)
 {
@@ -42,9 +41,9 @@ bool WriteCsv(
     // Write the new, fixed header
     csv_file << Formatters::FormatCsvHeader() << std::endl;
 
-    // Iterate through results and write the multiple rows that each may generate
-    for (const auto& res : all_results) {
-        csv_file << Formatters::FormatCsvRows(res);
+    // Iterate through the pre-sorted rows and write each one.
+    for (const auto& row : sorted_rows) {
+        csv_file << Formatters::FormatCsvRow(row);
     }
 
     csv_file.close();

src/core/io/OutputWriter.cpp

@@ -7,13 +7,11 @@
  */
 #pragma once
 
-#include <vector>
 #include <ostream>
 #include <filesystem>
 #include <cairo/cairo.h>
 #include <opencv2/core.hpp>
-#include "../analysis/Analysis.hpp"
-#include "../arguments/ArgumentsOptions.hpp"
+#include "../utils/Formatters.hpp"
 
 namespace fs = std::filesystem;
 
@@ -41,16 +39,13 @@ bool WriteDebugImage(const cv::Mat& image, const fs::path& path, std::ostream& l
 
 /**
  * @brief Writes the analysis results to a CSV file.
- * @param all_results The vector of DynamicRangeResult structs to write.
- * @param opts The program options, used to get the SNR thresholds for the header.
+ * @param sorted_rows The flattened and sorted vector of result rows to write.
  * @param path The full filesystem path for the output CSV.
  * @param log_stream A stream for logging success or error messages.
  * @return true on success, false on failure.
  */
 bool WriteCsv(
-    const std::vector<DynamicRangeResult>& all_results,
-    const ProgramOptions& opts,
+    const std::vector<Formatters::FlatResultRow>& sorted_rows,
     const fs::path& path,
     std::ostream& log_stream);
-
 } // namespace OutputWriter

src/core/io/OutputWriter.hpp

@@ -5,19 +5,22 @@
  */
 #include "CommandGenerator.hpp"
 #include "../arguments/ArgumentManager.hpp"
+#include "../arguments/Constants.hpp"
 #include "Constants.hpp"
 #include <filesystem>
 #include <iomanip>
 #include <libintl.h>
 #include <sstream>
 
 #define _(string) gettext(string)
+
 namespace fs = std::filesystem;
 
 namespace CommandGenerator {
 
 std::string GenerateCommand(CommandFormat format)
 {
+    using namespace DynaRange::Arguments::Constants;
     std::stringstream command_ss;
     command_ss << DynaRange::Utils::Constants::CLI_EXECUTABLE_NAME;
     auto& mgr = ArgumentManager::Instance();
@@ -28,104 +31,103 @@ std::string GenerateCommand(CommandFormat format)
             command_ss << " --" << name;
             return;
         }
-        // Map long names to short names for the short command format
+        
         static const std::map<std::string, std::string> short_map
-            = { { "black-level", " -B" }, { "black-file", " -b" }, { "saturation-level", " -S" }, { "saturation-file", " -s" }, { "input-files", " -i" }, { "patch-ratio", " -r" },
-                  { "snrthreshold-db", " -d" }, { "drnormalization-mpx", " -m" }, { "poly-fit", " -f" }, { "output-file", " -o" }, { "plot-format", " -p" }, { "plot-params", " -P" },
-                  { "print-patches", " -g" }, { "raw-channel", " -w" }, { "chart", " -c" }, { "chart-colour", " -C" }, { "chart-coords", " -x" }, { "chart-patches", " -M" } };
+            = { { BlackLevel, " -B" }, { BlackFile, " -b" }, { SaturationLevel, " -S" }, { SaturationFile, " -s" }, { InputFiles, " -i" }, { PatchRatio, " -r" },
+                  { SnrThresholdDb, " -d" }, { DrNormalizationMpx, " -m" }, { PolyFit, " -f" }, { OutputFile, " -o" }, { PlotFormat, " -p" }, { PlotParams, " -P" },
+                  { PrintPatches, " -g" }, { RawChannels, " -w" }, { Chart, " -c" }, { ChartColour, " -C" }, { ChartCoords, " -x" }, { ChartPatches, " -M" } };
         auto it = short_map.find(name);
         if (it != short_map.end()) {
             command_ss << it->second;
         } else {
-            command_ss << " --" << name; // Fallback for args without a short version
+            command_ss << " --" << name; 
         }
     };
 
-    std::string black_file = mgr.Get<std::string>("black-file");
+    std::string black_file = mgr.Get<std::string>(BlackFile);
     if (!black_file.empty()) {
-        add_arg("black-file");
+        add_arg(BlackFile);
         if (format == CommandFormat::GuiPreview || format == CommandFormat::Full) {
             command_ss << " \"" << black_file << "\"";
         } else {
             command_ss << " \"" << fs::path(black_file).filename().string() << "\"";
         }
     } else {
-        add_arg("black-level");
-        command_ss << " " << std::fixed << std::setprecision(2) << mgr.Get<double>("black-level");
+        add_arg(BlackLevel);
+        command_ss << " " << std::fixed << std::setprecision(2) << mgr.Get<double>(BlackLevel);
     }
 
-    std::string sat_file = mgr.Get<std::string>("saturation-file");
+    std::string sat_file = mgr.Get<std::string>(SaturationFile);
     if (!sat_file.empty()) {
-        add_arg("saturation-file");
+        add_arg(SaturationFile);
         if (format == CommandFormat::GuiPreview || format == CommandFormat::Full) {
             command_ss << " \"" << sat_file << "\"";
         } else {
             command_ss << " \"" << fs::path(sat_file).filename().string() << "\"";
         }
     } else {
-        add_arg("saturation-level");
-        command_ss << " " << std::fixed << std::setprecision(2) << mgr.Get<double>("saturation-level");
+        add_arg(SaturationLevel);
+        command_ss << " " << std::fixed << std::setprecision(2) << mgr.Get<double>(SaturationLevel);
     }
 
     if (format == CommandFormat::Full) {
-        add_arg("output-file");
-        command_ss << " \"" << mgr.Get<std::string>("output-file") << "\"";
+        add_arg(OutputFile);
+        command_ss << " \"" << mgr.Get<std::string>(OutputFile) << "\"";
     }
 
-    if (!mgr.Get<bool>("snr-threshold-is-default")) {
-        add_arg("snrthreshold-db");
-        const auto& thresholds = mgr.Get<std::vector<double>>("snrthreshold-db");
+    if (!mgr.Get<bool>(SnrThresholdIsDefault)) {
+        add_arg(SnrThresholdDb);
+        const auto& thresholds = mgr.Get<std::vector<double>>(SnrThresholdDb);
         for (const auto& threshold : thresholds) {
             command_ss << " " << threshold;
         }
     }
 
-    add_arg("drnormalization-mpx");
-    command_ss << " " << mgr.Get<double>("drnormalization-mpx");
-    add_arg("poly-fit");
-    command_ss << " " << mgr.Get<int>("poly-fit");
-    add_arg("patch-ratio");
-    command_ss << " " << mgr.Get<double>("patch-ratio");
+    add_arg(DrNormalizationMpx);
+    command_ss << " " << mgr.Get<double>(DrNormalizationMpx);
+    add_arg(PolyFit);
+    command_ss << " " << mgr.Get<int>(PolyFit);
+    add_arg(PatchRatio);
+    command_ss << " " << mgr.Get<double>(PatchRatio);
 
-    if (mgr.Get<bool>("generate-plot")) {
-        add_arg("plot-format");
-        command_ss << " " << mgr.Get<std::string>("plot-format");
+    if (mgr.Get<bool>(GeneratePlot)) {
+        add_arg(PlotFormat);
+        command_ss << " " << mgr.Get<std::string>(PlotFormat);
 
-        add_arg("plot-params");
-        const auto& plot_params = mgr.Get<std::vector<int>>("plot-params");
+        add_arg(PlotParams);
+        const auto& plot_params = mgr.Get<std::vector<int>>(PlotParams);
         for (const auto& val : plot_params) {
             command_ss << " " << val;
         }
     }
 
-    const auto& chart_coords = mgr.Get<std::vector<double>>("chart-coords");
+    const auto& chart_coords = mgr.Get<std::vector<double>>(ChartCoords);
     if (!chart_coords.empty()) {
-        add_arg("chart-coords");
+        add_arg(ChartCoords);
         for (const auto& coord : chart_coords)
             command_ss << " " << coord;
     }
 
-    const auto& chart_patches = mgr.Get<std::vector<int>>("chart-patches");
+    const auto& chart_patches = mgr.Get<std::vector<int>>(ChartPatches);
     if (!chart_patches.empty()) {
-        add_arg("chart-patches");
+        add_arg(ChartPatches);
         for (const auto& val : chart_patches)
             command_ss << " " << val;
     }
 
-    // Add --raw-channel to the command string if it's not the default.
-    const auto& raw_channels_vec = mgr.Get<std::vector<int>>("raw-channel");
+    const auto& raw_channels_vec = mgr.Get<std::vector<int>>(RawChannels);
     const std::vector<int> default_channels = { 0, 0, 0, 0, 1 };
     if (raw_channels_vec != default_channels) {
-        add_arg("raw-channel");
+        add_arg(RawChannels);
         for (const auto& val : raw_channels_vec) {
             command_ss << " " << val;
         }
     }
 
     if (format == CommandFormat::Full || format == CommandFormat::GuiPreview) {
-        const auto& input_files = mgr.Get<std::vector<std::string>>("input-files");
+        const auto& input_files = mgr.Get<std::vector<std::string>>(InputFiles);
         if (!input_files.empty()) {
-            add_arg("input-files");
+            add_arg(InputFiles);
             for (const auto& file : input_files) {
                 command_ss << " \"" << file << "\"";
             }