upscalePowerOf2()

void fl::upscalePowerOf2	(	const CRGB *	input,
		CRGB *	output,
		u8	inputWidth,
		u8	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 170 of file upscale.cpp.

                                                         {
    u8 width = xyMap.getWidth();
    u8 height = xyMap.getHeight();
    if (width != xyMap.getWidth() || height != xyMap.getHeight()) {
        // xyMap has width and height that do not fit in an u16.
        return;
    }
    u16 n = xyMap.getTotal();
 
    for (u8 y = 0; y < height; y++) {
        for (u8 x = 0; x < width; x++) {
            // Use 8-bit fixed-point arithmetic with 8 fractional bits
            // (scale factor of 256)
            u16 fx = ((u16)x * (inputWidth - 1) * 256) / (width - 1);
            u16 fy =
                ((u16)y * (inputHeight - 1) * 256) / (height - 1);
 
            u8 ix = fx >> 8; // Integer part
            u8 iy = fy >> 8;
            u8 dx = fx & 0xFF; // Fractional part
            u8 dy = fy & 0xFF;
 
            u8 ix1 = (ix + 1 < inputWidth) ? ix + 1 : ix;
            u8 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 =
                bilinearInterpolatePowerOf2(c00.r, c10.r, c01.r, c11.r, dx, dy);
            result.g =
                bilinearInterpolatePowerOf2(c00.g, c10.g, c01.g, c11.g, dx, dy);
            result.b =
                bilinearInterpolatePowerOf2(c00.b, c10.b, c01.b, c11.b, dx, dy);
 
            u16 idx = xyMap.mapToIndex(x, y);
            if (idx < n) {
                output[idx] = result;
            }
        }
    }
}

References bilinearInterpolatePowerOf2(), 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: