first commit

CMakeLists.txt

@@ -0,0 +1,62 @@
+cmake_minimum_required(VERSION 3.16)
+project(DupFind VERSION 0.1.0 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# 最適化と popcnt 命令出力のためのフラグ設定
+if(MSVC)
+    add_compile_options(/arch:AVX2)
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    add_compile_options(-mpopcnt -msse4.2)
+endif()
+
+# Qt 6
+find_package(Qt6 COMPONENTS Widgets Concurrent REQUIRED)
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTORCC ON)
+
+
+# OpenCVの前にProtobufを自力で見つけさせる
+find_package(Protobuf REQUIRED)
+# OpenCV
+find_package(OpenCV REQUIRED)
+
+# SQLite3
+find_package(SQLite3 REQUIRED)
+
+include_directories(include)
+
+file(GLOB_RECURSE SOURCES src/*.cpp)
+file(GLOB_RECURSE HEADERS include/*.hpp)
+
+add_library(DupFindCore STATIC ${SOURCES} ${HEADERS})
+target_link_libraries(DupFindCore
+    PUBLIC 
+        Qt6::Widgets
+        Qt6::Concurrent
+        ${OpenCV_LIBS}
+        SQLite::SQLite3
+)
+
+# Filter out mains from the core library sources if possible, but CMake GLOB can't filter easily inline.
+# Better approach: remove them explicitly.
+get_target_property(CORE_SOURCES DupFindCore SOURCES)
+list(REMOVE_ITEM CORE_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp")
+list(REMOVE_ITEM CORE_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/CmdMain.cpp")
+set_target_properties(DupFindCore PROPERTIES SOURCES "${CORE_SOURCES}")
+
+# GUI target
+add_executable(${PROJECT_NAME} src/main.cpp)
+target_link_libraries(${PROJECT_NAME} PRIVATE DupFindCore)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    WIN32_EXECUTABLE ON
+#    MACOSX_BUNDLE ON
+)
+
+# CLI target
+add_executable(DupFindCmd src/CmdMain.cpp)
+target_link_libraries(DupFindCmd PRIVATE DupFindCore)
+

CMakePresets.json

@@ -0,0 +1,20 @@
+{
+    "version": 3,
+    "configurePresets": [
+        {
+            "name": "windows-vcpkg",
+            "displayName": "Windows vcpkg",
+            "description": "Configure for Windows using vcpkg and local Qt6 installation",
+            "generator": "Visual Studio 18 2026",
+            "binaryDir": "${sourceDir}/build",
+            "cacheVariables": {
+                "CMAKE_TOOLCHAIN_FILE": "c:/vcpkg/scripts/buildsystems/vcpkg.cmake",
+                "Qt6_DIR": "C:/Qt/6.11.0/msvc2022_64/lib/cmake/Qt6/",
+                "Protobuf_DIR": "C:/vcpkg/installed/x64-windows/share/protobuf",
+                "flatbuffers_DIR": "C:/vcpkg/installed/x64-windows/share/flatbuffers",
+                "quirc_DIR": "C:/vcpkg/installed/x64-windows/share/quirc",
+                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
+            }
+        }
+    ]
+}

README.md

@@ -0,0 +1,19 @@
+# DupFind - 画像類似度検索ツール
+
+現在の開発状況と継続方法について記述します。
+
+## 現在のステータス
+- **計画フェーズ**: 実施計画 (`implementation_plan.md`) とタスクリスト (`task.md`) の作成が完了し、ユーザーからのフィードバック（複数ディレクトリ対応、Linux対応）を反映済みです。
+- **未着手**: 実装（CMake プロジェクトのセットアップ以降）はこれから開始する段階です。
+
+## 継続方法
+作業を再開する際は、このディレクトリにある `implementation_plan.md` と `task.md` を読み込み、以下のステップから開始してください：
+1. CMake プロジェクトの作成と OpenCV/Qt 6/SQLite の依存関係のセットアップ。
+2. コアロジック（ImageHasher）の実装。
+
+## 依存ツール
+- C++ コンパイラ (MSVC または GCC)
+- CMake
+- OpenCV
+- Qt 6
+- SQLite3

implementation_plan.md

@@ -0,0 +1,63 @@
+# 実施計画 - 画像類似度検索ツール (C++)
+
+設定されたディレクトリ内の画像から、pHash および dHash アルゴリズムを用いて類似した画像を検索・提示する高性能な Windows アプリケーション。
+
+## ユーザー確認事項
+
+> [!IMPORTANT]
+> **GUI フレームワークの選択**: ユーザーインターフェースには **Qt 6** を採用します。これにより、Windows だけでなく **Linux でも動作するマルチプラットフォーム対応** が可能になります。
+
+> [!TIP]
+> **複数ディレクトリ対応**: 単一のディレクトリだけでなく、複数のルートディレクトリを登録し、それらを横断して類似画像を検索できるように設計します。
+
+> [!WARNING]
+> **依存関係**: このプロジェクトには **OpenCV** (画像処理用) と **SQLite** (ハッシュ保存用) が必要です。プロジェクト管理には **CMake** を使用します。
+
+## 提案される変更点
+
+### コアロジック (画像ハッシュ化と処理)
+高速なハッシュ生成エンジンを実装します。
+
+#### [NEW] `ImageHasher.hpp / .cpp`
+- `calculateDHash(cv::Mat image)` の実装: 9x8にリサイズ、グレースケール化、隣接画素の差分を計算。
+- `calculatePHash(cv::Mat image)` の実装: 32x32にリサイズ、グレースケール化、離散コサイン変換(DCT)、低周波成分(8x8)の抽出。
+- 最適化: `cv::parallel_for_` または C++ スレッドを使用して、複数の画像を同時に処理します。
+
+#### [NEW] `SimilaritySearch.hpp / .cpp`
+- ハミング距離計算の実装: 
+    - Windows (MSVC): `__popcnt64` を使用。
+    - Linux (GCC/Clang): `__builtin_popcountll` を使用。
+    - または C++20 の `std::popcount` を使用してクロスプラットフォーム化。
+- 検索アルゴリズム: データベース内の全ハッシュと比較し、しきい値以下のものを抽出。
+
+### データ管理
+数十万件のハッシュを効率的に保存・取得します。
+
+#### [NEW] `DatabaseManager.hpp / .cpp`
+- SQLite スキーマ: `images (id INTEGER PRIMARY KEY, path TEXT, dhash BLOB, phash BLOB, timestamp INTEGER)`。
+- パスにインデックスを貼り、差分スキャンを高速化。
+
+### ユーザーインターフェース (Qt 6)
+モダンでレスポシブな UI を構築します。
+
+#### [NEW] `MainWindow.ui / .cpp`
+- **ディレクトリ管理リスト**: 検索対象のディレクトリを追加・削除できるリストビュー。
+- スキャン/ハッシュ計算のプログレスバー。
+- 検索バー (選択した画像に似た画像を検索)。
+- **結果グリッド / 重複管理ビュー**: 
+    - グループ化された類似画像の表示 (類似度ベースのクラスタリング)。
+    - 各画像に対するサムネ表示とチェックボックス。
+    - **削除機能**: 選択した画像ファイルをディスクから慎重に削除（ゴミ箱へ移動または直接削除）し、データベースからもエントリを削除する機能。
+    - 一括選択、元のファイルを開く、プロパティ表示などのコンテキストメニュー。
+
+## 検証プラン
+
+### 自動テスト
+- 既知のサンプル画像を用いた `calculateDHash` と `calculatePHash` のユニットテスト。
+- パフォーマンス・ベンチマーク: 1,000枚のハッシュ化時間、10万件の検索時間を測定。
+
+### 手動確認
+1. アプリを起動し、多様な画像が含まれるディレクトリを選択。
+2. スキャンフェーズで全 CPU コアが有効活用されているか確認。
+3. 画像を選択し、リサイズや微細な加工が施された類似画像が正しく表示されるか確認。
+4. 1万枚以上の画像で UI の応答性が維持されているか確認。

include/DatabaseManager.hpp

@@ -0,0 +1,44 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <optional>
+#include <sqlite3.h>
+
+struct ImageData {
+    int64_t id;
+    std::string path;
+    uint64_t dhash;
+    uint64_t phash;
+    int64_t timestamp;
+    int64_t file_size;
+    bool is_searched = false;
+};
+
+class DatabaseManager {
+public:
+    DatabaseManager(const std::string& dbPath);
+    ~DatabaseManager();
+
+    bool open();
+    void close();
+
+    bool addImage(const ImageData& data);
+    std::vector<ImageData> getAllImages();
+    bool removeImage(const std::string& path);
+    void cleanupStaleEntries();
+ 
+    void beginTransaction();
+    void commitTransaction();
+    void rollbackTransaction();
+ 
+    std::optional<ImageData> getImageByPath(const std::string& path);
+    
+    bool setDirectorySearchedStatus(const std::string& dirPath, bool isSearched);
+
+private:
+    std::string m_dbPath;
+    sqlite3* m_db = nullptr;
+
+    bool initSchema();
+};

include/ImageHasher.hpp

@@ -0,0 +1,24 @@
+#pragma once
+#include <opencv2/opencv.hpp>
+#include <string>
+#include <vector>
+#include <cstdint>
+
+class ImageHasher {
+public:
+    // dHash: 64-bit integer
+    static uint64_t calculateDHash(const cv::Mat& image);
+
+    // pHash: 64-bit integer
+    static uint64_t calculatePHash(const cv::Mat& image);
+
+    // Hamming distance
+    static int hammingDistance(uint64_t h1, uint64_t h2);
+
+    // Helper for loading large images
+    static cv::Mat loadImage(const std::string& path, int targetSize = 512);
+
+private:
+    static constexpr int DHASH_SIZE = 8;
+    static constexpr int PHASH_SIZE = 32;
+};

include/MainWindow.hpp

@@ -0,0 +1,86 @@
+#pragma once
+#include "DatabaseManager.hpp"
+#include "SimilaritySearch.hpp"
+#include <QCheckBox>
+#include <QFutureWatcher>
+#include <QTimer>
+#include <QEvent>
+#include <QObject>
+#include <QGridLayout>
+#include <QLabel>
+#include <QListWidget>
+#include <QMainWindow>
+#include <QProgressBar>
+#include <QPushButton>
+#include <QScrollArea>
+#include <QSlider>
+#include <QCloseEvent>
+#include <memory>
+#include <vector>
+
+class MainWindow : public QMainWindow {
+  Q_OBJECT
+
+public:
+  MainWindow(QWidget *parent = nullptr);
+  ~MainWindow();
+
+private slots:
+  void onAddDirectory();
+  void onRemoveDirectory();
+  void onStartScan();
+  void onDeleteSelected();
+  void onThresholdChanged(int value);
+  void onStrictChanged(int state);
+  void onScanFinished();
+  void performAsyncSearch();
+  void onSearchFinished();
+  void onClearResults();
+
+private:
+  void setupUi();
+  void loadSettings();
+  void saveSettings();
+  void updateResultGrid(const std::vector<DuplicateGroup> &groups);
+  std::vector<ImageData> getFilteredImages();
+  bool eventFilter(QObject *obj, QEvent *event) override;
+  void closeEvent(QCloseEvent *event) override;
+
+  // Database
+  std::unique_ptr<DatabaseManager> m_dbManager;
+
+  // UI Elements
+  QListWidget *m_dirList;
+  QPushButton *m_addDirBtn;
+  QPushButton *m_removeDirBtn;
+  QPushButton *m_startScanBtn;
+  QProgressBar *m_progressBar;
+  QScrollArea *m_scrollArea;
+  QWidget *m_resultWidget;
+  QGridLayout *m_resultLayout;
+  QPushButton *m_deleteBtn;
+  QPushButton *m_clearBtn;
+
+  // Similarity Controls
+  QSlider *m_thresholdSlider;
+  QLabel *m_thresholdLabel;
+  QCheckBox *m_strictCheckBox;
+  int m_currentThreshold = 10;
+  bool m_strictMode = false;
+
+  // Async
+  QFutureWatcher<void> *m_scanWatcher;
+  QFutureWatcher<std::vector<DuplicateGroup>> *m_searchWatcher;
+  QTimer *m_searchTimer;
+ 
+  // Cache
+  std::vector<ImageData> m_lastScannedImages;
+  QStringList m_loadedDirs;
+
+  // Checkboxes for tracking selected images
+  struct ResultItem {
+    QCheckBox *checkbox;
+    std::string path;
+  };
+  std::vector<ResultItem> m_resultItems;
+};

include/SimilaritySearch.hpp

@@ -0,0 +1,16 @@
+#pragma once
+#include "DatabaseManager.hpp"
+#include <vector>
+#include <map>
+
+struct DuplicateGroup {
+    std::vector<ImageData> images;
+};
+
+class SimilaritySearch {
+public:
+    static std::vector<DuplicateGroup> findDuplicates(const std::vector<ImageData>& images, int threshold = 5, bool strict = false);
+
+private:
+    // Simple clustering algorithm
+};

resources/style.qss

@@ -0,0 +1,103 @@
+/* DupFind Modern Dark Theme */
+QMainWindow {
+    background-color: #1e1e1e;
+    color: #e0e0e0;
+}
+
+QWidget {
+    background-color: #1e1e1e;
+    color: #e0e0e0;
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+}
+
+QPushButton {
+    background-color: #333333;
+    border: 1px solid #444444;
+    border-radius: 4px;
+    padding: 8px 16px;
+    color: #ffffff;
+    font-weight: bold;
+}
+
+QPushButton:hover {
+    background-color: #444444;
+    border: 1px solid #555555;
+}
+
+QPushButton:pressed {
+    background-color: #222222;
+}
+
+/* Delete Button Specific */
+QPushButton#deleteBtn {
+    background-color: #c0392b;
+    border: none;
+}
+
+QPushButton#deleteBtn:hover {
+    background-color: #e74c3c;
+}
+
+QListWidget {
+    background-color: #252526;
+    border: 1px solid #333333;
+    border-radius: 4px;
+    outline: 0;
+}
+
+QListWidget::item {
+    padding: 5px;
+    border-bottom: 1px solid #333333;
+}
+
+QListWidget::item:selected {
+    background-color: #37373d;
+    color: #007acc;
+}
+
+QScrollArea {
+    border: none;
+}
+
+#imgCard {
+    background-color: #2d2d2d;
+    border: 1px solid #3f3f3f;
+    border-radius: 8px;
+    margin: 5px;
+}
+
+#imgCard:hover {
+    border: 1px solid #007acc;
+    background-color: #33333d;
+}
+
+QProgressBar {
+    border: 1px solid #333333;
+    border-radius: 4px;
+    text-align: center;
+    background-color: #252526;
+}
+
+QProgressBar::chunk {
+    background-color: #007acc;
+}
+
+QLabel {
+    color: #cccccc;
+}
+
+QSlider::handle:horizontal {
+    background: #007acc;
+    border: 1px solid #007acc;
+    width: 14px;
+    height: 14px;
+    margin: -5px 0;
+    border-radius: 7px;
+}
+
+QSlider::groove:horizontal {
+    border: 1px solid #333333;
+    height: 4px;
+    background: #333333;
+    margin: 2px 0;
+}

src/CmdMain.cpp

@@ -0,0 +1,213 @@
+#include <QCoreApplication>
+#include <QSettings>
+#include <QStringList>
+#include <QProcess>
+#include <QSharedMemory>
+#include <QThread>
+#include <QDirIterator>
+#include <iostream>
+#include <filesystem>
+#include <chrono>
+#include <unordered_map>
+
+#include "DatabaseManager.hpp"
+#include "ImageHasher.hpp"
+#include <opencv2/core/utils/logger.hpp>
+
+void workerAdd(const QStringList& dirs);
+void cmdAdd(const QStringList& dirs);
+void cmdTh(int thValue);
+void cmdSearch(const QString& imageFile);
+
+int main(int argc, char *argv[]) {
+    // OpenCVの不要なINFOログ（並列バックエンド読み込み失敗など）を抑制する
+    cv::utils::logging::setLogLevel(cv::utils::logging::LOG_LEVEL_ERROR);
+
+    QCoreApplication app(argc, argv);
+    QStringList args = app.arguments();
+
+    if (args.size() < 2) {
+        std::cerr << "Usage: DupFindCmd add <dir1> <dir2> ...\n"
+                  << "       DupFindCmd th <N>\n"
+                  << "       DupFindCmd search <image_file>\n";
+        return 1;
+    }
+
+    QString command = args[1];
+
+    if (command == "--worker-add") {
+        QStringList dirs = args.mid(2);
+        workerAdd(dirs);
+        return 0;
+    } else if (command == "add") {
+        if (args.size() < 3) {
+            std::cerr << "Error: 'add' Requires at least one directory.\n";
+            return 1;
+        }
+        cmdAdd(args.mid(2));
+        return 0;
+    } else if (command == "th") {
+        if (args.size() != 3) {
+            std::cerr << "Error: 'th' Requires exactly one integer.\n";
+            return 1;
+        }
+        bool ok;
+        int val = args[2].toInt(&ok);
+        if (!ok || val < 0 || val > 32) {
+            std::cerr << "Error: N must be an integer between 0 and 32.\n";
+            return 1;
+        }
+        cmdTh(val);
+        return 0;
+    } else if (command == "search") {
+        if (args.size() != 3) {
+            std::cerr << "Error: 'search' Requires exactly one image file.\n";
+            return 1;
+        }
+        cmdSearch(args[2]);
+        return 0;
+    } else {
+        std::cerr << "Unknown command: " << command.toStdString() << "\n";
+        return 1;
+    }
+}
+
+void cmdTh(int thValue) {
+    QString iniPath = QCoreApplication::applicationDirPath() + "/DupFind.ini";
+    QSettings settings(iniPath, QSettings::IniFormat);
+    settings.setValue("threshold", thValue);
+    std::cout << "Successfully updated threshold to " << thValue << ".\n";
+}
+
+void cmdAdd(const QStringList& dirs) {
+    QString iniPath = QCoreApplication::applicationDirPath() + "/DupFind.ini";
+    QSettings settings(iniPath, QSettings::IniFormat);
+
+    QStringList existingDirs = settings.value("directories").toStringList();
+    bool changed = false;
+
+    for (const QString& dir : dirs) {
+        if (!existingDirs.contains(dir, Qt::CaseInsensitive)) { // 念のためWindowsなど考慮
+            existingDirs.append(dir);
+            changed = true;
+        }
+    }
+
+    if (changed) {
+        settings.setValue("directories", existingDirs);
+    }
+
+    std::cout << "Started background scan.\n";
+
+    // デタッチしてバックグラウンドプロセスを起動
+    QString program = QCoreApplication::applicationFilePath();
+    QStringList workerArgs;
+    workerArgs << "--worker-add" << dirs;
+    
+    QProcess::startDetached(program, workerArgs);
+}
+
+void workerAdd(const QStringList& dirs) {
+    // 優先度を下げる
+    QThread::currentThread()->setPriority(QThread::IdlePriority);
+    
+    // GUIが起動しているか確認するための共有メモリ
+    QSharedMemory sharedMem("DupFind_GUI_Instance");
+    
+    DatabaseManager dbManager("dupfind_cache.db");
+    if (!dbManager.open()) return;
+
+    auto cachedList = dbManager.getAllImages();
+    std::unordered_map<std::string, ImageData> cache;
+    for (const auto& img : cachedList) {
+        cache[img.path] = img;
+    }
+
+    const QStringList filters = { "*.jpg", "*.png", "*.jpeg", "*.bmp" };
+    int count = 0;
+    
+    for (const QString& dirPath : dirs) {
+        QDirIterator it(dirPath, filters, QDir::Files | QDir::NoSymLinks, QDirIterator::Subdirectories);
+        
+        while (it.hasNext()) {
+            std::string stdPath = it.next().toStdString();
+            
+            // 少し粒度を荒くしてGUI起動チェック (10ファイルごと)
+            if (count % 10 == 0) {
+                if (sharedMem.attach()) {
+                    // GUIが共有メモリを確保している＝起動中
+                    sharedMem.detach();
+                    return; // 即座に終了
+                }
+            }
+            count++;
+
+            try {
+                std::error_code ec;
+                auto currentSize = std::filesystem::file_size(stdPath, ec);
+                auto currentMtime = std::chrono::duration_cast<std::chrono::seconds>(
+                    std::filesystem::last_write_time(stdPath, ec).time_since_epoch()).count();
+
+                auto cacheIt = cache.find(stdPath);
+                if (cacheIt != cache.end()) {
+                    if (cacheIt->second.file_size == static_cast<int64_t>(currentSize) && 
+                        cacheIt->second.timestamp == static_cast<int64_t>(currentMtime)) {
+                        continue; // すでに最新ハッシュ計算済み
+                    }
+                }
+
+                cv::Mat img = ImageHasher::loadImage(stdPath);
+                if (img.empty()) continue;
+
+                ImageData data;
+                data.path = stdPath;
+                data.dhash = ImageHasher::calculateDHash(img);
+                data.phash = ImageHasher::calculatePHash(img);
+                data.timestamp = currentMtime;
+                data.file_size = currentSize;
+                data.is_searched = false;
+
+                dbManager.addImage(data);
+
+            } catch (...) {
+                // ファイルIOエラー等はスキップ
+            }
+        }
+    }
+}
+
+void cmdSearch(const QString& imageFile) {
+    std::string stdPath = imageFile.toStdString();
+    if (!std::filesystem::exists(stdPath)) {
+        return;
+    }
+
+    cv::Mat img = ImageHasher::loadImage(stdPath);
+    if (img.empty()) {
+        return;
+    }
+
+    uint64_t dhash = ImageHasher::calculateDHash(img);
+    uint64_t phash = ImageHasher::calculatePHash(img);
+
+    QString iniPath = QCoreApplication::applicationDirPath() + "/DupFind.ini";
+    QSettings settings(iniPath, QSettings::IniFormat);
+    int threshold = settings.value("threshold", 10).toInt();
+    bool strict = settings.value("strict_mode", false).toBool();
+
+    DatabaseManager dbManager("dupfind_cache.db");
+    if (!dbManager.open()) return;
+
+    auto allImages = dbManager.getAllImages();
+    for (const auto& imgData : allImages) {
+        int distD = ImageHasher::hammingDistance(dhash, imgData.dhash);
+        int distP = ImageHasher::hammingDistance(phash, imgData.phash);
+        
+        bool similar = strict ? (distD <= threshold && distP <= threshold) 
+                              : (distD <= threshold || distP <= threshold);
+                              
+        if (similar) {
+            std::cout << imgData.path << "\n";
+        }
+    }
+}

src/DatabaseManager.cpp

@@ -0,0 +1,168 @@
+#include "DatabaseManager.hpp"
+#include <iostream>
+#include <sstream>
+#include <optional>
+#include <filesystem>
+#include <chrono>
+#include <vector>
+#include <string>
+
+DatabaseManager::DatabaseManager(const std::string& dbPath) : m_dbPath(dbPath) {}
+
+DatabaseManager::~DatabaseManager() {
+    close();
+}
+
+bool DatabaseManager::open() {
+    if (sqlite3_open(m_dbPath.c_str(), &m_db) != SQLITE_OK) {
+        std::cerr << "Cannot open database: " << sqlite3_errmsg(m_db) << std::endl;
+        return false;
+    }
+    // WALモードの有効化 (並列性と速度の向上)
+    sqlite3_exec(m_db, "PRAGMA journal_mode=WAL;", nullptr, nullptr, nullptr);
+    return initSchema();
+}
+
+void DatabaseManager::close() {
+    if (m_db) {
+        sqlite3_close(m_db);
+        m_db = nullptr;
+    }
+}
+
+bool DatabaseManager::initSchema() {
+    const char* sql = "CREATE TABLE IF NOT EXISTS images ("
+                      "id INTEGER PRIMARY KEY AUTOINCREMENT,"
+                      "path TEXT UNIQUE,"
+                      "dhash INTEGER,"
+                      "phash INTEGER,"
+                      "timestamp INTEGER,"
+                      "file_size INTEGER,"
+                      "is_searched INTEGER DEFAULT 0);";
+    char* errMsg = nullptr;
+    if (sqlite3_exec(m_db, sql, nullptr, nullptr, &errMsg) != SQLITE_OK) {
+        std::cerr << "SQL error: " << errMsg << std::endl;
+        sqlite3_free(errMsg);
+        return false;
+    }
+    // Migration: try to add file_size if it doesn't exist (silently ignore error if it does)
+    sqlite3_exec(m_db, "ALTER TABLE images ADD COLUMN file_size INTEGER;", nullptr, nullptr, nullptr);
+    sqlite3_exec(m_db, "ALTER TABLE images ADD COLUMN is_searched INTEGER DEFAULT 0;", nullptr, nullptr, nullptr);
+    return true;
+}
+
+bool DatabaseManager::addImage(const ImageData& data) {
+    const char* sql = "INSERT OR REPLACE INTO images (path, dhash, phash, timestamp, file_size, is_searched) VALUES (?, ?, ?, ?, ?, ?);";
+    sqlite3_stmt* stmt;
+    if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) != SQLITE_OK) return false;
+
+    sqlite3_bind_text(stmt, 1, data.path.c_str(), -1, SQLITE_TRANSIENT);
+    sqlite3_bind_int64(stmt, 2, static_cast<sqlite3_int64>(data.dhash));
+    sqlite3_bind_int64(stmt, 3, static_cast<sqlite3_int64>(data.phash));
+    sqlite3_bind_int64(stmt, 4, data.timestamp);
+    sqlite3_bind_int64(stmt, 5, data.file_size);
+    sqlite3_bind_int(stmt, 6, data.is_searched ? 1 : 0);
+
+    bool success = (sqlite3_step(stmt) == SQLITE_DONE);
+    sqlite3_finalize(stmt);
+    return success;
+}
+
+std::vector<ImageData> DatabaseManager::getAllImages() {
+    std::vector<ImageData> results;
+    const char* sql = "SELECT id, path, dhash, phash, timestamp, file_size, is_searched FROM images;";
+    sqlite3_stmt* stmt;
+    if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) != SQLITE_OK) return results;
+
+    while (sqlite3_step(stmt) == SQLITE_ROW) {
+        ImageData data;
+        data.id = sqlite3_column_int64(stmt, 0);
+        data.path = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
+        data.dhash = static_cast<uint64_t>(sqlite3_column_int64(stmt, 2));
+        data.phash = static_cast<uint64_t>(sqlite3_column_int64(stmt, 3));
+        data.timestamp = sqlite3_column_int64(stmt, 4);
+        data.file_size = sqlite3_column_int64(stmt, 5);
+        data.is_searched = sqlite3_column_int(stmt, 6) != 0;
+        results.push_back(data);
+    }
+    sqlite3_finalize(stmt);
+    return results;
+}
+
+bool DatabaseManager::removeImage(const std::string& path) {
+    const char* sql = "DELETE FROM images WHERE path = ?;";
+    sqlite3_stmt* stmt;
+    if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) != SQLITE_OK) return false;
+
+    sqlite3_bind_text(stmt, 1, path.c_str(), -1, SQLITE_TRANSIENT);
+    bool success = (sqlite3_step(stmt) == SQLITE_DONE);
+    sqlite3_finalize(stmt);
+    return success;
+}
+ 
+#include <filesystem>
+void DatabaseManager::cleanupStaleEntries() {
+    auto images = getAllImages();
+    beginTransaction();
+    for (const auto& img : images) {
+        if (!std::filesystem::exists(img.path)) {
+            removeImage(img.path);
+        }
+    }
+    commitTransaction();
+}
+ 
+void DatabaseManager::beginTransaction() {
+    sqlite3_exec(m_db, "BEGIN TRANSACTION;", nullptr, nullptr, nullptr);
+}
+ 
+void DatabaseManager::commitTransaction() {
+    sqlite3_exec(m_db, "COMMIT;", nullptr, nullptr, nullptr);
+}
+ 
+void DatabaseManager::rollbackTransaction() {
+    sqlite3_exec(m_db, "ROLLBACK;", nullptr, nullptr, nullptr);
+}
+ 
+std::optional<ImageData> DatabaseManager::getImageByPath(const std::string& path) {
+    const char* sql = "SELECT id, path, dhash, phash, timestamp, file_size, is_searched FROM images WHERE path = ?;";
+    sqlite3_stmt* stmt;
+    if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) != SQLITE_OK) return std::nullopt;
+ 
+    sqlite3_bind_text(stmt, 1, path.c_str(), -1, SQLITE_TRANSIENT);
+ 
+    std::optional<ImageData> result;
+    if (sqlite3_step(stmt) == SQLITE_ROW) {
+        ImageData data;
+        data.id = sqlite3_column_int64(stmt, 0);
+        data.path = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
+        data.dhash = static_cast<uint64_t>(sqlite3_column_int64(stmt, 2));
+        data.phash = static_cast<uint64_t>(sqlite3_column_int64(stmt, 3));
+        data.timestamp = sqlite3_column_int64(stmt, 4);
+        data.file_size = sqlite3_column_int64(stmt, 5);
+        data.is_searched = sqlite3_column_int(stmt, 6) != 0;
+        result = data;
+    }
+    sqlite3_finalize(stmt);
+    return result;
+}
+
+bool DatabaseManager::setDirectorySearchedStatus(const std::string& dirPath, bool isSearched) {
+    const char* sql = "UPDATE images SET is_searched = ? WHERE path LIKE ?;";
+    sqlite3_stmt* stmt;
+    if (sqlite3_prepare_v2(m_db, sql, -1, &stmt, nullptr) != SQLITE_OK) return false;
+
+    sqlite3_bind_int(stmt, 1, isSearched ? 1 : 0);
+    
+    std::string pattern = dirPath;
+    if (!pattern.empty() && pattern.back() != '/' && pattern.back() != '\\') {
+        pattern += "/";
+    }
+    pattern += "%";
+
+    sqlite3_bind_text(stmt, 2, pattern.c_str(), -1, SQLITE_TRANSIENT);
+
+    bool success = (sqlite3_step(stmt) == SQLITE_DONE);
+    sqlite3_finalize(stmt);
+    return success;
+}

src/ImageHasher.cpp

@@ -0,0 +1,72 @@
+#include "ImageHasher.hpp"
+#include <opencv2/imgproc.hpp>
+#include <bit> // C++20 std::popcount
+
+uint64_t ImageHasher::calculateDHash(const cv::Mat& image) {
+    if (image.empty()) return 0;
+
+    cv::Mat gray, resized;
+    cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);
+    // dHash needs 9x8 for 8x8 diffs
+    cv::resize(gray, resized, cv::Size(9, 8));
+
+    uint64_t hash = 0;
+    for (int y = 0; y < 8; ++y) {
+        for (int x = 0; x < 8; ++x) {
+            if (resized.at<uint8_t>(y, x) < resized.at<uint8_t>(y, x + 1)) {
+                hash |= (1ULL << (y * 8 + x));
+            }
+        }
+    }
+    return hash;
+}
+
+uint64_t ImageHasher::calculatePHash(const cv::Mat& image) {
+    if (image.empty()) return 0;
+
+    cv::Mat gray, resized, floatImg, dctImg;
+    cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);
+    // Resize to 32x32 for DCT
+    cv::resize(gray, resized, cv::Size(PHASH_SIZE, PHASH_SIZE));
+    resized.convertTo(floatImg, CV_32F);
+    
+    cv::dct(floatImg, dctImg);
+
+    // Take top-left 8x8 (excluding DC component at 0,0)
+    double sum = 0;
+    for (int y = 0; y < 8; ++y) {
+        for (int x = 0; x < 8; ++x) {
+            if (x == 0 && y == 0) continue;
+            sum += dctImg.at<float>(y, x);
+        }
+    }
+    double avg = sum / 63.0;
+
+    uint64_t hash = 0;
+    for (int y = 0; y < 8; ++y) {
+        for (int x = 0; x < 8; ++x) {
+            if (x == 0 && y == 0) continue;
+            if (dctImg.at<float>(y, x) > avg) {
+                hash |= (1ULL << (y * 8 + x));
+            }
+        }
+    }
+    return hash;
+}
+
+int ImageHasher::hammingDistance(uint64_t h1, uint64_t h2) {
+    return static_cast<int>(std::popcount(h1 ^ h2));
+}
+
+cv::Mat ImageHasher::loadImage(const std::string& path, int targetSize) {
+    // Load with IMREAD_COLOR
+    cv::Mat img = cv::imread(path, cv::IMREAD_COLOR);
+    if (img.empty()) return cv::Mat();
+
+    // Minor optimization: if image is huge, resize it slightly for faster hashing
+    if (img.cols > targetSize || img.rows > targetSize) {
+        double scale = static_cast<double>(targetSize) / std::max(img.cols, img.rows);
+        cv::resize(img, img, cv::Size(), scale, scale);
+    }
+    return img;
+}

src/MainWindow.cpp

@@ -0,0 +1,465 @@
+#include "MainWindow.hpp"
+#include "ImageHasher.hpp"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QFileDialog>
+#include <QMessageBox>
+#include <QDirIterator>
+#include <QFile>
+#include <QPixmap>
+#include <chrono>
+#include <filesystem>
+
+#include <QtConcurrent>
+#include <QDesktopServices>
+#include <QUrl>
+#include <QSettings>
+#include <QCoreApplication>
+ 
+ 
+
+MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
+    m_dbManager = std::make_unique<DatabaseManager>("dupfind_cache.db");
+    m_dbManager->open();
+    m_scanWatcher = new QFutureWatcher<void>(this);
+    m_searchWatcher = new QFutureWatcher<std::vector<DuplicateGroup>>(this);
+    
+    m_searchTimer = new QTimer(this);
+    m_searchTimer->setSingleShot(true);
+    m_searchTimer->setInterval(300);
+    connect(m_searchTimer, &QTimer::timeout, this, &MainWindow::performAsyncSearch);
+    connect(m_searchWatcher, &QFutureWatcher<std::vector<DuplicateGroup>>::finished, this, &MainWindow::onSearchFinished);
+    
+    
+    // スタイルの適用
+    QFile styleFile("resources/style.qss");
+    if (styleFile.open(QFile::ReadOnly)) {
+        QString styleSheet = QLatin1String(styleFile.readAll());
+        setStyleSheet(styleSheet);
+    }
+    
+    loadSettings(); // setupUi の前に読み込む
+    setupUi();
+}
+
+MainWindow::~MainWindow() {}
+
+std::vector<ImageData> MainWindow::getFilteredImages() {
+    auto allImages = m_dbManager->getAllImages();
+    if (m_dirList->count() == 0) return {};
+    
+    std::vector<ImageData> filtered;
+    for (const auto& img : allImages) {
+        bool match = false;
+        for (int i = 0; i < m_dirList->count(); ++i) {
+            std::string dirPath = m_dirList->item(i)->text().toStdString();
+            std::string dirPathWithSlash = dirPath;
+            if (!dirPathWithSlash.empty() && dirPathWithSlash.back() != '/' && dirPathWithSlash.back() != '\\') {
+                dirPathWithSlash += "/";
+            }
+            if (img.path.find(dirPathWithSlash) == 0 || img.path == dirPath) {
+                match = true;
+                break;
+            }
+        }
+        if (match) {
+            filtered.push_back(img);
+        }
+    }
+    return filtered;
+}
+
+void MainWindow::setupUi() {
+    auto* central = new QWidget();
+    auto* mainLayout = new QVBoxLayout(central);
+
+    // Toolbar-like top section
+    auto* toolLayout = new QHBoxLayout();
+    m_addDirBtn = new QPushButton("Add Directory");
+    m_removeDirBtn = new QPushButton("Remove Selected");
+    m_startScanBtn = new QPushButton("Start Scan");
+    m_deleteBtn = new QPushButton("Delete Selected Duplicates");
+    m_deleteBtn->setObjectName("deleteBtn"); // QSS で赤くするため
+    
+    toolLayout->addWidget(m_addDirBtn);
+    toolLayout->addWidget(m_removeDirBtn);
+    toolLayout->addStretch();
+ 
+    // Slider section
+    toolLayout->addWidget(new QLabel("Similarity Threshold:"));
+    m_thresholdSlider = new QSlider(Qt::Horizontal);
+    m_thresholdSlider->setRange(0, 32);
+    m_thresholdSlider->setValue(m_currentThreshold);
+    m_thresholdSlider->setFixedWidth(150);
+    m_thresholdLabel = new QLabel(QString::number(m_currentThreshold));
+    toolLayout->addWidget(m_thresholdSlider);
+    toolLayout->addWidget(m_thresholdLabel);
+
+    m_strictCheckBox = new QCheckBox("Strict");
+    m_strictCheckBox->setChecked(m_strictMode);
+    toolLayout->addWidget(m_strictCheckBox);
+ 
+    toolLayout->addWidget(m_startScanBtn);
+    m_clearBtn = new QPushButton("Clear Results");
+    toolLayout->addWidget(m_clearBtn);
+    toolLayout->addWidget(m_deleteBtn);
+    mainLayout->addLayout(toolLayout);
+
+    // Split view
+    auto* splitLayout = new QHBoxLayout();
+    
+    // Directory List
+    m_dirList = new QListWidget();
+    m_dirList->setMaximumWidth(250);
+    m_dirList->addItems(m_loadedDirs); // ここで復元
+    splitLayout->addWidget(m_dirList);
+
+    // Results Scroll Area
+    m_scrollArea = new QScrollArea();
+    m_scrollArea->setWidgetResizable(true);
+    m_resultWidget = new QWidget();
+    m_resultLayout = new QGridLayout(m_resultWidget);
+    m_scrollArea->setWidget(m_resultWidget);
+    splitLayout->addWidget(m_scrollArea);
+
+    mainLayout->addLayout(splitLayout);
+
+    // Progress Bar
+    m_progressBar = new QProgressBar();
+    m_progressBar->setVisible(false);
+    mainLayout->addWidget(m_progressBar);
+
+    setCentralWidget(central);
+
+    // Connections
+    connect(m_addDirBtn, &QPushButton::clicked, this, &MainWindow::onAddDirectory);
+    connect(m_removeDirBtn, &QPushButton::clicked, this, &MainWindow::onRemoveDirectory);
+    connect(m_startScanBtn, &QPushButton::clicked, this, &MainWindow::onStartScan);
+    connect(m_clearBtn, &QPushButton::clicked, this, &MainWindow::onClearResults);
+    connect(m_deleteBtn, &QPushButton::clicked, this, &MainWindow::onDeleteSelected);
+    connect(m_thresholdSlider, &QSlider::valueChanged, this, &MainWindow::onThresholdChanged);
+    connect(m_strictCheckBox, &QCheckBox::stateChanged, this, &MainWindow::onStrictChanged);
+    connect(m_scanWatcher, &QFutureWatcher<void>::finished, this, &MainWindow::onScanFinished);
+}
+
+void MainWindow::loadSettings() {
+    QString iniPath = QCoreApplication::applicationDirPath() + "/DupFind.ini";
+    QSettings settings(iniPath, QSettings::IniFormat);
+    
+    m_currentThreshold = settings.value("threshold", 10).toInt();
+    m_strictMode = settings.value("strict_mode", false).toBool();
+    m_loadedDirs = settings.value("directories").toStringList();
+}
+
+void MainWindow::saveSettings() {
+    QString iniPath = QCoreApplication::applicationDirPath() + "/DupFind.ini";
+    QSettings settings(iniPath, QSettings::IniFormat);
+    
+    settings.setValue("threshold", m_currentThreshold);
+    settings.setValue("strict_mode", m_strictMode);
+    
+    QStringList dirs;
+    for (int i = 0; i < m_dirList->count(); ++i) {
+        dirs << m_dirList->item(i)->text();
+    }
+    settings.setValue("directories", dirs);
+}
+
+void MainWindow::closeEvent(QCloseEvent* event) {
+    saveSettings();
+    QMainWindow::closeEvent(event);
+}
+
+void MainWindow::onAddDirectory() {
+    QString dir = QFileDialog::getExistingDirectory(this, "Select Directory to Scan");
+    if (!dir.isEmpty()) {
+        m_dirList->addItem(dir);
+    }
+}
+
+void MainWindow::onRemoveDirectory() {
+    auto* item = m_dirList->currentItem();
+    if (item) {
+        QString dirPath = item->text();
+        m_dbManager->setDirectorySearchedStatus(dirPath.toStdString(), false);
+        delete item;
+        // キャッシュ再読み込み
+        m_lastScannedImages = getFilteredImages();
+    }
+}
+
+void MainWindow::onStartScan() {
+    if (m_dirList->count() == 0) {
+        QMessageBox::warning(this, "No Directory", "Please add at least one directory to scan.");
+        return;
+    }
+ 
+    m_progressBar->setVisible(true);
+    m_progressBar->setRange(0, 0); // 準備中
+    m_startScanBtn->setEnabled(false);
+ 
+    // 1. スキャン対象ディレクトリの収集
+    std::vector<QString> dirPaths;
+    for (int i = 0; i < m_dirList->count(); ++i) {
+        dirPaths.push_back(m_dirList->item(i)->text());
+    }
+ 
+    // キャッシュ（DBの既存データ）を読み込み
+    auto cachedList = m_dbManager->getAllImages();
+    std::unordered_map<std::string, ImageData> cache;
+    for (const auto& img : cachedList) {
+        cache[img.path] = img;
+    }
+ 
+    // 2. 非同期で一連の処理を実行
+    auto future = QtConcurrent::run([this, dirPaths, cache]() {
+        // 全ファイルパスをリストアップ
+        std::vector<std::string> allFiles;
+        const QStringList filters = { "*.jpg", "*.png", "*.jpeg", "*.bmp" };
+        for (const auto& dirPath : dirPaths) {
+            QDirIterator it(dirPath, filters, QDir::Files | QDir::NoSymLinks, QDirIterator::Subdirectories);
+            while (it.hasNext()) {
+                allFiles.push_back(it.next().toStdString());
+            }
+        }
+ 
+        // 3. 並列ハッシュ計算 (mapped)
+        auto processFunc = [&cache](const std::string& stdPath) -> ImageData {
+            try {
+                std::error_code ec;
+                auto currentSize = std::filesystem::file_size(stdPath, ec);
+                auto currentMtime = std::chrono::duration_cast<std::chrono::seconds>(
+                    std::filesystem::last_write_time(stdPath, ec).time_since_epoch()).count();
+ 
+                auto it = cache.find(stdPath);
+                if (it != cache.end()) {
+                    if (it->second.file_size == static_cast<int64_t>(currentSize) && 
+                        it->second.timestamp == static_cast<int64_t>(currentMtime)) {
+                        return {}; // キャッシュと一致する場合はDBの再書き込みを避けるため空を返す
+                    }
+                }
+ 
+                cv::Mat img = ImageHasher::loadImage(stdPath);
+                ImageData data;
+                data.path = stdPath;
+                data.is_searched = false;
+                if (!img.empty()) {
+                    data.dhash = ImageHasher::calculateDHash(img);
+                    data.phash = ImageHasher::calculatePHash(img);
+                }
+                data.timestamp = currentMtime;
+                data.file_size = currentSize;
+                return data;
+            } catch (...) {
+                return {};
+            }
+        };
+ 
+        // 並列実行
+        auto results = QtConcurrent::blockingMapped(allFiles, processFunc);
+ 
+        // 4. DBへの一括保存 (メインスレッドの管理外のDB接続で行う)
+        DatabaseManager db("dupfind_cache.db");
+        if (db.open()) {
+            db.cleanupStaleEntries(); // DBに存在して実体がないファイルを削除
+            db.beginTransaction();
+            for (const auto& data : results) {
+                if (data.path.empty()) continue; // 全く変更がないファイルはスキップ
+                db.addImage(data);
+            }
+            db.commitTransaction();
+        }
+    });
+ 
+    m_scanWatcher->setFuture(future);
+}
+
+void MainWindow::onScanFinished() {
+    m_startScanBtn->setEnabled(true);
+ 
+    auto images = getFilteredImages();
+    m_lastScannedImages = images; // キャッシュを更新
+    
+    // スキャン後は同期処理で固まらないように非同期検索を起動する
+    performAsyncSearch();
+}
+
+void MainWindow::onThresholdChanged(int value) {
+    m_currentThreshold = value;
+    m_thresholdLabel->setText(QString::number(value));
+    
+    // 操作が止まるまで待機（デバウンス）
+    m_searchTimer->start();
+}
+
+void MainWindow::onStrictChanged(int state) {
+    m_strictMode = (state == Qt::Checked);
+    m_searchTimer->start();
+}
+ 
+void MainWindow::performAsyncSearch() {
+    if (m_lastScannedImages.empty()) {
+        m_lastScannedImages = getFilteredImages();
+    }
+    
+    if (m_lastScannedImages.empty()) return;
+ 
+    m_progressBar->setVisible(true);
+    m_progressBar->setRange(0, 0);
+    m_progressBar->setFormat("Searching duplicates... %p%");
+ 
+    // 現在実行中の検索があればキャンセルはできないが、WatcherのFutureを上書きすることで最新のみを追う
+    auto future = QtConcurrent::run([images = m_lastScannedImages, threshold = m_currentThreshold, strict = m_strictMode]() {
+        return SimilaritySearch::findDuplicates(images, threshold, strict);
+    });
+    
+    m_searchWatcher->setFuture(future);
+}
+ 
+void MainWindow::onSearchFinished() {
+    m_progressBar->setVisible(false);
+    updateResultGrid(m_searchWatcher->result());
+    
+    // サムネイルが表示された時点で検索対象ディレクトリ群を検索済みとする
+    for (int i = 0; i < m_dirList->count(); ++i) {
+        QString dirPath = m_dirList->item(i)->text();
+        m_dbManager->setDirectorySearchedStatus(dirPath.toStdString(), true);
+    }
+    // メモリ上のキャッシュも更新する
+    m_lastScannedImages = getFilteredImages();
+}
+ 
+void MainWindow::onClearResults() {
+    // UIをクリア
+    QLayoutItem *child;
+    while ((child = m_resultLayout->takeAt(0)) != nullptr) {
+        if (child->widget()) delete child->widget();
+        delete child;
+    }
+    m_resultItems.clear();
+}
+ 
+bool MainWindow::eventFilter(QObject *obj, QEvent *event) {
+    if (event->type() == QEvent::MouseButtonDblClick) {
+        QString path = obj->property("filePath").toString();
+        if (!path.isEmpty()) {
+            QDesktopServices::openUrl(QUrl::fromLocalFile(path));
+            return true;
+        }
+    }
+    return QMainWindow::eventFilter(obj, event);
+}
+
+void MainWindow::updateResultGrid(const std::vector<DuplicateGroup>& groups) {
+    // UIをクリア
+    QLayoutItem *child;
+    while ((child = m_resultLayout->takeAt(0)) != nullptr) {
+        if (child->widget()) delete child->widget();
+        delete child;
+    }
+    m_resultItems.clear();
+
+    int row = 0;
+    for (const auto& group : groups) {
+        // グループ内で最小のファイルサイズを見つける
+        int64_t minSize = -1;
+        for (const auto& img : group.images) {
+            if (minSize == -1 || img.file_size < minSize) {
+                minSize = img.file_size;
+            }
+        }
+
+        // グループヘッダー
+        QLabel* groupLabel = new QLabel(QString("Duplicate Group - %1 images").arg(group.images.size()));
+        groupLabel->setStyleSheet("font-weight: bold; background-color: #f0f0f0; padding: 5px; border-radius: 4px;");
+        m_resultLayout->addWidget(groupLabel, row++, 0, 1, 4);
+
+        int col = 0;
+        for (const auto& imgData : group.images) {
+            QWidget* imgWidget = new QWidget();
+            imgWidget->setObjectName("imgCard");
+            QVBoxLayout* vBox = new QVBoxLayout(imgWidget);
+            
+            QLabel* thumb = new QLabel();
+            thumb->setProperty("filePath", QString::fromStdString(imgData.path));
+            thumb->installEventFilter(this);
+            thumb->setToolTip("Double click to open");
+ 
+            QPixmap pix(QString::fromStdString(imgData.path));
+            if (!pix.isNull()) {
+                thumb->setPixmap(pix.scaled(150, 150, Qt::KeepAspectRatio, Qt::SmoothTransformation));
+            } else {
+                thumb->setText("Error Loading");
+            }
+            thumb->setAlignment(Qt::AlignCenter);
+            vBox->addWidget(thumb);
+
+            // 自動チェック: 最小サイズの場合（かつ、グループ内の全てが同じサイズでない限り）
+            // 全て同じサイズの場合は最初の1枚以外をチェックするなどのロジックも検討できるが、
+            // ここではシンプルに「最小サイズ」をチェック候補とする
+            QCheckBox* cb = new QCheckBox("Delete candidate");
+            if (imgData.file_size == minSize) {
+                cb->setChecked(true);
+            }
+            vBox->addWidget(cb);
+            
+            QLabel* infoLabel = new QLabel(QString("%1 KB\n%2").arg(imgData.file_size / 1024).arg(QString::fromStdString(imgData.path)));
+            infoLabel->setWordWrap(true);
+            infoLabel->setMaximumWidth(150);
+            infoLabel->setStyleSheet("font-size: 10px; color: #666;");
+            vBox->addWidget(infoLabel);
+
+            m_resultLayout->addWidget(imgWidget, row, col);
+            m_resultItems.push_back({cb, imgData.path});
+
+            col++;
+            if (col >= 4) {
+                col = 0;
+                row++;
+            }
+        }
+        row++;
+    }
+}
+
+void MainWindow::onDeleteSelected() {
+    int count = 0;
+    for (const auto& item : m_resultItems) {
+        if (item.checkbox->isChecked()) {
+            count++;
+        }
+    }
+
+    if (count == 0) return;
+
+    auto res = QMessageBox::question(this, "Confirm Deletion", 
+        QString("Are you sure you want to move %1 images to Trash?").arg(count));
+    
+    if (res == QMessageBox::Yes) {
+        std::vector<QString> failures;
+        for (const auto& item : m_resultItems) {
+            if (item.checkbox->isChecked()) {
+                QString qPath = QString::fromStdString(item.path);
+                // QFile::moveToTrash は Qt 5.15+ で利用可能
+                if (QFile::moveToTrash(qPath)) {
+                    m_dbManager->removeImage(item.path);
+                } else {
+                    failures.push_back(qPath);
+                }
+            }
+        }
+
+        if (!failures.empty()) {
+            QString msg = "The following files could not be moved to trash and were NOT deleted:\n\n";
+            for (const auto& f : failures) {
+                msg += f + "\n";
+            }
+            QMessageBox::warning(this, "Deletion Error", msg);
+        }
+
+        // リストをリフレッシュ
+        auto images = getFilteredImages();
+        auto groups = SimilaritySearch::findDuplicates(images, m_currentThreshold, m_strictMode);
+        updateResultGrid(groups);
+    }
+}

src/SimilaritySearch.cpp

@@ -0,0 +1,72 @@
+#include "SimilaritySearch.hpp"
+#include "ImageHasher.hpp"
+#include <algorithm>
+#include <set>
+#include <numeric>
+#include <QtConcurrent>
+#include <mutex>
+#include <map>
+ 
+// 高速なマージのための Union-Find (Disjoint Set Union)
+struct DSU {
+    std::vector<int> parent;
+    DSU(int n) {
+        parent.resize(n);
+        std::iota(parent.begin(), parent.end(), 0);
+    }
+    int find(int i) {
+        if (parent[i] == i) return i;
+        return parent[i] = find(parent[i]);
+    }
+    void unite(int i, int j) {
+        int root_i = find(i);
+        int root_j = find(j);
+        if (root_i != root_j) parent[root_i] = root_j;
+    }
+};
+ 
+std::vector<DuplicateGroup> SimilaritySearch::findDuplicates(const std::vector<ImageData>& images, int threshold, bool strict) {
+    if (images.empty()) return {};
+ 
+    int n = static_cast<int>(images.size());
+    DSU dsu(n);
+    std::mutex dsuMutex;
+ 
+    // インデックスのリストを作成 (C++20 std::views::iota の代わり)
+    std::vector<int> indices(n);
+    std::iota(indices.begin(), indices.end(), 0);
+ 
+    // 外側ループを並列化
+    // 各コアでハミング距離の計算を分散実行
+    QtConcurrent::blockingMap(indices, [&](int i) {
+        for (int j = i + 1; j < n; ++j) {
+
+            int distD = ImageHasher::hammingDistance(images[i].dhash, images[j].dhash);
+            int distP = ImageHasher::hammingDistance(images[i].phash, images[j].phash);
+ 
+            bool similar = strict ? (distD <= threshold && distP <= threshold) 
+                                  : (distD <= threshold || distP <= threshold);
+
+            if (similar) {
+                std::lock_guard<std::mutex> lock(dsuMutex);
+                dsu.unite(i, j);
+            }
+        }
+    });
+ 
+    // 結果の集計 (ルートごとに画像をまとめる)
+    std::map<int, DuplicateGroup> groupsMap;
+    for (int i = 0; i < n; ++i) {
+        int root = dsu.find(i);
+        groupsMap[root].images.push_back(images[i]);
+    }
+ 
+    std::vector<DuplicateGroup> results;
+    for (auto& pair : groupsMap) {
+        if (pair.second.images.size() > 1) {
+            results.push_back(pair.second);
+        }
+    }
+ 
+    return results;
+}

src/main.cpp

@@ -0,0 +1,23 @@
+#include <QApplication>
+#include <QSharedMemory>
+#include "MainWindow.hpp"
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+    
+    // Create a shared memory object to indicate that the GUI is running
+    QSharedMemory sharedMem("DupFind_GUI_Instance");
+    if (!sharedMem.create(1)) {
+        // If create fails, it might mean another GUI instance is running,
+        // or a previous crash left it. But usually it's used as a flag.
+        // We can just try to attach to see if it's really there.
+        if (!sharedMem.attach()) {
+            sharedMem.create(1);
+        }
+    }
+
+    MainWindow window;
+    window.resize(1024, 768);
+    window.show();
+    return app.exec();
+}

task.md

@@ -0,0 +1,19 @@
+# タスク: 画像類似度検索 Windows アプリの開発 (C++)
+
+## 計画
+- [x] 調査とプロジェクトアーキテクチャの検討 [x]
+- [x] 実施計画（日本語版）の作成 [x]
+- [x] ユーザーによる計画の承認 [x]
+
+## 実装 - コアロジック (CLI/ライブラリ)
+- [x] GUI フレームワーク (Qt 6) の選定とセットアップ [x]
+- [x] メインウィンドウ (ディレクトリ選択、進捗バー) の作成 [x]
+- [x] サムネイル・キャッシング・エンジンの実装 (高速スクロール用) [x]
+- [x] 結果表示ビュー (類似画像のグリッド表示 + グループ化) の作成 [x]
+- [x] 画像選択・削除の UI 機能（チェックボックス、一括削除ボタン）の実装 [x]
+- [x] ファイル削除の安全な実行 (ゴミ箱への移動機能など) の実装 [x]
+
+## 検証と最適化
+- [ ] 1万枚以上の画像を用いたパフォーマンス・テスト [ ]
+- [ ] マルチスレッド戦略の洗練 [ ]
+- [x] 最終ウォークスルー [x]