Function convertNatronImageToCairoImageForComponents

Engine/RotoContext.cpp:2431–2476

template <typename PIX, int maxValue, int srcNComps, int dstNComps>
static void
convertNatronImageToCairoImageForComponents(unsigned char* cairoImg,
                                            std::size_t stride,
                                            Image* image,
                                            const RectI& roi,
                                            const RectI& dstBounds,
                                            double shapeColor[3])
{
    unsigned char* dstPix = cairoImg;

    dstPix += ( (roi.y1 - dstBounds.y1) * stride + (roi.x1 - dstBounds.x1) );

    Image::ReadAccess acc = image->getReadRights();

    for (int y = 0; y < roi.height(); ++y, dstPix += stride) {
        const PIX* srcPix = (const PIX*)acc.pixelAt(roi.x1, roi.y1 + y);
        assert(srcPix);

        for (int x = 0; x < roi.width(); ++x) {
#         ifdef DEBUG_NAN
            for (int c = 0; c < srcNComps; ++c) {
                assert( !std::isnan(srcPix[x * srcNComps + c]) ); // check for NaN
            }
#         endif
            if (dstNComps == 1) {
                dstPix[x] = (float)srcPix[x * srcNComps] * (255.f / maxValue);
            } else if (dstNComps == 4) {
                if (srcNComps == 4) {
                    //We are in the !buildUp case, do exactly the opposite that is done in convertNatronImageToCairoImageForComponents
                    dstPix[x * dstNComps + 0] = shapeColor[2] == 0 ? 0 : (float)(srcPix[x * srcNComps + 2] * (255.f / maxValue) ) / shapeColor[2];
                    dstPix[x * dstNComps + 1] = shapeColor[1] == 0 ? 0 : (float)(srcPix[x * srcNComps + 1] * (255.f / maxValue) ) / shapeColor[1];
                    dstPix[x * dstNComps + 2] = shapeColor[0] == 0 ? 0 : (float)(srcPix[x * srcNComps + 0] * (255.f / maxValue) ) / shapeColor[0];
                    dstPix[x * dstNComps + 3] = 255; //(float)srcPix[x * srcNComps + 3] * (255.f / maxValue);
                } else {
                    assert(srcNComps == 1);
                    float pix = (float)srcPix[x];
                    dstPix[x * dstNComps + 0] = pix * (255.f / maxValue);
                    dstPix[x * dstNComps + 1] = pix * (255.f / maxValue);
                    dstPix[x * dstNComps + 2] = pix * (255.f / maxValue);
                    dstPix[x * dstNComps + 3] = pix * (255.f / maxValue);
                }
            }
            // no need to check for NaN, dstPix is unsigned char
        }
    }
}

template <typename PIX, int maxValue, int srcComps>
static void