15 uint16_t dx, uint16_t dy);
18 uint8_t v11, uint8_t dx, uint8_t dy);
21 uint16_t inputWidth, uint16_t inputHeight,
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;
28 for (uint16_t
y = 0;
y < outputHeight;
y++) {
29 for (uint16_t
x = 0;
x < outputWidth;
x++) {
31 uint32_t fx = ((uint32_t)
x * (inputWidth - 1) * scale_factor) /
33 uint32_t fy = ((uint32_t)
y * (inputHeight - 1) * scale_factor) /
36 uint16_t ix = fx / scale_factor;
37 uint16_t iy = fy / scale_factor;
38 uint16_t dx = fx % scale_factor;
39 uint16_t dy = fy % scale_factor;
41 uint16_t ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
42 uint16_t iy1 = (iy + 1 < inputHeight) ? iy + 1 : iy;
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;
49 CRGB c00 = input[i00];
50 CRGB c10 = input[i10];
51 CRGB c01 = input[i01];
52 CRGB c11 = input[i11];
59 uint16_t idx =
xyMap.mapToIndex(
x,
y);
67 uint16_t dx, uint16_t dy) {
68 uint16_t dx_inv = 256 - dx;
69 uint16_t dy_inv = 256 - dy;
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;
76 uint32_t sum = v00 * w00 + v10 * w10 + v01 * w01 + v11 * w11;
80 uint8_t result = (uint8_t)((sum + 32768) >> 16);
87 uint8_t width =
xyMap.getWidth();
88 uint8_t height =
xyMap.getHeight();
89 if (width !=
xyMap.getWidth() || height !=
xyMap.getHeight()) {
93 uint16_t n =
xyMap.getTotal();
95 for (uint8_t
y = 0;
y < height;
y++) {
96 for (uint8_t
x = 0;
x < width;
x++) {
99 uint16_t fx = ((uint16_t)
x * (inputWidth - 1) * 256) / (width - 1);
101 ((uint16_t)
y * (inputHeight - 1) * 256) / (height - 1);
103 uint8_t ix = fx >> 8;
104 uint8_t iy = fy >> 8;
105 uint8_t dx = fx & 0xFF;
106 uint8_t dy = fy & 0xFF;
108 uint8_t ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
109 uint8_t iy1 = (iy + 1 < inputHeight) ? iy + 1 : iy;
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;
116 CRGB c00 = input[i00];
117 CRGB c10 = input[i10];
118 CRGB c01 = input[i01];
119 CRGB c11 = input[i11];
129 uint16_t idx =
xyMap.mapToIndex(
x,
y);
131 output[idx] = result;
138 uint8_t v11, uint8_t dx, uint8_t dy) {
139 uint16_t dx_inv = 256 - dx;
140 uint16_t dy_inv = 256 - dy;
143 uint16_t w00 = (dx_inv * dy_inv) >> 8;
144 uint16_t w10 = (dx * dy_inv) >> 8;
145 uint16_t w01 = (dx_inv * dy) >> 8;
146 uint16_t w11 = (dx * dy) >> 8;
149 uint16_t weight_sum = w00 + w10 + w01 + w11;
152 uint16_t sum = v00 * w00 + v10 * w10 + v01 * w01 + v11 * w11;
155 uint8_t result = (sum + (weight_sum >> 1)) / weight_sum;
162 uint8_t v11,
float dx,
float dy) {
163 float dx_inv = 1.0f - dx;
164 float dy_inv = 1.0f - dy;
167 float w00 = dx_inv * dy_inv;
168 float w10 = dx * dy_inv;
169 float w01 = dx_inv * dy;
173 float sum = v00 * w00 + v10 * w10 + v01 * w01 + v11 * w11;
176 uint8_t result =
static_cast<uint8_t
>(sum + 0.5f);
183 uint16_t inputWidth, uint16_t inputHeight,
185 uint16_t n =
xyMap.getTotal();
186 uint16_t outputWidth =
xyMap.getWidth();
187 uint16_t outputHeight =
xyMap.getHeight();
189 for (uint16_t
y = 0;
y < outputHeight;
y++) {
190 for (uint16_t
x = 0;
x < outputWidth;
x++) {
193 static_cast<float>(
x) * (inputWidth - 1) / (outputWidth - 1);
195 static_cast<float>(
y) * (inputHeight - 1) / (outputHeight - 1);
197 uint16_t ix =
static_cast<uint16_t
>(fx);
198 uint16_t iy =
static_cast<uint16_t
>(fy);
202 uint16_t ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
203 uint16_t iy1 = (iy + 1 < inputHeight) ? iy + 1 : iy;
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;
210 CRGB c00 = input[i00];
211 CRGB c10 = input[i10];
212 CRGB c01 = input[i01];
213 CRGB c11 = input[i11];
223 uint16_t idx =
xyMap.mapToIndex(
x,
y);
225 output[idx] = result;
234 uint8_t outputWidth =
xyMap.getWidth();
235 uint8_t outputHeight =
xyMap.getHeight();
236 if (outputWidth !=
xyMap.getWidth() || outputHeight !=
xyMap.getHeight()) {
240 uint16_t n =
xyMap.getTotal();
242 for (uint8_t
y = 0;
y < outputHeight;
y++) {
243 for (uint8_t
x = 0;
x < outputWidth;
x++) {
246 static_cast<float>(
x) * (inputWidth - 1) / (outputWidth - 1);
248 static_cast<float>(
y) * (inputHeight - 1) / (outputHeight - 1);
250 uint8_t ix =
static_cast<uint8_t
>(fx);
251 uint8_t iy =
static_cast<uint8_t
>(fy);
255 uint8_t ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
256 uint8_t iy1 = (iy + 1 < inputHeight) ? iy + 1 : iy;
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;
263 CRGB c00 = input[i00];
264 CRGB c10 = input[i10];
265 CRGB c01 = input[i01];
266 CRGB c11 = input[i11];
276 uint16_t idx =
xyMap.mapToIndex(
x,
y);
278 output[idx] = result;
XYMap xyMap(WIDTH, HEIGHT, false)
Demonstrates how to mix noise generation with color palettes on a 2D LED matrix.
Defines the red, green, and blue (RGB) pixel struct.
Implements the FastLED namespace macros.
uint8_t bilinearInterpolate(uint8_t v00, uint8_t v10, uint8_t v01, uint8_t v11, uint16_t dx, uint16_t dy)
uint8_t bilinearInterpolatePowerOf2(uint8_t v00, uint8_t v10, uint8_t v01, uint8_t v11, uint8_t dx, uint8_t dy)
void bilinearExpandArbitraryFloat(const CRGB *input, CRGB *output, uint16_t inputWidth, uint16_t inputHeight, XYMap xyMap)
void bilinearExpandFloat(const CRGB *input, CRGB *output, uint8_t inputWidth, uint8_t inputHeight, XYMap xyMap)
uint8_t bilinearInterpolateFloat(uint8_t v00, uint8_t v10, uint8_t v01, uint8_t v11, float dx, float dy)
void bilinearExpandArbitrary(const CRGB *input, CRGB *output, uint16_t inputWidth, uint16_t inputHeight, XYMap xyMap)
Performs bilinear interpolation for upscaling an image.
void bilinearExpandPowerOf2(const CRGB *input, CRGB *output, uint8_t inputWidth, uint8_t inputHeight, XYMap xyMap)
Performs bilinear interpolation for upscaling an image.
Implements a simple red square effect for 2D LED grids.
Representation of an RGB pixel (Red, Green, Blue)