+
+MainWindow::MainWindow(QWidget *parent)
+ : QMainWindow(parent)
+ , m_centralWidget(nullptr)
+ , m_mainSplitter(nullptr)
+ , m_rightSplitter(nullptr)
+ , m_fileListWidget(nullptr)
+ , m_parameterWidget(nullptr)
+ , m_imageViewer(nullptr)
+ , m_openFilesAction(nullptr)
+ , m_openFolderAction(nullptr)
+ , m_clearAction(nullptr)
+ , m_exitAction(nullptr)
+ , m_aboutAction(nullptr)
+ , m_settingsAction(nullptr)
+ , m_progressBar(nullptr)
+ , m_statusLabel(nullptr)
+ , m_fileCountLabel(nullptr)
+ , m_convertButton(nullptr)
+ , m_stopButton(nullptr)
+ , m_conversionWorker(nullptr)
+ , m_statusUpdateTimer(nullptr)
+ , m_conversionInProgress(false)
+ , m_totalFiles(0)
+ , m_convertedFiles(0)
+{
+ setupUI();
+ setupMenuBar();
+ setupStatusBar();
+ connectSignals();
+
+ setAcceptDrops(true);
+ setWindowTitle("RAWtoACES GUI - Academy Software Foundation");
+ QIcon appIcon;
+ if (QFile::exists(":/icons/rawtoaces-brand.png")) {
+ appIcon = QIcon(":/icons/rawtoaces-brand.png");
+ } else {
+ appIcon = QIcon(":/icons/rawtoaces.png");
+ }
+ setWindowIcon(appIcon);
+
+ // Log dock
+ setupLogDock();
+
+ // Initialize timer
+ m_statusUpdateTimer = new QTimer(this);
+ m_statusUpdateTimer->setInterval(100);
+ connect(m_statusUpdateTimer, &QTimer::timeout, this, &MainWindow::updateStatusBar);
+
+ loadSettings();
+}
+
+MainWindow::~MainWindow()
+{
+ saveSettings();
+
+ if (m_conversionWorker) {
+ m_conversionWorker->stop();
+ m_conversionWorker->wait();
+ delete m_conversionWorker;
+ }
+}
+
+void MainWindow::setupUI()
+{
+ m_centralWidget = new QWidget;
+ setCentralWidget(m_centralWidget);
+
+ // Create main splitter
+ m_mainSplitter = new QSplitter(Qt::Horizontal);
+
+ // Create file list widget
+ m_fileListWidget = new FileListWidget;
+ m_fileListWidget->setMinimumWidth(300);
+
+ // Create right splitter for parameters and image viewer
+ m_rightSplitter = new QSplitter(Qt::Vertical);
+
+ // Create parameter widget
+ m_parameterWidget = new ParameterWidget;
+ m_parameterWidget->setMinimumHeight(200);
+
+ // Create image viewer
+ m_imageViewer = new ImageViewer;
+ m_imageViewer->setMinimumHeight(300);
+ // Connect selection from viewer to parameter widget setters
+ connect(m_imageViewer, &ImageViewer::selectionChanged, this, [this](const QRect &sel){
+ QRect imgSel = m_imageViewer->getSelectionInImagePixels();
+ if (!imgSel.isEmpty()) {
+ // Decide routing based on current WB mode; if WB box mode -> WB, else -> crop
+ auto params = m_parameterWidget->getParameters();
+ if (params.wbMethod == "box") {
+ m_parameterWidget->setWbBoxFromSelection(imgSel);
+ } else {
+ m_parameterWidget->setCropBoxFromSelection(imgSel);
+ }
+ }
+ });
+
+ // Add widgets to right splitter
+ m_rightSplitter->addWidget(m_parameterWidget);
+ m_rightSplitter->addWidget(m_imageViewer);
+ m_rightSplitter->setSizes({300, 500});
+
+ // Add widgets to main splitter
+ m_mainSplitter->addWidget(m_fileListWidget);
+ m_mainSplitter->addWidget(m_rightSplitter);
+ m_mainSplitter->setSizes({400, 800});
+
+ // Create control buttons
+ QHBoxLayout *buttonLayout = new QHBoxLayout;
+
+ m_convertButton = new QPushButton("Convert Files");
+ m_convertButton->setEnabled(false);
+ m_convertButton->setMinimumHeight(40);
+ m_convertButton->setStyleSheet("QPushButton { font-weight: bold; background-color: #2E7D32; } QPushButton:hover { background-color: #4CAF50; }");
+
+ m_stopButton = new QPushButton("Stop");
+ m_stopButton->setEnabled(false);
+ m_stopButton->setMinimumHeight(40);
+ m_stopButton->setStyleSheet("QPushButton { font-weight: bold; background-color: #C62828; } QPushButton:hover { background-color: #F44336; }");
+
+ buttonLayout->addStretch();
+ buttonLayout->addWidget(m_convertButton);
+ buttonLayout->addWidget(m_stopButton);
+ buttonLayout->addStretch();
+
+ // Main layout
+ QVBoxLayout *mainLayout = new QVBoxLayout;
+ mainLayout->addWidget(m_mainSplitter);
+ mainLayout->addLayout(buttonLayout);
+
+ m_centralWidget->setLayout(mainLayout);
+}
+
+void MainWindow::setupMenuBar()
+{
+ // File menu
+ QMenu *fileMenu = menuBar()->addMenu("&File");
+
+ m_openFilesAction = new QAction("&Open Files...", this);
+ m_openFilesAction->setShortcut(QKeySequence::Open);
+ m_openFilesAction->setIcon(style()->standardIcon(QStyle::SP_DialogOpenButton));
+ fileMenu->addAction(m_openFilesAction);
+
+ m_openFolderAction = new QAction("Open &Folder...", this);
+ m_openFolderAction->setShortcut(QKeySequence("Ctrl+Shift+O"));
+ m_openFolderAction->setIcon(style()->standardIcon(QStyle::SP_DirOpenIcon));
+ fileMenu->addAction(m_openFolderAction);
+
+ fileMenu->addSeparator();
+
+ m_clearAction = new QAction("&Clear List", this);
+ m_clearAction->setShortcut(QKeySequence("Ctrl+L"));
+ m_clearAction->setIcon(style()->standardIcon(QStyle::SP_TrashIcon));
+ fileMenu->addAction(m_clearAction);
+
+ fileMenu->addSeparator();
+
+ m_exitAction = new QAction("E&xit", this);
+ m_exitAction->setShortcut(QKeySequence::Quit);
+ fileMenu->addAction(m_exitAction);
+
+ // Tools menu
+ QMenu *toolsMenu = menuBar()->addMenu("&Tools");
+
+ m_settingsAction = new QAction("&Settings...", this);
+ m_settingsAction->setShortcut(QKeySequence::Preferences);
+ m_settingsAction->setIcon(style()->standardIcon(QStyle::SP_FileDialogDetailedView));
+ toolsMenu->addAction(m_settingsAction);
+
+ // View menu
+ QMenu *viewMenu = menuBar()->addMenu("&View");
+ m_viewLogAction = new QAction("&Log", this);
+ m_viewLogAction->setCheckable(true);
+ m_viewLogAction->setChecked(true);
+ viewMenu->addAction(m_viewLogAction);
+ connect(m_viewLogAction, &QAction::toggled, [this](bool on){ if (m_logDock) m_logDock->setVisible(on); });
+
+ // Help menu
+ QMenu *helpMenu = menuBar()->addMenu("&Help");
+
+ m_aboutAction = new QAction("&About", this);
+ helpMenu->addAction(m_aboutAction);
+}
+
+void MainWindow::setupStatusBar()
+{
+ m_statusLabel = new QLabel("Ready");
+ statusBar()->addWidget(m_statusLabel);
+
+ m_progressBar = new QProgressBar;
+ m_progressBar->setVisible(false);
+ statusBar()->addPermanentWidget(m_progressBar);
+
+ m_fileCountLabel = new QLabel("Files: 0");
+ statusBar()->addPermanentWidget(m_fileCountLabel);
+}
+
+void MainWindow::connectSignals()
+{
+ // Menu actions
+ connect(m_openFilesAction, &QAction::triggered, this, &MainWindow::openFiles);
+ connect(m_openFolderAction, &QAction::triggered, this, &MainWindow::openFolder);
+ connect(m_clearAction, &QAction::triggered, this, &MainWindow::clearFiles);
+ connect(m_exitAction, &QAction::triggered, this, &QWidget::close);
+ connect(m_aboutAction, &QAction::triggered, this, &MainWindow::showAbout);
+ connect(m_settingsAction, &QAction::triggered, this, &MainWindow::showSettings);
+
+ // Buttons
+ connect(m_convertButton, &QPushButton::clicked, this, &MainWindow::startConversion);
+ connect(m_stopButton, &QPushButton::clicked, this, &MainWindow::stopConversion);
+
+ // File list widget
+ connect(m_fileListWidget, &FileListWidget::filesChanged, this, &MainWindow::updateConversionButton);
+ connect(m_fileListWidget, &FileListWidget::fileSelected, this, &MainWindow::onFileSelectionChanged);
+}
+
+void MainWindow::setupLogDock()
+{
+ m_logDock = new QDockWidget("Log", this);
+ m_logDock->setObjectName("LogDock");
+ m_logDock->setAllowedAreas(Qt::BottomDockWidgetArea | Qt::TopDockWidgetArea);
+ m_logView = new QPlainTextEdit(m_logDock);
+ m_logView->setReadOnly(true);
+ m_logView->setMaximumBlockCount(5000);
+ m_logDock->setWidget(m_logView);
+ addDockWidget(Qt::BottomDockWidgetArea, m_logDock);
+
+ // Dock context actions: Clear/Copy/Save
+ m_clearLogAction = new QAction("Clear Log", this);
+ connect(m_clearLogAction, &QAction::triggered, this, &MainWindow::clearLog);
+ m_copyLogAction = new QAction("Copy All", this);
+ connect(m_copyLogAction, &QAction::triggered, this, &MainWindow::copyLog);
+ m_saveLogAction = new QAction("Save Logโฆ", this);
+ connect(m_saveLogAction, &QAction::triggered, this, &MainWindow::saveLog);
+ m_logDock->addActions({m_clearLogAction, m_copyLogAction, m_saveLogAction});
+ m_logDock->setContextMenuPolicy(Qt::ActionsContextMenu);
+}
+
+void MainWindow::addFiles(const QStringList &files)
+{
+ if (m_fileListWidget) {
+ m_fileListWidget->addFiles(files);
+ }
+}
+
+void MainWindow::dragEnterEvent(QDragEnterEvent *event)
+{
+ if (event->mimeData()->hasUrls()) {
+ event->acceptProposedAction();
+ }
+}
+
+void MainWindow::dropEvent(QDropEvent *event)
+{
+ QStringList files;
+ for (const QUrl &url : event->mimeData()->urls()) {
+ if (url.isLocalFile()) {
+ files << url.toLocalFile();
+ }
+ }
+
+ if (!files.isEmpty()) {
+ addFiles(files);
+ }
+}
+
+void MainWindow::closeEvent(QCloseEvent *event)
+{
+ if (m_conversionInProgress) {
+ int ret = QMessageBox::question(this, "Conversion in Progress",
+ "A conversion is currently in progress. Do you want to stop it and exit?",
+ QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
+
+ if (ret == QMessageBox::Yes) {
+ stopConversion();
+ event->accept();
+ } else {
+ event->ignore();
+ return;
+ }
+ }
+
+ saveSettings();
+ event->accept();
+}
+
+void MainWindow::openFiles()
+{
+ QStringList files = QFileDialog::getOpenFileNames(this,
+ "Select RAW Files",
+ SettingsManager::instance().getLastDirectory(),
+ "RAW Files (*.raw *.cr2 *.cr3 *.nef *.arw *.dng *.orf *.raf *.rw2);;All Files (*)");
+
+ if (!files.isEmpty()) {
+ addFiles(files);
+ SettingsManager::instance().setLastDirectory(QFileInfo(files.first()).absolutePath());
+ }
+}
+
+void MainWindow::openFolder()
+{
+ QString folder = QFileDialog::getExistingDirectory(this,
+ "Select Folder Containing RAW Files",
+ SettingsManager::instance().getLastDirectory());
+
+ if (!folder.isEmpty()) {
+ QStringList files;
+ QDir dir(folder);
+ QStringList filters;
+ filters << "*.raw" << "*.cr2" << "*.cr3" << "*.nef" << "*.arw"
+ << "*.dng" << "*.orf" << "*.raf" << "*.rw2";
+
+ for (const QString &filter : filters) {
+ files += dir.entryList(QStringList() << filter, QDir::Files);
+ }
+
+ // Convert to absolute paths
+ QStringList absoluteFiles;
+ for (const QString &file : files) {
+ absoluteFiles << dir.absoluteFilePath(file);
+ }
+
+ if (!absoluteFiles.isEmpty()) {
+ addFiles(absoluteFiles);
+ SettingsManager::instance().setLastDirectory(folder);
+ } else {
+ QMessageBox::information(this, "No Files Found",
+ "No RAW files were found in the selected folder.");
+ }
+ }
+}
+
+void MainWindow::clearFiles()
+{
+ if (m_fileListWidget) {
+ m_fileListWidget->clear();
+ }
+}
+
+void MainWindow::showAbout()
+{
+ QMessageBox::about(this, "About RAWtoACES GUI",
+ "RAWtoACES GUI v1.0.0
"
+ "A graphical user interface for the RAWtoACES command-line tool.
"
+ "RAWtoACES converts digital camera RAW files to ACES container files.
"
+ "Academy Software Foundation
"
+ "Website: https://www.aswf.io
"
+ "Built with Qt and modern C++
");
+}
+
+void MainWindow::showSettings()
+{
+ // TODO: Implement settings dialog
+ QMessageBox::information(this, "Settings", "Settings dialog not yet implemented.");
+}
+
+void MainWindow::startConversion()
+{
+ if (!m_fileListWidget || m_fileListWidget->getFileCount() == 0) {
+ return;
+ }
+
+ // Get conversion parameters
+ auto parameters = m_parameterWidget->getParameters();
+ auto files = m_fileListWidget->getAllFiles();
+
+ // Create worker thread
+ m_conversionWorker = new ConversionWorker(files, parameters);
+ connect(m_conversionWorker, &ConversionWorker::progress,
+ this, &MainWindow::onConversionProgress);
+ connect(m_conversionWorker, &ConversionWorker::finished,
+ this, &MainWindow::onConversionFinished);
+ connect(m_conversionWorker, &ConversionWorker::logMessage,
+ this, &MainWindow::appendLog);
+
+ // Update UI
+ m_conversionInProgress = true;
+ m_convertButton->setEnabled(false);
+ m_stopButton->setEnabled(true);
+ m_progressBar->setVisible(true);
+ m_progressBar->setRange(0, files.size());
+ m_progressBar->setValue(0);
+ m_statusUpdateTimer->start();
+
+ // Start conversion
+ m_conversionWorker->start();
+}
+
+void MainWindow::stopConversion()
+{
+ if (m_conversionWorker) {
+ m_conversionWorker->stop();
+ m_statusLabel->setText("Stopping conversion...");
+ }
+}
+
+void MainWindow::onConversionProgress(int current, int total, const QString &filename)
+{
+ m_progressBar->setValue(current);
+ m_statusLabel->setText(QString("Converting: %1").arg(QFileInfo(filename).fileName()));
+ m_convertedFiles = current;
+ m_totalFiles = total;
+}
+
+void MainWindow::onConversionFinished(bool success, const QString &message)
+{
+ m_conversionInProgress = false;
+ m_convertButton->setEnabled(true);
+ m_stopButton->setEnabled(false);
+ m_progressBar->setVisible(false);
+ m_statusUpdateTimer->stop();
+
+ if (success) {
+ m_statusLabel->setText("Conversion completed successfully");
+ QMessageBox::information(this, "Conversion Complete",
+ "All files have been converted successfully.");
+ } else {
+ m_statusLabel->setText("Conversion failed");
+ QMessageBox::critical(this, "Conversion Error",
+ QString("Conversion failed: %1").arg(message));
+ }
+
+ // Clean up worker
+ if (m_conversionWorker) {
+ m_conversionWorker->deleteLater();
+ m_conversionWorker = nullptr;
+ }
+}
+
+void MainWindow::onFileSelectionChanged(const QString &filename)
+{
+ if (m_imageViewer) {
+ m_imageViewer->loadImage(filename);
+ }
+}
+
+void MainWindow::updateStatusBar()
+{
+ if (m_fileListWidget) {
+ int fileCount = m_fileListWidget->getFileCount();
+ m_fileCountLabel->setText(QString("Files: %1").arg(fileCount));
+ }
+}
+
+void MainWindow::clearLog()
+{
+ if (m_logView) m_logView->clear();
+}
+
+void MainWindow::appendLog(const QString &text)
+{
+ if (!m_logView) return;
+ const QString trimmed = text.trimmed();
+ if (trimmed.isEmpty()) return;
+ const QString ts = QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss");
+ m_logView->appendPlainText(QString("[%1] %2").arg(ts, trimmed));
+ // Auto-scroll
+ QScrollBar *sb = m_logView->verticalScrollBar();
+ if (sb) sb->setValue(sb->maximum());
+}
+
+void MainWindow::copyLog()
+{
+ if (!m_logView) return;
+ m_logView->selectAll();
+ m_logView->copy();
+ m_logView->moveCursor(QTextCursor::End);
+}
+
+void MainWindow::saveLog()
+{
+ if (!m_logView) return;
+ const QString path = QFileDialog::getSaveFileName(this, "Save Log", QDir::homePath()+"/rawtoaces-gui.log", "Text Files (*.txt);;All Files (*)");
+ if (path.isEmpty()) return;
+ QFile f(path);
+ if (f.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text)) {
+ QTextStream out(&f);
+ out << m_logView->toPlainText();
+ f.close();
+ statusBar()->showMessage(QString("Saved log to %1").arg(path), 3000);
+ } else {
+ QMessageBox::warning(this, "Save Log", QString("Failed to save log to %1").arg(path));
+ }
+}
+
+void MainWindow::updateConversionButton()
+{
+ if (m_fileListWidget && m_convertButton) {
+ m_convertButton->setEnabled(m_fileListWidget->getFileCount() > 0 && !m_conversionInProgress);
+ }
+}
+
+void MainWindow::saveSettings()
+{
+ QSettings settings;
+ settings.setValue("geometry", saveGeometry());
+ settings.setValue("windowState", saveState());
+ settings.setValue("mainSplitter", m_mainSplitter->saveState());
+ settings.setValue("rightSplitter", m_rightSplitter->saveState());
+}
+
+void MainWindow::loadSettings()
+{
+ QSettings settings;
+ restoreGeometry(settings.value("geometry").toByteArray());
+ restoreState(settings.value("windowState").toByteArray());
+
+ if (m_mainSplitter) {
+ m_mainSplitter->restoreState(settings.value("mainSplitter").toByteArray());
+ }
+ if (m_rightSplitter) {
+ m_rightSplitter->restoreState(settings.value("rightSplitter").toByteArray());
+ }
+}
diff --git a/gui/src/MainWindow.h b/gui/src/MainWindow.h
new file mode 100644
index 00000000..b959395d
--- /dev/null
+++ b/gui/src/MainWindow.h
@@ -0,0 +1,112 @@
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+class FileListWidget;
+class ParameterWidget;
+class ImageViewer;
+class ConversionWorker;
+
+class MainWindow : public QMainWindow
+{
+ Q_OBJECT
+
+public:
+ explicit MainWindow(QWidget *parent = nullptr);
+ ~MainWindow();
+
+ void addFiles(const QStringList &files);
+
+protected:
+ void dragEnterEvent(QDragEnterEvent *event) override;
+ void dropEvent(QDropEvent *event) override;
+ void closeEvent(QCloseEvent *event) override;
+
+private slots:
+ void openFiles();
+ void openFolder();
+ void clearFiles();
+ void showAbout();
+ void showSettings();
+ void startConversion();
+ void stopConversion();
+ void onConversionProgress(int current, int total, const QString &filename);
+ void onConversionFinished(bool success, const QString &message);
+ void onFileSelectionChanged(const QString &filename);
+ void updateStatusBar();
+ void clearLog();
+ void copyLog();
+ void saveLog();
+ void appendLog(const QString &text);
+
+private:
+ void setupUI();
+ void setupMenuBar();
+ void setupStatusBar();
+ void setupLogDock();
+ void connectSignals();
+ void updateConversionButton();
+ void saveSettings();
+ void loadSettings();
+
+ // UI Components
+ QWidget *m_centralWidget;
+ QSplitter *m_mainSplitter;
+ QSplitter *m_rightSplitter;
+
+ FileListWidget *m_fileListWidget;
+ ParameterWidget *m_parameterWidget;
+ ImageViewer *m_imageViewer;
+
+ // Menu and toolbar
+ QAction *m_openFilesAction;
+ QAction *m_openFolderAction;
+ QAction *m_clearAction;
+ QAction *m_exitAction;
+ QAction *m_aboutAction;
+ QAction *m_settingsAction;
+
+ // Status bar
+ QProgressBar *m_progressBar;
+ QLabel *m_statusLabel;
+ QLabel *m_fileCountLabel;
+
+ // Control buttons
+ QPushButton *m_convertButton;
+ QPushButton *m_stopButton;
+
+ // Worker thread
+ ConversionWorker *m_conversionWorker;
+ QTimer *m_statusUpdateTimer;
+
+ // State
+ bool m_conversionInProgress;
+ int m_totalFiles;
+ int m_convertedFiles;
+
+ // Log dock
+ QDockWidget *m_logDock;
+ QPlainTextEdit *m_logView;
+ QAction *m_viewLogAction;
+ QAction *m_clearLogAction;
+ QAction *m_copyLogAction;
+ QAction *m_saveLogAction;
+};
diff --git a/gui/src/ParameterWidget.cpp b/gui/src/ParameterWidget.cpp
new file mode 100644
index 00000000..7eec7392
--- /dev/null
+++ b/gui/src/ParameterWidget.cpp
@@ -0,0 +1,544 @@
+#include "ParameterWidget.h"
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+ParameterWidget::ParameterWidget(QWidget *parent)
+ : QWidget(parent)
+ , m_scrollArea(nullptr)
+ , m_contentWidget(nullptr)
+ , m_wbGroup(nullptr)
+ , m_matrixGroup(nullptr)
+ , m_processingGroup(nullptr)
+ , m_outputGroup(nullptr)
+ , m_advancedGroup(nullptr)
+ , m_advancedVisible(false)
+{
+ setupUI();
+}
+
+void ParameterWidget::setupUI()
+{
+ setWindowTitle("Conversion Parameters");
+
+ // Create scroll area for parameters
+ m_scrollArea = new QScrollArea;
+ m_scrollArea->setWidgetResizable(true);
+ m_scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+ m_scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+
+ // Create content widget
+ m_contentWidget = new QWidget;
+
+ // Setup parameter groups
+ setupWhiteBalanceGroup();
+ setupMatrixGroup();
+ setupProcessingGroup();
+ setupOutputGroup();
+ setupAdvancedGroup();
+
+ // Layout content widget
+ QVBoxLayout *contentLayout = new QVBoxLayout;
+ contentLayout->addWidget(m_wbGroup);
+ contentLayout->addWidget(m_matrixGroup);
+ contentLayout->addWidget(m_processingGroup);
+ contentLayout->addWidget(m_outputGroup);
+ contentLayout->addWidget(m_advancedGroup);
+ contentLayout->addStretch();
+
+ m_contentWidget->setLayout(contentLayout);
+ m_scrollArea->setWidget(m_contentWidget);
+
+ // Main layout
+ QVBoxLayout *mainLayout = new QVBoxLayout;
+ mainLayout->addWidget(m_scrollArea);
+ setLayout(mainLayout);
+
+ // Connect signals
+ connect(m_wbMethodCombo, QOverload::of(&QComboBox::currentIndexChanged),
+ this, &ParameterWidget::onWbMethodChanged);
+ connect(m_matMethodCombo, QOverload::of(&QComboBox::currentIndexChanged),
+ this, &ParameterWidget::onMatMethodChanged);
+
+ // Initialize UI state
+ onWbMethodChanged();
+ onMatMethodChanged();
+}
+
+void ParameterWidget::setupWhiteBalanceGroup()
+{
+ m_wbGroup = new QGroupBox("White Balance");
+ QGridLayout *layout = new QGridLayout;
+
+ // White balance method
+ layout->addWidget(new QLabel("Method:"), 0, 0);
+ m_wbMethodCombo = new QComboBox;
+ m_wbMethodCombo->addItems({"metadata", "illuminant", "box", "custom"});
+ m_wbMethodCombo->setToolTip("White balance calculation method");
+ layout->addWidget(m_wbMethodCombo, 0, 1);
+
+ // Illuminant
+ layout->addWidget(new QLabel("Illuminant:"), 1, 0);
+ m_illuminantCombo = new QComboBox;
+ m_illuminantCombo->addItems({"D50", "D55", "D60", "D65", "D75"});
+ m_illuminantCombo->setCurrentText("D55");
+ layout->addWidget(m_illuminantCombo, 1, 1);
+
+ // Custom illuminant
+ m_customIlluminantEdit = new QLineEdit;
+ m_customIlluminantEdit->setPlaceholderText("e.g., 3200K, D60");
+ layout->addWidget(m_customIlluminantEdit, 1, 2);
+
+ // WB Box controls
+ layout->addWidget(new QLabel("WB Box:"), 2, 0);
+ QHBoxLayout *boxLayout = new QHBoxLayout;
+
+ m_wbBoxXSpin = new QSpinBox;
+ m_wbBoxXSpin->setRange(0, 9999);
+ m_wbBoxXSpin->setSuffix(" x");
+ boxLayout->addWidget(m_wbBoxXSpin);
+
+ m_wbBoxYSpin = new QSpinBox;
+ m_wbBoxYSpin->setRange(0, 9999);
+ m_wbBoxYSpin->setSuffix(" y");
+ boxLayout->addWidget(m_wbBoxYSpin);
+
+ m_wbBoxWSpin = new QSpinBox;
+ m_wbBoxWSpin->setRange(0, 9999);
+ m_wbBoxWSpin->setSuffix(" w");
+ boxLayout->addWidget(m_wbBoxWSpin);
+
+ m_wbBoxHSpin = new QSpinBox;
+ m_wbBoxHSpin->setRange(0, 9999);
+ m_wbBoxHSpin->setSuffix(" h");
+ boxLayout->addWidget(m_wbBoxHSpin);
+
+ QWidget *boxWidget = new QWidget;
+ boxWidget->setLayout(boxLayout);
+ layout->addWidget(boxWidget, 2, 1, 1, 2);
+
+ // Custom WB multipliers
+ layout->addWidget(new QLabel("Custom WB:"), 3, 0);
+ QHBoxLayout *wbLayout = new QHBoxLayout;
+
+ m_customWbR = new QDoubleSpinBox;
+ m_customWbR->setRange(0.1, 10.0);
+ m_customWbR->setValue(1.0);
+ m_customWbR->setDecimals(3);
+ m_customWbR->setSuffix(" R");
+ wbLayout->addWidget(m_customWbR);
+
+ m_customWbG1 = new QDoubleSpinBox;
+ m_customWbG1->setRange(0.1, 10.0);
+ m_customWbG1->setValue(1.0);
+ m_customWbG1->setDecimals(3);
+ m_customWbG1->setSuffix(" G1");
+ wbLayout->addWidget(m_customWbG1);
+
+ m_customWbB = new QDoubleSpinBox;
+ m_customWbB->setRange(0.1, 10.0);
+ m_customWbB->setValue(1.0);
+ m_customWbB->setDecimals(3);
+ m_customWbB->setSuffix(" B");
+ wbLayout->addWidget(m_customWbB);
+
+ m_customWbG2 = new QDoubleSpinBox;
+ m_customWbG2->setRange(0.1, 10.0);
+ m_customWbG2->setValue(1.0);
+ m_customWbG2->setDecimals(3);
+ m_customWbG2->setSuffix(" G2");
+ wbLayout->addWidget(m_customWbG2);
+
+ QWidget *wbWidget = new QWidget;
+ wbWidget->setLayout(wbLayout);
+ layout->addWidget(wbWidget, 3, 1, 1, 2);
+
+ m_wbGroup->setLayout(layout);
+}
+
+void ParameterWidget::setupMatrixGroup()
+{
+ m_matrixGroup = new QGroupBox("Matrix Calculation");
+ QGridLayout *layout = new QGridLayout;
+
+ // Matrix method
+ layout->addWidget(new QLabel("Method:"), 0, 0);
+ m_matMethodCombo = new QComboBox;
+ m_matMethodCombo->addItems({"spectral", "metadata", "Adobe", "custom"});
+ layout->addWidget(m_matMethodCombo, 0, 1);
+
+ // Custom camera make/model
+ layout->addWidget(new QLabel("Camera Make:"), 1, 0);
+ m_customMakeEdit = new QLineEdit;
+ m_customMakeEdit->setPlaceholderText("e.g., Canon, Nikon");
+ layout->addWidget(m_customMakeEdit, 1, 1);
+
+ layout->addWidget(new QLabel("Camera Model:"), 2, 0);
+ m_customModelEdit = new QLineEdit;
+ m_customModelEdit->setPlaceholderText("e.g., EOS 5D Mark IV");
+ layout->addWidget(m_customModelEdit, 2, 1);
+
+ // Custom matrix (will be shown/hidden based on method)
+ m_customMatrixWidget = new QWidget;
+ QGridLayout *matrixLayout = new QGridLayout;
+ m_matrixSpins.resize(9);
+
+ for (int i = 0; i < 9; ++i) {
+ m_matrixSpins[i] = new QDoubleSpinBox;
+ m_matrixSpins[i]->setRange(-10.0, 10.0);
+ m_matrixSpins[i]->setValue(i % 4 == 0 ? 1.0 : 0.0); // Identity matrix default
+ m_matrixSpins[i]->setDecimals(6);
+ m_matrixSpins[i]->setSingleStep(0.1);
+ matrixLayout->addWidget(m_matrixSpins[i], i / 3, i % 3);
+ }
+
+ m_customMatrixWidget->setLayout(matrixLayout);
+ layout->addWidget(new QLabel("Custom Matrix:"), 3, 0);
+ layout->addWidget(m_customMatrixWidget, 3, 1);
+
+ m_matrixGroup->setLayout(layout);
+}
+
+void ParameterWidget::setupProcessingGroup()
+{
+ m_processingGroup = new QGroupBox("Processing Options");
+ QGridLayout *layout = new QGridLayout;
+
+ // Headroom
+ layout->addWidget(new QLabel("Headroom:"), 0, 0);
+ m_headroomSpin = new QDoubleSpinBox;
+ m_headroomSpin->setRange(1.0, 20.0);
+ m_headroomSpin->setValue(6.0);
+ m_headroomSpin->setDecimals(1);
+ m_headroomSpin->setToolTip("Highlight headroom factor");
+ layout->addWidget(m_headroomSpin, 0, 1);
+
+ // Scale
+ layout->addWidget(new QLabel("Scale:"), 0, 2);
+ m_scaleSpin = new QDoubleSpinBox;
+ m_scaleSpin->setRange(0.1, 10.0);
+ m_scaleSpin->setValue(1.0);
+ m_scaleSpin->setDecimals(2);
+ m_scaleSpin->setToolTip("Additional scaling factor");
+ layout->addWidget(m_scaleSpin, 0, 3);
+
+ // Auto brightness
+ m_autobrightCheck = new QCheckBox("Auto Brightness");
+ m_autobrightCheck->setToolTip("Enable automatic exposure adjustment");
+ layout->addWidget(m_autobrightCheck, 1, 0);
+
+ // Half size
+ m_halfSizeCheck = new QCheckBox("Half Size");
+ m_halfSizeCheck->setToolTip("Decode image at half size resolution");
+ layout->addWidget(m_halfSizeCheck, 1, 1);
+
+ // Demosaic algorithm
+ layout->addWidget(new QLabel("Demosaic:"), 2, 0);
+ m_demosaicCombo = new QComboBox;
+ m_demosaicCombo->addItems({"AHD", "VNG", "PPG", "DCB", "AHD-Mod", "AFD", "VCD", "Mixed", "LMMSE", "AMaZE", "DHT", "AAHD"});
+ layout->addWidget(m_demosaicCombo, 2, 1);
+
+ // Highlight mode
+ layout->addWidget(new QLabel("Highlight Mode:"), 2, 2);
+ m_highlightModeCombo = new QComboBox;
+ m_highlightModeCombo->addItems({"0 - Clip", "1 - Unclip", "2 - Blend", "3 - Rebuild", "4 - Rebuild", "5 - Rebuild", "6 - Rebuild", "7 - Rebuild", "8 - Rebuild", "9 - Rebuild"});
+ layout->addWidget(m_highlightModeCombo, 2, 3);
+
+ m_processingGroup->setLayout(layout);
+}
+
+void ParameterWidget::setupOutputGroup()
+{
+ m_outputGroup = new QGroupBox("Output Options");
+ QGridLayout *layout = new QGridLayout;
+
+ // Output directory
+ layout->addWidget(new QLabel("Output Directory:"), 0, 0);
+ m_outputDirEdit = new QLineEdit;
+ m_outputDirEdit->setPlaceholderText("Leave empty to use input directory");
+ layout->addWidget(m_outputDirEdit, 0, 1);
+
+ m_browseOutputButton = new QPushButton("Browse...");
+ connect(m_browseOutputButton, &QPushButton::clicked, this, &ParameterWidget::chooseOutputDirectory);
+ layout->addWidget(m_browseOutputButton, 0, 2);
+
+ // Checkboxes
+ m_overwriteCheck = new QCheckBox("Overwrite existing files");
+ layout->addWidget(m_overwriteCheck, 1, 0);
+
+ m_createDirsCheck = new QCheckBox("Create output directories");
+ layout->addWidget(m_createDirsCheck, 1, 1);
+
+ m_disableCacheCheck = new QCheckBox("Disable cache");
+ layout->addWidget(m_disableCacheCheck, 1, 2);
+
+ m_outputGroup->setLayout(layout);
+}
+
+void ParameterWidget::setupAdvancedGroup()
+{
+ m_advancedGroup = new QGroupBox("Advanced Options");
+
+ // Advanced toggle button
+ m_advancedToggleButton = new QPushButton("Show Advanced Options");
+ connect(m_advancedToggleButton, &QPushButton::clicked, this, &ParameterWidget::showAdvancedOptions);
+
+ // Advanced widget (initially hidden)
+ m_advancedWidget = new QWidget;
+ QGridLayout *layout = new QGridLayout;
+
+ // Black level
+ layout->addWidget(new QLabel("Black Level:"), 0, 0);
+ m_blackLevelSpin = new QSpinBox;
+ m_blackLevelSpin->setRange(-1, 65535);
+ m_blackLevelSpin->setValue(-1);
+ m_blackLevelSpin->setSpecialValueText("Auto");
+ layout->addWidget(m_blackLevelSpin, 0, 1);
+
+ // Saturation level
+ layout->addWidget(new QLabel("Saturation Level:"), 0, 2);
+ m_saturationSpin = new QSpinBox;
+ m_saturationSpin->setRange(0, 65535);
+ m_saturationSpin->setValue(0);
+ m_saturationSpin->setSpecialValueText("Auto");
+ layout->addWidget(m_saturationSpin, 0, 3);
+
+ // Chromatic aberration
+ layout->addWidget(new QLabel("Chromatic Aberration:"), 1, 0);
+ QHBoxLayout *chromLayout = new QHBoxLayout;
+
+ m_chromAberrationR = new QDoubleSpinBox;
+ m_chromAberrationR->setRange(0.5, 2.0);
+ m_chromAberrationR->setValue(1.0);
+ m_chromAberrationR->setDecimals(3);
+ m_chromAberrationR->setSuffix(" R");
+ chromLayout->addWidget(m_chromAberrationR);
+
+ m_chromAberrationB = new QDoubleSpinBox;
+ m_chromAberrationB->setRange(0.5, 2.0);
+ m_chromAberrationB->setValue(1.0);
+ m_chromAberrationB->setDecimals(3);
+ m_chromAberrationB->setSuffix(" B");
+ chromLayout->addWidget(m_chromAberrationB);
+
+ QWidget *chromWidget = new QWidget;
+ chromWidget->setLayout(chromLayout);
+ layout->addWidget(chromWidget, 1, 1, 1, 2);
+
+ // Debug options
+ m_verboseCheck = new QCheckBox("Verbose output");
+ layout->addWidget(m_verboseCheck, 2, 0);
+
+ m_timingCheck = new QCheckBox("Show timing");
+ layout->addWidget(m_timingCheck, 2, 1);
+
+ m_advancedWidget->setLayout(layout);
+ m_advancedWidget->setVisible(false);
+
+ // Group layout
+ QVBoxLayout *groupLayout = new QVBoxLayout;
+ groupLayout->addWidget(m_advancedToggleButton);
+ groupLayout->addWidget(m_advancedWidget);
+ m_advancedGroup->setLayout(groupLayout);
+}
+
+void ParameterWidget::onWbMethodChanged()
+{
+ QString method = m_wbMethodCombo->currentText();
+
+ // Show/hide controls based on method
+ m_illuminantCombo->setVisible(method == "illuminant");
+ m_customIlluminantEdit->setVisible(method == "illuminant");
+
+ // Enable/disable WB box controls
+ bool boxMode = (method == "box");
+ m_wbBoxXSpin->setEnabled(boxMode);
+ m_wbBoxYSpin->setEnabled(boxMode);
+ m_wbBoxWSpin->setEnabled(boxMode);
+ m_wbBoxHSpin->setEnabled(boxMode);
+
+ // Enable/disable custom WB controls
+ bool customMode = (method == "custom");
+ m_customWbR->setEnabled(customMode);
+ m_customWbG1->setEnabled(customMode);
+ m_customWbB->setEnabled(customMode);
+ m_customWbG2->setEnabled(customMode);
+
+ emit parametersChanged();
+}
+
+void ParameterWidget::onMatMethodChanged()
+{
+ QString method = m_matMethodCombo->currentText();
+
+ // Show/hide custom matrix controls
+ m_customMatrixWidget->setVisible(method == "custom");
+
+ emit parametersChanged();
+}
+
+void ParameterWidget::onParameterChanged()
+{
+ emit parametersChanged();
+}
+
+void ParameterWidget::chooseOutputDirectory()
+{
+ QString dir = QFileDialog::getExistingDirectory(this, "Choose Output Directory", m_outputDirEdit->text());
+ if (!dir.isEmpty()) {
+ m_outputDirEdit->setText(dir);
+ emit parametersChanged();
+ }
+}
+
+void ParameterWidget::showAdvancedOptions()
+{
+ m_advancedVisible = !m_advancedVisible;
+ m_advancedWidget->setVisible(m_advancedVisible);
+ m_advancedToggleButton->setText(m_advancedVisible ? "Hide Advanced Options" : "Show Advanced Options");
+}
+
+ConversionParameters ParameterWidget::getParameters() const
+{
+ ConversionParameters params;
+
+ // White balance
+ params.wbMethod = m_wbMethodCombo->currentText();
+ params.illuminant = m_illuminantCombo->currentText();
+ if (!m_customIlluminantEdit->text().isEmpty()) {
+ params.illuminant = m_customIlluminantEdit->text();
+ }
+ params.wbBoxOrigin = QPoint(m_wbBoxXSpin->value(), m_wbBoxYSpin->value());
+ params.wbBoxSize = QSize(m_wbBoxWSpin->value(), m_wbBoxHSpin->value());
+ params.customWb = {m_customWbR->value(), m_customWbG1->value(), m_customWbB->value(), m_customWbG2->value()};
+
+ // Matrix
+ params.matMethod = m_matMethodCombo->currentText();
+ params.customCameraMake = m_customMakeEdit->text();
+ params.customCameraModel = m_customModelEdit->text();
+
+ if (params.matMethod == "custom") {
+ params.customMatrix.resize(9);
+ for (int i = 0; i < 9; ++i) {
+ params.customMatrix[i] = m_matrixSpins[i]->value();
+ }
+ }
+
+ // Processing
+ params.headroom = m_headroomSpin->value();
+ params.scale = m_scaleSpin->value();
+ params.autobrightEnabled = m_autobrightCheck->isChecked();
+ params.halfSize = m_halfSizeCheck->isChecked();
+ params.demosaicAlgorithm = m_demosaicCombo->currentText();
+ params.highlightMode = m_highlightModeCombo->currentIndex();
+
+ // Advanced
+ params.blackLevel = m_blackLevelSpin->value();
+ params.saturationLevel = m_saturationSpin->value();
+ params.chromaticAberration = QPointF(m_chromAberrationR->value(), m_chromAberrationB->value());
+ params.verbose = m_verboseCheck->isChecked();
+ params.useTiming = m_timingCheck->isChecked();
+
+ // Output
+ params.outputDir = m_outputDirEdit->text();
+ params.overwrite = m_overwriteCheck->isChecked();
+ params.createDirs = m_createDirsCheck->isChecked();
+ params.useCache = !m_disableCacheCheck->isChecked();
+
+ return params;
+}
+
+void ParameterWidget::setParameters(const ConversionParameters ¶ms)
+{
+ // White balance
+ m_wbMethodCombo->setCurrentText(params.wbMethod);
+ m_illuminantCombo->setCurrentText(params.illuminant);
+ m_wbBoxXSpin->setValue(params.wbBoxOrigin.x());
+ m_wbBoxYSpin->setValue(params.wbBoxOrigin.y());
+ m_wbBoxWSpin->setValue(params.wbBoxSize.width());
+ m_wbBoxHSpin->setValue(params.wbBoxSize.height());
+
+ if (params.customWb.size() >= 4) {
+ m_customWbR->setValue(params.customWb[0]);
+ m_customWbG1->setValue(params.customWb[1]);
+ m_customWbB->setValue(params.customWb[2]);
+ m_customWbG2->setValue(params.customWb[3]);
+ }
+
+ // Matrix
+ m_matMethodCombo->setCurrentText(params.matMethod);
+ m_customMakeEdit->setText(params.customCameraMake);
+ m_customModelEdit->setText(params.customCameraModel);
+
+ if (params.customMatrix.size() == 9) {
+ for (int i = 0; i < 9; ++i) {
+ m_matrixSpins[i]->setValue(params.customMatrix[i]);
+ }
+ }
+
+ // Processing
+ m_headroomSpin->setValue(params.headroom);
+ m_scaleSpin->setValue(params.scale);
+ m_autobrightCheck->setChecked(params.autobrightEnabled);
+ m_halfSizeCheck->setChecked(params.halfSize);
+ m_demosaicCombo->setCurrentText(params.demosaicAlgorithm);
+ m_highlightModeCombo->setCurrentIndex(params.highlightMode);
+
+ // Advanced
+ m_blackLevelSpin->setValue(params.blackLevel);
+ m_saturationSpin->setValue(params.saturationLevel);
+ m_chromAberrationR->setValue(params.chromaticAberration.x());
+ m_chromAberrationB->setValue(params.chromaticAberration.y());
+ m_verboseCheck->setChecked(params.verbose);
+ m_timingCheck->setChecked(params.useTiming);
+
+ // Output
+ m_outputDirEdit->setText(params.outputDir);
+ m_overwriteCheck->setChecked(params.overwrite);
+ m_createDirsCheck->setChecked(params.createDirs);
+ m_disableCacheCheck->setChecked(!params.useCache);
+
+ // Update UI state
+ onWbMethodChanged();
+ onMatMethodChanged();
+}
+
+void ParameterWidget::resetToDefaults()
+{
+ setParameters(ConversionParameters());
+}
+
+void ParameterWidget::setWbBoxFromSelection(const QRect &rect)
+{
+ if (!rect.isValid()) return;
+ m_wbBoxXSpin->setValue(rect.x());
+ m_wbBoxYSpin->setValue(rect.y());
+ m_wbBoxWSpin->setValue(rect.width());
+ m_wbBoxHSpin->setValue(rect.height());
+ if (m_wbMethodCombo->currentText() != "box") {
+ m_wbMethodCombo->setCurrentText("box");
+ onWbMethodChanged();
+ }
+ emit parametersChanged();
+}
+
+void ParameterWidget::setCropBoxFromSelection(const QRect &rect)
+{
+ if (!rect.isValid()) return;
+ if (!m_advancedVisible) {
+ showAdvancedOptions();
+ }
+ m_cropXSpin->setValue(rect.x());
+ m_cropYSpin->setValue(rect.y());
+ m_cropWSpin->setValue(rect.width());
+ m_cropHSpin->setValue(rect.height());
+ if (m_cropModeCombo->currentText() == "none") {
+ m_cropModeCombo->setCurrentText("soft");
+ }
+ emit parametersChanged();
+}
diff --git a/gui/src/ParameterWidget.h b/gui/src/ParameterWidget.h
new file mode 100644
index 00000000..d7178c74
--- /dev/null
+++ b/gui/src/ParameterWidget.h
@@ -0,0 +1,154 @@
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+struct ConversionParameters {
+ // White balance
+ QString wbMethod = "metadata";
+ QString illuminant = "D55";
+ QPoint wbBoxOrigin = QPoint(0, 0);
+ QSize wbBoxSize = QSize(0, 0);
+ QVector customWb = {1.0, 1.0, 1.0, 1.0};
+
+ // Matrix calculation
+ QString matMethod = "spectral";
+ QVector customMatrix;
+ QString customCameraMake;
+ QString customCameraModel;
+
+ // Processing options
+ double headroom = 6.0;
+ double scale = 1.0;
+ bool autobrightEnabled = false;
+ double adjustMaxThreshold = 0.75;
+ int blackLevel = -1;
+ int saturationLevel = 0;
+ QPointF chromaticAberration = QPointF(1.0, 1.0);
+ bool halfSize = false;
+ int highlightMode = 0;
+ QRect cropBox = QRect(0, 0, 0, 0);
+ QString cropMode = "soft";
+ int flip = 0;
+ double denoiseThreshold = 0.0;
+ QString demosaicAlgorithm = "AHD";
+
+ // Output options
+ bool overwrite = false;
+ QString outputDir;
+ bool createDirs = false;
+ bool useCache = true;
+
+ // Debug options
+ bool verbose = false;
+ bool useTiming = false;
+};
+
+class ParameterWidget : public QWidget
+{
+ Q_OBJECT
+
+public:
+ explicit ParameterWidget(QWidget *parent = nullptr);
+
+ ConversionParameters getParameters() const;
+ void setParameters(const ConversionParameters ¶ms);
+ void resetToDefaults();
+ // Apply rectangles from viewer (image pixel coords)
+ void setWbBoxFromSelection(const QRect &rect);
+ void setCropBoxFromSelection(const QRect &rect);
+
+signals:
+ void parametersChanged();
+
+private slots:
+ void onWbMethodChanged();
+ void onMatMethodChanged();
+ void onParameterChanged();
+ void chooseOutputDirectory();
+ void showAdvancedOptions();
+
+private:
+ void setupUI();
+ void setupWhiteBalanceGroup();
+ void setupMatrixGroup();
+ void setupProcessingGroup();
+ void setupOutputGroup();
+ void setupAdvancedGroup();
+ void updateWbControls();
+ void updateMatControls();
+
+ // UI Groups
+ QScrollArea *m_scrollArea;
+ QWidget *m_contentWidget;
+ QGroupBox *m_wbGroup;
+ QGroupBox *m_matrixGroup;
+ QGroupBox *m_processingGroup;
+ QGroupBox *m_outputGroup;
+ QGroupBox *m_advancedGroup;
+
+ // White balance controls
+ QComboBox *m_wbMethodCombo;
+ QComboBox *m_illuminantCombo;
+ QLineEdit *m_customIlluminantEdit;
+ QSpinBox *m_wbBoxXSpin;
+ QSpinBox *m_wbBoxYSpin;
+ QSpinBox *m_wbBoxWSpin;
+ QSpinBox *m_wbBoxHSpin;
+ QDoubleSpinBox *m_customWbR;
+ QDoubleSpinBox *m_customWbG1;
+ QDoubleSpinBox *m_customWbB;
+ QDoubleSpinBox *m_customWbG2;
+
+ // Matrix controls
+ QComboBox *m_matMethodCombo;
+ QLineEdit *m_customMakeEdit;
+ QLineEdit *m_customModelEdit;
+ QWidget *m_customMatrixWidget;
+ QVector m_matrixSpins;
+
+ // Processing controls
+ QDoubleSpinBox *m_headroomSpin;
+ QDoubleSpinBox *m_scaleSpin;
+ QCheckBox *m_autobrightCheck;
+ QDoubleSpinBox *m_adjustMaxSpin;
+ QSpinBox *m_blackLevelSpin;
+ QSpinBox *m_saturationSpin;
+ QDoubleSpinBox *m_chromAberrationR;
+ QDoubleSpinBox *m_chromAberrationB;
+ QCheckBox *m_halfSizeCheck;
+ QComboBox *m_highlightModeCombo;
+ QComboBox *m_demosaicCombo;
+
+ // Output controls
+ QLineEdit *m_outputDirEdit;
+ QPushButton *m_browseOutputButton;
+ QCheckBox *m_overwriteCheck;
+ QCheckBox *m_createDirsCheck;
+ QCheckBox *m_disableCacheCheck;
+
+ // Advanced controls
+ QWidget *m_advancedWidget;
+ bool m_advancedVisible;
+ QPushButton *m_advancedToggleButton;
+ QSpinBox *m_cropXSpin;
+ QSpinBox *m_cropYSpin;
+ QSpinBox *m_cropWSpin;
+ QSpinBox *m_cropHSpin;
+ QComboBox *m_cropModeCombo;
+ QComboBox *m_flipCombo;
+ QDoubleSpinBox *m_denoiseSpin;
+ QCheckBox *m_verboseCheck;
+ QCheckBox *m_timingCheck;
+};
diff --git a/gui/src/ProgressDialog.cpp b/gui/src/ProgressDialog.cpp
new file mode 100644
index 00000000..4fe37d23
--- /dev/null
+++ b/gui/src/ProgressDialog.cpp
@@ -0,0 +1,185 @@
+#include "ProgressDialog.h"
+#include
+#include
+#include
+#include
+
+ProgressDialog::ProgressDialog(QWidget *parent)
+ : QDialog(parent)
+ , m_progressBar(nullptr)
+ , m_statusLabel(nullptr)
+ , m_detailsLabel(nullptr)
+ , m_cancelButton(nullptr)
+ , m_pauseButton(nullptr)
+ , m_expandButton(nullptr)
+ , m_detailsWidget(nullptr)
+ , m_logTextEdit(nullptr)
+ , m_isExpanded(false)
+ , m_canCancel(true)
+ , m_canPause(false)
+{
+ setupUI();
+ setFixedSize(400, 150);
+}
+
+ProgressDialog::~ProgressDialog()
+{
+}
+
+void ProgressDialog::setupUI()
+{
+ setWindowTitle("Processing...");
+ setModal(true);
+
+ // Main layout
+ QVBoxLayout *mainLayout = new QVBoxLayout(this);
+
+ // Status label
+ m_statusLabel = new QLabel("Initializing...");
+ m_statusLabel->setWordWrap(true);
+ mainLayout->addWidget(m_statusLabel);
+
+ // Progress bar
+ m_progressBar = new QProgressBar;
+ m_progressBar->setRange(0, 100);
+ m_progressBar->setValue(0);
+ mainLayout->addWidget(m_progressBar);
+
+ // Details label (file being processed, etc.)
+ m_detailsLabel = new QLabel("");
+ m_detailsLabel->setStyleSheet("QLabel { color: #666; font-size: 11px; }");
+ m_detailsLabel->setWordWrap(true);
+ mainLayout->addWidget(m_detailsLabel);
+
+ // Button layout
+ QHBoxLayout *buttonLayout = new QHBoxLayout;
+
+ m_expandButton = new QPushButton("Show Details");
+ m_expandButton->setCheckable(true);
+ connect(m_expandButton, &QPushButton::toggled, this, &ProgressDialog::toggleDetails);
+
+ m_pauseButton = new QPushButton("Pause");
+ m_pauseButton->setEnabled(false);
+ connect(m_pauseButton, &QPushButton::clicked, this, &ProgressDialog::pauseClicked);
+
+ m_cancelButton = new QPushButton("Cancel");
+ connect(m_cancelButton, &QPushButton::clicked, this, &ProgressDialog::cancelClicked);
+
+ buttonLayout->addWidget(m_expandButton);
+ buttonLayout->addStretch();
+ buttonLayout->addWidget(m_pauseButton);
+ buttonLayout->addWidget(m_cancelButton);
+
+ mainLayout->addLayout(buttonLayout);
+
+ // Details widget (initially hidden)
+ m_detailsWidget = new QWidget;
+ QVBoxLayout *detailsLayout = new QVBoxLayout(m_detailsWidget);
+ detailsLayout->setContentsMargins(0, 0, 0, 0);
+
+ m_logTextEdit = new QTextEdit;
+ m_logTextEdit->setMaximumHeight(150);
+ m_logTextEdit->setReadOnly(true);
+ m_logTextEdit->setFont(QFont("Courier", 9));
+ detailsLayout->addWidget(m_logTextEdit);
+
+ mainLayout->addWidget(m_detailsWidget);
+ m_detailsWidget->hide();
+}
+
+void ProgressDialog::setProgress(int value)
+{
+ m_progressBar->setValue(value);
+}
+
+void ProgressDialog::setRange(int minimum, int maximum)
+{
+ m_progressBar->setRange(minimum, maximum);
+}
+
+void ProgressDialog::setStatus(const QString &status)
+{
+ m_statusLabel->setText(status);
+}
+
+void ProgressDialog::setDetails(const QString &details)
+{
+ m_detailsLabel->setText(details);
+}
+
+void ProgressDialog::appendLog(const QString &message)
+{
+ if (m_logTextEdit) {
+ m_logTextEdit->append(message);
+ // Auto-scroll to bottom
+ QTextCursor cursor = m_logTextEdit->textCursor();
+ cursor.movePosition(QTextCursor::End);
+ m_logTextEdit->setTextCursor(cursor);
+ }
+}
+
+void ProgressDialog::setCanCancel(bool canCancel)
+{
+ m_canCancel = canCancel;
+ m_cancelButton->setEnabled(canCancel);
+}
+
+void ProgressDialog::setCanPause(bool canPause)
+{
+ m_canPause = canPause;
+ m_pauseButton->setEnabled(canPause);
+}
+
+void ProgressDialog::setIndeterminate(bool indeterminate)
+{
+ if (indeterminate) {
+ m_progressBar->setRange(0, 0);
+ } else {
+ m_progressBar->setRange(0, 100);
+ }
+}
+
+void ProgressDialog::reset()
+{
+ m_progressBar->setValue(0);
+ m_statusLabel->setText("Initializing...");
+ m_detailsLabel->setText("");
+ if (m_logTextEdit) {
+ m_logTextEdit->clear();
+ }
+}
+
+void ProgressDialog::toggleDetails(bool show)
+{
+ m_isExpanded = show;
+
+ if (show) {
+ m_detailsWidget->show();
+ m_expandButton->setText("Hide Details");
+ setFixedSize(400, 350);
+ } else {
+ m_detailsWidget->hide();
+ m_expandButton->setText("Show Details");
+ setFixedSize(400, 150);
+ }
+}
+
+void ProgressDialog::pauseClicked()
+{
+ emit pauseRequested();
+}
+
+void ProgressDialog::cancelClicked()
+{
+ emit cancelRequested();
+}
+
+void ProgressDialog::closeEvent(QCloseEvent *event)
+{
+ if (m_canCancel) {
+ emit cancelRequested();
+ event->accept();
+ } else {
+ event->ignore();
+ }
+}
diff --git a/gui/src/ProgressDialog.h b/gui/src/ProgressDialog.h
new file mode 100644
index 00000000..522f8153
--- /dev/null
+++ b/gui/src/ProgressDialog.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+class ProgressDialog : public QDialog {
+ Q_OBJECT
+public:
+ explicit ProgressDialog(QWidget *parent = nullptr);
+ ~ProgressDialog();
+
+ void setProgress(int value);
+ void setRange(int minimum, int maximum);
+ void setStatus(const QString &status);
+ void setDetails(const QString &details);
+ void appendLog(const QString &message);
+
+ void setCanCancel(bool canCancel);
+ void setCanPause(bool canPause);
+ void setIndeterminate(bool indeterminate);
+ void reset();
+
+signals:
+ void pauseRequested();
+ void cancelRequested();
+
+protected:
+ void closeEvent(QCloseEvent *event) override;
+
+private slots:
+ void toggleDetails(bool show);
+ void pauseClicked();
+ void cancelClicked();
+
+private:
+ void setupUI();
+
+ QProgressBar *m_progressBar;
+ QLabel *m_statusLabel;
+ QLabel *m_detailsLabel;
+ QPushButton *m_cancelButton;
+ QPushButton *m_pauseButton;
+ QPushButton *m_expandButton;
+ QWidget *m_detailsWidget;
+ QTextEdit *m_logTextEdit;
+
+ bool m_isExpanded;
+ bool m_canCancel;
+ bool m_canPause;
+};
diff --git a/gui/src/SettingsManager.cpp b/gui/src/SettingsManager.cpp
new file mode 100644
index 00000000..0e04c1a5
--- /dev/null
+++ b/gui/src/SettingsManager.cpp
@@ -0,0 +1,80 @@
+#include "SettingsManager.h"
+#include
+#include
+
+SettingsManager& SettingsManager::instance()
+{
+ static SettingsManager instance;
+ return instance;
+}
+
+SettingsManager::SettingsManager(QObject *parent)
+ : QObject(parent)
+ , m_settings(nullptr)
+{
+ m_settings = new QSettings(this);
+ m_lastDirectory = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
+}
+
+void SettingsManager::loadSettings()
+{
+ m_lastDirectory = m_settings->value("lastDirectory",
+ QStandardPaths::writableLocation(QStandardPaths::PicturesLocation)).toString();
+}
+
+void SettingsManager::saveSettings()
+{
+ m_settings->setValue("lastDirectory", m_lastDirectory);
+ m_settings->sync();
+}
+
+QString SettingsManager::getLastDirectory() const
+{
+ return m_lastDirectory;
+}
+
+void SettingsManager::setLastDirectory(const QString &directory)
+{
+ m_lastDirectory = directory;
+ m_settings->setValue("lastDirectory", directory);
+}
+
+ConversionParameters SettingsManager::getDefaultParameters() const
+{
+ return m_defaultParameters;
+}
+
+void SettingsManager::setDefaultParameters(const ConversionParameters ¶meters)
+{
+ m_defaultParameters = parameters;
+}
+
+QByteArray SettingsManager::getWindowGeometry() const
+{
+ return m_settings->value("windowGeometry").toByteArray();
+}
+
+void SettingsManager::setWindowGeometry(const QByteArray &geometry)
+{
+ m_settings->setValue("windowGeometry", geometry);
+}
+
+QByteArray SettingsManager::getWindowState() const
+{
+ return m_settings->value("windowState").toByteArray();
+}
+
+void SettingsManager::setWindowState(const QByteArray &state)
+{
+ m_settings->setValue("windowState", state);
+}
+
+QByteArray SettingsManager::getSplitterState(const QString &name) const
+{
+ return m_settings->value(QString("splitter_%1").arg(name)).toByteArray();
+}
+
+void SettingsManager::setSplitterState(const QString &name, const QByteArray &state)
+{
+ m_settings->setValue(QString("splitter_%1").arg(name), state);
+}
diff --git a/gui/src/SettingsManager.h b/gui/src/SettingsManager.h
new file mode 100644
index 00000000..6ee6a6b6
--- /dev/null
+++ b/gui/src/SettingsManager.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include
+#include
+#include
+#include "ParameterWidget.h"
+
+class SettingsManager : public QObject
+{
+ Q_OBJECT
+
+public:
+ static SettingsManager& instance();
+
+ void loadSettings();
+ void saveSettings();
+
+ // Last used directory
+ QString getLastDirectory() const;
+ void setLastDirectory(const QString &directory);
+
+ // Conversion parameters
+ ConversionParameters getDefaultParameters() const;
+ void setDefaultParameters(const ConversionParameters ¶meters);
+
+ // UI settings
+ QByteArray getWindowGeometry() const;
+ void setWindowGeometry(const QByteArray &geometry);
+
+ QByteArray getWindowState() const;
+ void setWindowState(const QByteArray &state);
+
+ QByteArray getSplitterState(const QString &name) const;
+ void setSplitterState(const QString &name, const QByteArray &state);
+
+private:
+ explicit SettingsManager(QObject *parent = nullptr);
+ ~SettingsManager() = default;
+
+ SettingsManager(const SettingsManager&) = delete;
+ SettingsManager& operator=(const SettingsManager&) = delete;
+
+ QSettings *m_settings;
+ QString m_lastDirectory;
+ ConversionParameters m_defaultParameters;
+};
diff --git a/gui/src/main.cpp b/gui/src/main.cpp
new file mode 100644
index 00000000..25cb1f4f
--- /dev/null
+++ b/gui/src/main.cpp
@@ -0,0 +1,66 @@
+#include
+#include
+#include
+#include
+#include
+#include
+#include "MainWindow.h"
+#include "SettingsManager.h"
+
+int main(int argc, char *argv[])
+{
+ QApplication app(argc, argv);
+
+ // Set application properties
+ app.setApplicationName("RAWtoACES GUI");
+ app.setApplicationVersion("1.0.0");
+ app.setOrganizationName("Academy Software Foundation");
+ app.setOrganizationDomain("aswf.io");
+
+ // Set application style
+ app.setStyle(QStyleFactory::create("Fusion"));
+
+ // Apply dark theme
+ QPalette darkPalette;
+ darkPalette.setColor(QPalette::Window, QColor(53, 53, 53));
+ darkPalette.setColor(QPalette::WindowText, Qt::white);
+ darkPalette.setColor(QPalette::Base, QColor(25, 25, 25));
+ darkPalette.setColor(QPalette::AlternateBase, QColor(53, 53, 53));
+ darkPalette.setColor(QPalette::ToolTipBase, Qt::white);
+ darkPalette.setColor(QPalette::ToolTipText, Qt::white);
+ darkPalette.setColor(QPalette::Text, Qt::white);
+ darkPalette.setColor(QPalette::Button, QColor(53, 53, 53));
+ darkPalette.setColor(QPalette::ButtonText, Qt::white);
+ darkPalette.setColor(QPalette::BrightText, Qt::red);
+ darkPalette.setColor(QPalette::Link, QColor(42, 130, 218));
+ darkPalette.setColor(QPalette::Highlight, QColor(42, 130, 218));
+ darkPalette.setColor(QPalette::HighlightedText, Qt::black);
+ app.setPalette(darkPalette);
+
+ // Initialize settings
+ SettingsManager::instance().loadSettings();
+
+ // Create and show main window
+ MainWindow window;
+ window.show();
+ // Optional smoke-test: if env RAWTOACES_GUI_SMOKE_TEST is set, quit shortly after launch
+ if (qEnvironmentVariableIsSet("RAWTOACES_GUI_SMOKE_TEST")) {
+ QTimer::singleShot(1200, &app, &QCoreApplication::quit);
+ }
+
+ // Handle command line arguments
+ QStringList args = app.arguments();
+ if (args.size() > 1) {
+ QStringList files;
+ for (int i = 1; i < args.size(); ++i) {
+ if (QFile::exists(args[i])) {
+ files << args[i];
+ }
+ }
+ if (!files.isEmpty()) {
+ window.addFiles(files);
+ }
+ }
+
+ return app.exec();
+}
diff --git a/gui/src/utils/FileUtils.cpp b/gui/src/utils/FileUtils.cpp
new file mode 100644
index 00000000..1e4104bf
--- /dev/null
+++ b/gui/src/utils/FileUtils.cpp
@@ -0,0 +1,243 @@
+#include "../../include/utils/FileUtils.h"
+#include
+#include
+#include
+#include
+#include
+
+namespace FileUtils {
+
+bool isRawFile(const QString &filename)
+{
+ static const QStringList rawExtensions = {
+ "cr2", "cr3", "nef", "arw", "dng", "raf", "orf", "rw2", "pef", "srw",
+ "x3f", "bay", "bmq", "cs1", "dc2", "dcr", "fff", "hdr", "k25", "kdc",
+ "mdc", "mos", "mrw", "raw", "rwl", "sr2", "srf", "sti", "3fr", "ari",
+ "cap", "iiq", "eip", "dcs", "dcr", "drf", "erf", "gpr", "iiq", "mef",
+ "mfw", "nrw", "ptx", "pxn", "r3d", "rwz", "srf", "srw2"
+ };
+
+ QFileInfo fileInfo(filename);
+ QString extension = fileInfo.suffix().toLower();
+ return rawExtensions.contains(extension);
+}
+
+bool isImageFile(const QString &filename)
+{
+ static const QStringList imageExtensions = {
+ "jpg", "jpeg", "png", "tiff", "tif", "bmp", "gif", "webp", "exr", "hdr"
+ };
+
+ QFileInfo fileInfo(filename);
+ QString extension = fileInfo.suffix().toLower();
+ return imageExtensions.contains(extension) || isRawFile(filename);
+}
+
+QString getFileExtension(const QString &filename)
+{
+ QFileInfo fileInfo(filename);
+ return fileInfo.suffix().toLower();
+}
+
+QString getBaseName(const QString &filename)
+{
+ QFileInfo fileInfo(filename);
+ return fileInfo.baseName();
+}
+
+QString getDirectory(const QString &filename)
+{
+ QFileInfo fileInfo(filename);
+ return fileInfo.absolutePath();
+}
+
+qint64 getFileSize(const QString &filename)
+{
+ QFileInfo fileInfo(filename);
+ return fileInfo.size();
+}
+
+QString formatFileSize(qint64 size)
+{
+ const QStringList units = {"B", "KB", "MB", "GB", "TB"};
+ int unitIndex = 0;
+ double sizeDouble = size;
+
+ while (sizeDouble >= 1024 && unitIndex < units.size() - 1) {
+ sizeDouble /= 1024;
+ unitIndex++;
+ }
+
+ return QString("%1 %2").arg(sizeDouble, 0, 'f', 1).arg(units[unitIndex]);
+}
+
+QDateTime getFileModificationTime(const QString &filename)
+{
+ QFileInfo fileInfo(filename);
+ return fileInfo.lastModified();
+}
+
+bool fileExists(const QString &filename)
+{
+ return QFile::exists(filename);
+}
+
+bool createDirectory(const QString &path)
+{
+ QDir dir;
+ return dir.mkpath(path);
+}
+
+QString getUniqueFilename(const QString &filename)
+{
+ if (!QFile::exists(filename)) {
+ return filename;
+ }
+
+ QFileInfo fileInfo(filename);
+ QString baseName = fileInfo.baseName();
+ QString extension = fileInfo.suffix();
+ QString directory = fileInfo.absolutePath();
+
+ int counter = 1;
+ QString newFilename;
+
+ do {
+ newFilename = QString("%1/%2_%3.%4")
+ .arg(directory)
+ .arg(baseName)
+ .arg(counter)
+ .arg(extension);
+ counter++;
+ } while (QFile::exists(newFilename));
+
+ return newFilename;
+}
+
+QString getApplicationDataPath()
+{
+ QString appName = QCoreApplication::applicationName();
+ if (appName.isEmpty()) {
+ appName = "RAWtoACES_GUI";
+ }
+
+ QString path = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
+ if (path.isEmpty()) {
+ path = QStandardPaths::writableLocation(QStandardPaths::HomeLocation) +
+ "/.config/" + appName;
+ }
+
+ // Ensure the directory exists
+ QDir dir;
+ if (!dir.exists(path)) {
+ dir.mkpath(path);
+ }
+
+ return path;
+}
+
+QString getTemporaryPath()
+{
+ QString tempPath = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
+ QString appTempPath = tempPath + "/RAWtoACES_GUI";
+
+ QDir dir;
+ if (!dir.exists(appTempPath)) {
+ dir.mkpath(appTempPath);
+ }
+
+ return appTempPath;
+}
+
+QStringList getFilesInDirectory(const QString &directory, const QStringList &filters, bool recursive)
+{
+ QStringList files;
+ QDir dir(directory);
+
+ if (!dir.exists()) {
+ return files;
+ }
+
+ QDir::Filters dirFilters = QDir::Files | QDir::Readable;
+ if (recursive) {
+ dirFilters |= QDir::AllDirs | QDir::NoDotAndDotDot;
+ }
+
+ QFileInfoList fileInfoList = dir.entryInfoList(filters, dirFilters);
+
+ for (const QFileInfo &fileInfo : fileInfoList) {
+ if (fileInfo.isFile()) {
+ files.append(fileInfo.absoluteFilePath());
+ } else if (fileInfo.isDir() && recursive) {
+ files.append(getFilesInDirectory(fileInfo.absoluteFilePath(), filters, recursive));
+ }
+ }
+
+ return files;
+}
+
+QStringList getRawFilesInDirectory(const QString &directory, bool recursive)
+{
+ QStringList rawFilters;
+ QStringList rawExtensions = {
+ "*.cr2", "*.cr3", "*.nef", "*.arw", "*.dng", "*.raf", "*.orf", "*.rw2",
+ "*.pef", "*.srw", "*.x3f", "*.bay", "*.bmq", "*.cs1", "*.dc2", "*.dcr",
+ "*.fff", "*.hdr", "*.k25", "*.kdc", "*.mdc", "*.mos", "*.mrw", "*.raw",
+ "*.rwl", "*.sr2", "*.srf", "*.sti", "*.3fr", "*.ari", "*.cap", "*.iiq",
+ "*.eip", "*.dcs", "*.drf", "*.erf", "*.gpr", "*.mef", "*.mfw", "*.nrw",
+ "*.ptx", "*.pxn", "*.r3d", "*.rwz", "*.srw2"
+ };
+
+ // Add uppercase versions
+ for (const QString &ext : rawExtensions) {
+ rawFilters.append(ext.toUpper());
+ }
+ rawFilters.append(rawExtensions);
+
+ return getFilesInDirectory(directory, rawFilters, recursive);
+}
+
+bool copyFile(const QString &source, const QString &destination)
+{
+ // Remove destination if it exists
+ if (QFile::exists(destination)) {
+ QFile::remove(destination);
+ }
+
+ return QFile::copy(source, destination);
+}
+
+bool moveFile(const QString &source, const QString &destination)
+{
+ // Remove destination if it exists
+ if (QFile::exists(destination)) {
+ QFile::remove(destination);
+ }
+
+ return QFile::rename(source, destination);
+}
+
+bool deleteFile(const QString &filename)
+{
+ return QFile::remove(filename);
+}
+
+QString makeRelativePath(const QString &fromPath, const QString &toPath)
+{
+ QDir fromDir(fromPath);
+ return fromDir.relativeFilePath(toPath);
+}
+
+QString makeAbsolutePath(const QString &basePath, const QString &relativePath)
+{
+ QDir baseDir(basePath);
+ return baseDir.absoluteFilePath(relativePath);
+}
+
+bool validatePath(const QString &path)
+{
+ QFileInfo fileInfo(path);
+ return fileInfo.exists() && fileInfo.isReadable();
+}
+
+} // namespace FileUtils
diff --git a/gui/src/utils/FileUtils.h b/gui/src/utils/FileUtils.h
new file mode 100644
index 00000000..4e2898c9
--- /dev/null
+++ b/gui/src/utils/FileUtils.h
@@ -0,0 +1,3 @@
+#pragma once
+
+#include "../../include/utils/FileUtils.h"
diff --git a/gui/src/utils/ImageUtils.cpp b/gui/src/utils/ImageUtils.cpp
new file mode 100644
index 00000000..2d13b8f1
--- /dev/null
+++ b/gui/src/utils/ImageUtils.cpp
@@ -0,0 +1,99 @@
+#include "ImageUtils.h"
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include "FileUtils.h"
+#include "RawPreview.h"
+
+namespace ImageUtils {
+
+QImage createPlaceholder(const QString &label, int width, int height)
+{
+ QImage img(width, height, QImage::Format_ARGB32_Premultiplied);
+ img.fill(QColor(64, 64, 64));
+
+ QPainter p(&img);
+ p.setRenderHint(QPainter::Antialiasing);
+ p.setPen(Qt::white);
+ p.setFont(QFont("Arial", 12));
+
+ QRect r = QRect(0, 0, width, height);
+ p.drawText(r, Qt::AlignCenter, label);
+
+ return img;
+}
+
+QImage loadPreview(const QString &filepath, int maxWidth, int maxHeight)
+{
+ QFileInfo fi(filepath);
+ if (!fi.exists()) {
+ return createPlaceholder("File not found", maxWidth, maxHeight);
+ }
+
+ // Try RAW embedded preview first if it's a RAW file
+ if (FileUtils::isRawFile(filepath)) {
+ QImage rawThumb = RawPreview::extractEmbeddedPreview(filepath);
+ if (!rawThumb.isNull()) {
+ return rawThumb.scaled(maxWidth, maxHeight, Qt::KeepAspectRatio, Qt::SmoothTransformation);
+ }
+ }
+
+ // Try Qt-supported formats
+ QImageReader reader(filepath);
+ if (reader.canRead()) {
+ reader.setAutoTransform(true);
+ QImage img = reader.read();
+ if (!img.isNull()) {
+ img = img.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+ img = img.scaled(maxWidth, maxHeight, Qt::KeepAspectRatio, Qt::SmoothTransformation);
+ return img;
+ }
+ }
+
+ // Fallback placeholder
+ return createPlaceholder(QString("Preview not available\n%1").arg(fi.fileName()), maxWidth, maxHeight);
+}
+
+QImage frameImage(const QImage &src, int targetWidth, int targetHeight,
+ const QColor &background, const QColor &border)
+{
+ QImage canvas(targetWidth, targetHeight, QImage::Format_ARGB32_Premultiplied);
+ canvas.fill(background);
+
+ if (!src.isNull()) {
+ QSize target(targetWidth - 4, targetHeight - 4); // padding for border
+ QImage scaled = src.scaled(target, Qt::KeepAspectRatio, Qt::SmoothTransformation);
+ QPoint topLeft((targetWidth - scaled.width())/2, (targetHeight - scaled.height())/2);
+ QPainter p(&canvas);
+ p.setRenderHint(QPainter::Antialiasing);
+ p.drawImage(topLeft, scaled);
+ // border
+ p.setPen(QPen(border));
+ p.drawRect(0, 0, targetWidth-1, targetHeight-1);
+ }
+ return canvas;
+}
+
+QImage loadFramedThumbnail(const QString &filepath, int targetWidth, int targetHeight,
+ const QColor &background, const QColor &border)
+{
+ QImage preview = loadPreview(filepath, targetWidth, targetHeight);
+ return frameImage(preview, targetWidth, targetHeight, background, border);
+}
+
+QPixmap toPixmap(const QImage &image)
+{
+ QPixmap pm = QPixmap::fromImage(image);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
+ if (QGuiApplication::primaryScreen()) {
+ pm.setDevicePixelRatio(QGuiApplication::primaryScreen()->devicePixelRatio());
+ }
+#endif
+ return pm;
+}
+
+} // namespace ImageUtils
diff --git a/gui/src/utils/ImageUtils.h b/gui/src/utils/ImageUtils.h
new file mode 100644
index 00000000..1cff5e5b
--- /dev/null
+++ b/gui/src/utils/ImageUtils.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include
+#include
+#include
+#include
+
+namespace ImageUtils {
+
+// Load a preview image for a given file (RAW files get a placeholder)
+QImage loadPreview(const QString &filepath, int maxWidth = 1024, int maxHeight = 1024);
+
+// Load a preview and render into a framed thumbnail of target size
+QImage loadFramedThumbnail(const QString &filepath, int targetWidth = 96, int targetHeight = 72,
+ const QColor &background = QColor(40,40,40),
+ const QColor &border = QColor(80,80,80));
+
+// Convert QImage to QPixmap with device pixel ratio handling
+QPixmap toPixmap(const QImage &image);
+
+// Create a placeholder preview for non-decodable files
+QImage createPlaceholder(const QString &label, int width = 400, int height = 300);
+
+// Draw an image centered on a background with a subtle border
+QImage frameImage(const QImage &src, int targetWidth, int targetHeight,
+ const QColor &background = QColor(40,40,40),
+ const QColor &border = QColor(80,80,80));
+
+}
diff --git a/gui/src/utils/RawPreview.cpp b/gui/src/utils/RawPreview.cpp
new file mode 100644
index 00000000..36a11225
--- /dev/null
+++ b/gui/src/utils/RawPreview.cpp
@@ -0,0 +1,52 @@
+#include "RawPreview.h"
+
+#ifdef USE_LIBRAW
+#include
+#endif
+
+#include
+#include
+
+namespace RawPreview {
+
+QImage extractEmbeddedPreview(const QString &filepath)
+{
+#ifdef USE_LIBRAW
+ libraw_data_t proc;
+ if (libraw_open_file(&proc, filepath.toUtf8().constData()) != LIBRAW_SUCCESS) {
+ libraw_close(&proc);
+ return QImage();
+ }
+
+ if (libraw_unpack_thumb(&proc) != LIBRAW_SUCCESS) {
+ libraw_close(&proc);
+ return QImage();
+ }
+
+ QImage img;
+ if (proc.thumbnail.tformat == LIBRAW_THUMBNAIL_JPEG
+#ifdef LIBRAW_THUMBNAIL_JPEG2000
+ || proc.thumbnail.tformat == LIBRAW_THUMBNAIL_JPEG2000
+#endif
+ ) {
+ QByteArray bytes(reinterpret_cast(proc.thumbnail.thumb), proc.thumbnail.tlength);
+ img = QImage::fromData(bytes);
+ } else if (proc.thumbnail.tformat == LIBRAW_THUMBNAIL_BITMAP) {
+ // 8-bit RGB
+ int w = proc.thumbnail.twidth;
+ int h = proc.thumbnail.theight;
+ int stride = w * 3;
+ const uchar* data = reinterpret_cast(proc.thumbnail.thumb);
+ QImage temp(data, w, h, stride, QImage::Format_RGB888);
+ img = temp.copy(); // copy away from LibRaw buffer
+ }
+
+ libraw_close(&proc);
+ return img;
+#else
+ Q_UNUSED(filepath);
+ return QImage();
+#endif
+}
+
+} // namespace RawPreview
diff --git a/gui/src/utils/RawPreview.h b/gui/src/utils/RawPreview.h
new file mode 100644
index 00000000..fd94d5d4
--- /dev/null
+++ b/gui/src/utils/RawPreview.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include
+#include
+
+namespace RawPreview {
+
+// Try to extract an embedded thumbnail/preview via LibRaw (if available).
+// Returns null QImage on failure.
+QImage extractEmbeddedPreview(const QString &filepath);
+
+}
diff --git a/gui/tests/CMakeLists.txt b/gui/tests/CMakeLists.txt
new file mode 100644
index 00000000..78692eb5
--- /dev/null
+++ b/gui/tests/CMakeLists.txt
@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.16)
+
+find_package(Qt6 REQUIRED COMPONENTS Test Widgets)
+
+set(CMAKE_AUTOMOC ON)
+
+add_executable(rawtoaces_gui_tests
+ test_basic.cpp
+ ../src/ParameterWidget.cpp
+ ../src/utils/ImageUtils.cpp
+ ../src/utils/RawPreview.cpp
+ ../src/utils/FileUtils.cpp
+)
+
+target_include_directories(rawtoaces_gui_tests PRIVATE
+ ${CMAKE_CURRENT_SOURCE_DIR}/../src
+ ${CMAKE_CURRENT_SOURCE_DIR}/../include
+)
+
+target_link_libraries(rawtoaces_gui_tests
+ Qt6::Test
+ Qt6::Widgets
+)
+
+add_test(NAME rawtoaces_gui_tests COMMAND rawtoaces_gui_tests)
diff --git a/gui/tests/test_basic.cpp b/gui/tests/test_basic.cpp
new file mode 100644
index 00000000..e381fa9a
--- /dev/null
+++ b/gui/tests/test_basic.cpp
@@ -0,0 +1,39 @@
+#include
+#include
+#include "../src/utils/ImageUtils.h"
+#include "../src/ParameterWidget.h"
+
+class BasicGuiTests : public QObject {
+ Q_OBJECT
+private slots:
+ void imageutils_placeholder();
+ void imageutils_frame_size();
+ void parameterwidget_selection_mapping();
+};
+
+void BasicGuiTests::imageutils_placeholder()
+{
+ QImage img = ImageUtils::loadPreview("/path/does/not/exist.raw", 128, 96);
+ QVERIFY(!img.isNull());
+ QCOMPARE(img.width(), 128);
+}
+
+void BasicGuiTests::imageutils_frame_size()
+{
+ QImage framed = ImageUtils::loadFramedThumbnail("/path/does/not/exist.raw", 96, 72);
+ QCOMPARE(framed.size(), QSize(96,72));
+}
+
+void BasicGuiTests::parameterwidget_selection_mapping()
+{
+ ParameterWidget w;
+ QRect r(10, 20, 30, 40);
+ w.setWbBoxFromSelection(r);
+ auto params = w.getParameters();
+ QCOMPARE(params.wbMethod, QString("box"));
+ QCOMPARE(params.wbBoxOrigin, QPoint(10,20));
+ QCOMPARE(params.wbBoxSize, QSize(30,40));
+}
+
+QTEST_MAIN(BasicGuiTests)
+#include "test_basic.moc"
diff --git a/include/rawtoaces/image_converter.h b/include/rawtoaces/image_converter.h
index f461064a..c4a082a4 100644
--- a/include/rawtoaces/image_converter.h
+++ b/include/rawtoaces/image_converter.h
@@ -11,13 +11,13 @@ namespace rta
namespace util
{
-/// Collect all files from a given`path` into batchs. If the `path` is a
+/// Collect all files from a given `path` into batchs. If the `path` is a
/// directory, create an entry in `batches` and fill it with the file names
/// from that directory. If the `path` is a file, add its name to the first
/// entry in `batches`.
-/// - parameter path: path to a file or directory to process.
-/// - parameter batches: the collection of batches to fill in.
-/// - returns `false` if the file or directory requested in `path` does not
+/// @param path path to a file or directory to process.
+/// @param batches the collection of batches to fill in.
+/// @result `false` if the file or directory requested in `path` does not
/// exist.
bool collect_image_files(
const std::string &path, std::vector> &batches );
@@ -41,20 +41,20 @@ class ImageConverter
/// the camera.
Illuminant,
/// Calculate white balance by averaging over a specified region of
- /// the image. See `wbBox`. In this mode if an empty box if provided,
+ /// the image. See `WB_box`. In this mode if an empty box if provided,
/// white balancing is done by averaging over the whole image.
Box,
/// Use custom white balancing multipliers. This mode is useful if
/// the white balancing coefficients are calculated by an external
/// tool.
Custom
- } wbMethod = WBMethod::Metadata;
+ } WB_method = WBMethod::Metadata;
enum class MatrixMethod
{
/// Use the camera spectral sensitivity curves to solve for the colour
/// conversion matrix. In this mode the illuminant is either provided
- /// directly in `illuminant` if `wbMethod` ==
+ /// directly in `illuminant` if `WB_method` ==
/// `WBMethod::Illuminant`, or the best illuminant is derived from the
/// white balancing multipliers.
Spectral,
@@ -67,7 +67,7 @@ class ImageConverter
/// Specify a custom matrix in `colourMatrix`. This mode is useful if
/// the matrix is calculated by an external tool.
Custom
- } matrixMethod = MatrixMethod::Spectral;
+ } matrix_method = MatrixMethod::Spectral;
/// Cropping mode.
enum class CropMode
@@ -81,18 +81,18 @@ class ImageConverter
} crop_mode = CropMode::Hard;
/// An illuminant to use for white balancing and/or colour matrix
- /// calculation. Only used when `wbMethod` ==
- /// `WBMethod::Illuminant` and `matrixMethod` == `MatrixMethod::Spectral`.
+ /// calculation. Only used when `WB_method` ==
+ /// `WBMethod::Illuminant` and `matrix_method` == `MatrixMethod::Spectral`.
/// An illuminant can be provided as a black body correlated colour
/// temperature, like `3200K`; or a D-series illuminant, like `D56`;
/// or any other illuminant, in such case it must be present in the data
/// folder.
std::string illuminant;
- float headroom = 6.0;
- int wbBox[4] = { 0 };
- float customWB[4] = { 1.0, 1.0, 1.0, 1.0 };
- float customMatrix[3][3] = { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };
+ float headroom = 6.0;
+ int WB_box[4] = { 0 };
+ float custom_WB[4] = { 1.0, 1.0, 1.0, 1.0 };
+ float custom_matrix[3][3] = { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };
std::string custom_camera_make;
std::string custom_camera_model;
@@ -105,8 +105,8 @@ class ImageConverter
bool half_size = false;
int highlight_mode = 0;
int flip = 0;
- int cropbox[4] = { 0, 0, 0, 0 };
- float aberration[2] = { 1.0f, 1.0f };
+ int crop_box[4] = { 0, 0, 0, 0 };
+ float chromatic_aberration[2] = { 1.0f, 1.0f };
float denoise_threshold = 0;
float scale = 1.0f;
std::string demosaic_algorithm = "AHD";
@@ -128,8 +128,7 @@ class ImageConverter
/// The parser object can be amended by the calling code afterwards if
/// needed. This method is optional, all of the settings above can be
/// modified directly.
- /// - parameter arg_parser:
- /// The command line parser object to be updated.
+ /// @param arg_parser The command line parser object to be updated.
void init_parser( OIIO::ArgParse &arg_parser );
/// Initialise the converter settings from the command line parser object.
@@ -138,10 +137,8 @@ class ImageConverter
/// `OIIO::ArgParse::parse_args()`.
/// This method is optional, all of the settings above can be modified
/// directly.
- /// - parameter arg_parser:
- /// the command line parser object
- /// - returns
- /// `true` if parsed successfully
+ /// @param arg_parser the command line parser object
+ /// @result `true` if parsed successfully
bool parse_parameters( const OIIO::ArgParse &arg_parser );
/// Collects all illuminants supported by this version.
@@ -156,13 +153,13 @@ class ImageConverter
/// This method loads the metadata from the given image file and
/// initialises the options to give the OIIO raw image reader to
/// decode the pixels.
- /// - parameter input_filename:
+ /// @param input_filename
/// A file name of the raw image file to read the metadata from.
- /// - parameter options:
+ /// @param options
/// Conversion hints to be passed to OIIO when reading an image file.
/// The list can be pre- or post- updated with other hints, unrelated to
/// the rawtoaces conversion.
- /// - returns
+ /// @result
/// `true` if configured successfully.
bool configure(
const std::string &input_filename, OIIO::ParamValueList &options );
@@ -171,13 +168,13 @@ class ImageConverter
/// matrix method, and the metadata of the given OIIO::ImageSpec object.
/// Use this method if you already have an image read from file to save
/// on disk operations.
- /// - parameter imageSpec:
+ /// @param imageSpec
/// An image spec obtained from OIIO::ImageInput or OIIO::ImageBuf.
- /// - parameter hints:
+ /// @param hints
/// Conversion hints to be passed to OIIO when reading an image file.
/// The list can be pre- or post- updated with other hints, unrelated to
/// the rawtoaces conversion.
- /// - returns
+ /// @result
/// `true` if configured successfully.
bool
configure( const OIIO::ImageSpec &imageSpec, OIIO::ParamValueList &hints );
@@ -192,56 +189,56 @@ class ImageConverter
/// Apply the colour space conversion matrix (or matrices) to convert the
/// image buffer from the raw camera colour space to ACES.
- /// - parameter dst:
+ /// @param dst
/// Destination image buffer.
- /// - parameter src:
+ /// @param src
/// Source image buffer, can be the same as `dst` for in-place
/// conversion.
- /// - returns
+ /// @result
/// `true` if applied successfully.
bool apply_matrix(
OIIO::ImageBuf &dst, const OIIO::ImageBuf &src, OIIO::ROI roi = {} );
/// Apply the headroom scale to image buffer.
- /// - parameter dst:
+ /// @param dst
/// Destination image buffer.
- /// - parameter src:
+ /// @param src
/// Source image buffer, can be the same as `dst` for in-place
/// conversion.
- /// - returns
+ /// @result
/// `true` if applied successfully.
bool apply_scale(
OIIO::ImageBuf &dst, const OIIO::ImageBuf &src, OIIO::ROI roi = {} );
/// Apply the cropping mode as specified in crop_mode.
- /// - parameter dst:
+ /// @param dst
/// Destination image buffer.
- /// - parameter src:
+ /// @param src
/// Source image buffer, can be the same as `dst` for in-place
/// conversion.
- /// - returns
+ /// @result
/// `true` if applied successfully.
bool apply_crop(
OIIO::ImageBuf &dst, const OIIO::ImageBuf &src, OIIO::ROI roi = {} );
/// Make output file path and check if it is writable.
- /// - parameter path:
+ /// @param path
/// A reference to a variable containing the input file path. The output file path gets generated
/// in-place.
- /// - parameter suffix:
+ /// @param suffix
/// A suffix to add to the file name.
- /// - returns
+ /// @result
/// `true` if the file can be written, e.g. the output directory exists, or creating directories
/// is allowed; the file does not exist or overwriting is allowed.
bool
make_output_path( std::string &path, const std::string &suffix = "_aces" );
/// Saves the image into ACES Container.
- /// - parameter output_filename:
+ /// @param output_filename
/// Full path to the file to be saved.
- /// - parameter buf:
+ /// @param buf
/// Image buffer to be saved.
- /// - returns
+ /// @result
/// `true` if saved successfully.
bool
save_image( const std::string &output_filename, const OIIO::ImageBuf &buf );
@@ -249,28 +246,28 @@ class ImageConverter
/// A convenience single-call method to process an image. This is equivalent to calling the following
/// methods sequentially: `make_output_path`->`configure`->`apply_matrix`->
/// `apply_scale`->`apply_crop`->`save`.
- /// - parameter input_filename:
+ /// @param input_filename
/// Full path to the file to be converted.
- /// - returns
+ /// @result
/// `true` if processed successfully.
bool process_image( const std::string &input_filename );
/// Get the solved white balance multipliers of the currently processed
/// image. The multipliers become available after calling either of the
/// two `configure` methods.
- /// - returns a reference to the multipliers vector.
+ /// @result a reference to the multipliers vector.
const std::vector &get_WB_multipliers();
/// Get the solved input transform matrix of the currently processed image.
/// The multipliers become available after calling either of the two
/// `configure` methods.
- /// - returns a reference to the matrix.
+ /// @result a reference to the matrix.
const std::vector> &get_IDT_matrix();
/// Get the solved chromatic adaptation transform matrix of the currently
/// processed image. The multipliers become available after calling either
/// of the two `configure` methods.
- /// - returns a reference to the matrix.
+ /// @result a reference to the matrix.
const std::vector> &get_CAT_matrix();
private:
diff --git a/include/rawtoaces/rawtoaces_core.h b/include/rawtoaces/rawtoaces_core.h
index dfc098eb..1621efc9 100644
--- a/include/rawtoaces/rawtoaces_core.h
+++ b/include/rawtoaces/rawtoaces_core.h
@@ -27,96 +27,147 @@ static const std::vector > CAT_D65_to_ACES = {
// clang-format on
-/// Calculate spectral power distribution of a daylight illuminant of given CCT
-/// - parameter cct: correlated colour temperature of the requested illuminant.
-/// - parameter spectrum: a reference to a `Spectrum` object to full with the
-/// calculated values.
+/// Calculate spectral power distribution (SPD) of CIE standard daylight illuminant.
+/// The function generates the spectral power distribution for a daylight illuminant
+/// based on the requested correlated color temperature using CIE standard formulas.
+///
+/// @param cct Correlated colour temperature of the requested illuminant either in Kelvin (in range of 4000-25000), or in short form from an illuminant name, e.g. 55 for D55 (in range of 40-250).
+/// @param spectrum Reference to a `Spectrum` object to fill with the calculated values
+/// @pre cct is in valid range for daylight calculations
void calculate_daylight_SPD( const int &cct, Spectrum &spectrum );
-/// Calculate spectral power distribution of a blackbody illuminant of given CCT
-/// - parameter cct: correlated colour temperature of the requested illuminant.
-/// - parameter spectrum: a reference to a `Spectrum` object to full with the
-/// calculated values.
+/// Calculate spectral power distribution (SPD) of blackbody radiation at given temperature.
+/// Generates a blackbody curve using Planck's law for the specified correlated color temperature.
+/// The function calculates spectral power distribution across wavelengths defined by Spectrum object.
+///
+/// @param cct Correlated colour temperature of the requested illuminant (1500-3999 Kelvin)
+/// @param spectrum Reference to a `Spectrum` object to fill with the calculated values
+/// @pre cct is in valid range for blackbody calculations (1500-3999)
void calculate_blackbody_SPD( const int &cct, Spectrum &spectrum );
/// Solve an input transform using spectral sensitivity curves of a camera.
class SpectralSolver
{
public:
- SpectralSolver();
-
- /// Load spectral sensitivity data for a camera.
- /// - parameter path: a path to the data file
- /// - parameter make: the camera make to verify the loaded data against.
- /// - parameter model: the camera model to verify the loaded data against.
- /// - returns `true` if loaded successfully.
- bool load_camera(
- const std::string &path,
- const std::string &make,
- const std::string &model );
-
- /// Load spectral power distribution data for an illuminant.
- /// If an illuminant type specified, try to find the matching data,
- /// otherwise load all known illuminants.
- /// - parameter paths: a set of data file paths to the data file
- /// - parameter type: illuminant type to load.
- /// - returns `true` if loaded successfully.
- bool load_illuminant(
- const std::vector &paths, const std::string &type = "" );
-
- /// Load spectral reflectivity data for a training set (a colour chart).
- /// - parameter path: a path to the data file
- /// - returns `true` if loaded successfully.
- bool load_training_data( const std::string &path );
-
- /// Load spectral sensitivity data for an observer
- /// (colour matching functions).
- /// - parameter path: a path to the data file
- /// - returns `true` if loaded successfully.
- bool load_observer( const std::string &path );
+ /// The camera spectral data. Can be either assigned directly, loaded
+ /// in-place place via `solver.camera.load()`, or found via
+ /// `solver.find_camera()`.
+ SpectralData camera;
+
+ /// The illuminant spectral data. Can be either assigned directly, loaded
+ /// in-place place via `solver.illuminant.load()`, or found via
+ /// `solver.find_illuminant()`.
+ SpectralData illuminant;
+
+ /// The observer spectral data. Can be either assigned directly, or loaded
+ /// in-place place via `solver.observer.load()`.
+ SpectralData observer;
+
+ /// The training set spectral data. Can be either assigned directly, or loaded
+ /// in-place place via `solver.training_data.load()`.
+ SpectralData training_data;
+
+ /// Initialize SpectralSolver with database search path.
+ /// Sets up internal data structures including IDT matrix and white balance multipliers
+ /// with neutral values. Initializes verbosity level to 0 for silent operation.
+ /// Takes the database search path as an optional parameter for finding spectral data files.
+ ///
+ /// @param search_directories optional database search path for spectral data files
+ SpectralSolver( const std::vector &search_directories = {} );
+
+ /// A helper method collecting spectral data files of a given type from the database.
+ /// This function searches through the configured search directories to find all
+ /// spectral data files matching the specified type (e.g., "camera", "illuminant").
+ /// It searches for type subdirectories at the top level of each directory and returns JSON files matching the type.
+ ///
+ /// @param type data type of the files to search for (e.g., "camera", "illuminant", "cmf")
+ /// @return a collection of file paths found in the database
+ std::vector
+ collect_data_files( const std::string &type ) const;
+
+ /// A helper method loading the spectral data for a file at the given path.
+ /// This function loads spectral data from a file, handling both absolute and relative paths.
+ /// For relative paths, it searches through all configured search directories.
+ ///
+ /// @param file_path the path to the file to load. If the path is relative,
+ /// all locations in the search path will be searched in.
+ /// @param out_data the `SpectralData` object to be filled with the loaded data.
+ /// @return `true` if loaded successfully, `false` otherwise
+ bool
+ load_spectral_data( const std::string &file_path, SpectralData &out_data );
+
+ /// Load spectral sensitivity data for a camera by searching the database.
+ /// This function searches through camera data files in the database to find
+ /// a match for the specified camera manufacturer and model. It loads the
+ /// spectral sensitivity data into the camera member variable.
+ ///
+ /// @param make the camera make to search for
+ /// @param model the camera model to search for
+ /// @return `true` if loaded successfully, `false` otherwise
+ bool find_camera( const std::string &make, const std::string &model );
+
+ /// Find spectral power distribution data of an illuminant of the given type.
+ /// This function can handle both built-in illuminant types (e.g., "d55", "3200k")
+ /// and custom illuminants stored in the database. For built-in types, it generates
+ /// the spectral data using standard formulas.
+ ///
+ /// @param type illuminant type. Can be one of the built-in types,
+ /// e.g. `d55`, `3200k`, or a custom illuminant stored in the database.
+ /// @return `true` if loaded successfully, `false` otherwise
+ bool find_illuminant( const std::string &type );
/// Find the illuminant best matching the given white-balancing multipliers.
- /// See `get_best_illuminant()` to access the result.
- /// - parameter wb_multipliers: white-balancing multipliers to match.
- /// - parameter highlight: the highlight recovery mode, used for
- /// normalisation.
- void find_best_illuminant(
- const std::vector &wb_multipliers, int highlight );
-
- /// Select an illuminant of a given type.
- /// See `get_best_illuminant()` to access the result.
- /// - parameter type: illuminant type to select.
- /// - parameter highlight: the highlight recovery mode, used for
- /// normalisation.
- void select_illuminant( const std::string &type, int highlight );
-
- /// Calculate an input transform matrix.
- /// See `get_IDT_matrix()` to access the result.
- /// - returns `true` if calculated successfully.
+ /// This function analyzes all available illuminants and selects the one that best matches
+ /// the white balance coefficients. It uses Sum of Squared Errors (SSE) to find the
+ /// optimal match and automatically scales the white balance multipliers.
+ ///
+ /// @param wb_multipliers white-balancing multipliers to match
+ /// @return `true` if loaded successfully, `false` otherwise
+ bool find_illuminant( const std::vector &wb_multipliers );
+
+ /// Calculate the white-balance multipliers for the given configuration.
+ /// This function computes RGB white balance multipliers by integrating camera spectral
+ /// sensitivity with illuminant power spectrum. The multipliers normalize the camera
+ /// response to achieve proper white balance under the specified illuminant conditions.
+ /// The `camera` and `illuminant` data have to be configured prior to this call.
+ ///
+ /// @return `true` if calculated successfully, `false` otherwise
+ /// @pre camera and illuminant data must be properly loaded
+ bool calculate_WB();
+
+ /// Calculate an input transform matrix using curve fitting optimization.
+ /// This function computes the optimal IDT matrix by comparing camera RGB responses
+ /// with target XYZ values across all training patches.
+ /// The `camera`, `illuminant`, `observer` and `training_data` have to be configured prior to this call.
+ ///
+ /// @return `true` if calculated successfully, `false` otherwise
+ /// @pre camera, illuminant, observer, and training_data must be properly loaded
bool calculate_IDT_matrix();
- /// Get the illuminant configured using `find_best_illuminant()` or
- /// `select_illuminant()`.
- /// - returns a reference to the illuminant.
- const SpectralData &get_best_illuminant() const;
-
/// Get the matrix calculated using `calculate_IDT_matrix()`.
- /// - returns a reference to the matrix.
+ /// This function returns a reference to the 3ร3 IDT matrix that transforms camera
+ /// RGB values to standardized color space. The matrix is computed by curve fitting
+ /// optimization and represents the optimal color transformation for the camera under
+ /// the specified illuminant conditions.
+ ///
+ /// @return a reference to the 3ร3 IDT transformation matrix
+ /// @pre calculate_IDT_matrix() must have been called successfully
const std::vector> &get_IDT_matrix() const;
- /// Get the white-balance multipliers calculated using
- /// `find_best_illuminant()` or `select_illuminant()`.
- /// - returns a reference to the multipliers.
+ /// Get the white-balance multipliers calculated using `find_illuminant()` or `calculate_WB()`.
+ /// This function returns a reference to the 3-element vector containing RGB white
+ /// balance multipliers. These multipliers scale the camera response to achieve
+ /// proper white balance under the specified illuminant conditions.
+ ///
+ /// @return a reference to the 3-element white balance multiplier vector [R, G, B]
+ /// @pre white balance calculation must have been performed successfully
const std::vector &get_WB_multipliers() const;
int verbosity = 0;
private:
- SpectralData _camera;
- SpectralData _best_illuminant;
- SpectralData _observer;
- SpectralData _training_data;
- std::vector _illuminants;
+ std::vector _search_directories;
+ std::vector _all_illuminants;
std::vector _WB_multipliers;
std::vector> _IDT_matrix;
@@ -141,18 +192,38 @@ struct Metadata
class MetadataSolver
{
public:
- /// Initialise the solver using DNG metadata.
- /// - parameter metadata: DNG metadata
+ /// Initialize the solver using DNG metadata.
+ /// Creates a MetadataSolver instance with the provided camera metadata
+ /// for calculating IDT and CAT matrices.
+ ///
+ /// @param metadata DNG metadata containing camera calibration and exposure information
MetadataSolver( const core::Metadata &metadata );
- /// Calculate an input transform matrix.
- /// - returns: calculated matrix
+ /// Calculate the Input Device Transform (IDT) matrix for DNG color space conversion.
+ /// This function computes the final IDT matrix that transforms camera RGB values
+ /// to ACES RGB color space. It combines the Color Adaptation Transform (CAT) matrix
+ /// with the D65 ACES RGB to XYZ transformation matrix to create a complete
+ /// camera-to-ACES transformation pipeline.
+ ///
+ /// @return 3ร3 Input Device Transform matrix for DNG to ACES conversion
+ /// @pre _metadata must contain valid camera calibration data
+ /// @pre calculate_CAT_matrix() must return a valid CAT matrix
std::vector> calculate_IDT_matrix();
- /// Calculate a chromatic adaptation transform matrix. Strictly speaking,
- /// this matrix is not required for image processing, as it is embedded in
- /// the IDT, see `calculate_IDT_matrix`.
- /// - returns: calculated matrix
+ /// Calculate the Color Adaptation Transform (CAT) matrix for color space conversion.
+ /// This function computes the CAT matrix needed to transform colors from the camera's
+ /// white point to the target ACES RGB white point. It first obtains the camera's
+ /// XYZ transformation matrix and white point, then creates the target ACES RGB to XYZ
+ /// matrix, and finally calculates the color adaptation transform between the two
+ /// white points using the Bradford or CAT02 method.
+ ///
+ /// The CAT matrix is essential for maintaining color appearance when converting
+ /// between different illuminant conditions, ensuring that colors look consistent
+ /// across different lighting environments. Strictly speaking, this matrix is not
+ /// required for image processing, as it is embedded in the IDT, see `calculate_IDT_matrix`.
+ ///
+ /// @return 3ร3 Color Adaptation Transform matrix
+ /// @pre _metadata must contain valid camera calibration and neutral RGB data
std::vector> calculate_CAT_matrix();
private:
diff --git a/include/rawtoaces/spectral_data.h b/include/rawtoaces/spectral_data.h
index 9ff879f9..3b8c583a 100644
--- a/include/rawtoaces/spectral_data.h
+++ b/include/rawtoaces/spectral_data.h
@@ -31,8 +31,8 @@ struct Spectrum
/// Comparison operator, mostly required for storing the `Spectrum`
/// data in containers.
- /// - parameter shape: another `Shape` object to compare `this` with.
- /// - returns: `true` if the objects are equal.
+ /// @param shape another `Shape` object to compare `this` with.
+ /// @result `true` if the objects are equal.
bool operator==( const Shape &shape ) const;
} shape;
@@ -50,8 +50,8 @@ struct Spectrum
/// The `Spectrum` object constructor. Allocates as many spectral samples
/// as required for the `shape` parameter, and initialises them with
/// `value`.
- /// - parameter value: the value to initialise the spectral samples with.
- /// - parameter shape: the shape of the spectral data to create. Pass a shape
+ /// @param value the value to initialise the spectral samples with.
+ /// @param shape the shape of the spectral data to create. Pass a shape
/// with zero step, like `rta::core::Spectrum::EmptyShape` to avoid
/// allocating any samples.
Spectrum( double value = 0, const Shape &shape = ReferenceShape );
@@ -85,11 +85,11 @@ struct Spectrum
void reshape();
/// Integrate the spectral curve.
- /// - returns: the sum of all elements in `values`.
+ /// @result the sum of all elements in `values`.
double integrate();
/// Find the maximum element in `values`
- /// - returns: the maximum element in `values`.
+ /// @result the maximum element in `values`.
double max() const;
};
@@ -133,8 +133,8 @@ struct SpectralData
/// A convenience operator returning the `Spectrum` of a given channel name
/// in the "main" data set.
- /// - parameter name: the channel name in the "main" data set to return.
- /// - returns: the `Spectrum` object corresponding to the given channel
+ /// @param name the channel name in the "main" data set to return.
+ /// @result the `Spectrum` object corresponding to the given channel
/// name.
/// - throws: if the requested channel is not found.
Spectrum &operator[]( std::string name );
@@ -142,11 +142,11 @@ struct SpectralData
/// A convenience method returning the `Spectrum` of a given channel name
/// in the given data set.
- /// - parameter set_name: the set name to search for.
- /// - parameter channel_name: the channel name to search for.
- /// - returns: the `Spectrum` object reference if found.
+ /// @param set_name the set name to search for.
+ /// @param channel_name the channel name to search for.
+ /// @result the `Spectrum` object reference if found.
/// name.
- /// - throws: if the requested channel is not found.
+ /// @throw if the requested channel is not found.
Spectrum &get( std::string set_name, std::string channel_name );
const Spectrum &get( std::string set_name, std::string channel_name ) const;
};
diff --git a/include/rawtoaces/usage_timer.h b/include/rawtoaces/usage_timer.h
index aea0bfaa..002235b6 100644
--- a/include/rawtoaces/usage_timer.h
+++ b/include/rawtoaces/usage_timer.h
@@ -22,8 +22,8 @@ class UsageTimer
/// Print a message for a given path with the addition of the time
/// passed since the last invocation of `reset()`.
- /// - parameter path: The file math to print.
- /// - parameter message: The message to print.
+ /// @param path The file math to print.
+ /// @param message The message to print.
void print( const std::string &path, const std::string &message );
private:
diff --git a/src/rawtoaces_core/CMakeLists.txt b/src/rawtoaces_core/CMakeLists.txt
index 5168c6bb..abfbab5a 100644
--- a/src/rawtoaces_core/CMakeLists.txt
+++ b/src/rawtoaces_core/CMakeLists.txt
@@ -1,6 +1,11 @@
cmake_minimum_required(VERSION 3.12)
include_directories( "${CMAKE_CURRENT_SOURCE_DIR}" )
+# Include coverage support if enabled
+if( ENABLE_COVERAGE )
+ include( ${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/CodeCoverage.cmake )
+endif()
+
set( CORE_PUBLIC_HEADER
../../include/rawtoaces/rawtoaces_core.h
../../include/rawtoaces/spectral_data.h
@@ -35,6 +40,11 @@ target_include_directories( ${RAWTOACES_CORE_LIB} PUBLIC
$
)
+# Enable coverage for this library if coverage is enabled
+if( ENABLE_COVERAGE AND COVERAGE_SUPPORTED )
+ setup_coverage_flags(${RAWTOACES_CORE_LIB})
+endif()
+
set_target_properties( ${RAWTOACES_CORE_LIB} PROPERTIES
OUTPUT_NAME "rawtoaces_core"
EXPORT_NAME "rawtoaces_core"
diff --git a/src/rawtoaces_core/define.h b/src/rawtoaces_core/define.h
index 165fc1e2..398fcec6 100644
--- a/src/rawtoaces_core/define.h
+++ b/src/rawtoaces_core/define.h
@@ -56,21 +56,20 @@ const double e = 0.008856451679;
const double k = 7.787037037037;
// Planck's constant ([J*s] Joule-seconds)
-const double bh = 6.626176 * 1e-34;
+const double plancks_constant = 6.626176 * 1e-34;
// Boltzmann constant ([J/K] Joules per Kelvin)
-const double bk = 1.380662 * 1e-23;
+const double boltzmann_constant = 1.380662 * 1e-23;
// Speed of light ([m/s] meters per second)
-const double bc = 2.99792458 * 1e8;
+const double light_speed = 2.99792458 * 1e8;
-const double dmin = std::numeric_limits::min();
-const double dmax = std::numeric_limits::max();
+const double max_double_value = std::numeric_limits::max();
// clang-format off
-static const double XYZ_w[3] = {0.952646074569846, 1.0, 1.00882518435159};
-static const double d50 [3] = {0.9642, 1.0000, 0.8250};
-static const double d60 [3] = {0.952646074569846, 1.0000, 1.00882518435159};
-static const double d65 [3] = {0.9547, 1.0000, 1.0883};
+static const double ACES_white_point_XYZ[3] = {0.952646074569846, 1.0, 1.00882518435159};
+static const double d50_white_point_XYZ[3] = {0.9642, 1.0000, 0.8250};
+static const double d60_white_point_XYZ[3] = {0.952646074569846, 1.0000, 1.00882518435159};
+static const double d65_white_point_XYZ[3] = {0.9547, 1.0000, 1.0883};
static const double neutral3[3][3] = {
{1.0, 0.0, 0.0},
@@ -179,7 +178,7 @@ static const double chromaticitiesACES[4][2] = {
};
// Roberson UV Table
-static const double Robertson_uvtTable[][3] = {
+static const double robertson_uvt_table[][3] = {
{ 0.18006, 0.26352, -0.24341 },
{ 0.18066, 0.26589, -0.25479 },
{ 0.18133, 0.26846, -0.26876 },
@@ -214,7 +213,7 @@ static const double Robertson_uvtTable[][3] = {
};
// Roberson Mired Matrix
-static const double RobertsonMired[] = {
+static const double robertson_mired_table[] = {
1.0e-10, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0,
80.0, 90.0, 100.0, 125.0, 150.0, 175.0, 200.0, 225.0,
250.0, 275.0, 300.0, 325.0, 350.0, 375.0, 400.0, 425.0,
@@ -266,12 +265,6 @@ inline std::vector openDir( std::string path = "." )
return paths;
};
-// Function to clear the memories occupied by vectors
-template inline void clearVM( std::vector vct )
-{
- std::vector().swap( vct );
-};
-
// Function to covert upper-case to lower-case
inline void lowerCase( char *tex )
{
diff --git a/src/rawtoaces_core/mathOps.h b/src/rawtoaces_core/mathOps.h
index 10808361..3f96764f 100644
--- a/src/rawtoaces_core/mathOps.h
+++ b/src/rawtoaces_core/mathOps.h
@@ -20,17 +20,6 @@ namespace core
{
// Non-class functions
-inline double invertD( double val )
-{
- assert( fabs( val - 0.0 ) >= DBL_EPSILON );
-
- return 1.0 / val;
-};
-
-template T clip( T val, T target )
-{
- return std::min( val, target );
-};
template int isSquare( const vector> &vm )
{
@@ -73,9 +62,18 @@ vector subVectors( const vector &vectorA, const vector &vectorB )
return diff;
};
-// This is not the typical "cross" product
+/// Calculate the 2D cross product (scalar) of two 2D vectors.
+/// This function computes the cross product of two 2D vectors, which results in a scalar
+/// value representing the signed area of the parallelogram formed by the vectors.
+/// The cross product is positive when vectorB is counterclockwise from vectorA,
+/// negative when clockwise, and zero when the vectors are collinear.
+///
+/// @param vectorA First 2D vector [x1, y1]
+/// @param vectorB Second 2D vector [x2, y2]
+/// @return Scalar cross product: x1*y2 - x2*y1
+/// @pre vectorA.size() == 2 && vectorB.size() == 2
template
-T cross2( const vector &vectorA, const vector &vectorB )
+T cross2d_scalar( const vector &vectorA, const vector &vectorB )
{
assert( vectorA.size() == 2 && vectorB.size() == 2 );
return vectorA[0] * vectorB[1] - vectorA[1] * vectorB[0];
@@ -117,16 +115,6 @@ template vector invertV( const vector &vMtx )
return result;
};
-template vector> diagVM( const vector &vct )
-{
- assert( vct.size() != 0 );
- vector> vctdiag( vct.size(), vector( vct.size(), T( 0.0 ) ) );
-
- FORI( vct.size() ) vctdiag[i][i] = vct[i];
-
- return vctdiag;
-};
-
template vector diagV( const vector &vct )
{
assert( vct.size() != 0 );
@@ -196,43 +184,6 @@ template void scaleVector( vector &vct, const T scale )
return;
};
-template void scaleVectorMax( vector &vct )
-{
- Eigen::Matrix v;
- v.resize( vct.size(), 1 );
-
- FORI( vct.size() ) v( i, 0 ) = vct[i];
- v *= ( 1.0 / v.maxCoeff() );
-
- FORI( vct.size() ) vct[i] = v( i, 0 );
-
- return;
-};
-
-template void scaleVectorMin( vector &vct )
-{
- Eigen::Matrix v;
- v.resize( vct.size(), 1 );
-
- FORI( vct.size() ) v( i, 0 ) = vct[i];
- v *= ( 1.0 / v.minCoeff() );
-
- FORI( vct.size() ) vct[i] = v( i, 0 );
-
- return;
-};
-
-template void scaleVectorD( vector &vct )
-{
- Eigen::Matrix v;
- v.resize( vct.size(), 1 );
-
- FORI( v.rows() ) v( i, 0 ) = vct[i];
- FORI( v.rows() ) vct[i] = v.maxCoeff() / vct[i];
-
- return;
-};
-
template
vector mulVectorElement( const vector &vct1, const vector &vct2 )
{
@@ -254,21 +205,6 @@ vector mulVectorElement( const vector &vct1, const vector &vct2 )
return vct3;
};
-template
-vector divVectorElement( const vector &vct1, const vector &vct2 )
-{
- assert( vct1.size() == vct2.size() );
-
- vector vct2D( vct2.size(), T( 1.0 ) );
- FORI( vct2.size() )
- {
- assert( vct2[i] != T( 0.0 ) );
- vct2D[i] = T( 1.0 ) / vct2[i];
- }
-
- return mulVectorElement( vct1, vct2D );
-};
-
template
vector mulVector( vector vct1, vector vct2, int k = 3 )
{
@@ -347,74 +283,16 @@ vector mulVector( const vector &vct1, const vector> &vct2 )
return mulVector( vct2, vct1 );
};
+/// Calculate the Sum of Squared Errors (SSE) between two vectors.
+/// The SSE measures how well the calculated values (tcp) match the reference values (src).
+/// Formula: ฮฃ((tcp[i] / src[i] - 1)ยฒ)
+///
+/// @param tcp The calculated/target values to compare
+/// @param src The reference/source values to compare against
+/// @return The sum of squared relative errors
+/// @pre tcp.size() == src.size()
template
-T *mulVectorArray(
- T *data,
- const uint32_t total,
- const uint8_t dim,
- const vector> &vct )
-{
- assert( vct.size() == dim && isSquare( vct ) );
-
- /**
- // new implementation based on Eigen::Eigen::Matrix (Slow...)
-
- Eigen::Matrix MI, mvct;
- MI.resize(total/dim, dim);
- mvct.resize(dim, dim);
- FORIJ(MI.rows(), MI.cols()) MI(i,j) = data[i*dim+j];
- FORIJ(dim, dim) mvct(i,j) = static_cast(vct[i][j]);
-
- Eigen::Matrix MR(MI * (mvct.transpose()));
- FORI(total) data[i] = MR(i);
- */
-
- if ( dim == 3 || dim == 4 )
- {
- for ( uint32_t i = 0; i < total; i += dim )
- {
- T temp[4];
-
- for ( uint8_t j = 0; j < dim; j++ )
- {
- temp[j] = 0;
-
- for ( uint8_t k = 0; k < dim; k++ )
- temp[j] += vct[j][k] * data[i + k];
- }
-
- for ( uint8_t j = 0; j < dim; j++ )
- data[i + j] = temp[j];
- }
- }
-
- return data;
-};
-
-template
-vector>
-solveVM( const vector> &vct1, const vector> &vct2 )
-{
-
- Eigen::Matrix m1, m2, m3;
- m1.resize( vct1.size(), vct1[0].size() );
- m2.resize( vct2.size(), vct2[0].size() );
-
- FORIJ( vct1.size(), vct1[0].size() )
- m1( i, j ) = vct1[i][j];
- FORIJ( vct2.size(), vct2[0].size() )
- m2( i, j ) = vct2[i][j];
-
- // colPivHouseholderQr()
- m3 = m1.jacobiSvd( Eigen::ComputeThinU | Eigen::ComputeThinV ).solve( m2 );
-
- vector> vct3( m3.rows(), vector
+