Qt6 UI basics and image source input

.gitignore

@@ -36,3 +36,6 @@ output/
 *.exe
 *.out
 *.app
+
+# vscode
+.vscode/settings.json

.vscode/c_cpp_properties.json

@@ -8,8 +8,8 @@
             ],
             "defines": [],
             "compilerPath": "/usr/bin/gcc",
-            "cStandard": "c17",
-            "cppStandard": "c++17",
+            "cStandard": "c23",
+            "cppStandard": "c++23",
             "intelliSenseMode": "gcc-x64"
         }
     ],

meson.build

@@ -1,24 +1,69 @@
 project('printf', 'cpp',
-  default_options: ['cpp_std=c++17']
+  default_options: ['cpp_std=c++23']
 )
 
 # Dependencies
 nlohmann_json = dependency('nlohmann_json', required: true)
 opencv = dependency('opencv4', required: true)
-qt6_dep = dependency('qt6', modules: ['Core'])
+qt6_dep = dependency('qt6', modules: ['Core', 'Widgets', 'Gui', 'Qml'])
 
 
+
+
+# Qt6 preprocessing
+qt6 = import('qt6')
+
+ui_files = files()
+
+moc_headers = files(
+  'src/ui/source_entry_view.hpp',
+  'src/ui/image_source_view.hpp',
+  'src/ui/preset_view.hpp',
+  'src/ui/mask_filter_view.hpp',
+)
+
+qresources = files('src/qml/resources.qrc')
+
+prep = qt6.preprocess(
+  moc_headers : moc_headers,
+  ui_files : ui_files,
+  qresources : qresources,
+)
+
+
+# Include directories
+inc = include_directories(
+  'src',
+  'src/interfaces',
+  'src/img',
+  'src/img/filters',
+  'src/img/tiling',
+  'src/settings',
+  'src/util',
+  'src/ui',
+  'src/qml',
+)
+
 # Source files
 srcs = files(
-    'src/main.cpp',
-    'src/img/filters/filter.hpp',
-    'src/img/filters/size.hpp',
-    'src/img/filters/size.cpp',
-    'src/img/filters/mask.hpp',
-    'src/img/filters/mask.cpp',
+  'src/img/filters/mask.cpp',
+  'src/img/filters/rotate.cpp',
+  'src/img/filters/size.cpp',
+  'src/img/filters/padding.cpp',
+  'src/img/tiling/grid_tiling.cpp',
+  'src/img/cached_image.cpp',
+  'src/img/image_source.cpp',
+  'src/settings/document_preset.cpp',
+  'src/ui/source_entry_view.cpp',
+  'src/ui/image_source_view.cpp',
+  'src/ui/mask_filter_view.cpp',
+  'src/ui/preset_view.cpp',
+  'src/util/jsonprobe.cpp',
+  'src/main.cpp',
 )
 
 # Executable
-executable('printf', srcs,
+executable('printf', [srcs, prep],
+  include_directories: inc,
   dependencies: [nlohmann_json, opencv, qt6_dep]
 )

presets/document/tekercs.json

@@ -0,0 +1,9 @@
+{
+    "name": "609.6mm tekercs",
+    "roll_width_mm": 609.6,
+    "resolution_ppi": 300,
+    "margin_mm": 0,
+    "gutter_mm": 0,
+    "guide": true,
+    "correct_quantity": false
+}

presets/image/a3.json

@@ -0,0 +1,6 @@
+{
+    "name": "A3",
+    "width": 297,
+    "height": 420,
+    "suggested_resolution": 300
+}

presets/image/a4.json

@@ -0,0 +1,6 @@
+{
+    "name": "A4",
+    "width": 210,
+    "height": 297,
+    "suggested_resolution": 300
+}

presets/mask/circlemask.json

@@ -0,0 +1,4 @@
+{
+    "name": "Circle Mask",
+    "path": "assets/mask.png"
+}

presets/printer/evil_plotter.json

@@ -0,0 +1,5 @@
+{
+    "name": "Canon imagePROGRAF PRO-4000",
+    "max_print_height": 18000,
+    "min_print_height": 101.6
+}

src/img/cached_image.cpp

@@ -0,0 +1,26 @@
+#include "cached_image.hpp"
+
+CachedImage::CachedImage(const ICachableImage& source) : source(source), isDirty(true) {}
+
+cv::Mat CachedImage::get_img() {
+    regenerate();
+    return cache;
+}
+
+void CachedImage::regenerate() {
+    if (!isDirty) return;
+    cache = source.get_cachable();
+    isDirty = false;
+}
+
+size_t CachedImage::get_width() {
+    regenerate();
+    return cache.cols;
+}
+
+size_t CachedImage::get_height() {
+    regenerate();
+    return cache.rows;
+}
+
+void CachedImage::set_dirty() { isDirty = true; }

src/img/cached_image.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <opencv2/opencv.hpp>
+#include "icachable.hpp"
+#include "icache.hpp"
+
+class CachedImage : ICache {
+  private:
+    const ICachableImage& source;
+    cv::Mat cache;
+    bool isDirty;
+
+    void regenerate();
+
+  public:
+    CachedImage(const ICachableImage& source);
+
+    cv::Mat get_img();
+
+    size_t get_width();
+
+    size_t get_height();
+
+    void set_dirty() override;
+};

src/img/filters/filter.hpp

@@ -3,5 +3,5 @@
 
 class Filter {
   public:
-    virtual cv::Mat apply(const cv::Mat &image) = 0;
+    virtual cv::Mat apply(const cv::Mat &image) const = 0;
 };

src/img/filters/mask.cpp

@@ -4,7 +4,7 @@
 
 MaskFilter::MaskFilter(const cv::Mat &mask) : mask(mask) {}
 
-cv::Mat MaskFilter::apply(const cv::Mat &image) {
+cv::Mat MaskFilter::apply(const cv::Mat &image) const {
     auto fitMask = SizeFilter::resize(mask, image.cols, image.rows);
 
     if (invert) {

src/img/filters/mask.hpp

@@ -11,7 +11,7 @@ class MaskFilter : public Filter {
   public:
     MaskFilter(const cv::Mat &mask);
 
-    cv::Mat apply(const cv::Mat &image) override;
+    cv::Mat apply(const cv::Mat &image) const override;
 
     void setInvert(bool invert);
 };

src/img/filters/padding.cpp

@@ -0,0 +1,44 @@
+#include "padding.hpp"
+
+PaddingFilter::PaddingFilter(size_t padding, bool guide): padding(padding), guide(guide) {}
+
+cv::Mat PaddingFilter::apply(const cv::Mat &image) const {
+    cv::Mat padded;
+    cv::copyMakeBorder(image, padded, padding, padding, padding, padding, cv::BORDER_CONSTANT, cv::Scalar(255, 255, 255));
+
+    if (guide) {
+        // TODO: make this configurable
+        int thickness = 1;
+        cv::Scalar color = cv::Scalar(0, 0, 0);
+        int width = padded.cols;
+        int height = padded.rows;
+
+        // the lines are outside of the image, full width
+        /* 
+        cv::line(padded, cv::Point(0, padding - 1), cv::Point(padded.cols - 1, padding - 1), color, thickness, cv::LINE_8); // top
+        cv::line(padded, cv::Point(0, padded.rows - padding), cv::Point(padded.cols - 1, padded.rows - padding), color, thickness, cv::LINE_8); // bottom
+        cv::line(padded, cv::Point(padding - 1, 0), cv::Point(padding - 1, padded.rows - 1), color, thickness, cv::LINE_8); // left
+        cv::line(padded, cv::Point(padded.cols - padding, 0), cv::Point(padded.cols - padding, padded.rows - 1), color, thickness, cv::LINE_8); // right
+         */
+
+        // the lines are only outside of the image, show only on the gutter
+        // top
+        cv::line(padded, cv::Point(0, padding), cv::Point(padding - 1, padding), color, thickness, cv::LINE_8);
+        cv::line(padded, cv::Point(width - padding, padding), cv::Point(width - 1, padding), color, thickness, cv::LINE_8);
+
+        // bottom
+        cv::line(padded, cv::Point(0, height - padding - 1), cv::Point(padding - 1, height - padding - 1), color, thickness, cv::LINE_8);
+        cv::line(padded, cv::Point(width - padding, height - padding - 1), cv::Point(width - 1, height - padding - 1), color, thickness, cv::LINE_8);
+
+        // left
+        cv::line(padded, cv::Point(padding, 0), cv::Point(padding, padding - 1), color, thickness, cv::LINE_8);
+        cv::line(padded, cv::Point(padding, height - padding), cv::Point(padding, height - 1), color, thickness, cv::LINE_8);
+
+        // right
+        cv::line(padded, cv::Point(width - padding - 1, 0), cv::Point(width - padding - 1, padding - 1), color, thickness, cv::LINE_8);
+        cv::line(padded, cv::Point(width - padding - 1, height - padding), cv::Point(width - padding - 1, height - 1), color, thickness, cv::LINE_8);
+
+    }
+
+    return padded;
+}

src/img/filters/padding.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include <opencv2/imgproc.hpp>
+
+#include "filter.hpp"
+
+class PaddingFilter : public Filter {
+  private:
+    size_t padding;
+    bool guide;
+
+  public:
+    PaddingFilter(size_t padding, bool guide = false);
+
+    cv::Mat apply(const cv::Mat &image) const override;
+};

src/img/filters/rotate.cpp

@@ -0,0 +1,9 @@
+#include "rotate.hpp"
+
+cv::Mat RotateFilter::apply(const cv::Mat &image) const { return RotateFilter::rotate(image, default_rotation_dir); }
+
+cv::Mat RotateFilter::rotate(const cv::Mat &image, cv::RotateFlags rotation_dir) {
+    cv::Mat rotated;
+    cv::rotate(image, rotated, rotation_dir);
+    return rotated;
+}

src/img/filters/rotate.hpp

@@ -0,0 +1,13 @@
+#pragma once
+#include <opencv2/imgproc.hpp>
+
+#include "filter.hpp"
+
+class RotateFilter : public Filter {
+  private:
+    static const cv::RotateFlags default_rotation_dir = cv::ROTATE_90_CLOCKWISE;
+
+  public:
+    cv::Mat apply(const cv::Mat &image) const override;
+    static cv::Mat rotate(const cv::Mat &image, cv::RotateFlags rotation_dir);
+};

src/img/filters/size.cpp

@@ -2,13 +2,21 @@
 
 SizeFilter::SizeFilter(int width, int height) : width(width), height(height) {}
 
-cv::Mat SizeFilter::apply(const cv::Mat &image) { return SizeFilter::resize(image, width, height); }
+cv::Mat SizeFilter::apply(const cv::Mat &image) const { return SizeFilter::resize(image, width, height); }
 
 cv::Mat SizeFilter::resize(const cv::Mat &image, int width, int height, int interDown, int interUp) {
+    if (width == image.cols && height == image.rows) {
+        return image;
+    }
+
     bool downScaling = width < image.cols || height < image.rows;
 
     cv::Mat resized;
     cv::resize(image, resized, cv::Size(width, height), 0, 0, downScaling ? interDown : interUp);
 
     return resized;
 }
+
+cv::Mat SizeFilter::resize_to_width(const cv::Mat &image, int width, int interDown, int interUp) {
+    return SizeFilter::resize(image, width, image.rows * width / image.cols, interDown, interUp);
+}

src/img/filters/size.hpp

@@ -14,8 +14,10 @@ class SizeFilter : public Filter {
   public:
     SizeFilter(int width, int height);
 
-    cv::Mat apply(const cv::Mat &image) override;
+    cv::Mat apply(const cv::Mat &image) const override;
 
     static cv::Mat resize(const cv::Mat &image, int width, int height, int interDown = sizeInterDown,
                           int interUp = sizeInterUp);
+
+    static cv::Mat resize_to_width(const cv::Mat &image, int width, int interDown = sizeInterDown, int interUp = sizeInterUp);
 };

src/img/image_source.cpp

@@ -0,0 +1,28 @@
+#include "image_source.hpp"
+
+ImageSource::ImageSource(cv::Mat source, size_t amount) : original(source), amount(amount), cached(*this), filters(), rotated(false) {
+    width = source.cols;
+    height = source.rows;
+}
+
+void ImageSource::add_filter(Filter * filter) {
+    filters.push_back(filter);
+    cached.set_dirty();
+}
+
+void ImageSource::clear_filters() {
+    for (auto filter : filters)
+    {
+        delete filter;
+    }
+    filters.clear();
+    cached.set_dirty();
+}
+
+cv::Mat ImageSource::apply_filters() const {
+    cv::Mat image = original;
+    for (auto filter : filters) {
+        image = filter->apply(image);
+    }
+    return image;
+}