FastLED 3.9.15
Loading...
Searching...
No Matches
upscale.cpp
Go to the documentation of this file.
1
4
5#include <stdint.h>
6
7#include "crgb.h"
8#include "fl/namespace.h"
9#include "fl/upscale.h"
10#include "fl/xymap.h"
11
12namespace fl {
13
14uint8_t bilinearInterpolate(uint8_t v00, uint8_t v10, uint8_t v01, uint8_t v11,
15 uint16_t dx, uint16_t dy);
16
17uint8_t bilinearInterpolatePowerOf2(uint8_t v00, uint8_t v10, uint8_t v01,
18 uint8_t v11, uint8_t dx, uint8_t dy);
19
20void upscaleArbitrary(const CRGB *input, CRGB *output, uint16_t inputWidth,
21 uint16_t inputHeight, XYMap xyMap) {
22 uint16_t n = xyMap.getTotal();
23 uint16_t outputWidth = xyMap.getWidth();
24 uint16_t outputHeight = xyMap.getHeight();
25 const uint16_t scale_factor = 256; // Using 8 bits for the fractional part
26
27 for (uint16_t y = 0; y < outputHeight; y++) {
28 for (uint16_t x = 0; x < outputWidth; x++) {
29 // Calculate the corresponding position in the input grid
30 uint32_t fx = ((uint32_t)x * (inputWidth - 1) * scale_factor) /
31 (outputWidth - 1);
32 uint32_t fy = ((uint32_t)y * (inputHeight - 1) * scale_factor) /
33 (outputHeight - 1);
34
35 uint16_t ix = fx / scale_factor; // Integer part of x
36 uint16_t iy = fy / scale_factor; // Integer part of y
37 uint16_t dx = fx % scale_factor; // Fractional part of x
38 uint16_t dy = fy % scale_factor; // Fractional part of y
39
40 uint16_t ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
41 uint16_t iy1 = (iy + 1 < inputHeight) ? iy + 1 : iy;
42
43 uint16_t i00 = iy * inputWidth + ix;
44 uint16_t i10 = iy * inputWidth + ix1;
45 uint16_t i01 = iy1 * inputWidth + ix;
46 uint16_t i11 = iy1 * inputWidth + ix1;
47
48 CRGB c00 = input[i00];
49 CRGB c10 = input[i10];
50 CRGB c01 = input[i01];
51 CRGB c11 = input[i11];
52
53 CRGB result;
54 result.r = bilinearInterpolate(c00.r, c10.r, c01.r, c11.r, dx, dy);
55 result.g = bilinearInterpolate(c00.g, c10.g, c01.g, c11.g, dx, dy);
56 result.b = bilinearInterpolate(c00.b, c10.b, c01.b, c11.b, dx, dy);
57
58 uint16_t idx = xyMap.mapToIndex(x, y);
59 if (idx < n) {
60 output[idx] = result;
61 }
62 }
63 }
64}
65uint8_t bilinearInterpolate(uint8_t v00, uint8_t v10, uint8_t v01, uint8_t v11,
66 uint16_t dx, uint16_t dy) {
67 uint16_t dx_inv = 256 - dx;
68 uint16_t dy_inv = 256 - dy;
69
70 uint32_t w00 = (uint32_t)dx_inv * dy_inv;
71 uint32_t w10 = (uint32_t)dx * dy_inv;
72 uint32_t w01 = (uint32_t)dx_inv * dy;
73 uint32_t w11 = (uint32_t)dx * dy;
74
75 uint32_t sum = v00 * w00 + v10 * w10 + v01 * w01 + v11 * w11;
76
77 // Normalize the result by dividing by 65536 (shift right by 16 bits),
78 // with rounding
79 uint8_t result = (uint8_t)((sum + 32768) >> 16);
80
81 return result;
82}
83
84void upscalePowerOf2(const CRGB *input, CRGB *output, uint8_t inputWidth,
85 uint8_t inputHeight, XYMap xyMap) {
86 uint8_t width = xyMap.getWidth();
87 uint8_t height = xyMap.getHeight();
88 if (width != xyMap.getWidth() || height != xyMap.getHeight()) {
89 // xyMap has width and height that do not fit in an uint16_t.
90 return;
91 }
92 uint16_t n = xyMap.getTotal();
93
94 for (uint8_t y = 0; y < height; y++) {
95 for (uint8_t x = 0; x < width; x++) {
96 // Use 8-bit fixed-point arithmetic with 8 fractional bits
97 // (scale factor of 256)
98 uint16_t fx = ((uint16_t)x * (inputWidth - 1) * 256) / (width - 1);
99 uint16_t fy =
100 ((uint16_t)y * (inputHeight - 1) * 256) / (height - 1);
101
102 uint8_t ix = fx >> 8; // Integer part
103 uint8_t iy = fy >> 8;
104 uint8_t dx = fx & 0xFF; // Fractional part
105 uint8_t dy = fy & 0xFF;
106
107 uint8_t ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
108 uint8_t iy1 = (iy + 1 < inputHeight) ? iy + 1 : iy;
109
110 uint16_t i00 = iy * inputWidth + ix;
111 uint16_t i10 = iy * inputWidth + ix1;
112 uint16_t i01 = iy1 * inputWidth + ix;
113 uint16_t i11 = iy1 * inputWidth + ix1;
114
115 CRGB c00 = input[i00];
116 CRGB c10 = input[i10];
117 CRGB c01 = input[i01];
118 CRGB c11 = input[i11];
119
120 CRGB result;
121 result.r =
122 bilinearInterpolatePowerOf2(c00.r, c10.r, c01.r, c11.r, dx, dy);
123 result.g =
124 bilinearInterpolatePowerOf2(c00.g, c10.g, c01.g, c11.g, dx, dy);
125 result.b =
126 bilinearInterpolatePowerOf2(c00.b, c10.b, c01.b, c11.b, dx, dy);
127
128 uint16_t idx = xyMap.mapToIndex(x, y);
129 if (idx < n) {
130 output[idx] = result;
131 }
132 }
133 }
134}
135
136uint8_t bilinearInterpolatePowerOf2(uint8_t v00, uint8_t v10, uint8_t v01,
137 uint8_t v11, uint8_t dx, uint8_t dy) {
138 uint16_t dx_inv = 256 - dx; // 0 to 256
139 uint16_t dy_inv = 256 - dy; // 0 to 256
140
141 // Scale down weights to fit into uint16_t
142 uint16_t w00 = (dx_inv * dy_inv) >> 8; // Max value 256
143 uint16_t w10 = (dx * dy_inv) >> 8;
144 uint16_t w01 = (dx_inv * dy) >> 8;
145 uint16_t w11 = (dx * dy) >> 8;
146
147 // Sum of weights should be approximately 256
148 uint16_t weight_sum = w00 + w10 + w01 + w11;
149
150 // Compute the weighted sum of pixel values
151 uint16_t sum = v00 * w00 + v10 * w10 + v01 * w01 + v11 * w11;
152
153 // Normalize the result
154 uint8_t result = (sum + (weight_sum >> 1)) / weight_sum;
155
156 return result;
157}
158
159// Floating-point version of bilinear interpolation
160uint8_t upscaleFloat(uint8_t v00, uint8_t v10, uint8_t v01,
161 uint8_t v11, float dx, float dy) {
162 float dx_inv = 1.0f - dx;
163 float dy_inv = 1.0f - dy;
164
165 // Calculate the weights for each corner
166 float w00 = dx_inv * dy_inv;
167 float w10 = dx * dy_inv;
168 float w01 = dx_inv * dy;
169 float w11 = dx * dy;
170
171 // Compute the weighted sum
172 float sum = v00 * w00 + v10 * w10 + v01 * w01 + v11 * w11;
173
174 // Clamp the result to [0, 255] and round
175 uint8_t result = static_cast<uint8_t>(sum + 0.5f);
176
177 return result;
178}
179
180// Floating-point version for arbitrary grid sizes
181void upscaleArbitraryFloat(const CRGB *input, CRGB *output, uint16_t inputWidth,
182 uint16_t inputHeight, XYMap xyMap) {
183 uint16_t n = xyMap.getTotal();
184 uint16_t outputWidth = xyMap.getWidth();
185 uint16_t outputHeight = xyMap.getHeight();
186
187 for (uint16_t y = 0; y < outputHeight; y++) {
188 for (uint16_t x = 0; x < outputWidth; x++) {
189 // Map output pixel to input grid position
190 float fx =
191 static_cast<float>(x) * (inputWidth - 1) / (outputWidth - 1);
192 float fy =
193 static_cast<float>(y) * (inputHeight - 1) / (outputHeight - 1);
194
195 uint16_t ix = static_cast<uint16_t>(fx);
196 uint16_t iy = static_cast<uint16_t>(fy);
197 float dx = fx - ix;
198 float dy = fy - iy;
199
200 uint16_t ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
201 uint16_t iy1 = (iy + 1 < inputHeight) ? iy + 1 : iy;
202
203 uint16_t i00 = iy * inputWidth + ix;
204 uint16_t i10 = iy * inputWidth + ix1;
205 uint16_t i01 = iy1 * inputWidth + ix;
206 uint16_t i11 = iy1 * inputWidth + ix1;
207
208 CRGB c00 = input[i00];
209 CRGB c10 = input[i10];
210 CRGB c01 = input[i01];
211 CRGB c11 = input[i11];
212
213 CRGB result;
214 result.r =
215 upscaleFloat(c00.r, c10.r, c01.r, c11.r, dx, dy);
216 result.g =
217 upscaleFloat(c00.g, c10.g, c01.g, c11.g, dx, dy);
218 result.b =
219 upscaleFloat(c00.b, c10.b, c01.b, c11.b, dx, dy);
220
221 uint16_t idx = xyMap.mapToIndex(x, y);
222 if (idx < n) {
223 output[idx] = result;
224 }
225 }
226 }
227}
228
229// Floating-point version for power-of-two grid sizes
230void upscaleFloat(const CRGB *input, CRGB *output, uint8_t inputWidth,
231 uint8_t inputHeight, XYMap xyMap) {
232 uint8_t outputWidth = xyMap.getWidth();
233 uint8_t outputHeight = xyMap.getHeight();
234 if (outputWidth != xyMap.getWidth() || outputHeight != xyMap.getHeight()) {
235 // xyMap has width and height that do not fit in a uint8_t.
236 return;
237 }
238 uint16_t n = xyMap.getTotal();
239
240 for (uint8_t y = 0; y < outputHeight; y++) {
241 for (uint8_t x = 0; x < outputWidth; x++) {
242 // Map output pixel to input grid position
243 float fx =
244 static_cast<float>(x) * (inputWidth - 1) / (outputWidth - 1);
245 float fy =
246 static_cast<float>(y) * (inputHeight - 1) / (outputHeight - 1);
247
248 uint8_t ix = static_cast<uint8_t>(fx);
249 uint8_t iy = static_cast<uint8_t>(fy);
250 float dx = fx - ix;
251 float dy = fy - iy;
252
253 uint8_t ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
254 uint8_t iy1 = (iy + 1 < inputHeight) ? iy + 1 : iy;
255
256 uint16_t i00 = iy * inputWidth + ix;
257 uint16_t i10 = iy * inputWidth + ix1;
258 uint16_t i01 = iy1 * inputWidth + ix;
259 uint16_t i11 = iy1 * inputWidth + ix1;
260
261 CRGB c00 = input[i00];
262 CRGB c10 = input[i10];
263 CRGB c01 = input[i01];
264 CRGB c11 = input[i11];
265
266 CRGB result;
267 result.r =
268 upscaleFloat(c00.r, c10.r, c01.r, c11.r, dx, dy);
269 result.g =
270 upscaleFloat(c00.g, c10.g, c01.g, c11.g, dx, dy);
271 result.b =
272 upscaleFloat(c00.b, c10.b, c01.b, c11.b, dx, dy);
273
274 uint16_t idx = xyMap.mapToIndex(x, y);
275 if (idx < n) {
276 output[idx] = result;
277 }
278 }
279 }
280}
281
282} // namespace fl
x
uint32_t x[NUM_LAYERS]
Definition Fire2023.ino:82
y
uint32_t y[NUM_LAYERS]
Definition Fire2023.ino:83
crgb.h
Defines the red, green, and blue (RGB) pixel struct.
xyMap
XYMap xyMap
Definition gfx.cpp:8
namespace.h
Implements the FastLED namespace macros.
fl::upscaleArbitrary
void upscaleArbitrary(const CRGB *input, CRGB *output, uint16_t inputWidth, uint16_t inputHeight, XYMap xyMap)
Performs bilinear interpolation for upscaling an image.
Definition upscale.cpp:20
fl::upscaleFloat
uint8_t upscaleFloat(uint8_t v00, uint8_t v10, uint8_t v01, uint8_t v11, float dx, float dy)
Definition upscale.cpp:160
fl::bilinearInterpolate
uint8_t bilinearInterpolate(uint8_t v00, uint8_t v10, uint8_t v01, uint8_t v11, uint16_t dx, uint16_t dy)
Definition upscale.cpp:65
fl::bilinearInterpolatePowerOf2
uint8_t bilinearInterpolatePowerOf2(uint8_t v00, uint8_t v10, uint8_t v01, uint8_t v11, uint8_t dx, uint8_t dy)
Definition upscale.cpp:136
fl::upscalePowerOf2
void upscalePowerOf2(const CRGB *input, CRGB *output, uint8_t inputWidth, uint8_t inputHeight, XYMap xyMap)
Performs bilinear interpolation for upscaling an image.
Definition upscale.cpp:84
fl::upscaleArbitraryFloat
void upscaleArbitraryFloat(const CRGB *input, CRGB *output, uint16_t inputWidth, uint16_t inputHeight, XYMap xyMap)
Definition upscale.cpp:181
fl
Implements a simple red square effect for 2D LED grids.
Definition crgb.h:16
CRGB
Representation of an RGB pixel (Red, Green, Blue)
Definition crgb.h:55