Reorganize file structure (#10)

* Reorganize file structure

* format files

Author: wwsmiff

CMakeLists.txt

@@ -7,14 +7,15 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 project(image-exporter)
 
 add_executable(${PROJECT_NAME})
+target_include_directories(${PROJECT_NAME} PUBLIC ./include)
 target_sources(${PROJECT_NAME} PRIVATE
-  src/export.h
-  src/export.cpp
-  src/main.cpp
+  include/image_upscaler/image_upscaler.hpp
+  src/image_upscaler.cpp
+  tests/main.cpp
 )
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL Clang OR CMAKE_CXX_COMPILER_ID STREQUAL GNU)
   target_compile_options(${PROJECT_NAME} PRIVATE
-    -Wall -Wextra -Wpedantic -Wconversion -Werror=return-type
+    -Wall -Wextra -Wpedantic -Wconversion -Werror=return-type 
   )
 endif()

src/export.h include/image_upscaler/image_upscaler.hpp

@@ -1,39 +1,35 @@
 #pragma once
 
-#include <vector>
 #include <cstdint>
 #include <string>
+#include <vector>
 
-using std::uint8_t;
 using std::uint32_t;
+using std::uint8_t;
 
-struct Rgba
-{
+struct Rgba {
 	Rgba(uint32_t hex);
 	Rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
 	uint8_t r{0}, g{0}, b{0}, a{0};
-	static constexpr uint32_t to_hex(const Rgba &rgba);
+	static constexpr uint32_t to_hex(Rgba const& rgba);
 };
 
-struct Index2D
-{
+struct Index2D {
 	uint32_t x{0}, y{0};
 };
 
-struct Extent
-{
+struct Extent {
 	uint32_t width{0}, height{0};
 };
 
-struct Image
-{
+struct Image {
 	Image(uint32_t width, uint32_t height);
-	static void export_to_ppm(const Image &input, const std::string &path);
-	Rgba &operator[](Index2D index);
-	const Rgba &operator[](Index2D index) const;
-	
+	static void export_to_ppm(Image const& input, std::string const& path);
+	Rgba& operator[](Index2D index);
+	Rgba const& operator[](Index2D index) const;
+
 	Extent extent;
 	std::vector<Rgba> pixels;
 };
 
-Image upscale(const Image &input, uint32_t scale);
+Image upscale(Image const& input, uint32_t scale);

src/export.cpp

@@ -0,0 +1,61 @@
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include <image_upscaler/image_upscaler.hpp>
+
+/* Implementation of Rgba */
+Rgba::Rgba(uint32_t hex) : r((hex & 0xFF'00'00'00) >> 24), g((hex & 0x00'FF'00'00) >> 16), b((hex & 0x00'00'FF'00) >> 8), a(hex & 0x00'00'00'FF) {}
+
+Rgba::Rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a) : r(r), g(g), b(b), a(a) {}
+
+constexpr uint32_t Rgba::to_hex(Rgba const& rgba) { return ((rgba.r << 24) | (rgba.g << 16) | (rgba.b << 8) | (rgba.a)); }
+
+/* --- End --- */
+
+/* Implementation of Image */
+Image::Image(uint32_t width, uint32_t height) : extent{width, height}, pixels(width * height, Rgba(0)) {}
+
+void Image::export_to_ppm(Image const& input, std::string const& path) {
+	std::ofstream output(path);
+	output << "P3\n";
+	output << "# " << path << '\n';
+	output << input.extent.width << " " << input.extent.height << '\n';
+	output << "255\n";
+
+	for (uint32_t y = 0; y < input.extent.height; ++y) {
+		for (uint32_t x = 0; x < input.extent.width; ++x) {
+			Rgba current = input.pixels.at(y * input.extent.width + x);
+			output << static_cast<uint32_t>(current.r) << '\n' << static_cast<uint32_t>(current.g) << '\n' << static_cast<uint32_t>(current.b) << '\n';
+		}
+	}
+
+	output.close();
+}
+
+Rgba& Image::operator[](Index2D index) { return this->pixels.at(index.y * this->extent.width + index.x); }
+
+Rgba const& Image::operator[](Index2D index) const { return this->pixels.at(index.y * this->extent.width + index.x); }
+
+/* --- End --- */
+
+Image upscale(Image const& input, uint32_t scale) {
+	uint32_t target_width_v = input.extent.width * scale;
+	uint32_t target_height_v = input.extent.height * scale;
+	uint32_t x_index{0}, y_index{0};
+	Image target_image(target_width_v, target_height_v);
+
+	for (y_index = 0; y_index < input.extent.height; ++y_index) {
+		for (x_index = 0; x_index < input.extent.width; ++x_index) {
+			Rgba current = input[Index2D{x_index, y_index}];
+			if (Rgba::to_hex(current)) {
+				for (uint32_t i = y_index * scale; i < ((y_index + 1) * scale); ++i) {
+					for (uint32_t j = x_index * scale; j < ((x_index + 1) * scale); ++j) { target_image[Index2D{j, i}] = current; }
+				}
+			}
+		}
+	}
+
+	return target_image;
+}

src/image_upscaler.cpp

@@ -0,0 +1,3 @@
+#include <image_upscaler/image_upscaler.hpp>
+
+int main() { return 0; }