Add morphology operations + feature extraction

Author: TrAyZeN

include/morphology.h

@@ -0,0 +1,16 @@
+#ifndef MORPHOLOGY_H
+#define MORPHOLOGY_H
+
+#include "matrix.h"
+#include <stddef.h>
+
+Matrix structuring_element(size_t m, size_t n);
+
+void smooth(Matrix *image, Matrix kernel);
+void dilate(Matrix *image, Matrix kernel);
+void erode(Matrix *image, Matrix kernel);
+void opening(Matrix *image, Matrix kernel);
+void closing(Matrix *image, Matrix kernel);
+void difference(Matrix *image1, Matrix image2);
+
+#endif // MORPHOLOGY_H

include/segmentation.h

@@ -0,0 +1,9 @@
+#ifndef SEGMENTATION_H
+#define SEGMENTATION_H
+
+#include "matrix.h"
+
+void segment(Matrix image);
+void feature_extraction(Matrix *image);
+
+#endif // SEGMENTATION_H

src/main.c

@@ -2,6 +2,7 @@
 #include "error.h"
 #include "image.h"
 #include "matrix.h"
+#include "segmentation.h"
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
@@ -15,8 +16,12 @@ int main(int argc, char *argv[]) {
     try
         (bitmap_load(argv[1], &image));
 
+    feature_extraction(&image);
+
     try
         (bitmap_save("out.bmp", &image));
 
+    matrix_free(&image);
+
     return 0;
 }

src/morphology.c

@@ -0,0 +1,150 @@
+#include "morphology.h"
+#include "matrix.h"
+#include <assert.h>
+#include <float.h>
+
+float smooth_pixel(size_t y, size_t x, Matrix *image, Matrix kernel);
+float dilate_pixel(size_t y, size_t x, Matrix *image, Matrix kernel);
+float erode_pixel(size_t y, size_t x, Matrix *image, Matrix kernel);
+
+Matrix structuring_element(size_t m, size_t n) {
+    size_t i, j;
+    assert(m > 0 && n > 0 && m % 2 == 1 && n % 2 == 1);
+
+    Matrix se = matrix_new(m, n);
+    for (i = 0; i < m; i++) {
+        for (j = 0; j < n; j++) {
+            se.val[i][j] = 1.f;
+        }
+    }
+
+    return se;
+}
+
+void smooth(Matrix *image, Matrix kernel) {
+    size_t i, j;
+
+    Matrix smoothed = matrix_new(image->h, image->w);
+    for (i = 0; i < image->h; i++) {
+        for (j = 0; j < image->w; j++) {
+            smoothed.val[i][j] = smooth_pixel(i, j, image, kernel);
+        }
+    }
+
+    matrix_free(image);
+    *image = smoothed;
+}
+
+float smooth_pixel(size_t y, size_t x, Matrix *image, Matrix kernel) {
+    size_t i, j;
+    float pixel;
+
+    pixel = 0;
+    for (i = 0; i < kernel.h; i++) {
+        for (j = 0; j < kernel.w; j++) {
+            if (y + i >= kernel.h / 2 && x + j >= kernel.w / 2
+                && y + i < image->h + kernel.h / 2
+                && x + j < image->w + kernel.w / 2) {
+                pixel += image->val[y + i - kernel.h / 2][x + j - kernel.w / 2]
+                         * kernel.val[i][j];
+            }
+        }
+    }
+
+    return pixel / (kernel.h * kernel.w);
+}
+
+void dilate(Matrix *image, Matrix kernel) {
+    size_t i, j;
+
+    Matrix dilated = matrix_new(image->h, image->w);
+    for (i = 0; i < image->h; i++) {
+        for (j = 0; j < image->w; j++) {
+            dilated.val[i][j] = dilate_pixel(i, j, image, kernel);
+        }
+    }
+
+    matrix_free(image);
+    *image = dilated;
+}
+
+float dilate_pixel(size_t y, size_t x, Matrix *image, Matrix kernel) {
+    size_t i, j;
+    float max, v;
+
+    max = FLT_MIN;
+    for (i = 0; i < kernel.h; i++) {
+        for (j = 0; j < kernel.w; j++) {
+            if (y + i >= kernel.h / 2 && x + j >= kernel.w / 2
+                && y + i < image->h + kernel.h / 2
+                && x + j < image->w + kernel.w / 2) {
+                v = image->val[y + i - kernel.h / 2][x + j - kernel.w / 2]
+                    * kernel.val[i][j];
+                if (v > max) {
+                    max = v;
+                }
+            }
+        }
+    }
+
+    return max;
+}
+
+void erode(Matrix *image, Matrix kernel) {
+    size_t i, j;
+
+    Matrix eroded = matrix_new(image->h, image->w);
+    for (i = 0; i < image->h; i++) {
+        for (j = 0; j < image->w; j++) {
+            eroded.val[i][j] = erode_pixel(i, j, image, kernel);
+        }
+    }
+
+    matrix_free(image);
+    *image = eroded;
+}
+
+float erode_pixel(size_t y, size_t x, Matrix *image, Matrix kernel) {
+    size_t i, j;
+    float min, v;
+
+    min = FLT_MAX;
+    for (i = 0; i < kernel.h; i++) {
+        for (j = 0; j < kernel.w; j++) {
+            if (y + i >= kernel.h / 2 && x + j >= kernel.w / 2
+                && y + i < image->h + kernel.h / 2
+                && x + j < image->w + kernel.w / 2) {
+                v = image->val[y + i - kernel.h / 2][x + j - kernel.w / 2]
+                    * kernel.val[i][j];
+                if (v < min) {
+                    min = v;
+                }
+            }
+        }
+    }
+
+    return min;
+}
+
+void opening(Matrix *image, Matrix kernel) {
+    dilate(image, kernel);
+    erode(image, kernel);
+}
+
+void closing(Matrix *image, Matrix kernel) {
+    erode(image, kernel);
+    dilate(image, kernel);
+}
+
+void difference(Matrix *image1, Matrix image2) {
+    size_t i, j;
+    float d;
+    assert(image1->h == image2.h && image1->w == image2.w);
+
+    for (i = 0; i < image1->h; i++) {
+        for (j = 0; j < image1->w; j++) {
+            d = image1->val[i][j] - image2.val[i][j];
+            image1->val[i][j] = d < 0 ? -d : d;
+        }
+    }
+}

src/segmentation.c

@@ -0,0 +1,32 @@
+#include "segmentation.h"
+#include "image.h"
+#include "matrix.h"
+#include "morphology.h"
+
+/*
+ * Morphology based feature extraction method
+ * Proposed by Wu, Hsieh and Chen:
+ * https://www.cin.ufpe.br/~if751/projetos/artigos/Morphology-based%20text%20line%20extraction.pdf
+ */
+void feature_extraction(Matrix *image) {
+    Matrix kernel, closed;
+
+    kernel = structuring_element(3, 3);
+    smooth(image, kernel);
+    matrix_free(&kernel);
+
+    kernel = structuring_element(1, 21);
+    closed = matrix_copy(*image);
+    closing(&closed, kernel);
+    opening(image, kernel);
+    matrix_free(&kernel);
+
+    difference(image, closed);
+    matrix_free(&closed);
+
+    kernel = structuring_element(5, 5);
+    closing(image, kernel);
+    matrix_free(&kernel);
+
+    image_threshold(10.f, 255.f, image);
+}