tri11paragon
/
image-gp-6
mirror of https://github.com/tri11paragon/image-gp-6.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: tri11paragon:9d53c180e98e5411fc4c30930bc4bb5a71ac46a5
Branches Tags
tri11paragon:main
..
compare: tri11paragon:42de832ab549e6366c4228ea61baa86d04daaaf1
Branches Tags
tri11paragon:main

No commits in common. "9d53c180e98e5411fc4c30930bc4bb5a71ac46a5" and "42de832ab549e6366c4228ea61baa86d04daaaf1" have entirely different histories.
9d53c180e9 ... 42de832ab5

6 changed files with 299 additions and 460 deletions
Show Stats Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -1,5 +1,5 @@
cmake_minimum_required(VERSION 3.25)
project(image-gp-6 VERSION 0.0.16)
project(image-gp-6 VERSION 0.0.14)
include(FetchContent)

3
include/config.h
View File

@ -46,7 +46,4 @@ blt::gp::prog_config_t config = blt::gp::prog_config_t()
.set_pop_size(POP_SIZE)
.set_thread_count(0);
inline blt::gp::type_provider type_system;
inline blt::gp::gp_program program{type_system, SEED, config};
#endif //IMAGE_GP_6_CONFIG_H

52
include/float_operations.h
View File

@ -1,52 +0,0 @@
#pragma once
/*
* Copyright (C) 2024 Brett Terpstra
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <blt/gp/program.h>
#include <functional>
#include <helper.h>
#ifndef IMAGE_GP_6_FLOAT_OPERATIONS_H
#define IMAGE_GP_6_FLOAT_OPERATIONS_H
inline blt::gp::operation_t f_add([](float a, float b) {
return a + b;
}, "f_add");
inline blt::gp::operation_t f_sub([](float a, float b) {
return a - b;
}, "f_sub");
inline blt::gp::operation_t f_mul([](float a, float b) {
return a * b;
}, "f_mul");
inline blt::gp::operation_t f_pro_div([](float a, float b) {
return b == 0.0f ? 0.0f : (a / b);
}, "f_div");
inline blt::gp::operation_t f_literal([]() {
return program.get_random().get_float(0.0, 1.0);
}, "float_lit");
template<typename context>
void create_float_operations(blt::gp::operator_builder<context>& builder)
{
builder.add_operator(f_add);
builder.add_operator(f_sub);
builder.add_operator(f_mul);
builder.add_operator(f_pro_div);
builder.add_operator(f_literal, true);
}
#endif //IMAGE_GP_6_FLOAT_OPERATIONS_H

35
include/helper.h
View File

@ -19,8 +19,6 @@
#ifndef IMAGE_GP_6_HELPER_H
#define IMAGE_GP_6_HELPER_H
#include <images.h>
template<typename SINGLE_FUNC>
constexpr static auto make_single(SINGLE_FUNC&& func)
{
@ -43,37 +41,4 @@ constexpr static auto make_double(DOUBLE_FUNC&& func)
};
}
struct context
{
float x, y;
};
inline context get_ctx(blt::size_t i)
{
context ctx{};
i /= CHANNELS;
ctx.y = std::floor(static_cast<float>(i) / static_cast<float>(IMAGE_SIZE));
ctx.x = static_cast<float>(i) - (ctx.y * IMAGE_SIZE);
return ctx;
}
inline context get_pop_ctx(blt::size_t i)
{
auto const sq = static_cast<float>(std::sqrt(POP_SIZE));
context ctx{};
ctx.y = std::floor(static_cast<float>(i) / static_cast<float>(sq));
ctx.x = static_cast<float>(i) - (ctx.y * sq);
return ctx;
}
inline blt::size_t get_index(blt::size_t x, blt::size_t y)
{
return y * IMAGE_SIZE + x;
}
inline float perlin_noise(float x, float y, float z)
{
return (stb_perlin_noise3(x, y, z, 0, 0, 0) + 1.0f) / 2.0f;
}
#endif //IMAGE_GP_6_HELPER_H

339
include/image_operations.h
View File

@ -1,339 +0,0 @@
#pragma once
/*
* Copyright (C) 2024 Brett Terpstra
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <blt/gp/program.h>
#include <functional>
#include <helper.h>
#ifndef IMAGE_GP_6_IMAGE_OPERATIONS_H
#define IMAGE_GP_6_IMAGE_OPERATIONS_H
inline blt::gp::operation_t add(make_double(std::plus()), "add");
inline blt::gp::operation_t sub(make_double(std::minus()), "sub");
inline blt::gp::operation_t mul(make_double(std::multiplies()), "mul");
inline blt::gp::operation_t pro_div([](const full_image_t& a, const full_image_t& b) {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
img.rgb_data[i] = b.rgb_data[i] == 0 ? 0 : (a.rgb_data[i] / b.rgb_data[i]);
return img;
}, "div");
inline blt::gp::operation_t op_sin(make_single([](float a) {
return (std::sin(a) + 1.0f) / 2.0f;
}), "sin");
inline blt::gp::operation_t op_cos(make_single([](float a) {
return (std::cos(a) + 1.0f) / 2.0f;
}), "cos");
inline blt::gp::operation_t op_atan(make_single((float (*)(float)) &std::atan), "atan");
inline blt::gp::operation_t op_exp(make_single((float (*)(float)) &std::exp), "exp");
inline blt::gp::operation_t op_abs(make_single((float (*)(float)) &std::abs), "abs");
inline blt::gp::operation_t op_log(make_single((float (*)(float)) &std::log), "log");
inline blt::gp::operation_t op_v_mod([](const full_image_t& a, const full_image_t& b) {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
img.rgb_data[i] = b.rgb_data[i] <= 0 ? 0 : static_cast<float>(blt::mem::type_cast<unsigned int>(a.rgb_data[i]) %
blt::mem::type_cast<unsigned int>(b.rgb_data[i]));
return img;
}, "v_mod");
inline blt::gp::operation_t bitwise_and([](const full_image_t& a, const full_image_t& b) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
img.rgb_data[i] = static_cast<float>(type_cast<unsigned int>(a.rgb_data[i]) & type_cast<unsigned int>(b.rgb_data[i]));
return img;
}, "and");
inline blt::gp::operation_t bitwise_or([](const full_image_t& a, const full_image_t& b) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
img.rgb_data[i] = static_cast<float>(type_cast<unsigned int>(a.rgb_data[i]) | type_cast<unsigned int>(b.rgb_data[i]));
return img;
}, "or");
inline blt::gp::operation_t bitwise_invert([](const full_image_t& a) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
img.rgb_data[i] = static_cast<float>(~type_cast<unsigned int>(a.rgb_data[i]));
return img;
}, "invert");
inline blt::gp::operation_t bitwise_xor([](const full_image_t& a, const full_image_t& b) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
auto in_a = type_cast<unsigned int>(a.rgb_data[i]);
auto in_b = type_cast<unsigned int>(b.rgb_data[i]);
img.rgb_data[i] = static_cast<float>(in_a ^ in_b);
}
return img;
}, "xor");
inline blt::gp::operation_t dissolve([](const full_image_t& a, const full_image_t& b) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
auto diff = (a.rgb_data[i] - b.rgb_data[i]) / 2.0f;
img.rgb_data[i] = a.rgb_data[i] + diff;
}
return img;
}, "dissolve");
inline blt::gp::operation_t band_pass([](const full_image_t& a, float min, float max) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
if (a.rgb_data[i] >= min && a.rgb_data[i] <= max)
{
img.rgb_data[i] = a.rgb_data[i];
} else if (a.rgb_data[i] < min)
{
auto dist_min = min == 0 ? 0.0f : (a.rgb_data[i] / min);
img.rgb_data[i] = a.rgb_data[i] * dist_min;
} else if (a.rgb_data[i] > max)
{
auto dist_max = max == 0 ? 0.0f : ((a.rgb_data[i] - max) / max);
img.rgb_data[i] = a.rgb_data[i] * dist_max;
} else {
img.rgb_data[i] = 0;
}
}
return img;
}, "band_pass");
inline blt::gp::operation_t hsv_to_rgb([](const full_image_t& a) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto h = static_cast<blt::i32>(a.rgb_data[i * CHANNELS + 0]) % 360;
auto s = a.rgb_data[i * CHANNELS + 1];
auto v = a.rgb_data[i * CHANNELS + 2];
auto c = v * s;
auto x = c * static_cast<float>(1 - std::abs(((h / 60) % 2) - 1));
auto m = v - c;
blt::vec3 rgb;
if (h >= 0 && h < 60)
rgb = {c, x, 0.0f};
else if (h >= 60 && h < 120)
rgb = {x, c, 0.0f};
else if (h >= 120 && h < 180)
rgb = {0.0f, c, x};
else if (h >= 180 && h < 240)
rgb = {0.0f, x, c};
else if (h >= 240 && h < 300)
rgb = {x, 0.0f, c};
else if (h >= 300 && h < 360)
rgb = {c, 0.0f, x};
img.rgb_data[i * CHANNELS] = rgb.x() + m;
img.rgb_data[i * CHANNELS + 1] = rgb.y() + m;
img.rgb_data[i * CHANNELS + 2] = rgb.z() + m;
}
return img;
}, "hsv");
inline blt::gp::operation_t lit([]() {
full_image_t img{};
auto r = program.get_random().get_float(0.0f, 1.0f);
auto g = program.get_random().get_float(0.0f, 1.0f);
auto b = program.get_random().get_float(0.0f, 1.0f);
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
img.rgb_data[i * CHANNELS] = r;
img.rgb_data[i * CHANNELS + 1] = g;
img.rgb_data[i * CHANNELS + 2] = b;
}
return img;
}, "lit");
inline blt::gp::operation_t random_val([]() {
full_image_t img{};
for (auto& i : img.rgb_data)
i = program.get_random().get_float(0.0f, 1.0f);
return img;
}, "color_noise");
inline blt::gp::operation_t perlin([](const full_image_t& x, const full_image_t& y, const full_image_t& z, const full_image_t& scale) {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
auto s = scale.rgb_data[i];
img.rgb_data[i] = perlin_noise(x.rgb_data[i] / s, y.rgb_data[i] / s, z.rgb_data[i] / s);
}
return img;
}, "perlin");
inline blt::gp::operation_t perlin_terminal([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
auto ctx = get_ctx(i);
img.rgb_data[i] = perlin_noise(ctx.x / IMAGE_SIZE, ctx.y / IMAGE_SIZE, static_cast<float>(i % CHANNELS) / CHANNELS);
}
return img;
}, "perlin_term");
inline blt::gp::operation_t perlin_warped([](const full_image_t& u, const full_image_t& v) {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
auto ctx = get_ctx(i);
img.rgb_data[i] = perlin_noise(ctx.x / IMAGE_SIZE + u.rgb_data[i], ctx.y / IMAGE_SIZE + v.rgb_data[i],
static_cast<float>(i % CHANNELS) / CHANNELS);
}
return img;
}, "perlin_warped");
inline blt::gp::operation_t op_img_size([]() {
full_image_t img{};
for (float& i : img.rgb_data)
{
i = IMAGE_SIZE;
}
return img;
}, "img_size");
inline blt::gp::operation_t op_x_r([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).x;
img.rgb_data[i * CHANNELS] = ctx;
img.rgb_data[i * CHANNELS + 1] = 0;
img.rgb_data[i * CHANNELS + 2] = 0;
}
return img;
}, "x_r");
inline blt::gp::operation_t op_x_g([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).x;
img.rgb_data[i * CHANNELS] = 0;
img.rgb_data[i * CHANNELS + 1] = ctx;
img.rgb_data[i * CHANNELS + 2] = 0;
}
return img;
}, "x_g");
inline blt::gp::operation_t op_x_b([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).x;
img.rgb_data[i * CHANNELS] = 0;
img.rgb_data[i * CHANNELS + 1] = 0;
img.rgb_data[i * CHANNELS + 2] = ctx;
}
return img;
}, "x_b");
inline blt::gp::operation_t op_x_rgb([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).x;
img.rgb_data[i * CHANNELS] = ctx;
img.rgb_data[i * CHANNELS + 1] = ctx;
img.rgb_data[i * CHANNELS + 2] = ctx;
}
return img;
}, "x_rgb");
inline blt::gp::operation_t op_y_r([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).y;
img.rgb_data[i * CHANNELS] = ctx;
img.rgb_data[i * CHANNELS + 1] = 0;
img.rgb_data[i * CHANNELS + 2] = 0;
}
return img;
}, "y_r");
inline blt::gp::operation_t op_y_g([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).y;
img.rgb_data[i * CHANNELS] = 0;
img.rgb_data[i * CHANNELS + 1] = ctx;
img.rgb_data[i * CHANNELS + 2] = 0;
}
return img;
}, "y_g");
inline blt::gp::operation_t op_y_b([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).y;
img.rgb_data[i * CHANNELS] = 0;
img.rgb_data[i * CHANNELS + 1] = 0;
img.rgb_data[i * CHANNELS + 2] = ctx;
}
return img;
}, "y_b");
inline blt::gp::operation_t op_y_rgb([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).y;
img.rgb_data[i * CHANNELS] = ctx;
img.rgb_data[i * CHANNELS + 1] = ctx;
img.rgb_data[i * CHANNELS + 2] = ctx;
}
return img;
}, "y_rgb");
template<typename context>
void create_image_operations(blt::gp::operator_builder<context>& builder)
{
builder.add_operator(perlin);
builder.add_operator(perlin_terminal);
builder.add_operator(perlin_warped);
builder.add_operator(add);
builder.add_operator(sub);
builder.add_operator(mul);
builder.add_operator(pro_div);
builder.add_operator(op_sin);
builder.add_operator(op_cos);
builder.add_operator(op_atan);
builder.add_operator(op_exp);
builder.add_operator(op_log);
builder.add_operator(op_abs);
builder.add_operator(op_v_mod);
builder.add_operator(bitwise_and);
builder.add_operator(bitwise_or);
builder.add_operator(bitwise_invert);
builder.add_operator(bitwise_xor);
builder.add_operator(dissolve);
builder.add_operator(band_pass);
builder.add_operator(hsv_to_rgb);
bool state = false;
builder.add_operator(lit, true);
builder.add_operator(random_val);
builder.add_operator(op_x_r, state);
builder.add_operator(op_x_g, state);
builder.add_operator(op_x_b, state);
builder.add_operator(op_x_rgb, state);
builder.add_operator(op_y_r, state);
builder.add_operator(op_y_g, state);
builder.add_operator(op_y_b, state);
builder.add_operator(op_y_rgb, state);
}
#endif //IMAGE_GP_6_IMAGE_OPERATIONS_H

328
src/main.cpp
View File

@ -36,17 +36,15 @@
#include "opencv2/imgproc.hpp"
#include <random>
#include "slr.h"
#include "float_operations.h"
#include <images.h>
#include <helper.h>
#include <image_operations.h>
blt::gfx::matrix_state_manager global_matrices;
blt::gfx::resource_manager resources;
blt::gfx::batch_renderer_2d renderer_2d(resources, global_matrices);
blt::gfx::first_person_camera_2d camera;
static constexpr blt::size_t TYPE_COUNT = 2;
static constexpr blt::size_t TYPE_COUNT = 1;
std::array<double, POP_SIZE> fitness_values{};
double last_fitness = 0;
@ -55,7 +53,6 @@ double hovered_fitness_value = 0;
bool evaluate = true;
std::array<bool, TYPE_COUNT> has_literal_converter = {
true,
true
};
@ -72,16 +69,6 @@ std::array<std::function<void(blt::gp::gp_program& program, void*, void*, void*,
c1_out.rgb_data[i] = p1_in.rgb_data[i] - diff;
c2_out.rgb_data[i] = p2_in.rgb_data[i] + diff;
}
},
[](blt::gp::gp_program&, void* p1_in_ptr, void* p2_in_ptr, void* c1_out_ptr, void* c2_out_ptr) {
auto& p1_in = *static_cast<float*>(p1_in_ptr);
auto& p2_in = *static_cast<float*>(p2_in_ptr);
auto& c1_out = *static_cast<float*>(c1_out_ptr);
auto& c2_out = *static_cast<float*>(c2_out_ptr);
auto diff = p1_in - p2_in;
c1_out = p1_in - diff;
c2_out = p2_in + diff;
}
};
@ -92,27 +79,49 @@ std::array<std::function<void(blt::gp::gp_program& program, void*, void*)>, TYPE
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
c1_out.rgb_data[i] = p1_in.rgb_data[i] + program.get_random().get_float(-1.0f, 1.0f);
},
[](blt::gp::gp_program& program, void* p1_in_ptr, void* c1_out_ptr) {
auto& p1_in = *static_cast<float*>(p1_in_ptr);
auto& c1_out = *static_cast<float*>(c1_out_ptr);
c1_out = p1_in + program.get_random().get_float(-1.0f, 1.0f);
}
};
class image_crossover_t : public blt::gp::crossover_t
{
public:
blt::expected<result_t, error_t> apply(blt::gp::gp_program& prog, const blt::gp::tree_t& p1, const blt::gp::tree_t& p2) final
blt::expected<result_t, error_t> apply(blt::gp::gp_program& program, const blt::gp::tree_t& p1, const blt::gp::tree_t& p2) final
{
auto sel = prog.get_random().choice();
auto sel = program.get_random().choice();
if (sel)
return blt::gp::crossover_t::apply(prog, p1, p2);
return blt::gp::crossover_t::apply(program, p1, p2);
std::abort();
}
};
struct context
{
float x, y;
};
inline context get_ctx(blt::size_t i)
{
context ctx{};
i /= CHANNELS;
ctx.y = std::floor(static_cast<float>(i) / static_cast<float>(IMAGE_SIZE));
ctx.x = static_cast<float>(i) - (ctx.y * IMAGE_SIZE);
return ctx;
}
inline context get_pop_ctx(blt::size_t i)
{
auto const sq = static_cast<float>(std::sqrt(POP_SIZE));
context ctx{};
ctx.y = std::floor(static_cast<float>(i) / static_cast<float>(sq));
ctx.x = static_cast<float>(i) - (ctx.y * sq);
return ctx;
}
inline blt::size_t get_index(blt::size_t x, blt::size_t y)
{
return y * IMAGE_SIZE + x;
}
std::array<full_image_t, POP_SIZE> generation_images;
full_image_t base_image;
@ -120,8 +129,240 @@ blt::size_t last_run = 0;
blt::i32 time_between_runs = 16;
bool is_running = false;
blt::gp::type_provider type_system;
blt::gp::gp_program program{type_system, SEED, config};
std::unique_ptr<std::thread> gp_thread = nullptr;
blt::gp::operation_t add(make_double(std::plus()), "add");
blt::gp::operation_t sub(make_double(std::minus()), "sub");
blt::gp::operation_t mul(make_double(std::multiplies()), "mul");
blt::gp::operation_t pro_div([](const full_image_t& a, const full_image_t& b) {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
img.rgb_data[i] = b.rgb_data[i] == 0 ? 0 : (a.rgb_data[i] / b.rgb_data[i]);
return img;
}, "div");
blt::gp::operation_t op_sin(make_single([](float a) {
return (std::sin(a) + 1.0f) / 2.0f;
}), "sin");
blt::gp::operation_t op_cos(make_single([](float a) {
return (std::cos(a) + 1.0f) / 2.0f;
}), "cos");
blt::gp::operation_t op_atan(make_single((float (*)(float)) &std::atan), "atan");
blt::gp::operation_t op_exp(make_single((float (*)(float)) &std::exp), "exp");
blt::gp::operation_t op_abs(make_single((float (*)(float)) &std::abs), "abs");
blt::gp::operation_t op_log(make_single((float (*)(float)) &std::log), "log");
blt::gp::operation_t op_v_mod([](const full_image_t& a, const full_image_t& b) {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
img.rgb_data[i] = b.rgb_data[i] <= 0 ? 0 : static_cast<float>(blt::mem::type_cast<unsigned int>(a.rgb_data[i]) %
blt::mem::type_cast<unsigned int>(b.rgb_data[i]));
return img;
}, "v_mod");
blt::gp::operation_t bitwise_and([](const full_image_t& a, const full_image_t& b) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
img.rgb_data[i] = static_cast<float>(type_cast<unsigned int>(a.rgb_data[i]) & type_cast<unsigned int>(b.rgb_data[i]));
return img;
}, "and");
blt::gp::operation_t bitwise_or([](const full_image_t& a, const full_image_t& b) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
img.rgb_data[i] = static_cast<float>(type_cast<unsigned int>(a.rgb_data[i]) | type_cast<unsigned int>(b.rgb_data[i]));
return img;
}, "or");
blt::gp::operation_t bitwise_invert([](const full_image_t& a) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
img.rgb_data[i] = static_cast<float>(~type_cast<unsigned int>(a.rgb_data[i]));
return img;
}, "invert");
blt::gp::operation_t bitwise_xor([](const full_image_t& a, const full_image_t& b) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
auto in_a = type_cast<unsigned int>(a.rgb_data[i]);
auto in_b = type_cast<unsigned int>(b.rgb_data[i]);
img.rgb_data[i] = static_cast<float>(in_a ^ in_b);
}
return img;
}, "xor");
blt::gp::operation_t dissolve([](const full_image_t& a, const full_image_t& b) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
auto diff = (a.rgb_data[i] - b.rgb_data[i]) / 2.0f;
img.rgb_data[i] = a.rgb_data[i] + diff;
}
return img;
}, "dissolve");
blt::gp::operation_t hsv_to_rgb([](const full_image_t& a) {
using blt::mem::type_cast;
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto h = static_cast<blt::i32>(a.rgb_data[i * CHANNELS + 0]) % 360;
auto s = a.rgb_data[i * CHANNELS + 1];
auto v = a.rgb_data[i * CHANNELS + 2];
auto c = v * s;
auto x = c * static_cast<float>(1 - std::abs(((h / 60) % 2) - 1));
auto m = v - c;
blt::vec3 rgb;
if (h >= 0 && h < 60)
rgb = {c, x, 0.0f};
else if (h >= 60 && h < 120)
rgb = {x, c, 0.0f};
else if (h >= 120 && h < 180)
rgb = {0.0f, c, x};
else if (h >= 180 && h < 240)
rgb = {0.0f, x, c};
else if (h >= 240 && h < 300)
rgb = {x, 0.0f, c};
else if (h >= 300 && h < 360)
rgb = {c, 0.0f, x};
img.rgb_data[i * CHANNELS] = rgb.x() + m;
img.rgb_data[i * CHANNELS + 1] = rgb.y() + m;
img.rgb_data[i * CHANNELS + 2] = rgb.z() + m;
}
return img;
}, "hsv");
blt::gp::operation_t lit([]() {
full_image_t img{};
auto r = program.get_random().get_float(0.0f, 1.0f);
auto g = program.get_random().get_float(0.0f, 1.0f);
auto b = program.get_random().get_float(0.0f, 1.0f);
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
img.rgb_data[i * CHANNELS] = r;
img.rgb_data[i * CHANNELS + 1] = g;
img.rgb_data[i * CHANNELS + 2] = b;
}
return img;
}, "lit");
blt::gp::operation_t random_val([]() {
full_image_t img{};
for (auto& i : img.rgb_data)
i = program.get_random().get_float(0.0f, 1.0f);
return img;
}, "color_noise");
static blt::gp::operation_t perlin([](const full_image_t& x, const full_image_t& y, const full_image_t& z, const full_image_t& scale) {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
auto s = scale.rgb_data[i];
img.rgb_data[i] = stb_perlin_noise3(x.rgb_data[i] / s, y.rgb_data[i] / s, z.rgb_data[i] / s, 0, 0, 0);
}
return img;
}, "perlin");
static blt::gp::operation_t perlin_terminal([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
auto ctx = get_ctx(i);
img.rgb_data[i] =
stb_perlin_noise3(ctx.x / IMAGE_SIZE, ctx.y / IMAGE_SIZE, static_cast<float>(i % CHANNELS) / CHANNELS, 0, 0, 0);
}
return img;
}, "perlin_term");
static blt::gp::operation_t perlin_warped([](const full_image_t& u, const full_image_t& v) {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_CHANNELS_SIZE; i++)
{
auto ctx = get_ctx(i);
img.rgb_data[i] = stb_perlin_noise3(ctx.x / IMAGE_SIZE + u.rgb_data[i], ctx.y / IMAGE_SIZE + v.rgb_data[i],
static_cast<float>(i % CHANNELS) / CHANNELS, 0, 0, 0);
}
return img;
}, "perlin_warped");
static blt::gp::operation_t op_img_size([]() {
full_image_t img{};
for (float& i : img.rgb_data)
{
i = IMAGE_SIZE;
}
return img;
}, "img_size");
static blt::gp::operation_t op_x_r([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).x;
img.rgb_data[i * CHANNELS] = ctx;
img.rgb_data[i * CHANNELS + 1] = 0;
img.rgb_data[i * CHANNELS + 2] = 0;
}
return img;
}, "x_r");
static blt::gp::operation_t op_x_g([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).x;
img.rgb_data[i * CHANNELS] = 0;
img.rgb_data[i * CHANNELS + 1] = ctx;
img.rgb_data[i * CHANNELS + 2] = 0;
}
return img;
}, "x_g");
static blt::gp::operation_t op_x_b([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).x;
img.rgb_data[i * CHANNELS] = 0;
img.rgb_data[i * CHANNELS + 1] = 0;
img.rgb_data[i * CHANNELS + 2] = ctx;
}
return img;
}, "x_b");
static blt::gp::operation_t op_y_r([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).y;
img.rgb_data[i * CHANNELS] = ctx;
img.rgb_data[i * CHANNELS + 1] = 0;
img.rgb_data[i * CHANNELS + 2] = 0;
}
return img;
}, "y_r");
static blt::gp::operation_t op_y_g([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).y;
img.rgb_data[i * CHANNELS] = 0;
img.rgb_data[i * CHANNELS + 1] = ctx;
img.rgb_data[i * CHANNELS + 2] = 0;
}
return img;
}, "y_g");
static blt::gp::operation_t op_y_b([]() {
full_image_t img{};
for (blt::size_t i = 0; i < DATA_SIZE; i++)
{
auto ctx = get_ctx(i).y;
img.rgb_data[i * CHANNELS] = 0;
img.rgb_data[i * CHANNELS + 1] = 0;
img.rgb_data[i * CHANNELS + 2] = ctx;
}
return img;
}, "y_b");
constexpr float compare_values(float a, float b)
{
if (std::isnan(a) || std::isnan(b) || std::isinf(a) || std::isinf(b))
@ -320,11 +561,39 @@ void init(const blt::gfx::window_data&)
BLT_DEBUG("Setup Types and Operators");
type_system.register_type<full_image_t>();
type_system.register_type<float>();
blt::gp::operator_builder<context> builder{type_system};
create_image_operations(builder);
create_float_operations(builder);
builder.add_operator(perlin);
builder.add_operator(perlin_terminal);
builder.add_operator(perlin_warped);
builder.add_operator(add);
builder.add_operator(sub);
builder.add_operator(mul);
builder.add_operator(pro_div);
builder.add_operator(op_sin);
builder.add_operator(op_cos);
builder.add_operator(op_atan);
builder.add_operator(op_exp);
builder.add_operator(op_log);
builder.add_operator(op_abs);
builder.add_operator(op_v_mod);
builder.add_operator(bitwise_and);
builder.add_operator(bitwise_or);
builder.add_operator(bitwise_invert);
builder.add_operator(bitwise_xor);
builder.add_operator(dissolve);
builder.add_operator(hsv_to_rgb);
builder.add_operator(lit, true);
builder.add_operator(random_val);
const bool state = false;
builder.add_operator(op_x_r, true);
builder.add_operator(op_x_g, true);
builder.add_operator(op_x_b, state);
builder.add_operator(op_y_r, state);
builder.add_operator(op_y_g, state);
builder.add_operator(op_y_b, state);
program.set_operations(builder.build());
@ -367,9 +636,8 @@ void update(const blt::gfx::window_data& data)
const auto mouse_pos = blt::make_vec2(blt::gfx::calculateRay2D(data.width, data.height, global_matrices.getScale2D(), global_matrices.getView2D(),
global_matrices.getOrtho()));
for (blt::size_t i = 0; i < program.get_current_pop().get_individuals().size(); i++)
for (blt::size_t i = 0; i < config.population_size; i++)
{
auto& ind = program.get_current_pop().get_individuals()[i];
auto ctx = get_pop_ctx(i);
float x = ctx.x * IMAGE_SIZE + ctx.x * IMAGE_PADDING;
float y = ctx.y * IMAGE_SIZE + ctx.y * IMAGE_PADDING;
@ -384,6 +652,7 @@ void update(const blt::gfx::window_data& data)
renderer_2d.drawRectangleInternal(blt::make_color(0.9, 0.9, 0.3),
{x, y, IMAGE_SIZE + IMAGE_PADDING / 2.0f, IMAGE_SIZE + IMAGE_PADDING / 2.0f},
10.0f);
auto& ind = program.get_current_pop().get_individuals()[i];
auto& io = ImGui::GetIO();
@ -412,9 +681,8 @@ void update(const blt::gfx::window_data& data)
hovered_fitness_value = fitness_values[i];
}
auto val = static_cast<float>(ind.fitness.adjusted_fitness);
renderer_2d.drawRectangleInternal(
blt::make_color(val, val, val),
blt::make_vec4(blt::vec3(static_cast<float>(program.get_current_pop().get_individuals()[i].fitness.adjusted_fitness)), 1.0),
{x, y, IMAGE_SIZE + IMAGE_PADDING / 2.0f, IMAGE_SIZE + IMAGE_PADDING / 2.0f},
5.0f);