KisColorSmudgeSampleUtils Namespace Reference

Classes
struct	AveragedSampleWrapper
struct	WeightedSampleWrapper

Functions
template<class WeightingModeWrapper >
void	sampleColor (const QRect &srcRect, qreal sampleRadiusValue, KisColorSmudgeSourceSP sourceDevice, KisFixedPaintDeviceSP tempFixedDevice, KisFixedPaintDeviceSP maskDab, KoColor *resultColor)

Function Documentation

sampleColor()

template<class WeightingModeWrapper >

void KisColorSmudgeSampleUtils::sampleColor	(	const QRect &	srcRect,
		qreal	sampleRadiusValue,
		KisColorSmudgeSourceSP	sourceDevice,
		KisFixedPaintDeviceSP	tempFixedDevice,
		KisFixedPaintDeviceSP	maskDab,
		KoColor *	resultColor )

Sample color from srcRect in weighted way

The function samples srcRect in an efficient way. It samples "random" pixels using Halton sequence and waits until the sampled color "converges" to stable value. The sampled area is defined by sampleRadiusValue.

The way of weighting the pixels is defined by WeightingModeWrapper template policy. If WeightedSampleWrapper is used, then the sampled color is weighted by the passed brush mask in maskDab. If AveragedSampleWrapper is used, then maskDab is not used and all sampled pixels are averaged in a uniform way.

Parameters

sampleRadiusValue

defines how many pixels are sampled. When sampleRadiusValue is 0.0, only the central pixel is sampled. When sampleRadiusValue is 1.0, the entire range of srcRect is sampled. If AveragedSampleWrapper is used, then sampleRadiusValue may be increased up to 3.0 to sample outside srcRect.

When WeightedSampleWrapper is used, the sampler may sample more pixels than actually requested by sampleRadiusValue. It may happen if all the pixels in the sample radius area are masked out by maskDab.

Parameters

tempFixedDevice

is a temporary device that may be used by the function for internal purposes.

Definition at line 135 of file KisColorSmudgeSampleUtils.h.

{
    WeightingModeWrapper::verifySampleRadiusValue(&sampleRadiusValue);
 
    KIS_ASSERT_RECOVER_RETURN(*resultColor->colorSpace() == *sourceDevice->colorSpace());
    KIS_ASSERT_RECOVER_RETURN(*tempFixedDevice->colorSpace() == *sourceDevice->colorSpace());
 
    const QRect minimalRect = QRect(srcRect.center(), QSize(1,1));
 
    do {
        const QRect sampleRect = sampleRadiusValue > 0 ?
                    KisAlgebra2D::blowRect(srcRect, 0.5 * (sampleRadiusValue - 1.0)) | minimalRect :
                    minimalRect;
 
        tempFixedDevice->setRect(sampleRect);
        tempFixedDevice->lazyGrowBufferWithoutInitialization();
 
        const KoColorSpace *cs = tempFixedDevice->colorSpace();
        const int numPixels = sampleRect.width() * sampleRect.height();
        sourceDevice->readRect(sampleRect);
        sourceDevice->readBytes(tempFixedDevice->data(), sampleRect);
 
        KisAlgebra2D::HaltonSequenceGenerator hGen(2);
        KisAlgebra2D::HaltonSequenceGenerator vGen(3);
 
        QScopedPointer<KoMixColorsOp::Mixer> mixer(cs->mixColorsOp()->createMixer());
 
        const int minSamples =
                qMin(numPixels, qMax(64, qRound(0.02 * numPixels)));
 
        WeightingModeWrapper weightingModeWrapper(mixer.data(),
                                                  maskDab, srcRect,
                                                  tempFixedDevice, sampleRect);
 
        KoColor lastPickedColor(*resultColor);
 
        for (int i = 0; i < minSamples; i++) {
            const QPoint pt(hGen.generate(sampleRect.width() - 1),
                            vGen.generate(sampleRect.height() - 1));
 
            weightingModeWrapper.samplePixel(pt);
        }
 
        mixer->computeMixedColor(resultColor->data());
        lastPickedColor = *resultColor;
 
        const int batchSize = 16;
        int numSamplesLeft = numPixels - minSamples;
 
        while (numSamplesLeft > 0) {
            const int currentBatchSize = qMin(numSamplesLeft, batchSize);
            for (int i = 0; i < currentBatchSize; i++) {
                const QPoint pt(hGen.generate(sampleRect.width() - 1),
                                vGen.generate(sampleRect.height() - 1));
 
                weightingModeWrapper.samplePixel(pt);
            }
 
            mixer->computeMixedColor(resultColor->data());
 
            const quint8 difference =
                    cs->differenceA(resultColor->data(), lastPickedColor.data());
 
            if (difference <= 2) break;
 
            lastPickedColor = *resultColor;
            numSamplesLeft -= currentBatchSize;
        }
 
        if (!weightingModeWrapper.shouldRestartWithBiggerRadius() || sampleRadiusValue >= 1.0) {
            break;
        }
 
        sampleRadiusValue = qMin(1.0, sampleRadiusValue + 0.05);
 
    } while (1);
}

References KisAlgebra2D::blowRect(), KisFixedPaintDevice::colorSpace(), KoColor::colorSpace(), KoMixColorsOp::createMixer(), KisFixedPaintDevice::data(), KoColor::data(), KoColorSpace::differenceA(), KisAlgebra2D::HaltonSequenceGenerator::generate(), KIS_ASSERT_RECOVER_RETURN, KisFixedPaintDevice::lazyGrowBufferWithoutInitialization(), KoColorSpace::mixColorsOp, and KisFixedPaintDevice::setRect().