Method process

Quantize/Quantize.cpp:379–589

    template<bool processR, bool processG, bool processB, bool processA>
    void process(const OfxRectI& procWindow, const OfxPointD& rs)
    {
        unused(rs);
        assert( (!processR && !processG && !processB) || (nComponents == 3 || nComponents == 4) );
        assert( !processA || (nComponents == 1 || nComponents == 4) );
        assert(nComponents == 3 || nComponents == 4);
        float unpPix[4] = {0.f, 0.f, 0.f, 0.f};
        float tmpPix[4] = {0.f, 0.f, 0.f, 0.f};
        // set up a random number generator and set the seed
#ifdef USE_RANDOMGENERATOR
        RandomGenerator randy;
#endif
        double randValue;
        for (int y = procWindow.y1; y < procWindow.y2; y++) {
            if ( _effect.abort() ) {
                break;
            }

            PIX *dstPix = (PIX *) _dstImg->getPixelAddress(procWindow.x1, y);
            for (int x = procWindow.x1; x < procWindow.x2; x++) {
                // for a given x,y position, the output should always be the same.
                if (_dither == eDitherRandom) {
#                 ifdef USE_RANDOMGENERATOR
                    randy.reseed(hash(x + 0x10000 * _seed) + y);
                    randValue = randy.random();
#                 else
                    randValue = hash(hash(hash(_seed ^ x) ^ y) ^ nComponents) / ( (double)0x100000000ULL );
#                 endif
                }

                const PIX *srcPix = (const PIX *)  (_srcImg ? _srcImg->getPixelAddress(x, y) : 0);
                ofxsUnPremult<PIX, nComponents, maxValue>(srcPix, unpPix, _premult, _premultChannel);

                // process the pixel (the actual computation goes here)
                switch (_dither) {
                case eDitherNone: {
                    // no dithering (identical tu Nuke's Posterize)
                    for (int c = 0; c < 4; ++c) {
                        float rounded = (unpPix[c] <= 0) ? std::floor(unpPix[c] * _colors) : std::ceil(unpPix[c] * _colors - 1.);
                        //tmpPix[c] = std::floor(unpPix[c] * _colors) / (_colors - 1.); // ok except when unpPix[c] * _colors is a positive integer
                        tmpPix[c] = rounded / (_colors - 1.);
                    }
                    break;
                }
                case eDitherOrderedBayer2: {
                    // 2x2 Bayer
#undef MSIZE
#define MSIZE 2
                    int subx = x % MSIZE;
                    if (subx < 0) {
                        subx += MSIZE;
                    }
                    int suby = y % MSIZE;
                    if (suby < 0) {
                        suby += MSIZE;
                    }
                    int dith = bayer2[subx][suby];
                    for (int c = 0; c < 4; ++c) {