christoph/negative-converter
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

feat: extend CliRunner with config file/batch mode and add comprehensive tests

Browse Source 
CliRunner:
- --batch / --config <file> flags trigger batch mode with directory scanning
- collect_files() with recursive support and case-insensitive extension matching
- build_pipeline() respects AppConfig conversion flags (invert toggle)
- Progress output to stderr: "[1/42] Processing DSC09246.ARW..."

Tests (test_pipeline.cpp):
- AppConfig: load/save roundtrip, missing file error, extension parsing,
  format mapping, write_default
- CropProcessor: levels adjustment, sharpening no-clip, empty image error
- ColorCorrector: AWB preserves neutral grey, skips B&W film
- Inverter: color negative changes values, B&W inversion, positive passthrough
- Preprocessor: 8-bit→16-bit conversion

test_rawloader.cpp: added missing <fstream> include

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Christoph K.
2026-03-14 09:42:01 +01:00
parent db39ef8c58
commit 73ccaa3e95
5 changed files with 499 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

231
src/cli/CliRunner.cpp
View File

@@ -1,4 +1,5 @@
#include "CliRunner.h"
#include "../converter/rawloader/RawLoader.h"
#include "../converter/preprocess/Preprocessor.h"
#include "../converter/negative/NegativeDetector.h"
@@ -7,111 +8,189 @@
#include "../converter/crop/CropProcessor.h"
#include "../converter/output/OutputWriter.h"
#include <algorithm>
#include <format>
#include <iostream>
namespace photoconv {
// ─────────────────────────────────────────────────────────────────────────────
// parse_args
// ─────────────────────────────────────────────────────────────────────────────
std::expected<CliRunner::Config, Error> CliRunner::parse_args(int argc, char* argv[]) {
Config config;
bool reading_inputs = false;
for (int i = 1; i < argc; ++i) {
std::string arg{argv[i]};
const std::string arg{argv[i]};
if (arg == "--cli") {
reading_inputs = false;
continue;
}
if (arg == "--batch") {
config.batch_mode = true;
reading_inputs = false;
continue;
}
if (arg == "--config") {
reading_inputs = false;
if (i + 1 < argc) {
config.config_file = argv[++i];
config.batch_mode = true; // --config implies batch mode
} else {
return std::unexpected(make_error(
ErrorCode::InvalidArgument, "--config requires a file path"));
}
continue;
}
if (arg == "-i" || arg == "--input") {
reading_inputs = true;
continue;
}
if (arg == "-o" || arg == "--output") {
reading_inputs = false;
if (i + 1 < argc) {
config.output_dir = argv[++i];
} else {
return std::unexpected(make_error(
ErrorCode::InvalidArgument, "Missing value for --output"));
ErrorCode::InvalidArgument, "--output requires a directory path"));
}
continue;
}
if (arg == "--format") {
reading_inputs = false;
if (i + 1 < argc) {
config.output_format = argv[++i];
} else {
return std::unexpected(make_error(
ErrorCode::InvalidArgument, "Missing value for --format"));
ErrorCode::InvalidArgument, "--format requires a value (png16|png8|tiff16|jpeg)"));
}
continue;
}
if (arg == "--quality") {
reading_inputs = false;
if (i + 1 < argc) {
config.jpeg_quality = std::stoi(argv[++i]);
} else {
return std::unexpected(make_error(
ErrorCode::InvalidArgument, "--quality requires a numeric value"));
}
continue;
}
if (arg == "-v" || arg == "--verbose") {
config.verbose = true;
reading_inputs = false;
continue;
}
if (arg == "--cli") {
reading_inputs = false;
continue;
}
if (arg == "-h" || arg == "--help") {
std::cout <<
"Usage: photo-converter --cli -i <files...> -o <output_dir> [options]\n"
"Usage: photo-converter --cli [options] -i <files...>\n"
" photo-converter --batch --config config.ini\n"
"\n"
"Options:\n"
" -i, --input <files...> Input image files (RAW or standard)\n"
" -o, --output <dir> Output directory (default: output/)\n"
" --format <fmt> Output format: png16, png8, tiff16, jpeg\n"
" --quality <0-100> JPEG quality (default: 95)\n"
" -v, --verbose Verbose output\n"
" -h, --help Show this help\n"
" --cli CLI mode (no GUI)\n"
" --batch Batch mode (read config for input directory)\n"
" --config <file> INI configuration file (implies --batch)\n"
" -i, --input <files...> Input image files (RAW or standard)\n"
" -o, --output <dir> Output directory (default: output/)\n"
" --format <fmt> Output format: png16 png8 tiff16 jpeg\n"
" --quality <0-100> JPEG quality (default: 95)\n"
" -v, --verbose Verbose output\n"
" -h, --help Show this help\n"
<< std::endl;
return std::unexpected(make_error(ErrorCode::InvalidArgument, "Help requested"));
}
// If reading inputs or no flag active, treat as input file
if (reading_inputs || arg[0] != '-') {
// If reading_inputs is active or the argument does not start with '-',
// treat it as an input file path.
if (reading_inputs || (!arg.empty() && arg.front() != '-')) {
config.input_files.emplace_back(arg);
reading_inputs = true;
}
}
if (config.input_files.empty()) {
// Validation: we need either input files or a config file for batch mode.
if (!config.batch_mode && config.input_files.empty()) {
return std::unexpected(make_error(
ErrorCode::InvalidArgument, "No input files specified. Use -i <files...>"));
ErrorCode::InvalidArgument,
"No input files specified. Use -i <files...> or --batch --config config.ini"));
}
return config;
}
// ─────────────────────────────────────────────────────────────────────────────
// run
// ─────────────────────────────────────────────────────────────────────────────
std::expected<int, Error> CliRunner::run(const Config& config) const {
// Determine output format
OutputFormat fmt = OutputFormat::PNG_16bit;
if (config.output_format == "png8") fmt = OutputFormat::PNG_8bit;
else if (config.output_format == "tiff16") fmt = OutputFormat::TIFF_16bit;
else if (config.output_format == "jpeg") fmt = OutputFormat::JPEG;
// ── Resolve AppConfig ────────────────────────────────────────────────────
AppConfig app_cfg{};
// Build pipeline
Pipeline pipeline;
pipeline.add_stage(std::make_unique<Preprocessor>());
pipeline.add_stage(std::make_unique<NegativeDetector>());
pipeline.add_stage(std::make_unique<Inverter>());
pipeline.add_stage(std::make_unique<ColorCorrector>());
pipeline.add_stage(std::make_unique<CropProcessor>());
pipeline.add_stage(std::make_unique<OutputWriter>(
OutputConfig{config.output_dir, fmt, config.jpeg_quality}));
if (!config.config_file.empty()) {
auto cfg_result = AppConfig::load(config.config_file);
if (!cfg_result.has_value()) {
return std::unexpected(cfg_result.error());
}
app_cfg = std::move(cfg_result.value());
std::cout << std::format("[CLI] Loaded config: {}", config.config_file.string())
<< std::endl;
}
// CLI flags override config file values where set explicitly.
if (!config.output_dir.empty()) {
app_cfg.batch.output_dir = config.output_dir;
}
if (!config.output_format.empty() && config.output_format != "png16") {
// "png16" is the default; only override if the user explicitly changed it.
app_cfg.conversion.output_format = config.output_format;
}
if (config.jpeg_quality != 95) {
app_cfg.quality.jpeg_quality = config.jpeg_quality;
}
// ── Collect input files ──────────────────────────────────────────────────
std::vector<std::filesystem::path> files = config.input_files;
if (files.empty() && config.batch_mode) {
const auto extensions = app_cfg.parsed_extensions();
files = collect_files(app_cfg.batch.input_dir, extensions,
app_cfg.batch.recursive);
if (files.empty()) {
std::cerr << std::format(
"[CLI] No matching files found in: {}",
app_cfg.batch.input_dir.string()) << std::endl;
return 0;
}
}
// ── Build pipeline ───────────────────────────────────────────────────────
RawLoader loader;
Pipeline pipeline = build_pipeline(app_cfg);
// ── Process files ────────────────────────────────────────────────────────
int success_count = 0;
const auto total = static_cast<int>(files.size());
for (const auto& file : config.input_files) {
std::cout << std::format("\n[CLI] Processing: {}", file.string()) << std::endl;
for (int idx = 0; idx < total; ++idx) {
const auto& file = files[static_cast<std::size_t>(idx)];
std::cerr << std::format("[{}/{}] Processing {}...",
idx + 1, total, file.filename().string())
<< std::endl;
// Load image
auto load_result = loader.load(file);
if (!load_result.has_value()) {
std::cerr << std::format("[CLI] Load failed: {}",
@@ -119,6 +198,7 @@ std::expected<int, Error> CliRunner::run(const Config& config) const {
continue;
}
// Run pipeline
auto result = pipeline.execute(std::move(load_result.value()));
if (!result.has_value()) {
std::cerr << std::format("[CLI] Pipeline failed: {}",
@@ -129,21 +209,84 @@ std::expected<int, Error> CliRunner::run(const Config& config) const {
++success_count;
}
std::cout << std::format("\n[CLI] Done: {}/{} files processed successfully",
success_count, config.input_files.size()) << std::endl;
std::cout << std::format("\n[CLI] Done: {}/{} file(s) converted successfully",
success_count, total) << std::endl;
return success_count;
}
std::expected<int, Error> CliRunner::parse_format(const std::string& fmt_str) {
if (fmt_str == "png16") return static_cast<int>(OutputFormat::PNG_16bit);
if (fmt_str == "png8") return static_cast<int>(OutputFormat::PNG_8bit);
if (fmt_str == "tiff16") return static_cast<int>(OutputFormat::TIFF_16bit);
if (fmt_str == "jpeg") return static_cast<int>(OutputFormat::JPEG);
// ─────────────────────────────────────────────────────────────────────────────
// collect_files
// ─────────────────────────────────────────────────────────────────────────────
return std::unexpected(make_error(
ErrorCode::InvalidArgument,
std::format("Unknown output format: '{}'. Use: png16, png8, tiff16, jpeg", fmt_str)));
std::vector<std::filesystem::path> CliRunner::collect_files(
const std::filesystem::path& dir,
const std::vector<std::string>& extensions,
const bool recursive)
{
std::vector<std::filesystem::path> result;
if (!std::filesystem::is_directory(dir)) {
std::cerr << std::format("[CLI] Input directory not found: {}", dir.string())
<< std::endl;
return result;
}
auto collect_entry = [&](const std::filesystem::directory_entry& entry) {
if (!entry.is_regular_file()) return;
// Compare extension case-insensitively.
std::string ext = entry.path().extension().string();
std::ranges::transform(ext, ext.begin(),
[](unsigned char c) { return static_cast<char>(std::tolower(c)); });
const bool match = std::ranges::any_of(extensions,
[&ext](const std::string& e) { return e == ext; });
if (match) {
result.push_back(entry.path());
}
};
if (recursive) {
for (const auto& entry : std::filesystem::recursive_directory_iterator{dir}) {
collect_entry(entry);
}
} else {
for (const auto& entry : std::filesystem::directory_iterator{dir}) {
collect_entry(entry);
}
}
std::ranges::sort(result);
return result;
}
// ─────────────────────────────────────────────────────────────────────────────
// build_pipeline
// ─────────────────────────────────────────────────────────────────────────────
Pipeline CliRunner::build_pipeline(const AppConfig& app_cfg) {
Pipeline pipeline;
pipeline.add_stage(std::make_unique<Preprocessor>());
pipeline.add_stage(std::make_unique<NegativeDetector>());
if (app_cfg.conversion.invert) {
pipeline.add_stage(std::make_unique<Inverter>());
}
pipeline.add_stage(std::make_unique<ColorCorrector>());
pipeline.add_stage(std::make_unique<CropProcessor>());
pipeline.add_stage(std::make_unique<OutputWriter>(OutputConfig{
app_cfg.batch.output_dir,
app_cfg.output_format(),
app_cfg.quality.jpeg_quality
}));
return pipeline;
}
} // namespace photoconv