upscaleArbitrary()

void fl::upscaleArbitrary	(	const CRGB *	input,
		CRGB *	output,
		u16	inputWidth,
		u16	inputHeight,
		const fl::XYMap &	xyMap )

Performs bilinear interpolation for upscaling an image.

Parameters

output	The output grid to write into the interpolated values.
input	The input grid to read from.
inputWidth	The width of the input grid.
inputHeight	The height of the input grid.
xyMap	The XYMap to use to determine where to write the pixel. If the pixel is mapped outside of the range then it is clipped.

Definition at line 106 of file upscale.cpp.

                                                           {
    u16 n = xyMap.getTotal();
    u16 outputWidth = xyMap.getWidth();
    u16 outputHeight = xyMap.getHeight();
    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;
 
            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);
 
            u16 idx = xyMap.mapToIndex(x, y);
            if (idx < n) {
                output[idx] = result;
            }
        }
    }
}

References bilinearInterpolate(), x, xyMap, and y.

Referenced by fl::ScaleUp::expand(), and upscale().

Here is the call graph for this function:

Here is the caller graph for this function: