[OSPP/DIP] Benchmarks for Morphological operations (#45)

README.md

@@ -45,9 +45,12 @@ Run the image processing benchmark:
 *ii. Please replace `<kernel name>` with name of the kernel which is to be used for*
 *benchmarking as specifed in `include/ImageProcessing/Kernels.h`.*
 
+*ii. Please replace `<kernelmorph name>` with name of the unsigned int kernel which is to be used for*
+*benchmarking as specifed in `include/ImageProcessing/Kernels.h`.*
+
 *iii. Please replace `<Boundary Option>` with `CONSTANT_PADDING` or `REPLICATE_PADDING`.*
 
-Ex. `./image-processing-benchmark ../../benchmarks/ImageProcessing/Images/YuTu.png laplacianKernelAlign CONSTANT_PADDING`
+Ex. `./image-processing-benchmark ../../benchmarks/ImageProcessing/Images/YuTu.png random3x3KernelAlign random3x3KernelAlignInt CONSTANT_PADDING`
 ```
 $ cd buddy-benchmark
 $ mkdir build && cd build
@@ -57,7 +60,7 @@ $ cmake -G Ninja .. \
     -DEIGEN_DIR=/PATH/TO/EIGEN/SOURCE/CODE \
     -DBUDDY_OPT_BUILD_DIR=/PATH/TO/BUDDY-MLIR/BUILD/
 $ ninja image-processing-benchmark
-$ cd bin && ./image-processing-benchmark <image path> <kernel name> <Boundary Option>
+$ cd bin && ./image-processing-benchmark <image path> <kernel name> <kernelmorph name> <Boundary Option>
 ```
 
 ## Deep Learning Benchmark

benchmarks/ImageProcessing/BuddyMorph2D.mlir

+//===- BuddyMorph2D.mlir ---------------------------------------------------===//
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides Buddy Morpholgical operations.
+//
+//===----------------------------------------------------------------------===//
+
+func.func @erosion_2d_constant_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue: f32)
+{
+  dip.erosion_2d <CONSTANT_PADDING> %inputImage, %kernel, %outputImage, %copymemref, %centerX, %centerY, %iterations, %constantValue: memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @erosion_2d_replicate_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue : f32)
+{
+  dip.erosion_2d <REPLICATE_PADDING> %inputImage, %kernel, %outputImage, %copymemref, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @dilation_2d_constant_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue: f32)
+{
+  dip.dilation_2d <CONSTANT_PADDING> %inputImage,  %kernel, %outputImage, %copymemref, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @dilation_2d_replicate_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue : f32)
+{
+  dip.dilation_2d <REPLICATE_PADDING> %inputImage, %kernel, %outputImage, %copymemref, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @opening_2d_constant_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %outputImage1 : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %copymemref1 : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue: f32)
+{
+  dip.opening_2d <CONSTANT_PADDING> %inputImage, %kernel, %outputImage, %outputImage1, %copymemref, %copymemref1, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @opening_2d_replicate_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %outputImage1 : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %copymemref1 : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue : f32)
+{
+  dip.opening_2d <REPLICATE_PADDING> %inputImage, %kernel, %outputImage, %outputImage1, %copymemref, %copymemref1, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @closing_2d_constant_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %outputImage1 : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %copymemref1 : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue: f32)
+{
+  dip.closing_2d <CONSTANT_PADDING> %inputImage, %kernel, %outputImage, %outputImage1, %copymemref, %copymemref1, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @closing_2d_replicate_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %outputImage1 : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %copymemref1 : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue : f32)
+{
+  dip.closing_2d <REPLICATE_PADDING> %inputImage,  %kernel, %outputImage, %outputImage1, %copymemref, %copymemref1, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>,memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @tophat_2d_constant_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %outputImage1 : memref<?x?xf32>,%outputImage2 : memref<?x?xf32>, %inputImage1 : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %copymemref1 : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue: f32)
+{
+  dip.tophat_2d <CONSTANT_PADDING> %inputImage, %kernel, %outputImage, %outputImage1, %outputImage2, %inputImage1, %copymemref, %copymemref1, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @tophat_2d_replicate_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %outputImage1 : memref<?x?xf32>, %outputImage2 : memref<?x?xf32>, %inputImage1 : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %copymemref1 : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue : f32)
+{
+  dip.tophat_2d <REPLICATE_PADDING> %inputImage, %kernel, %outputImage, %outputImage1, %outputImage2, %inputImage1, %copymemref, %copymemref1, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @bottomhat_2d_constant_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %outputImage1 : memref<?x?xf32>, %outputImage2 : memref<?x?xf32>, %inputImage1 : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %copymemref1 : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue: f32)
+{
+  dip.bottomhat_2d <CONSTANT_PADDING> %inputImage, %kernel, %outputImage, %outputImage1, %outputImage2, %inputImage1, %copymemref, %copymemref1, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @bottomhat_2d_replicate_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %outputImage1 : memref<?x?xf32>, %outputImage2 : memref<?x?xf32>, %inputImage1 : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %copymemref1 : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue : f32)
+{
+  dip.bottomhat_2d <REPLICATE_PADDING> %inputImage, %kernel, %outputImage, %outputImage1, %outputImage2, %inputImage1, %copymemref, %copymemref1, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}
+
+func.func @morphgrad_2d_constant_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %outputImage1 : memref<?x?xf32>,%outputImage2 : memref<?x?xf32>, %inputImage1 : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %copymemref1 : memref<?x?xf32>, %centerX : index, %centerY : index,%iterations : index, %constantValue: f32)
+{
+  dip.morphgrad_2d <CONSTANT_PADDING> %inputImage, %kernel, %outputImage, %outputImage1, %outputImage2,  %inputImage1, %copymemref, %copymemref1, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index,index, f32
+  return
+}
+
+func.func @morphgrad_2d_replicate_padding(%inputImage : memref<?x?xf32>, %kernel : memref<?x?xf32>, %outputImage : memref<?x?xf32>, %outputImage1 : memref<?x?xf32>,%outputImage2 : memref<?x?xf32>, %inputImage1 : memref<?x?xf32>, %copymemref : memref<?x?xf32>, %copymemref1 : memref<?x?xf32>, %centerX : index, %centerY : index, %iterations : index, %constantValue : f32)
+{
+  dip.morphgrad_2d <REPLICATE_PADDING> %inputImage, %kernel, %outputImage, %outputImage1,%outputImage2, %inputImage1, %copymemref, %copymemref1, %centerX, %centerY, %iterations, %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, index, f32
+  return
+}

benchmarks/ImageProcessing/CMakeLists.txt

@@ -102,6 +102,22 @@ add_custom_command(OUTPUT buddy-corr2d.o
 add_library(BuddyCorr2D STATIC buddy-corr2d.o)
 set_target_properties(BuddyCorr2D PROPERTIES LINKER_LANGUAGE CXX)
 
+add_custom_command(OUTPUT buddy-morph2d.o
+  COMMAND ${BUDDY_OPT_BUILD_DIR}/bin/buddy-opt 
+          ${BUDDY_SOURCE_DIR}/benchmarks/ImageProcessing/BuddyMorph2D.mlir 
+            -lower-dip="DIP-strip-mining=${SPLITING_SIZE}" 
+            -lower-affine -convert-scf-to-cf -convert-vector-to-llvm 
+            --llvm-request-c-wrappers
+            -convert-memref-to-llvm -convert-func-to-llvm 
+            -reconcile-unrealized-casts | 
+          ${LLVM_MLIR_BINARY_DIR}/mlir-translate --mlir-to-llvmir |
+          ${LLVM_MLIR_BINARY_DIR}/llc -mtriple=${BUDDY_OPT_TRIPLE} 
+            -mattr=${BUDDY_OPT_ATTR} --filetype=obj 
+            -o ${BUDDY_BINARY_DIR}/../benchmarks/ImageProcessing/buddy-morph2d.o
+)
+add_library(BuddyMorph2D STATIC buddy-morph2d.o)
+set_target_properties(BuddyMorph2D PROPERTIES LINKER_LANGUAGE CXX)
+
 #-------------------------------------------------------------------------------
 # Image Processing Benchmark Target
 #-------------------------------------------------------------------------------
@@ -113,6 +129,8 @@ add_executable(image-processing-benchmark
   MLIRConv2DBenchmark.cpp
   BuddyConv2DBenchmark.cpp
   BuddyCorr2DBenchmark.cpp
+  BuddyMorph2DBenchmark.cpp
+  OpenCVMorph2DBenchmark.cpp
   )
 
 target_include_directories(image-processing-benchmark 
@@ -127,6 +145,7 @@ target_link_libraries(image-processing-benchmark
   MLIRConv2D
   BuddyConv2D
   BuddyCorr2D
+  BuddyMorph2D
   Container
   PNGImage
   )

benchmarks/ImageProcessing/Main.cpp

@@ -24,27 +24,58 @@
 void initializeMLIRConv2D(char **);
 void initializeBuddyConv2D(char **);
 void initializeBuddyCorr2D(char **);
+void initializeBuddyMorph2D(char **);
+void initializeOpenCVMorph2D(char **);
 void initializeOpenCVFilter2D(char **);
 void initializeEigenConvolve2D(char **);
 
 void generateResultBuddyConv2D(char **);
 void generateResultBuddyCorr2D(char **);
+void generateResultBuddyErosion2D(char **);
+void generateResultBuddyOpening2D(char **);
+void generateResultBuddyClosing2D(char **);
+void generateResultBuddyTopHat2D(char **);
+void generateResultBuddyBottomHat2D(char **);
+void generateResultBuddyMorphGrad2D(char **);
+void generateResultBuddyDilation2D(char **);
+void generateResultOpenCVErode2D();
+void generateResultOpenCVDilate2D();
 void generateResultOpenCVFilter2D();
+void generateResultOpenCVOpening2D();
+void generateResultOpenCVClosing2D();
+void generateResultOpenCVTopHat2D();
+void generateResultOpenCVBottomHat2D();
+void generateResultOpenCVMorphGrad2D();
 void generateResultEigenConvolve2D();
 
 void registerBenchmarkBuddyCorr2D();
+void registerBenchmarkBuddyErosion2D();
+void registerBenchmarkBuddyDilation2D();
+void registerBenchmarkBuddyOpening2D();
+void registerBenchmarkBuddyClosing2D();
+void registerBenchmarkBuddyTopHat2D();
+void registerBenchmarkBuddyBottomHat2D();
+void registerBenchmarkBuddyMorphGrad2D();
+void registerBenchmarkOpenCVErode2D();
+void registerBenchmarkOpenCVDilate2D();
+void registerBenchmarkOpenCVOpening2D();
+void registerBenchmarkOpenCVClosing2D();
+void registerBenchmarkOpenCVTopHat2D();
+void registerBenchmarkOpenCVBottomHat2D();
+void registerBenchmarkOpenCVMorphGrad2D();
 void registerBenchmarkOpenCVFilter2D();
 
 // Run benchmarks.
 int main(int argc, char **argv) {
-  if (argc != 4) {
+  if (argc != 5) {
     throw std::invalid_argument(
         "Wrong format of command line arguments.\n"
         "Correct format is ./image-processing-benchmark <image path> <kernel "
-        "name> <Boundary Option>\n where "
+        "name> <kernelmorph> <Boundary Option>\n where "
         "image path provides path of the image to be processed, kernel name "
         "denotes the name "
         "of desired kernel as specified in "
+        "kernelmorph denotes the kernel to be used for morphological operations"
         "include/ImageProcessing/Kernels.h and Boundary options available "
         "are CONSTANT_PADDING, REPLICATE_PADDING.\n");
   }
@@ -52,11 +83,26 @@ int main(int argc, char **argv) {
   initializeMLIRConv2D(argv);
   initializeBuddyConv2D(argv);
   initializeBuddyCorr2D(argv);
+  initializeBuddyMorph2D(argv);
+  initializeOpenCVMorph2D(argv);
   initializeOpenCVFilter2D(argv);
   initializeEigenConvolve2D(argv);
 
   registerBenchmarkBuddyCorr2D();
   registerBenchmarkOpenCVFilter2D();
+  registerBenchmarkBuddyErosion2D();
+  registerBenchmarkBuddyDilation2D();
+  registerBenchmarkBuddyOpening2D();
+  registerBenchmarkBuddyClosing2D();
+  registerBenchmarkBuddyTopHat2D();
+  registerBenchmarkBuddyBottomHat2D();
+  registerBenchmarkOpenCVErode2D();
+  registerBenchmarkOpenCVOpening2D();
+  registerBenchmarkOpenCVClosing2D();
+  registerBenchmarkOpenCVTopHat2D();
+  registerBenchmarkOpenCVBottomHat2D();
+  registerBenchmarkOpenCVMorphGrad2D();
+  registerBenchmarkOpenCVDilate2D();
 
   ::benchmark::Initialize(&argc, argv);
   ::benchmark::RunSpecifiedBenchmarks();
@@ -65,6 +111,20 @@ int main(int argc, char **argv) {
   generateResultOpenCVFilter2D();
   generateResultBuddyConv2D(argv);
   generateResultBuddyCorr2D(argv);
+  generateResultBuddyErosion2D(argv);
+  generateResultBuddyDilation2D(argv);
+  generateResultBuddyOpening2D(argv);
+  generateResultBuddyClosing2D(argv);
+  generateResultBuddyTopHat2D(argv);
+  generateResultBuddyBottomHat2D(argv);
+  generateResultBuddyMorphGrad2D(argv);
+  generateResultOpenCVTopHat2D();
+  generateResultOpenCVBottomHat2D();
+  generateResultOpenCVMorphGrad2D();
+  generateResultOpenCVErode2D();
+  generateResultOpenCVDilate2D();
+  generateResultOpenCVOpening2D();
+  generateResultOpenCVClosing2D();
   generateResultEigenConvolve2D();
 
   return 0;

benchmarks/ImageProcessing/OpenCVMorph2DBenchmark.cpp

+//===- OpenCVMorph2DBenchmark.cpp ----------------------------------------===//
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the benchmark for OpenCV's Morphological Operations.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ImageProcessing/Kernels.h"
+#include <benchmark/benchmark.h>
+#include <opencv2/opencv.hpp>
+
+using namespace cv;
+using namespace std;
+
+// Declare input image, kernel and output image.
+Mat inputImageMorph2D, kernelMorph2D, outputErode2D, outputDilate2D,
+    outputOpening2D, outputClosing2D, outputTopHat2D, outputBottomHat2D,
+    outputMorphGrad2D;
+
+// Declare Boundary Options supported.
+enum BoundaryOption { constant_padding, replicate_padding };
+
+BoundaryOption OpenCVBoundaryType1;
+
+void initializeOpenCVMorph2D(char **argv) {
+  inputImageMorph2D = imread(argv[1], IMREAD_GRAYSCALE);
+
+  kernelMorph2D = Mat(get<1>(kernelMap1[argv[4]]), get<2>(kernelMap1[argv[4]]),
+                      CV_8UC1, get<0>(kernelMap1[argv[4]]));
+
+  if (static_cast<string>(argv[3]) == "REPLICATE_PADDING") {
+    OpenCVBoundaryType1 = replicate_padding;
+  } else {
+    OpenCVBoundaryType1 = constant_padding;
+  }
+}
+
+// Benchmarking function.
+static void OpenCV_Erode2D_Constant_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      erode(inputImageMorph2D, outputErode2D, kernelMorph2D, cv::Point(1, 1), 5,
+            cv::BORDER_CONSTANT, 0.0);
+    }
+  }
+}
+
+static void OpenCV_Erode2D_Replicate_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      erode(inputImageMorph2D, outputErode2D, kernelMorph2D, cv::Point(1, 1), 5,
+            cv::BORDER_REPLICATE, 0.0);
+    }
+  }
+}
+
+// Benchmarking function.
+static void OpenCV_Dilate2D_Constant_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      dilate(inputImageMorph2D, outputDilate2D, kernelMorph2D, cv::Point(1, 1),
+             5, cv::BORDER_CONSTANT, 0.0);
+    }
+  }
+}
+
+static void OpenCV_Dilate2D_Replicate_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      dilate(inputImageMorph2D, outputDilate2D, kernelMorph2D, cv::Point(1, 1),
+             5, cv::BORDER_REPLICATE, 0.0);
+    }
+  }
+}
+
+// Benchmarking function.
+static void OpenCV_Opening2D_Constant_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      cv::morphologyEx(inputImageMorph2D, outputOpening2D, 2, kernelMorph2D,
+                       cv::Point(1, 1), 3, cv::BORDER_CONSTANT, 0.0);
+    }
+  }
+}
+
+static void OpenCV_Opening2D_Replicate_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      cv::morphologyEx(inputImageMorph2D, outputOpening2D, 2, kernelMorph2D,
+                       cv::Point(1, 1), 3, cv::BORDER_REPLICATE, 0.0);
+    }
+  }
+}
+
+// Benchmarking function.
+static void OpenCV_Closing2D_Constant_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      cv::morphologyEx(inputImageMorph2D, outputClosing2D, 2, kernelMorph2D,
+                       cv::Point(1, 1), 3, cv::BORDER_CONSTANT, 0.0);
+    }
+  }
+}
+
+static void OpenCV_Closing2D_Replicate_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      cv::morphologyEx(inputImageMorph2D, outputClosing2D, 2, kernelMorph2D,
+                       cv::Point(1, 1), 3, cv::BORDER_REPLICATE, 0.0);
+    }
+  }
+}
+
+// Benchmarking function.
+static void OpenCV_TopHat2D_Constant_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      cv::morphologyEx(inputImageMorph2D, outputTopHat2D, 5, kernelMorph2D,
+                       cv::Point(1, 1), 3, cv::BORDER_CONSTANT, 0.0);
+    }
+  }
+}
+
+static void OpenCV_TopHat2D_Replicate_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      cv::morphologyEx(inputImageMorph2D, outputTopHat2D, 5, kernelMorph2D,
+                       cv::Point(1, 1), 3, cv::BORDER_REPLICATE, 0.0);
+    }
+  }
+}
+
+// Benchmarking function.
+static void OpenCV_BottomHat2D_Constant_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      cv::morphologyEx(inputImageMorph2D, outputBottomHat2D, 6, kernelMorph2D,
+                       cv::Point(1, 1), 3, cv::BORDER_CONSTANT, 0.0);
+    }
+  }
+}
+
+static void OpenCV_BottomHat2D_Replicate_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      cv::morphologyEx(inputImageMorph2D, outputBottomHat2D, 6, kernelMorph2D,
+                       cv::Point(1, 1), 3, cv::BORDER_REPLICATE, 0.0);
+    }
+  }
+}
+
+// Benchmarking function.
+static void OpenCV_MorphGrad2D_Constant_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      cv::morphologyEx(inputImageMorph2D, outputMorphGrad2D, 4, kernelMorph2D,
+                       cv::Point(1, 1), 3, cv::BORDER_CONSTANT, 0.0);
+    }
+  }
+}
+
+static void OpenCV_MorphGrad2D_Replicate_Padding(benchmark::State &state) {
+  for (auto _ : state) {
+    for (int i = 0; i < state.range(0); ++i) {
+      cv::morphologyEx(inputImageMorph2D, outputMorphGrad2D, 4, kernelMorph2D,
+                       cv::Point(1, 1), 3, cv::BORDER_REPLICATE, 0.0);
+    }
+  }
+}
+
+// Register benchmarking function.
+void registerBenchmarkOpenCVErode2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    BENCHMARK(OpenCV_Erode2D_Replicate_Padding)->Arg(1);
+  } else {
+    BENCHMARK(OpenCV_Erode2D_Constant_Padding)->Arg(1);
+  }
+}
+
+// Register benchmarking function.
+void registerBenchmarkOpenCVDilate2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    BENCHMARK(OpenCV_Dilate2D_Replicate_Padding)->Arg(1);
+  } else {
+    BENCHMARK(OpenCV_Dilate2D_Constant_Padding)->Arg(1);
+  }
+}
+
+// Register benchmarking function.
+void registerBenchmarkOpenCVOpening2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    BENCHMARK(OpenCV_Opening2D_Replicate_Padding)->Arg(1);
+  } else {
+    BENCHMARK(OpenCV_Opening2D_Constant_Padding)->Arg(1);
+  }
+}
+
+// Register benchmarking function.
+void registerBenchmarkOpenCVClosing2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    BENCHMARK(OpenCV_Closing2D_Replicate_Padding)->Arg(1);
+  } else {
+    BENCHMARK(OpenCV_Closing2D_Constant_Padding)->Arg(1);
+  }
+}
+
+// Register benchmarking function.
+void registerBenchmarkOpenCVTopHat2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    BENCHMARK(OpenCV_TopHat2D_Replicate_Padding)->Arg(1);
+  } else {
+    BENCHMARK(OpenCV_TopHat2D_Constant_Padding)->Arg(1);
+  }
+}
+
+// Register benchmarking function.
+void registerBenchmarkOpenCVBottomHat2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    BENCHMARK(OpenCV_BottomHat2D_Replicate_Padding)->Arg(1);
+  } else {
+    BENCHMARK(OpenCV_BottomHat2D_Constant_Padding)->Arg(1);
+  }
+}
+
+// Register benchmarking function.
+void registerBenchmarkOpenCVMorphGrad2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    BENCHMARK(OpenCV_MorphGrad2D_Replicate_Padding)->Arg(1);
+  } else {
+    BENCHMARK(OpenCV_MorphGrad2D_Constant_Padding)->Arg(1);
+  }
+}
+
+// Generate result image.
+void generateResultOpenCVErode2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    erode(inputImageMorph2D, outputErode2D, kernelMorph2D, cv::Point(1, 1), 5,
+          cv::BORDER_REPLICATE, 0.0);
+  } else {
+    erode(inputImageMorph2D, outputErode2D, kernelMorph2D, cv::Point(1, 1), 5,
+          cv::BORDER_CONSTANT, 0.0);
+  }
+
+  // Choose a PNG compression level
+  vector<int> compressionParams;
+  compressionParams.push_back(IMWRITE_PNG_COMPRESSION);
+  compressionParams.push_back(9);
+
+  // Write output to PNG.
+  bool result = false;
+  try {
+    result =
+        imwrite("ResultOpenCVErode2D.png", outputErode2D, compressionParams);
+  } catch (const cv::Exception &ex) {
+    fprintf(stderr, "Exception converting image to PNG format: %s\n",
+            ex.what());
+  }
+  if (result)
+    cout << "Saved PNG file." << endl;
+  else
+    cout << "ERROR: Can't save PNG file." << endl;
+}
+
+// Generate result image.
+void generateResultOpenCVDilate2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    dilate(inputImageMorph2D, outputDilate2D, kernelMorph2D, cv::Point(1, 1), 5,
+           cv::BORDER_REPLICATE, 0.0);
+  } else {
+    dilate(inputImageMorph2D, outputDilate2D, kernelMorph2D, cv::Point(1, 1), 5,
+           cv::BORDER_CONSTANT, 0.0);
+  }
+
+  // Choose a PNG compression level
+  vector<int> compressionParams;
+  compressionParams.push_back(IMWRITE_PNG_COMPRESSION);
+  compressionParams.push_back(9);
+
+  // Write output to PNG.
+  bool result = false;
+  try {
+    result =
+        imwrite("ResultOpenCVDilate2D.png", outputDilate2D, compressionParams);
+  } catch (const cv::Exception &ex) {
+    fprintf(stderr, "Exception converting image to PNG format: %s\n",
+            ex.what());
+  }
+  if (result)
+    cout << "Saved PNG file." << endl;
+  else
+    cout << "ERROR: Can't save PNG file." << endl;
+}
+
+// Generate result image.
+void generateResultOpenCVOpening2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    cv::morphologyEx(inputImageMorph2D, outputOpening2D, 2, kernelMorph2D,
+                     cv::Point(1, 1), 3, cv::BORDER_REPLICATE, 0.0);
+  } else {
+    cv::morphologyEx(inputImageMorph2D, outputOpening2D, 2, kernelMorph2D,
+                     cv::Point(1, 1), 3, cv::BORDER_CONSTANT, 0.0);
+  }
+
+  // Choose a PNG compression level
+  vector<int> compressionParams;
+  compressionParams.push_back(IMWRITE_PNG_COMPRESSION);
+  compressionParams.push_back(9);
+
+  // Write output to PNG.
+  bool result = false;
+  try {
+    result = imwrite("ResultOpenCVOpening2D.png", outputOpening2D,
+                     compressionParams);
+  } catch (const cv::Exception &ex) {
+    fprintf(stderr, "Exception converting image to PNG format: %s\n",
+            ex.what());
+  }
+  if (result)
+    cout << "Saved PNG file." << endl;
+  else
+    cout << "ERROR: Can't save PNG file." << endl;
+}
+
+// Generate result image.
+void generateResultOpenCVClosing2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    cv::morphologyEx(inputImageMorph2D, outputClosing2D, 2, kernelMorph2D,
+                     cv::Point(1, 1), 3, cv::BORDER_REPLICATE, 0.0);
+  } else {
+    cv::morphologyEx(inputImageMorph2D, outputClosing2D, 2, kernelMorph2D,
+                     cv::Point(1, 1), 3, cv::BORDER_CONSTANT, 0.0);
+  }
+
+  // Choose a PNG compression level
+  vector<int> compressionParams;
+  compressionParams.push_back(IMWRITE_PNG_COMPRESSION);
+  compressionParams.push_back(9);
+
+  // Write output to PNG.
+  bool result = false;
+  try {
+    result = imwrite("ResultOpenCVClosing2D.png", outputClosing2D,
+                     compressionParams);
+  } catch (const cv::Exception &ex) {
+    fprintf(stderr, "Exception converting image to PNG format: %s\n",
+            ex.what());
+  }
+  if (result)
+    cout << "Saved PNG file." << endl;
+  else
+    cout << "ERROR: Can't save PNG file." << endl;
+}
+
+// Generate result image.
+void generateResultOpenCVTopHat2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    cv::morphologyEx(inputImageMorph2D, outputTopHat2D, 5, kernelMorph2D,
+                     cv::Point(1, 1), 3, cv::BORDER_REPLICATE, 0.0);
+  } else {
+    cv::morphologyEx(inputImageMorph2D, outputTopHat2D, 5, kernelMorph2D,
+                     cv::Point(1, 1), 3, cv::BORDER_CONSTANT, 0.0);
+  }
+
+  // Choose a PNG compression level
+  vector<int> compressionParams;
+  compressionParams.push_back(IMWRITE_PNG_COMPRESSION);
+  compressionParams.push_back(9);
+
+  // Write output to PNG.
+  bool result = false;
+  try {
+    result =
+        imwrite("ResultOpenCVTopHat2D.png", outputTopHat2D, compressionParams);
+  } catch (const cv::Exception &ex) {
+    fprintf(stderr, "Exception converting image to PNG format: %s\n",
+            ex.what());
+  }
+  if (result)
+    cout << "Saved PNG file." << endl;
+  else
+    cout << "ERROR: Can't save PNG file." << endl;
+}
+
+// Generate result image.
+void generateResultOpenCVBottomHat2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    cv::morphologyEx(inputImageMorph2D, outputBottomHat2D, 6, kernelMorph2D,
+                     cv::Point(1, 1), 3, cv::BORDER_REPLICATE, 0.0);
+  } else {
+    cv::morphologyEx(inputImageMorph2D, outputBottomHat2D, 6, kernelMorph2D,
+                     cv::Point(1, 1), 3, cv::BORDER_CONSTANT, 0.0);
+  }
+
+  // Choose a PNG compression level
+  vector<int> compressionParams;
+  compressionParams.push_back(IMWRITE_PNG_COMPRESSION);
+  compressionParams.push_back(9);
+
+  // Write output to PNG.
+  bool result = false;
+  try {
+    result = imwrite("ResultOpenCVBottomHat2D.png", outputBottomHat2D,
+                     compressionParams);
+  } catch (const cv::Exception &ex) {
+    fprintf(stderr, "Exception converting image to PNG format: %s\n",
+            ex.what());
+  }
+  if (result)
+    cout << "Saved PNG file." << endl;
+  else
+    cout << "ERROR: Can't save PNG file." << endl;
+}
+
+// Generate result image.
+void generateResultOpenCVMorphGrad2D() {
+  if (OpenCVBoundaryType1 == replicate_padding) {
+    cv::morphologyEx(inputImageMorph2D, outputMorphGrad2D, 4, kernelMorph2D,
+                     cv::Point(1, 1), 3, cv::BORDER_REPLICATE, 0.0);
+  } else {
+    cv::morphologyEx(inputImageMorph2D, outputMorphGrad2D, 4, kernelMorph2D,
+                     cv::Point(1, 1), 3, cv::BORDER_CONSTANT, 0.0);
+  }
+
+  // Choose a PNG compression level
+  vector<int> compressionParams;
+  compressionParams.push_back(IMWRITE_PNG_COMPRESSION);
+  compressionParams.push_back(9);
+
+  // Write output to PNG.
+  bool result = false;
+  try {
+    result = imwrite("ResultOpenCVMorphGrad2D.png", outputMorphGrad2D,
+                     compressionParams);
+  } catch (const cv::Exception &ex) {
+    fprintf(stderr, "Exception converting image to PNG format: %s\n",
+            ex.what());
+  }
+  if (result)
+    cout << "Saved PNG file." << endl;
+  else
+    cout << "ERROR: Can't save PNG file." << endl;
+}

include/ImageProcessing/Kernels.h

@@ -78,6 +78,10 @@ static int logKernelCols = 5;
 static float random3x3KernelAlign[9] = {0, 4, 1, 
                                         3, 3, 8, 
                                         9, 6, 3};
+
+static uint8_t random3x3KernelAlignInt[9] = {0, 4, 1, 
+                                        3, 3, 8, 
+                                        9, 6, 3};                                        
 static int random3x3KernelRows = 3;
 static int random3x3KernelCols = 3;
 
@@ -85,7 +89,7 @@ static float random5x5KernelAlign[25] = {1, 9, 8, 8, 1,
                                          6, 6, 3, 3, 7, 
                                          1, 9, 5, 5, 7, 
                                          4, 5, 4, 3, 2, 
-                                         9, 8, 3, 8, 9};
+                                         9, 8, 3, 8, 9};                                       
 static int random5x5KernelRows = 5;
 static int random5x5KernelCols = 5;
 
@@ -95,7 +99,7 @@ static float random7x7KernelAlign[49] = {6, 3, 1, 5, 1, 9, 4,
                                         4, 5, 2, 6, 3, 9, 1, 
                                         7, 7, 2, 6, 7, 8, 6, 
                                         2, 8, 9, 2, 2, 7, 8, 
-                                        8, 9, 2, 3, 5, 3, 5};
+                                        8, 9, 2, 3, 5, 3, 5};                                      
 static int random7x7KernelRows = 7;
 static int random7x7KernelCols = 7;
 
@@ -107,7 +111,7 @@ static float random9x9KernelAlign[81] = {7, 9, 5, 0, 9, 8, 4, 9, 9,
                                          7, 2, 9, 8, 1, 4, 5, 7, 7, 
                                          7, 3, 4, 4, 3, 3, 4, 0, 7, 
                                          2, 7, 3, 5, 2, 3, 4, 2, 3, 
-                                         9, 5, 2, 7, 7, 4, 8, 7, 2};
+                                         9, 5, 2, 7, 7, 4, 8, 7, 2};                                       
 static int random9x9KernelRows = 9;
 static int random9x9KernelCols = 9;
 
@@ -121,7 +125,7 @@ static float random11x11KernelAlign[121] = {4, 5, 7, 6, 3, 6, 6, 6, 1, 9, 8,
                                             0, 6, 7, 9, 7, 5, 6, 6, 1, 8, 0,
                                             0, 7, 8, 3, 3, 8, 3, 2, 6, 9, 2,
                                             6, 5, 8, 1, 0, 7, 5, 8, 9, 7, 5,
-                                            6, 8, 4, 3, 7, 0, 6, 5, 1, 6, 5};
+                                            6, 8, 4, 3, 7, 0, 6, 5, 1, 6, 5};                                           
 static int random11x11KernelRows = 11;
 static int random11x11KernelCols = 11;
 
@@ -137,7 +141,7 @@ static float random13x13KernelAlign[169] = {8, 0, 6, 6, 7, 3, 4, 0, 6, 1, 5, 4,
                                             3, 1, 5, 4, 0, 7, 9, 4, 0, 2, 9, 3, 2,
                                             0, 4, 4, 1, 4, 6, 2, 8, 9, 7, 6, 8, 2,
                                             8, 2, 0, 6, 6, 3, 0, 1, 8, 0, 8, 9, 6,
-                                            9, 1, 5, 2, 6, 8, 8, 2, 1, 4, 9, 3, 2};
+                                            9, 1, 5, 2, 6, 8, 8, 2, 1, 4, 9, 3, 2};                                          
 static int random13x13KernelRows = 13;
 static int random13x13KernelCols = 13;
 
@@ -173,7 +177,11 @@ static std::map<std::string, std::tuple<float*, int, int>> kernelMap = {
     {"random9x9KernelAlign", {random9x9KernelAlign, random9x9KernelRows, random9x9KernelCols}},
     {"random11x11KernelAlign", {random11x11KernelAlign, random11x11KernelRows, random11x11KernelCols}},
     {"random13x13KernelAlign", {random13x13KernelAlign, random13x13KernelRows, random13x13KernelCols}},
-    {"random15x15KernelAlign", {random15x15KernelAlign, random15x15KernelRows, random15x15KernelCols}}
+    {"random15x15KernelAlign", {random15x15KernelAlign, random15x15KernelRows, random15x15KernelCols}}    
+};
+
+static std::map<std::string, std::tuple<uint8_t*, int, int>> kernelMap1 = {
+    {"random3x3KernelAlignInt", {random3x3KernelAlignInt, random3x3KernelRows, random3x3KernelCols}}
 };
 
 // clang-format on