Image compression / decompression (mmoskala07)

homework/grayscale-image/build.bat

@@ -0,0 +1,11 @@
+RMDIR build /S /Q
+mkdir build
+cd build
+cmake -G "MinGW Makefiles" ..
+MinGW32-make
+
+grayscaleImages.exe
+@REM grayscaleImages-ut.exe
+
+cd ..
+

homework/grayscale-image/compression.cpp

@@ -0,0 +1,75 @@
+#include "compression.hpp"
+#include <iomanip>
+#include <iostream>
+
+static size_t constexpr VALUE = 0;
+static size_t constexpr OCCURENCES = 1;
+
+comp_img_t compressGrayscale(img_t image) {
+    comp_img_t img_compressed;
+    uint8_t img_value = image[0][0];
+    uint8_t occurences = 0;
+
+    for (size_t row = 0; row < image.size(); row++) {
+        img_value = image[row][0];
+        occurences = 0;
+
+        for (size_t col = 0; col < image[0].size(); col++) {
+            if (img_value == image[row][col]) {
+                occurences++;
+            } else {
+                img_compressed.push_back(std::make_pair(img_value, occurences));
+                img_value = image[row][col];
+                occurences = 1;
+            }
+        }
+        img_compressed.push_back(std::make_pair(img_value, occurences));
+    }
+    return img_compressed;
+}
+
+img_t decompressGrayscale(comp_img_t image_compressed) {
+    img_t image;
+
+    size_t idx = 0;
+    uint8_t value = std::get<VALUE>(image_compressed[idx]);
+    size_t occurs = std::get<OCCURENCES>(image_compressed[idx]);
+
+    for (size_t row = 0; row < image.size(); row++) {
+        for (size_t col = 0; col < image[0].size(); col++) {
+            if (occurs == 0) {
+                if (++idx < image_compressed.size()) {
+                    value = std::get<VALUE>(image_compressed[idx]);
+                    occurs = std::get<OCCURENCES>(image_compressed[idx]);
+
+                    if (occurs == 0) {
+                        throw std::invalid_argument("Occurences equal as zero. Compression was not done correctly");
+                    }
+                } else {
+                    throw std::invalid_argument("Compressed image does not contain enough data");
+                }
+            }
+            image[row][col] = value;
+            occurs--;
+        }
+    }
+
+    if (idx + 1 != image_compressed.size() || occurs != 0) {
+        throw std::invalid_argument("Compressed image contains too many data");
+    }
+
+    return image;
+}
+
+void printMap(const std::array<std::array<uint8_t, 32>, 32>& img) {
+    for (auto row : img) {
+        for (auto pixel : row) {
+            if (pixel == 0) {
+                std::cout << "-";
+            } else {
+                std::cout << (unsigned char)pixel;
+            }
+        }
+        std::cout << std::endl;
+    }
+}

homework/grayscale-image/compression.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+constexpr size_t width = 32;
+constexpr size_t height = 32;
+
+using img_t = std::array<std::array<uint8_t, width>, height>;
+using comp_img_t = std::vector<std::pair<uint8_t, uint8_t>>;
+
+comp_img_t compressGrayscale(img_t image);
+img_t decompressGrayscale(comp_img_t image_compressed);
+
+void printMap(const std::array<std::array<uint8_t, 32>, 32>& img);

homework/grayscale-image/format.bat

@@ -0,0 +1 @@
+clang-format --style=file -i *.hpp *.cpp

homework/grayscale-image/main.cpp

@@ -1,7 +1,6 @@
 #include <array>
 #include <forward_list>
-
-// TODO: include
+#include "compression.hpp"
 
 std::array<std::array<uint8_t, 32>, 32> generateNinja() {
     return {
@@ -42,10 +41,10 @@ std::array<std::array<uint8_t, 32>, 32> generateNinja() {
 
 int main() {
     auto ninja = generateNinja();
-    // printMap(ninja);
+    printMap(ninja);
     auto compressed = compressGrayscale(ninja);
     auto decompressed = decompressGrayscale(compressed);
-    // printMap(decompressed);
+    printMap(decompressed);
 
     return 0;
 }

homework/grayscale-image/test.cpp

@@ -2,8 +2,7 @@
 #include <array>
 #include <utility>  // for std::pair<>
 #include <vector>
-
-// TODO: include
+#include "compression.hpp"
 #include "gtest/gtest.h"
 
 void expectBitmap(const std::vector<std::pair<uint8_t, uint8_t>>& bitmap, size_t fraction) {