New coding style

.clang-format

@@ -0,0 +1,32 @@
+---
+BasedOnStyle: Chromium
+AlignEscapedNewlinesLeft: 'true'
+AlignTrailingComments: 'true'
+AllowShortBlocksOnASingleLine: 'true'
+AllowShortIfStatementsOnASingleLine: 'false'
+AllowShortLoopsOnASingleLine: 'false'
+AlwaysBreakBeforeMultilineStrings: 'true'
+AlwaysBreakTemplateDeclarations: 'true'
+BreakBeforeBinaryOperators: 'true'
+BreakBeforeBraces: Stroustrup
+BreakBeforeTernaryOperators: 'true'
+BreakConstructorInitializersBeforeComma: 'false'
+ColumnLimit: '80'
+ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
+Cpp11BracedListStyle: 'true'
+IndentCaseLabels: 'true'
+KeepEmptyLinesAtTheStartOfBlocks: 'false'
+Language: Cpp
+MaxEmptyLinesToKeep: '2'
+PointerAlignment: Left
+SpaceBeforeAssignmentOperators: 'true'
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: 'false'
+SpacesInAngles: 'false'
+SpacesInCStyleCastParentheses: 'false'
+SpacesInParentheses: 'false'
+Standard: Cpp11
+TabWidth: '2'
+UseTab: ForIndentation
+
+...

include/genimg/common.hh

@@ -1,14 +1,14 @@
 #ifndef GENETIC_IMAGE_INCLUDE_GENIMG_COMMON_HH_
 #define GENETIC_IMAGE_INCLUDE_GENIMG_COMMON_HH_
 
+#include <spdlog/spdlog.h>
 #include <opencv2/core/core.hpp>
 #include <opencv2/highgui/highgui.hpp>
-#include <spdlog/spdlog.h>
 #include <string>
 #include <utility>
 
-[[nodiscard]] std::pair<cv::Mat, cv::Mat>
+[[nodiscard]] std::pair<cv::Mat, cv::Mat> init_image(
-init_image(std::string const &) noexcept;
+    std::string const&) noexcept;
 
 [[nodiscard]] double euclidian_distance(cv::Mat const&, cv::Mat const&);
 

include/genimg/drawing.hh

@@ -6,7 +6,10 @@
 
 enum class Shapes { Square, Circle };
 
-void draw_shape(cv::Mat &, cv::Point const &, int const, cv::Scalar const &,
+void draw_shape(cv::Mat&,
+                cv::Point const&,
+                int const,
+                cv::Scalar const&,
                 Shapes const&);
 
 #endif /* GENETIC_IMAGE_INCLUDE_GENIMG_DRAWING_HH_ */

include/genimg/methods.hh

@@ -1,9 +1,9 @@
 #ifndef GENETIC_IMAGE_INCLUDE_GENIMG_METHODS_HH_
 #define GENETIC_IMAGE_INCLUDE_GENIMG_METHODS_HH_
 
+#include <spdlog/spdlog.h>
 #include <opencv2/core/core.hpp>
 #include <opencv2/highgui/highgui.hpp>
-#include <spdlog/spdlog.h>
 
 void method1(cv::Mat const&, cv::Mat&, int);
 

include/genimg/parseargs.hh

@@ -4,8 +4,8 @@
 #include <filesystem>
 #include <tuple>
 
-[[nodiscard]] std::tuple<std::filesystem::path, std::filesystem::path, int, int,
+[[nodiscard]] std::
-                         bool>
+    tuple<std::filesystem::path, std::filesystem::path, int, int, bool>
     parse_args(int, char**);
 
 #endif /* GENETIC_IMAGE_INCLUDE_GENIMG_PARSEARGS_HH_ */

src/common.cc

@@ -3,8 +3,9 @@
 #include <cmath>
 #include <cstdlib>
 
-[[nodiscard]] std::pair<cv::Mat, cv::Mat>
+[[nodiscard]] std::pair<cv::Mat, cv::Mat> init_image(
-init_image(std::string const &t_input_file) noexcept {
+    std::string const& t_input_file) noexcept
+{
 	cv::Mat input_image = cv::imread(t_input_file, cv::IMREAD_COLOR);
 	if (!input_image.data) {
 		spdlog::critical("Could not open or find image!\n");
@@ -19,7 +20,8 @@ init_image(std::string const &t_input_file) noexcept {
 }
 
 [[nodiscard]] double euclidian_distance(cv::Mat const& t_img1,
-                                        cv::Mat const &t_img2) {
+                                        cv::Mat const& t_img2)
+{
 	double euclidian = 0.0;
 	for (auto itr1 = t_img1.begin<uchar>(), itr2 = t_img2.begin<uchar>();
 	     itr1 != t_img1.end<uchar>() && itr2 != t_img2.end<uchar>();

src/drawing.cc

@@ -1,24 +1,28 @@
 #include "drawing.hh"
+#include <spdlog/spdlog.h>
 #include <cstdlib>
 #include <memory>
 #include <opencv2/imgproc.hpp>
-#include <spdlog/spdlog.h>
 
-void drawSquare(cv::Mat &t_img, cv::Point const &t_top_left, int const t_size,
+void drawSquare(cv::Mat& t_img,
-                cv::Scalar const &t_color) {
+                cv::Point const& t_top_left,
+                int const t_size,
+                cv::Scalar const& t_color)
+{
 	auto points = std::make_unique<cv::Point[]>(4);
 	points.get()[0] = t_top_left;
 	points.get()[1] = cv::Point{t_top_left.x, t_top_left.y + t_size};
 	points.get()[2] = cv::Point{t_top_left.x + t_size, t_top_left.y + t_size};
 	points.get()[3] = cv::Point{t_top_left.x + t_size, t_top_left.y};
-  // spdlog::debug("Size:{} 1[{},{}] 2[{},{}] 3[{},{}] 4[{},{}]", t_size,
-  //               points[0].x, points[0].y, points[1].x, points[1].y, points[2].x,
-  //               points[2].y, points[3].x, points[3].y);
 	fillConvexPoly(t_img, points.get(), 4, t_color);
 }
 
-void draw_shape(cv::Mat &t_img, cv::Point const &t_top_left, int const t_size,
+void draw_shape(cv::Mat& t_img,
-                cv::Scalar const &t_color, Shapes const &t_shape) {
+                cv::Point const& t_top_left,
+                int const t_size,
+                cv::Scalar const& t_color,
+                Shapes const& t_shape)
+{
 	switch (t_shape) {
 		case Shapes::Square: {
 			drawSquare(t_img, t_top_left, t_size, t_color);

src/main.cc

@@ -1,14 +1,15 @@
-#include "common.hh"
-#include "methods.hh"
-#include "parseargs.hh"
 #include <cstdlib>
 #include <ctime>
 #include <iostream>
+#include "common.hh"
+#include "methods.hh"
+#include "parseargs.hh"
 
-int main(int ac, char **av) {
+int main(int ac, char** av)
+{
 	std::srand(std::time(nullptr));
-  auto const [input_file, output_file, iterations, method, verbose] =
+	auto const [input_file, output_file, iterations, method, verbose]
-      parse_args(ac, av);
+	    = parse_args(ac, av);
 	spdlog::set_level(verbose ? spdlog::level::debug : spdlog::level::info);
 	spdlog::debug("Input file:\t{}", input_file.native());
 	spdlog::debug("Output file:\t{}", output_file.native());

src/methods.cc

@@ -1,11 +1,11 @@
 #include "methods.hh"
-#include "common.hh"
-#include "drawing.hh"
 #include <algorithm>
 #include <array>
 #include <cstdlib>
 #include <thread>
 #include <vector>
+#include "common.hh"
+#include "drawing.hh"
 
 auto const thread_nbr = std::thread::hardware_concurrency();
 std::mutex numbers_mutex;
@@ -17,7 +17,8 @@ using std::rand;
 
 namespace methods_private {
 
-void adjustSize(cv::Mat const &t_process_img, cv::Point &t_top_left, int size) {
+void adjustSize(cv::Mat const& t_process_img, cv::Point& t_top_left, int size)
+{
 	int const height = t_process_img.size().height;
 	int const width = t_process_img.size().width;
 	int const shape_total_width = t_top_left.x + size;
@@ -30,22 +31,25 @@ void adjustSize(cv::Mat const &t_process_img, cv::Point &t_top_left, int size) {
 	}
 }
 
-[[nodiscard]] cv::Scalar randomColor() {
+[[nodiscard]] cv::Scalar randomColor()
+{
 	static std::uniform_int_distribution<> dis(0, 255);
 	return cv::Scalar(rand() % 255, rand() % 255, rand() % 255);
 }
 
-void newSquare1(cv::Mat &t_process_img, cv::Point &&t_top_left, int t_size) {
+void newSquare1(cv::Mat& t_process_img, cv::Point&& t_top_left, int t_size)
+{
 	adjustSize(t_process_img, t_top_left, t_size);
 	draw_shape(t_process_img, t_top_left, t_size, randomColor(), Shapes::Square);
 }
 
-void threadedGetColor(cv::Mat const &t_reference, ColorSet &t_colors, int t_h) {
+void threadedGetColor(cv::Mat const& t_reference, ColorSet& t_colors, int t_h)
+{
 	if (t_h > t_reference.size().height)
 		return;
 	for (int w = 0; w < t_reference.size().width; w += 3) {
-    Color temp = {t_reference.at<uchar>(t_h, w),
+		Color temp
-                  t_reference.at<uchar>(t_h, w + 1),
+		    = {t_reference.at<uchar>(t_h, w), t_reference.at<uchar>(t_h, w + 1),
 		       t_reference.at<uchar>(t_h, w + 2)};
 		auto pos = std::find(std::begin(t_colors), std::end(t_colors), temp);
 		if (pos == std::end(t_colors)) {
@@ -56,7 +60,8 @@ void threadedGetColor(cv::Mat const &t_reference, ColorSet &t_colors, int t_h) {
 	}
 }
 
-[[nodiscard]] ColorSet getColorSet(cv::Mat const &t_reference) {
+[[nodiscard]] ColorSet getColorSet(cv::Mat const& t_reference)
+{
 	ColorSet res{};
 	for (int h = 0; h < t_reference.size().height; h += thread_nbr) {
 		std::vector<std::thread> thread_list{};
@@ -72,8 +77,11 @@ void threadedGetColor(cv::Mat const &t_reference, ColorSet &t_colors, int t_h) {
 	return res;
 }
 
-void newSquare2(cv::Mat &t_process_img, cv::Point &&t_top_left, int t_size,
+void newSquare2(cv::Mat& t_process_img,
-                Color const &t_color) {
+                cv::Point&& t_top_left,
+                int t_size,
+                Color const& t_color)
+{
 	draw_shape(t_process_img, t_top_left, t_size,
 	           cv::Scalar{static_cast<double>(t_color[0]),
 	                      static_cast<double>(t_color[1]),
@@ -83,14 +91,16 @@ void newSquare2(cv::Mat &t_process_img, cv::Point &&t_top_left, int t_size,
 
 }  // namespace methods_private
 
-void method1(cv::Mat const &t_reference, cv::Mat &t_output, int t_iterations) {
+void method1(cv::Mat const& t_reference, cv::Mat& t_output, int t_iterations)
+{
 	auto diff = euclidian_distance(t_reference, t_output);
 	spdlog::debug("Beginning method1, initial difference: {}", diff);
 	while (t_iterations > 0 && diff >= 0) {
 		auto temp_image = t_output.clone();
 		int const rand_x = rand() % temp_image.size().width;
 		int const rand_y = rand() % temp_image.size().height;
-    int const size = rand() % std::min(t_reference.size().width - rand_x,
+		int const size = rand()
+		                 % std::min(t_reference.size().width - rand_x,
 		                            t_reference.size().height - rand_y);
 		methods_private::newSquare1(temp_image, cv::Point{rand_x, rand_y}, size);
 		if (auto const new_diff = euclidian_distance(t_reference, temp_image);
@@ -103,7 +113,8 @@ void method1(cv::Mat const &t_reference, cv::Mat &t_output, int t_iterations) {
 	}
 }
 
-void method2(cv::Mat const &t_reference, cv::Mat &t_output, int t_iterations) {
+void method2(cv::Mat const& t_reference, cv::Mat& t_output, int t_iterations)
+{
 	auto diff = euclidian_distance(t_reference, t_output);
 	spdlog::debug("Beginning method2, initial difference: {}", diff);
 	spdlog::debug("Running {} threads.", thread_nbr);
@@ -114,7 +125,8 @@ void method2(cv::Mat const &t_reference, cv::Mat &t_output, int t_iterations) {
 		auto temp_image = t_output.clone();
 		int const rand_x = rand() % temp_image.size().width;
 		int const rand_y = rand() % temp_image.size().height;
-    int const size = rand() % std::min(t_reference.size().width - rand_x,
+		int const size = rand()
+		                 % std::min(t_reference.size().width - rand_x,
 		                            t_reference.size().height - rand_y);
 		methods_private::newSquare2(temp_image, cv::Point{rand_x, rand_y}, size,
 		                            colors[rand() % colors.size()]);
@@ -128,7 +140,8 @@ void method2(cv::Mat const &t_reference, cv::Mat &t_output, int t_iterations) {
 	}
 }
 
-void method3(cv::Mat const &t_reference, cv::Mat &t_output, int t_iterations) {
+void method3(cv::Mat const& t_reference, cv::Mat& t_output, int t_iterations)
+{
 	auto const init_iter = t_iterations;
 	auto diff = euclidian_distance(t_reference, t_output);
 	spdlog::debug("Beginning method2, initial difference: {}", diff);
@@ -140,13 +153,13 @@ void method3(cv::Mat const &t_reference, cv::Mat &t_output, int t_iterations) {
 		auto temp_image = t_output.clone();
 		int const rand_x = rand() % temp_image.size().width;
 		int const rand_y = rand() % temp_image.size().height;
-    float const coef =
+		float const coef
-        static_cast<float>(t_iterations) / static_cast<float>(init_iter);
+		    = static_cast<float>(t_iterations) / static_cast<float>(init_iter);
 		int const min_size = static_cast<int>(
 		    (static_cast<float>(
-             std::min(t_reference.size().width, t_reference.size().height)) /
+		         std::min(t_reference.size().width, t_reference.size().height))
-         2.0f) *
+		     / 2.0f)
-        coef);
+		    * coef);
 		int const max_size = min_size * 2 + 1;
 		int const size = rand() % (max_size - min_size) + min_size;
 

src/parseargs.cc

@@ -8,27 +8,30 @@ constexpr int DEFAULT_ITERATIONS = 5000;
 using path = std::filesystem::path;
 namespace po = boost::program_options;
 
-void processFilenames(po::variables_map const &vm, path const &t_input,
+void processFilenames(po::variables_map const& vm,
-                      path &t_output) {
+                      path const& t_input,
+                      path& t_output)
+{
 	if (!vm.count("output")) {
-    t_output.replace_filename("output_" +
+		t_output.replace_filename("output_"
-                              std::string{t_input.filename().string()});
+		                          + std::string{t_input.filename().string()});
-  } else if (!t_output.has_extension()) {
+	}
+	else if (!t_output.has_extension()) {
 		t_output.replace_extension(".png");
 	}
 }
 
 [[nodiscard]] std::tuple<path, path, int, int, bool> parse_args(int t_ac,
-                                                                char **t_av) {
+                                                                char** t_av)
+{
 	po::options_description desc("Allowed options");
-  desc.add_options()
+	desc.add_options()("help,h", "Display this help message")(
-      ("help,h", "Display this help message")
+	    "input,i", po::value<path>(), "Input image")(
-      ("input,i", po::value<path>(), "Input image")
+	    "output,o", po::value<path>(),
-      ("output,o", po::value<path>(),
+	    "Image output path (default: input path + \"_output\")")(
-       "Image output path (default: input path + \"_output\")")
+	    "method,m", po::value<int>(), "Method number to be used (default: 1)")(
-      ("method,m", po::value<int>(), "Method number to be used (default: 1)")
+	    "iterations,n", po::value<int>(), "Number of iterations (default: 5000)")(
-      ("iterations,n", po::value<int>(), "Number of iterations (default: 5000)")
+	    "verbose,v", "Enables verbosity");
-      ("verbose,v", "Enables verbosity");
 	po::variables_map vm;
 	po::store(po::parse_command_line(t_ac, t_av, desc), vm);
 	po::notify(vm);
@@ -38,13 +41,13 @@ void processFilenames(po::variables_map const &vm, path const &t_input,
 	}
 
 	auto const input_path = vm["input"].as<path>();
-  auto output_path =
+	auto output_path
-      vm.count("output") ? vm["output"].as<path>() : input_path.filename();
+	    = vm.count("output") ? vm["output"].as<path>() : input_path.filename();
 	processFilenames(vm, input_path, output_path);
 
-  return std::make_tuple(input_path, output_path,
+	return std::make_tuple(
-                         vm.count("iterations") ? vm["iterations"].as<int>()
+	    input_path, output_path,
-                                                : DEFAULT_ITERATIONS,
+	    vm.count("iterations") ? vm["iterations"].as<int>() : DEFAULT_ITERATIONS,
 	    vm.count("method") ? vm["method"].as<int>() : 1,
 	    vm.count("verbose") ? true : false);
 }