feat: ui

Author: fffzlfk

lib/core/include/core/Laplacian.cuh

@@ -68,7 +68,7 @@ std::tuple<float, float> gpuLaplacian(const Mat &h_oriImg) {
     return std::make_tuple(time, res);
 }
 
-void cpuLaplacian(const Mat &src) {
+std::tuple<float, float> cpuLaplacian(const Mat &src) {
     Mat grayImage(src.size(), CV_8U, Scalar(0));
     ulonglong sum = 0;
 
@@ -92,7 +92,12 @@ void cpuLaplacian(const Mat &src) {
     }
     timer.Stop();
 
-    printf("Cpu elapsed time: %f\n", timer.Elapsed());
-    printf("Cpu res = %f\n", (float)sum / (rows * cols));
+    auto time = timer.Elapsed();
+    auto res = static_cast<float>(sum) / (rows * cols);
+
+    printf("Cpu elapsed time: %f\n", time);
+    printf("Cpu res = %f\n", res);
+
+    return std::make_tuple(time, res);
 }
 } // namespace laplacian

lib/core/include/core/SMD.cuh

@@ -67,7 +67,7 @@ std::tuple<float, float> gpuSMD(const Mat &h_oriImg) {
     return std::make_tuple(time, res);
 }
 
-void cpuSMD(const Mat &src) {
+std::tuple<float, float> cpuSMD(const Mat &src) {
     Mat grayImage(src.size(), CV_8U, Scalar(0));
     ulonglong sum = 0;
 
@@ -89,7 +89,12 @@ void cpuSMD(const Mat &src) {
     }
     timer.Stop();
 
-    printf("Cpu elapsed time: %f\n", timer.Elapsed());
-    printf("Cpu res = %f\n", (float)sum / (rows * cols));
+    auto time = timer.Elapsed();
+    auto res = static_cast<float>(sum) / (rows * cols);
+
+    printf("Cpu elapsed time: %f\n", time);
+    printf("Cpu res = %f\n", res);
+
+    return std::make_tuple(time, res);
 }
 } // namespace smd

lib/core/include/core/Tenengrad.cuh

@@ -73,7 +73,7 @@ std::tuple<float, float> gpuTenengrad(const Mat &h_oriImg) {
     return std::make_tuple(time, res);
 }
 
-void cpuTenengrad(const Mat &src) {
+std::tuple<float, float> cpuTenengrad(const Mat &src) {
     ::utils::CpuTimer timer;
     timer.Start();
 
@@ -106,8 +106,13 @@ void cpuTenengrad(const Mat &src) {
     }
     timer.Stop();
 
-    printf("Cpu elapsed time: %f\n", timer.Elapsed());
-    printf("Cpu res = %f\n", (float)sum / (rows * cols));
+    auto time = timer.Elapsed();
+    auto res = static_cast<float>(sum) / (cols * rows);
+
+    printf("Cpu elapsed time: %f\n", time);
+    printf("Cpu res = %f\n", res);
+
+    return std::make_tuple(time, res);
 }
 
 } // namespace tenengrad

lib/ui/include/ui/app.h

@@ -53,6 +53,15 @@ int run(int argc, char *argv[]) {
         }
     };
 
+    auto clear_button = button("Clear");
+    clear_button.on_click = [&](bool) {
+        files.clear();
+        list_size = 1;
+        ptr_list.resize(list_size);
+        content.resize(list_size);
+        _view.refresh();
+    };
+
     constexpr view_limits files_limits = {{400, 200},
                                           {full_extent, full_extent}};
 
@@ -61,7 +70,10 @@ int run(int argc, char *argv[]) {
             {10, 10, 10, 10},
             vtile(htile(left_margin(10, limit(files_limits,
                                               vscroller(hold(share(linked))))),
-                        left_margin(10, add_button)),
+                        left_margin(
+                            10,
+                            valign(0.5, vtile(top_margin(10, add_button),
+                                              top_margin(10, clear_button))))),
                   margin({10, 10, 10, 10}, make_buttons(_view, files)))),
         background);
     _app.run();

lib/ui/include/ui/buttons.h

@@ -1,32 +1,38 @@
 #pragma once
 
-#include <elements.hpp>
-#include "method_types.h"
 #include "dialog.h"
+#include "method_types.h"
+#include <elements.hpp>
 
 namespace ui {
 using namespace cycfi::elements;
-auto make_buttons(view &_view, const std::vector<std::string> &files) {
-    auto laplacian_button = button("Laplacian");
-    laplacian_button.on_click = [&](bool) {
-        auto dialog = make_dialog(_view, Method::Laplacian, files);
-        _view.add(dialog);
-        _view.refresh();
-    };
-    auto tenengrad_button = button("Tenengrad");
-    tenengrad_button.on_click = [&](bool) {
-        auto dialog = make_dialog(_view, Method::Tenengrad, files);
-        _view.add(dialog);
-        _view.refresh();
-    };
-    auto smd_button = button("SMD");
-    smd_button.on_click = [&](bool) {
-        auto dialog = make_dialog(_view, Method::SMD, files);
+
+auto make_button(view &_view, Method method,
+                 const std::vector<std::string> &files) {
+    auto on_click = [&_view, &files, method](bool) {
+        auto dialog = make_dialog(_view, method, files);
+        std::cout << MethodMap.at(method) << std::endl;
         _view.add(dialog);
         _view.refresh();
     };
-    return htile(left_margin(10, laplacian_button),
-                 left_margin(10, tenengrad_button),
-                 left_margin(10, smd_button));
+    auto _button = button(MethodMap.at(method));
+    _button.on_click = on_click;
+    return _button;
+}
+
+auto make_buttons(view &_view, const std::vector<std::string> &files) {
+    auto cpu_tenengrad_button = make_button(_view, Method::CPUTenengrad, files);
+    auto gpu_tenengrad_button = make_button(_view, Method::GPUTenengrad, files);
+    auto cpu_laplacian_button = make_button(_view, Method::CPULaplacian, files);
+    auto gpu_laplacian_button = make_button(_view, Method::GPULaplacian, files);
+    auto cpu_smd_button = make_button(_view, Method::CPUSMD, files);
+    auto gpu_smd_button = make_button(_view, Method::GPUSMD, files);
+
+    return htile(left_margin(10, cpu_tenengrad_button),
+                 left_margin(10, gpu_tenengrad_button),
+                 left_margin(10, cpu_laplacian_button),
+                 left_margin(10, gpu_laplacian_button),
+                 left_margin(10, cpu_smd_button),
+                 left_margin(10, gpu_smd_button));
 }
 } // namespace ui

lib/ui/include/ui/compute.h

@@ -1,23 +1,30 @@
 #pragma once
 
 #include "core/Laplacian.cuh"
-#include "core/Tenengrad.cuh"
 #include "core/SMD.cuh"
+#include "core/Tenengrad.cuh"
 #include "method_types.h"
 #include <tuple>
 #include <vector>
+#include <iostream>
 
 namespace ui {
 auto compute(Method method, const std::vector<std::string> &files,
              const size_t index) {
     auto filepath = files[index];
     auto image = cv::imread(filepath);
     switch (method) {
-    case Method::Laplacian:
+    case Method::CPULaplacian:
+        return laplacian::cpuLaplacian(image);
+    case Method::GPULaplacian:
         return laplacian::gpuLaplacian(image);
-    case Method::Tenengrad:
+    case Method::GPUTenengrad:
         return tenengrad::gpuTenengrad(image);
-    case Method::SMD:
+    case Method::CPUTenengrad:
+        return tenengrad::cpuTenengrad(image);
+    case Method::CPUSMD:
+        return smd::cpuSMD(image);
+    case Method::GPUSMD:
         return smd::gpuSMD(image);
     default:
         return std::make_tuple(.0f, .0f);

lib/ui/include/ui/method_types.h

@@ -4,14 +4,20 @@
 #include <unordered_map>
 namespace ui {
 enum class Method {
-    Tenengrad,
-    Laplacian,
-    SMD,
+    CPUTenengrad,
+    GPUTenengrad,
+    CPULaplacian,
+    GPULaplacian,
+    CPUSMD,
+    GPUSMD,
 };
 
 const std::unordered_map<Method, std::string> MethodMap = {
-    {Method::Tenengrad, "Tenengrad"},
-    {Method::Laplacian, "Laplacian"},
-    {Method::SMD, "SMD"},
+    {Method::CPUTenengrad, "CPU Tenengrad"},
+    {Method::GPUTenengrad, "GPU Tenengrad"},
+    {Method::CPULaplacian, "CPU Laplacian"},
+    {Method::GPULaplacian, "GPU Laplacian"},
+    {Method::CPUSMD, "CPU SMD"},
+    {Method::GPUSMD, "GPU SMD"},
 };
 } // namespace ui