[DIP] Add support for dip.rotate_2d (buddy-compiler#23)

Author: meshtag

examples/DIPDialect/CMakeLists.txt

@@ -12,16 +12,16 @@ endif()
 
 message(STATUS "Spliting size: ${SPLITING_SIZE}")
 
-add_custom_command(OUTPUT corr2d.o
-COMMAND ${BUDDY_BINARY_DIR}/buddy-opt ${BUDDY_EXAMPLES_DIR}/DIPDialect/corr2d.mlir -lower-dip="DIP-strip-mining=${SPLITING_SIZE}" -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm='emit-c-wrappers=1' -reconcile-unrealized-casts | 
+add_custom_command(OUTPUT dip.o
+COMMAND ${BUDDY_BINARY_DIR}/buddy-opt ${BUDDY_EXAMPLES_DIR}/DIPDialect/dip.mlir -lower-dip="DIP-strip-mining=${SPLITING_SIZE}" -arith-expand -lower-affine -convert-scf-to-cf -convert-math-to-llvm -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm='emit-c-wrappers=1' -reconcile-unrealized-casts | 
         ${LLVM_MLIR_BINARY_DIR}/mlir-translate --mlir-to-llvmir |
-        ${LLVM_MLIR_BINARY_DIR}/llc -mtriple=${BUDDY_TARGET_TRIPLE} -mattr=${BUDDY_OPT_ATTR} --filetype=obj -o ${BUDDY_BINARY_DIR}/../examples/DIPDialect/corr2d.o
+        ${LLVM_MLIR_BINARY_DIR}/llc -mtriple=${BUDDY_OPT_TRIPLE} -mattr=${BUDDY_OPT_ATTR} --filetype=obj -o ${BUDDY_BINARY_DIR}/../examples/DIPDialect/dip.o
 DEPENDS buddy-opt)
 
-add_library(Corr2D STATIC corr2d.o)
+add_library(DIP STATIC dip.o)
 
 SET_TARGET_PROPERTIES(
-Corr2D
+DIP
 PROPERTIES
 LINKER_LANGUAGE C)
 
@@ -30,4 +30,8 @@ include_directories(${OpenCV_INCLUDE_DIRS})
 
 add_executable(correlation2D correlation2D.cpp)
 add_dependencies(correlation2D buddy-opt)
-target_link_libraries(correlation2D ${OpenCV_LIBS} Corr2D)
+target_link_libraries(correlation2D ${OpenCV_LIBS} DIP)
+
+add_executable(rotation2D rotation2D.cpp)
+add_dependencies(rotation2D buddy-opt)
+target_link_libraries(rotation2D ${OpenCV_LIBS} DIP)

examples/DIPDialect/corr2d.mlir renamed to examples/DIPDialect/dip.mlir

@@ -9,3 +9,9 @@ func.func @corr_2d_replicate_padding(%inputImage : memref<?x?xf32>, %kernel : me
   dip.corr_2d REPLICATE_PADDING %inputImage, %kernel, %outputImage, %centerX, %centerY , %constantValue : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>, index, index, f32
   return
 }
+
+func.func @rotate_2d(%inputImage : memref<?x?xf32>, %angle : f32, %outputImage : memref<?x?xf32>)
+{
+  dip.rotate_2d %inputImage, %angle, %outputImage : memref<?x?xf32>, f32, memref<?x?xf32>
+  return
+}

examples/DIPDialect/rotation2D.cpp

@@ -0,0 +1,99 @@
+//====- rotation2D.cpp - Example of buddy-opt tool ===========================//
+//
+// 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 a 2D rotation example with dip.rotate_2d operation.
+// The dip.rotate_2d operation will be compiled into an object file with the
+// buddy-opt tool.
+// This file will be linked with the object file to generate the executable
+// file.
+//
+//===----------------------------------------------------------------------===//
+
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/opencv.hpp>
+
+#include <Interface/buddy/dip/dip.h>
+#include <Interface/buddy/dip/memref.h>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+bool testImages(cv::Mat img1, cv::Mat img2) {
+  if (img1.rows != img2.rows || img1.cols != img2.cols) {
+    std::cout << "Dimensions not equal\n";
+    return 0;
+  }
+
+  for (std::ptrdiff_t i = 0; i < img1.cols; ++i) {
+    for (std::ptrdiff_t j = 0; j < img1.rows; ++j) {
+      if (img1.at<uchar>(i, j) != img2.at<uchar>(i, j)) {
+        std::cout << "Pixels not equal at : (" << i << "," << j << ")\n";
+        std::cout << (int)img1.at<uchar>(i, j) << "\n";
+        std::cout << (int)img2.at<uchar>(i, j) << "\n\n";
+
+        std::cout << img1 << "\n\n";
+        std::cout << img2 << "\n\n";
+        return 0;
+      }
+    }
+  }
+  return 1;
+}
+
+bool testImplementation(int argc, char *argv[]) {
+  // Read as grayscale image.
+  Mat image = imread(argv[1], IMREAD_GRAYSCALE);
+  if (image.empty()) {
+    cout << "Could not read the image: " << argv[1] << endl;
+  }
+
+  int inputSize = image.rows * image.cols;
+
+  // Define the input with the image.
+  float *inputAlign = (float *)malloc(inputSize * sizeof(float));
+  for (int i = 0; i < image.rows; i++) {
+    for (int j = 0; j < image.cols; j++) {
+      inputAlign[image.rows * i + j] = (float)image.at<uchar>(i, j);
+    }
+  }
+
+  // Define allocated, sizes, and strides fields for the MemRef_descriptor.
+  float *allocated = (float *)malloc(1 * sizeof(float));
+  intptr_t sizesInput[2] = {image.rows, image.cols};
+  intptr_t stridesInput[2] = {image.rows, image.cols};
+
+  // Define memref descriptors.
+  MemRef_descriptor input =
+      MemRef_Descriptor(allocated, inputAlign, 0, sizesInput, stridesInput);
+  MemRef_descriptor output = dip::Rotate2D(input, 45, dip::ANGLE_TYPE::DEGREE);
+
+  // Define a cv::Mat with the output of Rotate2D.
+  Mat outputImageRotate2D(output->sizes[0], output->sizes[1], CV_32FC1,
+                          output->aligned);
+  imwrite(argv[2], outputImageRotate2D);
+
+  free(input);
+  free(inputAlign);
+
+  return 1;
+}
+
+int main(int argc, char *argv[]) {
+  testImplementation(argc, argv);
+
+  return 0;
+}

examples/README.md

@@ -115,6 +115,15 @@ Of course, you can also use your own configuration assigning values `-DBUDDY_DIP
 
 *Note: Maximum allowed value of `BUDDY_DIP_OPT_STRIP_MINING` for producing correct result is equal to image width.*
 
+ - Rotation example:
+```
+$ cd buddy-mlir/build
+$ cmake -G Ninja .. -DBUDDY_EXAMPLES=ON -DBUDDY_ENABLE_OPENCV=ON
+$ ninja rotation2D
+$ cd bin
+$ ./rotation2D ../../examples/ConvOpt/images/YuTu.png result-dip-rotate.png
+```
+
 We also provide the performance comparison between our `buddy-opt` tool and other state-of-the-art approaches. 
 For more details, please see [the benchamrk in the buddy-benchmark repo](https://github.com/buddy-compiler/buddy-benchmark#image-processing-benchmark).
 

include/Dialect/DIP/DIPOps.td

@@ -79,4 +79,34 @@ def DIP_Corr2DOp : DIP_Op<"corr_2d">
   }];
 }
 
+def DIP_Rotate2DOp : DIP_Op<"rotate_2d"> {
+  let summary = [{This operation intends to provide utility for rotating images via the DIP dialect. 
+  Image rotation has many applications such as data augmentation, alignment adjustment, etc. and 
+  can thus be used in native MLIR pipelines involving above mentioned uses. 
+
+  Standard affine rotation matrix [cosθ   sinθ] is used whenever |tan(θ/2)| > 8.1 for the user defined θ. 
+				                          [-sinθ  cosθ]
+  In all other cases, the 3 shear method is used to simplify calculations and minimize generated 
+  artifacts. The equivalent 3 shear matrix combination is as follows : 
+  [1  -tan(θ/2)]   *   [ 1       0]   *   [1    -tan(θ/2)]
+  [0      1    ]       [sinθ     1]       [0        1    ]
+
+  For example: 
+
+  ```mlir
+  dip.rotate_2d %inputImage, %angle, %outputImage : memref<?x?xf32>, f32, memref<?x?xf32>
+  ```
+}];
+
+  let arguments = (ins Arg<AnyRankedOrUnrankedMemRef, "inputMemref",
+                           [MemRead]>:$memrefI,
+                       F32 : $angle,
+                       Arg<AnyRankedOrUnrankedMemRef, "outputMemref",
+                           [MemRead]>:$memrefO);
+
+  let assemblyFormat = [{
+    $memrefI `,` $angle `,` $memrefO attr-dict `:` type($memrefI) `,` type($angle) `,` type($memrefO)
+  }];
+}
+
 #endif // DIP_DIPOPS_TD

include/Interface/buddy/dip/dip.h

@@ -36,10 +36,14 @@ void _mlir_ciface_corr_2d_constant_padding(
 void _mlir_ciface_corr_2d_replicate_padding(
     MemRef_descriptor input, MemRef_descriptor kernel, MemRef_descriptor output,
     unsigned int centerX, unsigned int centerY, float constantValue);
+
+void _mlir_ciface_rotate_2d(MemRef_descriptor input, float angleValue,
+                            MemRef_descriptor output);
 }
 } // namespace detail
 
 enum class BOUNDARY_OPTION { CONSTANT_PADDING, REPLICATE_PADDING };
+enum class ANGLE_TYPE { DEGREE, RADIAN };
 
 void Corr2D(MemRef_descriptor input, MemRef_descriptor kernel,
             MemRef_descriptor output, unsigned int centerX,
@@ -53,6 +57,39 @@ void Corr2D(MemRef_descriptor input, MemRef_descriptor kernel,
                                                    centerX, centerY, 0);
   }
 }
+
+MemRef_descriptor Rotate2D(MemRef_descriptor input, float angle,
+                           ANGLE_TYPE angleType) {
+  float angleRad;
+
+  if (angleType == ANGLE_TYPE::DEGREE)
+    angleRad = M_PI * angle / 180;
+  else
+    angleRad = angle;
+
+  float sinAngle = std::sin(angleRad);
+  float cosAngle = std::cos(angleRad);
+
+  int outputRows = std::round(std::abs(input->sizes[0] * cosAngle) +
+                              std::abs(input->sizes[1] * sinAngle)) + 1;
+  int outputCols = std::round(std::abs(input->sizes[1] * cosAngle) +
+                              std::abs(input->sizes[0] * sinAngle)) + 1;
+  float *outputAlign = (float *)malloc(outputRows * outputCols * sizeof(float));
+
+  for (int i = 0; i < outputRows; ++i)
+    for (int j = 0; j < outputCols; ++j)
+      outputAlign[i * outputRows + j] = 0;
+
+  float *allocated = (float *)malloc(1 * sizeof(float));
+  intptr_t sizesOutput[2] = {outputRows, outputCols};
+  intptr_t stridesOutput[2] = {outputRows, outputCols};
+  MemRef_descriptor output =
+      MemRef_Descriptor(allocated, outputAlign, 0, sizesOutput, stridesOutput);
+
+  detail::_mlir_ciface_rotate_2d(input, angleRad, output);
+
+  return output;
+}
 } // namespace dip
 
 #endif