Merge pull request #7 from ErickOF/feature-filter_module

Feature filter module

Author: ErickOF

.gitignore

@@ -227,3 +227,9 @@ tools/datagen/src/imgs/*_sobel_*
 # Ignore VCD files
 *.vcd
 test
+
+# Ignore output images
+modules/filter/*.bitmap
+modules/filter/*.gif
+modules/filter/*.jpg
+modules/filter/*.png

modules/filter/Makefile

@@ -1,12 +1,13 @@
 # Adding stb lib for image handling
-INCDIR_STB=lib/stb
-INCLUDES_STB := $(wildcard $(INCDIR_STB)/*.h)
+CFLAGS_OPENCV := $(shell pkg-config --cflags opencv4)
+LFLAGS_OPENCV := $(shell pkg-config --libs opencv4)
 
 # Include common Makefile
 include ../Makefile
 
 # Include stb lib for compilation
-INCLUDES += INCLUDES_STB
+CFLAGS += $(CFLAGS_OPENCV)
+LFLAGS += $(LFLAGS_OPENCV)
 
 # Defining preprocessor directive for debug
 ifdef IPS_DEBUG_EN
@@ -20,18 +21,21 @@ ifdef IPS_DUMP_EN
 		LFLAGS += -DIPS_DUMP_EN
 endif # IPS_DUMP_EN
 
-
-# Defining preprocessor directive for test mode one wildcard normal
+# Defining preprocessor directive for test modes
+ifdef TEST_MODE_IMAGE
+		CFLAGS += -DTEST_MODE_IMAGE
+		LFLAGS += -DTEST_MODE_IMAGE
+else
+ifdef TEST_MODE_ONE_WINDOW_RANDOM
+		CFLAGS += -DTEST_MODE_ONE_WINDOW -DTEST_MODE_ONE_WINDOW_RANDOM
+		LFLAGS += -DTEST_MODE_ONE_WINDOW -DTEST_MODE_ONE_WINDOW_RANDOM
+else
 ifdef TEST_MODE_ONE_WINDOW_NORMAL
 		CFLAGS += -DTEST_MODE_ONE_WINDOW -DTEST_MODE_ONE_WINDOW_NORMAL
 		LFLAGS += -DTEST_MODE_ONE_WINDOW -DTEST_MODE_ONE_WINDOW_NORMAL
 endif # TEST_MODE_ONE_WINDOW_NORMAL
-
-# Defining preprocessor directive for test mode one window random
-ifdef TEST_MODE_ONE_WINDOW_RANDOM
-		CFLAGS += -DTEST_MODE_ONE_WINDOW -DTEST_MODE_ONE_WINDOW_RANDOM
-		LFLAGS += -DTEST_MODE_ONE_WINDOW -DTEST_MODE_ONE_WINDOW_RANDOM
 endif # TEST_MODE_ONE_WINDOW_RANDOM
+endif # TEST_MODE_IMAGE
 
 # Defining preprocessor directive for model - by default PV model
 ifdef IPS_FILTER_LT_EN

modules/filter/include/ips_filter_at_model.hpp

@@ -98,26 +98,11 @@ void Filter<IN, OUT, N>::exec_filter()
     // Getting the image window to filter
     IN* img_window_tmp = this->img_window.read();
 
-#ifdef IPS_DEBUG_EN
-    std::cout << "Performing convolution" << std::endl;
-#endif // IPS_DEBUG_EN
-
     // Perform the convolution
     for (i = 0; i < N; ++i)
       for (j = 0; j < N; ++j)
-      {
-#ifdef IPS_DEBUG_EN
-        std::cout << "Starting [" << i << "][" << j << "]" << std::endl;
-#endif // IPS_DEBUG_EN
         result_tmp += this->kernel[i * N + j] * ((OUT) img_window_tmp[i * N + j]);
-#ifdef IPS_DEBUG_EN
-        std::cout << "Done [" << i << "][" << j << "]" << std::endl;
-#endif // IPS_DEBUG_EN
-      }
 
-#ifdef IPS_DEBUG_EN
-    std::cout << "Convolution result is done" << std::endl;
-#endif // IPS_DEBUG_EN
     this->result.write(result_tmp);
   }
 }
@@ -166,6 +151,21 @@ void Filter<IN, OUT, N>::init()
 
     std::cout << std::endl;
   }
+#else
+#ifdef IPS_DUMP_EN
+  size_t i, j;
+
+  for (i = 0; i < N; ++i)
+  {
+    for (j = 0; j < N; ++j)
+    {
+      // Adding the signals to the waveform
+      std::ostringstream var_name;
+      var_name << "kernel_" << i << "_" << j;
+      sc_trace(this->wf, this->kernel[i * N + j], var_name.str());
+    }
+  }
+#endif // IPS_DUMP_EN
 #endif // IPS_DEBUG_EN
 }
 #endif // IPS_FILTER_AT_MODEL_HPP

modules/filter/include/ips_filter_lt_model.hpp

@@ -156,6 +156,21 @@ void Filter<IN, OUT, N>::init()
 
     std::cout << std::endl;
   }
+#else
+#ifdef IPS_DUMP_EN
+  size_t i, j;
+
+  for (i = 0; i < N; ++i)
+  {
+    for (j = 0; j < N; ++j)
+    {
+      // Adding the signals to the waveform
+      std::ostringstream var_name;
+      var_name << "kernel_" << i << "_" << j;
+      sc_trace(this->wf, this->kernel[i * N + j], var_name.str());
+    }
+  }
+#endif // IPS_DUMP_EN
 #endif // IPS_DEBUG_EN
 }
 #endif // IPS_FILTER_LT_MODEL_HPP

modules/filter/include/ips_filter_pv_model.hpp

@@ -112,6 +112,21 @@ void Filter<IN, OUT, N>::init_kernel()
 
     std::cout << std::endl;
   }
+#else
+#ifdef IPS_DUMP_EN
+  size_t i, j;
+
+  for (i = 0; i < N; ++i)
+  {
+    for (j = 0; j < N; ++j)
+    {
+      // Adding the signals to the waveform
+      std::ostringstream var_name;
+      var_name << "kernel_" << i << "_" << j;
+      sc_trace(this->wf, this->kernel[i * N + j], var_name.str());
+    }
+  }
+#endif // IPS_DUMP_EN
 #endif // IPS_DEBUG_EN
 }
 #endif // IPS_FILTER_PV_MODEL_HPP

modules/filter/src/tb_filter.cpp

@@ -1,10 +1,22 @@
+#define int64  systemc_int64
+#define uint64 systemc_uint64
+#include <systemc.h>
 #ifdef TEST_MODE_ONE_WINDOW_RANDOM
 #include <cstdlib>
-#endif // TEST_MODE_ONE_WINDOW_RANDOM
+#elif defined(TEST_MODE_IMAGE)
+#include <cstdlib>
+#undef int64
+#undef uint64
+#define int64  opencv_int64
+#define uint64 opencv_uint64
+#include <opencv2/opencv.hpp>
+#undef int64
+#undef uint64
+#define SYSTEMC_TYPES_ALREADY_DEFINED
+#endif // TEST_MODE
 #ifdef IPS_DUMP_EN
 #include <sstream>
 #endif // IPS_DUMP_EN
-#include <systemc.h>
 
 #ifndef IPS_FILTER_KERNEL_SIZE
 #define IPS_FILTER_KERNEL_SIZE 3
@@ -15,6 +27,9 @@
 #ifndef IPS_OUT_TYPE_TB
 #define IPS_OUT_TYPE_TB float
 #endif // IPS_OUT_TYPE_TB
+#ifndef IPS_IMG_PATH_TB
+#define IPS_IMG_PATH_TB "../../tools/datagen/src/imgs/car_noisy_image.png"
+#endif // IPS_IMG_PATH_TB
 
 #ifndef IPS_FILTER_PV_EN
 // N * N * copy_pixel_to_mem_time + mult + redux + copy_pixel_to_mem_time
@@ -33,6 +48,152 @@
 #endif // IPS_FILTER_XX_EN
 
 
+#ifdef TEST_MODE_IMAGE
+#ifdef IPS_DUMP_EN
+void run_image(sc_trace_file* wf)
+#else
+void run_image()
+#endif // IPS_DUMP_EN
+{
+#ifdef IPS_DEBUG_EN
+  SC_REPORT_INFO("TEST_MODE_IMAGE", "Running test");
+#endif // IPS_DEBUG_EN
+
+  const std::string img_path = IPS_IMG_PATH_TB;
+  cv::Mat read_image = cv::imread(img_path, cv::IMREAD_GRAYSCALE);
+  cv::Mat image;
+  read_image.convertTo(image, CV_32F);
+
+  cv::Mat o_img(image.size(), image.type());
+
+#ifdef IPS_DUMP_EN
+  std::cout << "Loading image: " << img_path << std::endl;
+#endif // IPS_DUMP_EN
+
+  // Check if the image is loaded successfully
+  if (image.empty())
+  {
+    std::cerr << "Error: Could not open or find the image!" << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+#ifdef IPS_DUMP_EN
+  std::cout << "Image info: ";
+  std::cout << "rows = " << image.rows;
+  std::cout << " cols = " << image.cols;
+  std::cout << " channels = " << image.channels() << std::endl;
+#endif // IPS_DUMP_EN
+
+  // Variables
+  IPS_IN_TYPE_TB* img_window;
+  IPS_OUT_TYPE_TB result;
+
+  int i, j;
+  int x, y;
+
+#ifdef IPS_FILTER_AT_EN
+  sc_signal<IPS_IN_TYPE_TB*> s_img_window;
+  sc_signal<IPS_OUT_TYPE_TB> s_result;
+#endif // IPS_FILTER_AT_EN
+
+  // Initialize image window
+  img_window = new IPS_IN_TYPE_TB[IPS_FILTER_KERNEL_SIZE * IPS_FILTER_KERNEL_SIZE];
+
+  // Instantiate filter module and do the connection
+#ifdef IPS_DUMP_EN
+  for (i = 0; i < IPS_FILTER_KERNEL_SIZE; ++i)
+  {
+    for (j = 0; j < IPS_FILTER_KERNEL_SIZE; ++j)
+    {
+      std::ostringstream var_name;
+      var_name << "img_window_" << i << "_" << j;
+      sc_trace(wf, img_window[i * IPS_FILTER_KERNEL_SIZE + j], var_name.str());
+    }
+  }
+
+  Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTER_KERNEL_SIZE> filter("filter", wf);
+  sc_trace(wf, result, "result");
+#else
+  Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTER_KERNEL_SIZE> filter("filter");
+#endif // IPS_DUMP_EN
+#ifdef IPS_FILTER_AT_EN
+  filter.img_window(s_img_window);
+  filter.result(s_result);
+#endif // IPS_FILTER_AT_EN
+
+  sc_start();
+
+#ifdef IPS_DEBUG_EN
+  std::cout << "Test starting" << std::endl;
+  std::cout << "@" << sc_time_stamp() << std::endl;
+#endif // IPS_DEBUG_EN
+
+  // Create each window
+  for (y = 0; y < image.rows - IPS_FILTER_KERNEL_SIZE; ++y)
+  {
+    for (x = 0; x < image.cols - IPS_FILTER_KERNEL_SIZE; ++x)
+    {
+#ifdef IPS_DEBUG_EN
+      SC_REPORT_INFO("TEST_MODE_IMAGE", "filtering");
+#endif // IPS_DEBUG_EN
+
+      // Define the ROI
+      cv::Rect roi(x, y, IPS_FILTER_KERNEL_SIZE, IPS_FILTER_KERNEL_SIZE);
+      cv::Mat sub_img = image(roi);
+
+      for (i = 0; i < IPS_FILTER_KERNEL_SIZE; ++i)
+      {
+        for (j = 0; j < IPS_FILTER_KERNEL_SIZE; ++j)
+        {
+          img_window[i * IPS_FILTER_KERNEL_SIZE + j] = sub_img.at<IPS_IN_TYPE_TB>(i, j);
+#ifdef IPS_DEBUG_EN
+          std::cout << "[" << img_window[i * IPS_FILTER_KERNEL_SIZE + j] << "]";
+#endif // IPS_DEBUG_EN
+        }
+
+#ifdef IPS_DEBUG_EN
+        std::cout << std::endl;
+#endif // IPS_DEBUG_EN
+      }
+
+      // Apply convolution
+#ifdef IPS_FILTER_PV_EN
+      filter.filter(img_window, result);
+#elif defined(IPS_FILTER_LT_EN)
+      filter.filter(img_window, &result);
+      sc_start(DELAY_TIME + 10, SC_NS);
+#elif defined(IPS_FILTER_AT_EN)
+      s_img_window.write(img_window);
+      filter.filter();
+      sc_start(DELAY_TIME + 10, SC_NS);
+
+      result = s_result.read();
+#endif // IPS_FILTER_XX_EN
+
+      o_img.at<IPS_OUT_TYPE_TB>(y, x) = result;
+
+#ifdef IPS_DEBUG_EN
+      std::cout << "Result[" << x << "][" << y << "] = " << o_img.at<IPS_OUT_TYPE_TB>(y, x) << std::endl << std::endl;
+#endif // IPS_DEBUG_EN
+    }
+  }
+
+#ifdef IPS_DUMP_EN
+  sc_start(1, SC_NS);
+#endif // IPS_DUMP_EN
+
+  // Convert the floating-point image to 8-bit unsigned integer for saving
+  cv::Mat final_img;
+  o_img.convertTo(final_img, CV_8U, 1.0);
+
+  // Save the final image
+  std::string output_img_path = "filtered_image.png";
+  cv::imwrite(output_img_path, final_img);
+
+  delete [] img_window;
+}
+#endif // TEST_MODE_IMAGE
+
 #ifdef TEST_MODE_ONE_WINDOW
 #ifdef IPS_DUMP_EN
 void run_one_window(sc_trace_file* wf)
@@ -52,7 +213,7 @@ void run_one_window()
 #endif
 
   // Variables
-  IPS_IN_TYPE_TB *img_window;
+  IPS_IN_TYPE_TB* img_window;
   IPS_OUT_TYPE_TB result;
 
 #ifdef IPS_FILTER_AT_EN
@@ -155,8 +316,18 @@ int sc_main(int, char*[])
 #endif // IPS_DUMP_EN
 
 #ifdef TEST_MODE_ONE_WINDOW
+#ifdef IPS_DUMP_EN
   run_one_window(wf);
-#endif // TEST_MODE_ONE_WINDOW
+#else
+  run_one_window();
+#endif // IPS_DUMP_EN
+#elif defined(TEST_MODE_IMAGE)
+#ifdef IPS_DUMP_EN
+  run_image(wf);
+#else
+  run_image();
+#endif // IPS_DUMP_EN
+#endif // TEST_MODE
 
 #ifdef IPS_DUMP_EN
   std::cout << "@" << sc_time_stamp() << " Terminating simulation" << std::endl;