upscaleRectangular()

void fl::upscaleRectangular	(	const CRGB *	input,
		CRGB *	output,
		u16	inputWidth,
		u16	inputHeight,
		u16	outputWidth,
		u16	outputHeight )

Optimized upscale for rectangular/line-by-line XY maps.

Parameters

input	The input grid to read from.
output	The output grid to write into the interpolated values.
inputWidth	The width of the input grid.
inputHeight	The height of the input grid.
outputWidth	The width of the output grid.
outputHeight	The height of the output grid. This version bypasses XY mapping overhead for rectangular layouts.

Definition at line 20 of file upscale.cpp.

                                                                            {
    const u16 scale_factor = 256; // Using 8 bits for the fractional part
 
    for (u16 y = 0; y < outputHeight; y++) {
        for (u16 x = 0; x < outputWidth; x++) {
            // Calculate the corresponding position in the input grid
            u32 fx = ((u32)x * (inputWidth - 1) * scale_factor) /
                          (outputWidth - 1);
            u32 fy = ((u32)y * (inputHeight - 1) * scale_factor) /
                          (outputHeight - 1);
 
            u16 ix = fx / scale_factor; // Integer part of x
            u16 iy = fy / scale_factor; // Integer part of y
            u16 dx = fx % scale_factor; // Fractional part of x
            u16 dy = fy % scale_factor; // Fractional part of y
 
            u16 ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
            u16 iy1 = (iy + 1 < inputHeight) ? iy + 1 : iy;
 
            // Direct array access - no XY mapping overhead
            u16 i00 = iy * inputWidth + ix;
            u16 i10 = iy * inputWidth + ix1;
            u16 i01 = iy1 * inputWidth + ix;
            u16 i11 = iy1 * inputWidth + ix1;
 
            CRGB c00 = input[i00];
            CRGB c10 = input[i10];
            CRGB c01 = input[i01];
            CRGB c11 = input[i11];
 
            CRGB result;
            result.r = bilinearInterpolate(c00.r, c10.r, c01.r, c11.r, dx, dy);
            result.g = bilinearInterpolate(c00.g, c10.g, c01.g, c11.g, dx, dy);
            result.b = bilinearInterpolate(c00.b, c10.b, c01.b, c11.b, dx, dy);
 
            // Direct array access - no XY mapping overhead
            u16 idx = y * outputWidth + x;
            output[idx] = result;
        }
    }
}

References bilinearInterpolate(), x, and y.

Referenced by upscale().

Here is the call graph for this function:

Here is the caller graph for this function: