stephenseo/blue_noise_generation
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Fixes and Refactorings

Browse source
This commit is contained in:
Stephen Seo 2021-01-23 11:58:16 +09:00
parent ad32671e19
commit 850a5d22a9
2 changed files with 112 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

130
src/blue_noise.cpp
View file

@ -8,115 +8,6 @@
# include <cstdio>
#endif
void dither::internal::recursive_apply_radius(
int idx, int width, int height,
int radius, const std::function<bool(int)>& fn) {
std::unordered_set<int> visited;
#ifndef NDEBUG
if(recursive_apply_radius_impl(idx, width, height, radius, fn, visited)) {
puts("recursive_apply_radius_impl found result");
} else {
puts("recursive_apply_radius_impl did NOT find result");
}
#else
recursive_apply_radius_impl(idx, width, height, radius, fn, visited);
#endif
}
bool dither::internal::recursive_apply_radius_impl(
int idx, int width, int height,
int radius, const std::function<bool(int)>& fn,
std::unordered_set<int>& visited) {
if(fn(idx)) {
return true;
}
int x, y, temp;
std::tie(x, y) = oneToTwo(idx, width);
if(x + 1 < width) {
temp = idx + 1;
if(visited.find(temp) == visited.end()) {
visited.insert(temp);
if(recursive_apply_radius_impl(
temp, width, height, radius - 1, fn, visited)) {
return true;
}
}
} else {
temp = twoToOne(0, y, width);
if(visited.find(temp) == visited.end()) {
visited.insert(temp);
if(recursive_apply_radius_impl(
twoToOne(0, y, width),
width, height, radius - 1,
fn, visited)) {
return true;
}
}
}
if(x > 0) {
temp = idx - 1;
if(visited.find(temp) == visited.end()) {
visited.insert(temp);
if(recursive_apply_radius_impl(
idx - 1, width, height, radius - 1, fn, visited)) {
return true;
}
}
} else {
temp = twoToOne(width - 1, y, width);
if(visited.find(temp) == visited.end()) {
if(recursive_apply_radius_impl(
temp, width, height, radius - 1, fn, visited)) {
return true;
}
}
}
if(y + 1 < height) {
temp = idx + width;
if(visited.find(temp) == visited.end()) {
visited.insert(temp);
if(recursive_apply_radius_impl(
temp, width, height, radius - 1, fn, visited)) {
return true;
}
}
} else {
temp = twoToOne(x, 0, width);
if(visited.find(temp) == visited.end()) {
visited.insert(temp);
if(recursive_apply_radius_impl(
temp, width, height, radius - 1, fn, visited)) {
return true;
}
}
}
if(y > 0) {
temp = idx - width;
if(visited.find(temp) == visited.end()) {
visited.insert(temp);
if(recursive_apply_radius_impl(
temp, width, height, radius - 1, fn, visited)) {
return true;
}
}
} else {
temp = twoToOne(x, height - 1, width);
if(visited.find(temp) == visited.end()) {
visited.insert(temp);
if(recursive_apply_radius_impl(
temp, width, height, radius - 1, fn, visited)) {
return true;
}
}
}
return false;
}
std::vector<bool> dither::blue_noise(int width, int height, int threads) {
int count = width * height;
std::vector<float> filter_out;
@ -167,6 +58,9 @@ std::vector<bool> dither::blue_noise(int width, int height, int threads) {
int filter_size = (width + height) / 2;
internal::compute_filter(pbp, width, height, count, filter_size,
filter_out, threads);
internal::write_filter(filter_out, width, "filter_out_start.pgm");
while(true) {
//#ifndef NDEBUG
// if(++iterations % 10 == 0) {
@ -231,13 +125,29 @@ std::vector<bool> dither::blue_noise(int width, int height, int threads) {
}
}
if(min_zero != second_min) {
if(internal::dist(max_one, second_min, width) < 1.5f) {
pbp[max_one] = true;
break;
} else {
pbp[min_zero] = true;
}
if(iterations % 100 == 0) {
// generate blue_noise image from pbp
FILE *blue_noise_image = fopen("blue_noise.pbm", "w");
fprintf(blue_noise_image, "P1\n%d %d\n", width, height);
for(int y = 0; y < height; ++y) {
for(int x = 0; x < width; ++x) {
fprintf(blue_noise_image, "%d ", pbp[internal::twoToOne(x, y, width)] ? 1 : 0);
}
fputc('\n', blue_noise_image);
}
fclose(blue_noise_image);
}
}
internal::compute_filter(pbp, width, height, count, filter_size,
filter_out, threads);
internal::write_filter(filter_out, width, "filter_out_final.pgm");
//#ifndef NDEBUG
// generate blue_noise image from pbp

126
src/blue_noise.hpp
View file

@ -2,7 +2,7 @@
#define BLUE_NOISE_HPP
#include <vector>
#include <tuple>
#include <utility>
#include <cmath>
#include <functional>
#include <unordered_set>
@ -10,6 +10,8 @@
#include <mutex>
#include <thread>
#include <chrono>
#include <cstdio>
#include <queue>
namespace dither {
@ -20,11 +22,11 @@ namespace internal {
return x + y * width;
}
inline std::tuple<int, int> oneToTwo(int i, int width) {
inline std::pair<int, int> oneToTwo(int i, int width) {
return {i % width, i / width};
}
constexpr float mu_squared = 1.5 * 1.5;
constexpr float mu_squared = 1.5f * 1.5f;
inline float gaussian(float x, float y) {
return std::exp(-(x*x + y*y)/(2*mu_squared));
@ -34,7 +36,7 @@ namespace internal {
const std::vector<bool>& pbp,
int x, int y,
int width, int height, int filter_size) {
float sum = 0.0;
float sum = 0.0f;
// Should be range -M/2 to M/2, but size_t cannot be negative, so range
// is 0 to M.
@ -46,7 +48,7 @@ namespace internal {
int p_prime = (width + filter_size / 2 + x - p) % width;
bool pbp_value = pbp[twoToOne(p_prime, q_prime, width)];
if(pbp_value) {
sum += gaussian((float)p - filter_size/2.0, (float)q - filter_size/2.0);
sum += gaussian((float)p - filter_size/2.0f, (float)q - filter_size/2.0f);
}
}
}
@ -115,9 +117,9 @@ namespace internal {
}
inline std::tuple<int, int> filter_minmax(const std::vector<float>& filter) {
inline std::pair<int, int> filter_minmax(const std::vector<float>& filter) {
float min = std::numeric_limits<float>::infinity();
float max = 0.0;
float max = 0.0f;
int min_index = 0;
int max_index = 0;
@ -135,40 +137,96 @@ namespace internal {
return {min_index, max_index};
}
void recursive_apply_radius(
int idx, int width,
int height, int radius,
const std::function<bool(int)>& fn);
bool recursive_apply_radius_impl(
int idx, int width,
int height, int radius,
const std::function<bool(int)>& fn,
std::unordered_set<int>& visited);
inline int get_one_or_zero(
const std::vector<bool>& pbp, bool get_one,
int idx, int width, int height) {
int found_idx;
bool found = false;
for(int radius = 1; radius <= 12; ++radius) {
recursive_apply_radius(
idx, width, height, radius,
[&found_idx, &found, &pbp, &get_one] (int idx) {
if((get_one && pbp[idx]) || (!get_one && !pbp[idx])) {
found_idx = idx;
found = true;
return true;
} else {
return false;
}
});
if(found) {
return found_idx;
std::queue<int> checking_indices;
auto xy = oneToTwo(idx, width);
int count = 0;
int loops = 0;
enum { D_DOWN = 0, D_LEFT = 1, D_UP = 2, D_RIGHT = 3 } dir = D_RIGHT;
int next;
while(true) {
if(count == 0) {
switch(dir) {
case D_RIGHT:
xy.first = (xy.first + 1) % width;
++loops;
count = loops * 2 - 1;
dir = D_DOWN;
break;
case D_DOWN:
xy.first = (xy.first + width - 1) % width;
count = loops * 2 - 1;
dir = D_LEFT;
break;
case D_LEFT:
xy.second = (xy.second + height - 1) % height;
count = loops * 2 - 1;
dir = D_UP;
break;
case D_UP:
xy.first = (xy.first + 1) % width;
count = loops * 2 - 1;
dir = D_RIGHT;
break;
}
} else {
switch(dir) {
case D_DOWN:
xy.second = (xy.second + 1) % height;
--count;
break;
case D_LEFT:
xy.first = (xy.first + width - 1) % width;
--count;
break;
case D_UP:
xy.second = (xy.second + height - 1) % height;
--count;
break;
case D_RIGHT:
xy.first = (xy.first + 1) % width;
--count;
break;
}
}
next = twoToOne(xy.first, xy.second, width);
if((get_one && pbp[next]) || (!get_one && !pbp[next])) {
return next;
}
}
return idx;
}
inline void write_filter(const std::vector<float> &filter, int width, const char *filename) {
int min, max;
std::tie(min, max) = filter_minmax(filter);
printf("Writing to %s, min is %.3f, max is %.3f\n", filename, filter[min], filter[max]);
FILE *filter_image = fopen(filename, "w");
fprintf(filter_image, "P2\n%d %d\n65535\n", width, (int)filter.size() / width);
for(std::vector<float>::size_type i = 0; i < filter.size(); ++i) {
fprintf(filter_image, "%d ",
(int)(((filter[i] - filter[min])
/ (filter[max] - filter[min]))
* 65535.0f));
if((i + 1) % width == 0) {
fputc('\n', filter_image);
}
}
fclose(filter_image);
}
inline float dist(int a, int b, int width) {
auto axy = oneToTwo(a, width);
auto bxy = oneToTwo(b, width);
float dx = axy.first - bxy.first;
float dy = axy.second - bxy.second;
return std::sqrt(dx * dx + dy * dy);
}
} // namespace dither::internal
} // namespace dither