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