Initial commit (serial version)

Author: KevinMaggi

CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.20)
+project(Image_Kernel_Processing_OpenMP)
+
+set(CMAKE_C_STANDARD 11)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fopenmp")
+
+add_executable(Image_Kernel_Processing_OpenMP main.c Image.h Image.c Utils.h Utils.c stb_image.h stb_image_write.h Kernel.c Kernel.h Processing.c Processing.h)
+target_link_libraries(Image_Kernel_Processing_OpenMP m)

Image.c

@@ -0,0 +1,48 @@
+//
+// Created by kevin on 18/09/21.
+//
+
+#include "Image.h"
+#include <stdlib.h>
+
+Image *Image_new(int width, int height, int channels, unsigned char *data) {
+    Image *img = (Image *) malloc(sizeof(Image));
+
+    Image_setWidth(img, width);
+    Image_setHeight(img, height);
+    Image_setChannels(img, channels);
+    Image_setPitch(img, width * channels);
+
+    Image_setData(img, data);
+    return img;
+}
+
+Image *Image_new_empty(int width, int height, int channels) {
+    unsigned char *data = (unsigned char *) malloc(sizeof(unsigned char) * width * height * channels);
+    return Image_new(width, height, channels, data);
+}
+
+void Image_delete(Image *img) {
+    if (img != NULL) {
+        if (Image_getData(img) != NULL) {
+            free(Image_getData(img));
+        }
+        free(img);
+    }
+}
+
+void Image_setPixel(Image *img, int x, int y, int c, unsigned char val) {
+    unsigned char *data = Image_getData(img);
+    int channels = Image_getChannels(img);
+    int pitch = Image_getPitch(img);
+
+    data[y * pitch + x * channels + c] = val;
+}
+
+unsigned char Image_getPixel(Image *img, int x, int y, int c) {
+    unsigned char *data = Image_getData(img);
+    int channels = Image_getChannels(img);
+    int pitch = Image_getPitch(img);
+
+    return data[y * pitch + x * channels + c];
+}

Image.h

@@ -0,0 +1,86 @@
+//
+// Created by kevin on 18/09/21.
+//
+
+#ifndef IMAGE_KERNEL_PROCESSING_IMAGE_H
+#define IMAGE_KERNEL_PROCESSING_IMAGE_H
+
+
+/**
+ * Represents an image with data and its metadata
+ */
+typedef struct {
+    int width;
+    int height;
+    int channels;
+    int pitch;
+    unsigned char *data;
+} Image;
+
+/**
+ * RGB channels
+ */
+#define tri_color 3
+/**
+ * Gray-scale channel
+ */
+#define monochrome 1
+
+#define Image_getWidth(img) ((img)->width)
+#define Image_getHeight(img) ((img)->height)
+#define Image_getChannels(img) ((img)->channels)
+#define Image_getPitch(img) ((img)->pitch)
+#define Image_getData(img) ((img)->data)
+
+#define Image_setWidth(img, val) (Image_getWidth(img) = (val))
+#define Image_setHeight(img, val) (Image_getHeight(img) = (val))
+#define Image_setChannels(img, val) (Image_getChannels(img) = (val))
+#define Image_setPitch(img, val) (Image_getPitch(img) = (val))
+#define Image_setData(img, val) (Image_getData(img) = (val))
+
+/**
+ * Creates a new image from data and metadata
+ * @param width
+ * @param height
+ * @param channels
+ * @param data
+ * @return Image
+ */
+Image *Image_new(int width, int height, int channels, unsigned char *data);
+
+/**
+ * Creates a new empty image with only metadata
+ * @param width
+ * @param height
+ * @param channels
+ * @return
+ */
+Image *Image_new_empty(int width, int height, int channels);
+
+/**
+ * Returns the value of a channel of a given pixel
+ * @param img Image
+ * @param x x-axis coordinate
+ * @param y y-axis coordinate
+ * @param c channel
+ * @return value
+ */
+unsigned char Image_getPixel(Image *img, int x, int y, int c);
+
+/**
+ * Sets the value of a channel of a given pixel
+ * @param img Image
+ * @param x x-axis coordinate
+ * @param y y-axis coordinate
+ * @param c channel
+ * @param val value
+ */
+void Image_setPixel(Image *img, int x, int y, int c, unsigned char val);
+
+/**
+ * Frees the mem allocation of an image
+ * @param img Image
+ */
+void Image_delete(Image *img);
+
+#endif //IMAGE_KERNEL_PROCESSING_IMAGE_H

Kernel.c

@@ -0,0 +1,95 @@
+//
+// Created by kevin on 19/09/21.
+//
+
+#include <malloc.h>
+#include "Kernel.h"
+
+Kernel *Kernel_new(int size, double weight, unsigned long long int *coefficients) {
+    Kernel *krn = (Kernel *) malloc(sizeof(Kernel));
+
+    Kernel_setSize(krn, size);
+    Kernel_setWeight(krn, weight);
+    Kernel_setCoefficients(krn, coefficients);
+
+    return krn;
+}
+
+Kernel *Kernel_newEmpty(int size, double weight) {
+    unsigned long long int *coefficients = (unsigned long long int *) malloc(
+            sizeof(unsigned long long int) * size * size);
+    return Kernel_new(size, weight, coefficients);
+}
+
+unsigned long long int Kernel_getCoefficient(Kernel *krn, int x, int y) {
+    unsigned long long int *coefficients = Kernel_getCoefficients(krn);
+    int size = Kernel_getSize(krn);
+    return coefficients[y * size + x];
+}
+
+void Kernel_setCoefficient(Kernel *krn, int x, int y, unsigned long long int coefficient) {
+    unsigned long long int *coefficients = Kernel_getCoefficients(krn);
+    int size = Kernel_getSize(krn);
+
+    coefficients[y * size + x] = coefficient;
+}
+
+void Kernel_delete(Kernel *krn) {
+    if (krn != NULL) {
+        if (Kernel_getCoefficients(krn) != NULL) {
+            free(Kernel_getCoefficients(krn));
+        }
+        free(krn);
+    }
+}
+
+Kernel *Kernel_boxBlur(int size) {
+    Kernel *krn = Kernel_newEmpty(size, 1.0 / (double) (size * size));
+
+    for (int i = 0; i < size * size; i++) {
+        Kernel_getCoefficients(krn)[i] = 1;
+    }
+
+    return krn;
+}
+
+Kernel *Kernel_identity(int size) {
+    Kernel *krn = Kernel_newEmpty(size, unnormalized);
+
+    Kernel_getCoefficients(krn)[(size * size - 1) / 2] = 1;
+
+    return krn;
+}
+
+Kernel *Kernel_gaussianBlur(int size) {
+    unsigned long long int coef = 0;
+    unsigned long long int sum = 0;
+    unsigned long long int *coefficients = (unsigned long long int *) malloc(sizeof(unsigned long long int) * size);
+    for (int j = 0; j < size; j++) {
+        if (j == 0)
+            coef = 1;
+        else
+            coef = coef * (size - j) / j;
+        coefficients[j] = coef;
+        sum += coef;
+    }
+
+    Kernel *krn = Kernel_newEmpty(size, 1.0 / (double) (sum * sum));
+
+    for (int i = 0; i < size * size; i++) {
+        int col = i % size;
+        int row = i / size;
+        Kernel_getCoefficients(krn)[i] = (coefficients[row] * coefficients[col]);
+    }
+
+    free(coefficients);
+    return krn;
+}
+
+void Kernel_normalize(Kernel *krn) {
+    unsigned long long int sum = 0;
+    for (int i = 0; i < krn->size * krn->size; i++) {
+        sum += krn->coefficients[i];
+    }
+    krn->weight = 1.0 / (double) sum;
+}

Kernel.h

@@ -0,0 +1,108 @@
+//
+// Created by kevin on 19/09/21.
+//
+
+#ifndef IMAGE_KERNEL_PROCESSING_KERNEL_H
+#define IMAGE_KERNEL_PROCESSING_KERNEL_H
+
+/**
+ * Represents a Kernel matrix
+ */
+typedef struct {
+    /**
+     * radius of the kernel
+     */
+    int size;
+    /**
+     * scalar for normalization
+     */
+    double weight;
+    /**
+     * kernel's coefficients
+     */
+    unsigned long long int *coefficients;
+} Kernel;
+
+/**
+ * unnormalized weight
+ */
+#define unnormalized 1
+
+#define Kernel_getSize(krn) ((krn)->size)
+#define Kernel_getWeight(krn) ((krn)->weight)
+#define Kernel_getCoefficients(krn) ((krn)->coefficients)
+
+#define Kernel_setSize(krn, val) (Kernel_getSize(krn) = (val))
+#define Kernel_setWeight(krn, val) (Kernel_getWeight(krn) = (val))
+#define Kernel_setCoefficients(krn, val) (Kernel_getCoefficients(krn) = (val))
+
+/**
+ * Creates a new Kernel with a given coefficients and metadata
+ * @param size kernel's radius
+ * @param weight scalar weight
+ * @param coefficients matrix values
+ * @return Kernel
+ */
+Kernel *Kernel_new(int size, double weight, unsigned long long int *coefficients);
+
+/**
+ * Creates a new Kernel with only metadata
+ * @param size kernel's radius
+ * @param weight scalar weight
+ * @return Kernel
+ */
+Kernel *Kernel_newEmpty(int size, double weight);
+
+/**
+ * Returns a kernel's value
+ * @param krn Kernel
+ * @param x x index
+ * @param y y index
+ * @return coefficient
+ */
+unsigned long long int Kernel_getCoefficient(Kernel *krn, int x, int y);
+
+/**
+ * Sets a kernel's value
+ * @param krn Kernel
+ * @param x x index
+ * @param y y index
+ * @param coefficient value
+ */
+void Kernel_setCoefficient(Kernel *krn, int x, int y, unsigned long long int coefficient);
+
+/**
+ * Frees the mem allocation of a Kernel
+ * @param krn Kernel
+ */
+void Kernel_delete(Kernel *krn);
+
+/**
+ * Creates a pre-built Kernel for box-blur effect
+ * @param size radius
+ * @return Kernel
+ */
+Kernel *Kernel_boxBlur(int size);
+
+/**
+ * FOR TEST PURPOSE ONLY
+ * Creates a pre-built Kernel for identity
+ * @param size radius
+ * @return Kernel
+ */
+Kernel *Kernel_identity(int size);
+
+/**
+ * Creates a pre-built Kernel for approximate gaussian-blur effect
+ * @param size radius
+ * @return Kernel
+ */
+Kernel *Kernel_gaussianBlur(int size);
+
+/**
+ * Normalizes the weight
+ * @param krn
+ */
+void Kernel_normalize(Kernel *krn);
+
+#endif //IMAGE_KERNEL_PROCESSING_KERNEL_H

Processing.c

@@ -0,0 +1,40 @@
+//
+// Created by kevin on 26/09/21.
+//
+
+#include "Processing.h"
+
+Image *process(Image *img, Kernel *krn) {
+    Image *res = Image_new_empty(img->width, img->height, img->channels);
+
+    for (int iy = 0; iy < img->height; iy++) {
+        for (int ix = 0; ix < img->width; ix++) {
+            for (int ic = 0; ic < img->channels; ic++) {
+                unsigned long long int newVal = 0;
+                for (int ky = 0; ky < krn->size; ky++) {
+                    for (int kx = 0; kx < krn->size; kx++) {
+                        int kCenter = krn->size / 2;
+                        int dx = kx - kCenter;
+                        int dy = ky - kCenter;
+                        int px = ix + dx;
+                        int py = iy + dy;
+
+                        if (px < 0 || px >= img->width) {      // edge handling: extend
+                            px = (px < 0) ? 0 : (img->width - 1);
+                        }
+                        if (py < 0 || py >= img->height) {
+                            py = (py < 0) ? 0 : (img->height - 1);
+                        }
+
+                        newVal += (unsigned long long int) Image_getPixel(img, px, py, ic) *
+                                  Kernel_getCoefficient(krn, ky, kx);
+                    }
+                }
+                newVal = (unsigned long long int) ((long double) newVal * krn->weight);
+                Image_setPixel(res, ix, iy, ic, (unsigned char) newVal);
+            }
+        }
+    }
+
+    return res;
+}