Added all standard morphological transformations

example/Jamfile

@@ -30,6 +30,7 @@ local sources =
     histogram.cpp
     interleaved_ptr.cpp
     mandelbrot.cpp
+    morphology.cpp
     packed_pixel.cpp
     resize.cpp
     sobel_scharr.cpp

example/morphology.cpp

@@ -0,0 +1,127 @@
+//
+// Copyright 2021 Prathamesh Tagore <[email protected]>
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+#include <boost/gil.hpp>
+#include <boost/gil/extension/io/png.hpp>
+#include <iostream>
+#include <map>
+#include <string>
+#include <vector>
+
+// Default structuring element is SE = [1,1,1]
+//                                     |1,1,1|
+//                                     [1,1,1]
+// SE(1,1)(center pixel) is the one which coincides with the currently
+// considered pixel of the image to be convolved. The structuring element can be
+// easily changed by the user.
+namespace gil = boost::gil;
+int main(int argc, char **argv) {
+  std::map<std::string, bool> operations;
+  if (argc < 4 || argc > 11) {
+    throw std::invalid_argument(
+        "Wrong format of command line arguments.\n"
+        "Correct format is <Input_image.png> <Output_image_template>"
+        " <operation1> <operation2> <operation3> <operation4> <operation5> "
+        "<operation6>"
+        " <operation7> <operation8>\n");
+    // User has to enter atleast one operation and they can enter maximum 8
+    // operations considering binary conversion to be an
+    // operation.Output_image_template argument is the common component which
+    // will be added in all output images followed by a hyphen and the operation
+    // name.
+    // Example :
+    // ./example_morphology morphology_original.png out black_hat top_hat
+    // morphological_gradient dilation erosion opening closing binary
+    // Order of arguments entered will not matter with the exception of binary
+    // operation used for binary morphological operations.If binary is entered
+    // through the command line, it will always be the first operation to be
+    // applied.
+    return -1;
+  } else {
+    for (int i = 3; i < argc; ++i)
+      operations[argv[i]] = true;
+  }
+  gil::gray8_image_t img;
+  gil::read_image(argv[1], img, gil::png_tag{});
+
+  // Image can be converted to a binary format with high value as 255 and low
+  // value as 0 by using the threshold operator . This can be used for binary
+  // morphological operations . Convenient threshold for binary conversion may
+  // be chosen by the user.
+  if (operations["binary"]) {
+    threshold_binary(view(img), view(img), 170, 255);
+    std::string name = argv[2];
+    name += "-binary.png";
+    gil::write_view(name, view(img), gil::png_tag{});
+  }
+
+  std::vector<float> ker_vec(9, 1.0f); // Structuring element
+  gil::detail::kernel_2d<float> ker_mat(ker_vec.begin(), ker_vec.size(), 1, 1);
+  gil::gray8_image_t img_out_dilation(img.dimensions()),
+      img_out_erosion(img.dimensions()), img_out_opening(img.dimensions());
+  gil::gray8_image_t img_out_closing(img.dimensions()),
+      img_out_mg(img.dimensions()), img_out_top_hat(img.dimensions());
+  gil::gray8_image_t img_out_black_hat(img.dimensions());
+
+  // Do not pass empty input image views in functions defined below for
+  // morphological operations to avoid errors.
+  if (operations["dilation"]) {
+    // dilate(input_image_view,output_image_view,structuring_element,iterations)
+    dilate(view(img), view(img_out_dilation), ker_mat, 1);
+    std::string name = argv[2];
+    name += "-dilation.png";
+    gil::write_view(name, view(img_out_dilation), gil::png_tag{});
+  }
+
+  if (operations["erosion"]) {
+    // erode(input_image_view,output_image_view,structuring_element,iterations)
+    erode(view(img), view(img_out_erosion), ker_mat, 1);
+    std::string name = argv[2];
+    name += "-erosion.png";
+    gil::write_view(name, view(img_out_erosion), gil::png_tag{});
+  }
+
+  if (operations["opening"]) {
+    // opening(input_image_view,output_image_view,structuring_element)
+    opening(view(img), view(img_out_opening), ker_mat);
+    std::string name = argv[2];
+    name += "-opening.png";
+    gil::write_view(name, view(img_out_opening), gil::png_tag{});
+  }
+
+  if (operations["closing"]) {
+    // closing(input_image_view,output_image_view,structuring_element)
+    closing(view(img), view(img_out_closing), ker_mat);
+    std::string name = argv[2];
+    name += "-closing.png";
+    gil::write_view(name, view(img_out_closing), gil::png_tag{});
+  }
+
+  if (operations["morphological_gradient"]) {
+    // morphological_gradient(input_image_view,output_image_view,structuring_element)
+    morphological_gradient(view(img), view(img_out_mg), ker_mat);
+    std::string name = argv[2];
+    name += "-morphological_gradient.png";
+    gil::write_view(name, view(img_out_mg), gil::png_tag{});
+  }
+
+  if (operations["top_hat"]) {
+    // top_hat(input_image_view,output_image_view,structuring_element)
+    top_hat(view(img), view(img_out_top_hat), ker_mat);
+    std::string name = argv[2];
+    name += "-top_hat.png";
+    gil::write_view(name, view(img_out_top_hat), gil::png_tag{});
+  }
+
+  if (operations["black_hat"]) {
+    // black_hat(input_image_view,output_image_view,structuring_element)
+    black_hat(view(img), view(img_out_black_hat), ker_mat);
+    std::string name = argv[2];
+    name += "-black_hat.png";
+    gil::write_view(name, view(img_out_black_hat), gil::png_tag{});
+  }
+}

include/boost/gil.hpp

@@ -57,6 +57,7 @@
 #include <boost/gil/image_processing/histogram_matching.hpp>
 #include <boost/gil/image_processing/hough_parameter.hpp>
 #include <boost/gil/image_processing/hough_transform.hpp>
+#include <boost/gil/image_processing/morphology.hpp>
 #include <boost/gil/image_processing/numeric.hpp>
 #include <boost/gil/image_processing/scaling.hpp>
 #include <boost/gil/image_processing/threshold.hpp>