1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
#pragma once
#include <stdint.h>
#include <cstring>
#include <cstdio>
namespace daguerre {
typedef uint32_t hilbert_color;
struct rgb24 {
uint8_t r;
uint8_t g;
uint8_t b;
};
template <class color_t>
class image {
public:
bool delete_buffer_on_destruct;
color_t *buffer;
unsigned width;
unsigned height;
unsigned pitch;//in sizeof(color_t)
image()
: delete_buffer_on_destruct(false), buffer(0), width(0), height(0),
pitch(0) {}
image(unsigned width, unsigned height)
: delete_buffer_on_destruct(true), buffer(new color_t[width * height]),
width(width), height(height), pitch(width) {}
image(
color_t *buffer, unsigned width, unsigned height, unsigned pitch,
bool delete_buffer_on_destruct)
: delete_buffer_on_destruct(delete_buffer_on_destruct), buffer(buffer),
width(width), height(height), pitch(pitch) {}
~image() {
if (delete_buffer_on_destruct && buffer)
delete[] buffer;
}
image(const image<color_t> &other) = delete;
image(image<color_t> &&other)
: delete_buffer_on_destruct(other.delete_buffer_on_destruct),
buffer(other.buffer), width(other.width), height(other.height),
pitch(other.pitch) {
other.buffer = 0;
}
image<color_t> &operator =(const image<color_t> &other) = delete;
image<color_t> &operator =(image<color_t> &&other) {
if (delete_buffer_on_destruct && buffer)
delete[] buffer;
delete_buffer_on_destruct = other.delete_buffer_on_destruct;
buffer = other.buffer;
width = other.width;
height = other.height;
pitch = other.pitch;
other.buffer = 0;
return *this;
}
color_t get(unsigned x, unsigned y) const {
return buffer[y * pitch + x];
}
void set(unsigned x, unsigned y, const color_t &c) {
buffer[y * pitch + x] = c;
}
};
//it is assumed that the regions do not overlap in memory.
//copies into [to_x, to_x + width) x [to_y, to_y + height)
//from [from_x, from_x + width) x [from_y, from_y + height).
template <class color_t>
void copy_region(
image<color_t> &to, unsigned to_x, unsigned to_y,
const image<color_t> &from, unsigned from_x, unsigned from_y,
unsigned width, unsigned height) {
color_t *to_start = to.buffer + to.pitch * to_y + to_x;
const color_t *from_start = from.buffer + from.pitch * from_y + from_x;
for (unsigned y = 0; y < height; ++y)
std::memcpy(
to_start + to.pitch * y, from_start + from.pitch * y,
width * sizeof(color_t));
}
//it is assumed that the regions do not overlap in memory.
//copies into [to_x, to_x + width) x [to_y, to_y + height)
//from [from_x, from_x + width) x [from_y, from_y + height).
template <
class to_color_t, class from_color_t,
void overlay(to_color_t &dest, const from_color_t &src)>
void overlay_region(
image<to_color_t> &to, unsigned to_x, unsigned to_y,
const image<from_color_t> &from, unsigned from_x, unsigned from_y,
unsigned width, unsigned height) {
to_color_t *to_start = to.buffer + to.pitch * to_y + to_x;
const from_color_t *from_start =
from.buffer + from.pitch * from_y + from_x;
for (unsigned y = 0; y < height; ++y)
for (unsigned x = 0; x < width; ++x)
overlay(to_start[to.pitch * y + x], from_start[from.pitch * y + x]);
}
static inline void encode(hilbert_color &dest, const rgb24 &src) {
dest = __euler_encode_color(src.r, src.g, src.b);
}
image<hilbert_color> get_hilbert_framebuffer();
bool try_load_ppm(std::FILE *input, image<rgb24> &into);
}
|