phundrak/genetic-images
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

New coding style

Browse Source
This commit is contained in:
Phuntsok Drak-pa 2019-03-28 12:26:05 +01:00
parent 9192e89241
commit 912eafb9dd
10 changed files with 308 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
.clang-format Normal file
View File

@ -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
...

6
include/genimg/common.hh
View File

@ -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>
init_image(std::string const &) noexcept;
[[nodiscard]] std::pair<cv::Mat, cv::Mat> init_image(
std::string const&) noexcept;
[[nodiscard]] double euclidian_distance(cv::Mat const&, cv::Mat const&);

5
include/genimg/drawing.hh
View File

@ -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_ */

2
include/genimg/methods.hh
View File

@ -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);

4
include/genimg/parseargs.hh
View File

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

8
src/common.cc
View File

@ -3,8 +3,9 @@
#include <cmath>
#include <cstdlib>
[[nodiscard]] std::pair<cv::Mat, cv::Mat>
init_image(std::string const &t_input_file) noexcept {
[[nodiscard]] std::pair<cv::Mat, cv::Mat> init_image(
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>();

20
src/drawing.cc
View File

@ -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,
cv::Scalar const &t_color) {
void drawSquare(cv::Mat& t_img,
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,
cv::Scalar const &t_color, Shapes const &t_shape) {
void draw_shape(cv::Mat& t_img,
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);

13
src/main.cc
View File

@ -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] =
parse_args(ac, av);
auto const [input_file, output_file, iterations, method, verbose]
= 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());

55
src/methods.cc
View File

@ -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),
t_reference.at<uchar>(t_h, w + 1),
Color temp
= {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,
Color const &t_color) {
void newSquare2(cv::Mat& t_process_img,
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 =
static_cast<float>(t_iterations) / static_cast<float>(init_iter);
float const coef
= 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)) /
2.0f) *
coef);
std::min(t_reference.size().width, t_reference.size().height))
/ 2.0f)
* coef);
int const max_size = min_size * 2 + 1;
int const size = rand() % (max_size - min_size) + min_size;

41
src/parseargs.cc
View File

@ -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,
path &t_output) {
void processFilenames(po::variables_map const& vm,
path const& t_input,
path& t_output)
{
if (!vm.count("output")) {
t_output.replace_filename("output_" +
std::string{t_input.filename().string()});
} else if (!t_output.has_extension()) {
t_output.replace_filename("output_"
+ std::string{t_input.filename().string()});
}
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()
("help,h", "Display this help message")
("input,i", po::value<path>(), "Input image")
("output,o", po::value<path>(),
"Image output path (default: input path + \"_output\")")
("method,m", po::value<int>(), "Method number to be used (default: 1)")
("iterations,n", po::value<int>(), "Number of iterations (default: 5000)")
("verbose,v", "Enables verbosity");
desc.add_options()("help,h", "Display this help message")(
"input,i", po::value<path>(), "Input image")(
"output,o", po::value<path>(),
"Image output path (default: input path + \"_output\")")(
"method,m", po::value<int>(), "Method number to be used (default: 1)")(
"iterations,n", po::value<int>(), "Number of iterations (default: 5000)")(
"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 =
vm.count("output") ? vm["output"].as<path>() : input_path.filename();
auto output_path
= vm.count("output") ? vm["output"].as<path>() : input_path.filename();
processFilenames(vm, input_path, output_path);
return std::make_tuple(input_path, output_path,
vm.count("iterations") ? vm["iterations"].as<int>()
: DEFAULT_ITERATIONS,
return std::make_tuple(
input_path, output_path,
vm.count("iterations") ? vm["iterations"].as<int>() : DEFAULT_ITERATIONS,
vm.count("method") ? vm["method"].as<int>() : 1,
vm.count("verbose") ? true : false);
}