#include <KisColorSmudgeStrategyLightness.h>

Inheritance diagram for KisColorSmudgeStrategyLightness:

Public Member Functions
DabColoringStrategy &	coloringStrategy () override

void	initializePainting () override

	KisColorSmudgeStrategyLightness (KisPainter *painter, bool smearAlpha, bool useDullingMode, KisPaintThicknessOptionData::ThicknessMode thicknessMode)

QVector< QRect >	paintDab (const QRect &srcRect, const QRect &dstRect, const KoColor &currentPaintColor, qreal opacity, qreal colorRateValue, qreal smudgeRateValue, qreal maxPossibleSmudgeRateValue, qreal lightnessStrengthValue, qreal smudgeRadiusValue) override

void	updateMask (KisDabCache dabCache, const KisPaintInformation &info, const KisDabShape &shape, const QPointF &cursorPoint, QRect dstDabRect, qreal lightnessStrength) override

Public Member Functions inherited from KisColorSmudgeStrategyBase
void	blendBrush (const QVector< KisPainter * > dstPainters, KisColorSmudgeSourceSP srcSampleDevice, KisFixedPaintDeviceSP maskDab, bool preserveMaskDab, const QRect &srcRect, const QRect &dstRect, const KoColor &currentPaintColor, qreal opacity, qreal smudgeRateValue, qreal maxPossibleSmudgeRateValue, qreal colorRateValue, qreal smudgeRadiusValue)

void	blendInBackgroundWithDulling (KisFixedPaintDeviceSP dst, KisColorSmudgeSourceSP src, const QRect &dstRect, const KoColor &preparedDullingColor, const qreal smudgeRateOpacity)

void	blendInBackgroundWithSmearing (KisFixedPaintDeviceSP dst, KisColorSmudgeSourceSP src, const QRect &srcRect, const QRect &dstRect, const qreal smudgeRateOpacity)

virtual qreal	colorRateOpacity (qreal opacity, qreal smudgeRateValue, qreal colorRateValue, qreal maxPossibleSmudgeRateValue)

virtual qreal	dullingRateOpacity (qreal opacity, qreal smudgeRateValue)

virtual QString	finalCompositeOp (bool smearAlpha) const

virtual qreal	finalPainterOpacity (qreal opacity, qreal smudgeRateValue)

void	initializePaintingImpl (const KoColorSpace *dstColorSpace, bool smearAlpha, const QString &colorRateCompositeOpId)

	KisColorSmudgeStrategyBase (bool useDullingMode)

const KoColorSpace *	preciseColorSpace () const override

virtual void	sampleDullingColor (const QRect &srcRect, qreal sampleRadiusValue, KisColorSmudgeSourceSP sourceDevice, KisFixedPaintDeviceSP tempFixedDevice, KisFixedPaintDeviceSP maskDab, KoColor *resultColor)

virtual QString	smearCompositeOp (bool smearAlpha) const

virtual qreal	smearRateOpacity (qreal opacity, qreal smudgeRateValue)

Public Member Functions inherited from KisColorSmudgeStrategy
	KisColorSmudgeStrategy ()

virtual	~KisColorSmudgeStrategy ()=default

Private Attributes
DabColoringStrategyMask	m_coloringStrategy

KisPaintDeviceSP	m_colorOnlyDevice

KisPainter	m_finalPainter

KisPaintDeviceSP	m_heightmapDevice

KisPainter	m_heightmapPainter

KisPainter *	m_initializationPainter {nullptr}

KisOverlayPaintDeviceWrapper *	m_layerOverlayDevice {nullptr}

KisFixedPaintDeviceSP	m_maskDab

KisFixedPaintDeviceSP	m_origDab

KisPaintDeviceSP	m_projectionDevice

bool	m_shouldPreserveOriginalDab {true}

bool	m_smearAlpha {true}

KisColorSmudgeSourceSP	m_sourceWrapperDevice

KisPaintThicknessOptionData::ThicknessMode	m_thicknessMode

Additional Inherited Members
Protected Attributes inherited from KisColorSmudgeStrategyBase
const KoCompositeOp *	m_colorRateOp {nullptr}

KoColor	m_preparedDullingColor

const KoCompositeOp *	m_smearOp {nullptr}

Protected Attributes inherited from KisColorSmudgeStrategy
KisOptimizedByteArray::MemoryAllocatorSP	m_memoryAllocator

Detailed Description

Definition at line 14 of file KisColorSmudgeStrategyLightness.h.

Constructor & Destructor Documentation

◆ KisColorSmudgeStrategyLightness()

KisColorSmudgeStrategyLightness::KisColorSmudgeStrategyLightness	(	KisPainter *	painter,
		bool	smearAlpha,
		bool	useDullingMode,
		KisPaintThicknessOptionData::ThicknessMode	thicknessMode )

Definition at line 20 of file KisColorSmudgeStrategyLightness.cpp.

        : KisColorSmudgeStrategyBase(useDullingMode)
        , m_maskDab(new KisFixedPaintDevice(KoColorSpaceRegistry::instance()->alpha8()))
        , m_origDab(new KisFixedPaintDevice(KoColorSpaceRegistry::instance()->rgb8()))
        , m_smearAlpha(smearAlpha)
        , m_initializationPainter(painter)
        , m_thicknessMode(thicknessMode)
{
    KIS_SAFE_ASSERT_RECOVER(thicknessMode == KisPaintThicknessOptionData::OVERLAY ||
                            thicknessMode == KisPaintThicknessOptionData::OVERWRITE) {
 
        thicknessMode = KisPaintThicknessOptionData::OVERLAY;
    }
}

References KIS_SAFE_ASSERT_RECOVER.

Member Function Documentation

◆ coloringStrategy()

KisColorSmudgeStrategyBase::DabColoringStrategy & KisColorSmudgeStrategyLightness::coloringStrategy ( )

overridevirtual

Implements KisColorSmudgeStrategyBase.

Definition at line 85 of file KisColorSmudgeStrategyLightness.cpp.

{
    return m_coloringStrategy;
}

References m_coloringStrategy.

◆ initializePainting()

void KisColorSmudgeStrategyLightness::initializePainting ( )

overridevirtual

Implements KisColorSmudgeStrategy.

Definition at line 36 of file KisColorSmudgeStrategyLightness.cpp.

{
    KisColorSmudgeInterstrokeData *colorSmudgeData =
            dynamic_cast<KisColorSmudgeInterstrokeData*>(m_initializationPainter->device()->interstrokeData().data());
 
    if (colorSmudgeData) {
        m_projectionDevice = colorSmudgeData->projectionDevice;
        m_colorOnlyDevice = colorSmudgeData->colorBlendDevice;
        m_heightmapDevice = colorSmudgeData->heightmapDevice;
        m_layerOverlayDevice = &colorSmudgeData->overlayDeviceWrapper;
    }
 
    KIS_SAFE_ASSERT_RECOVER(colorSmudgeData) {
        m_projectionDevice = new KisPaintDevice(*m_initializationPainter->device());
 
        const KoColorSpace *cs = m_initializationPainter->device()->colorSpace();
        m_projectionDevice->convertTo(
                KoColorSpaceRegistry::instance()->colorSpace(
                        cs->colorModelId().id(),
                        Integer16BitsColorDepthID.id(),
                        cs->profile()));
 
        m_colorOnlyDevice = new KisPaintDevice(*m_projectionDevice);
        m_heightmapDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
        m_heightmapDevice->setDefaultBounds(m_colorOnlyDevice->defaultBounds());
        m_heightmapDevice->setSupportsWraparoundMode(m_colorOnlyDevice->supportsWraproundMode());
    }
 
    initializePaintingImpl(m_colorOnlyDevice->colorSpace(),
                           m_smearAlpha,
                           m_initializationPainter->compositeOpId());
 
    m_heightmapPainter.begin(m_heightmapDevice);
 
    // we should read data from the color layer, not from the final projection layer
    m_sourceWrapperDevice = toQShared(new KisColorSmudgeSourcePaintDevice(*m_layerOverlayDevice, 1));
 
    m_finalPainter.begin(m_colorOnlyDevice);
    m_finalPainter.setCompositeOpId(COMPOSITE_COPY);
    m_finalPainter.setSelection(m_initializationPainter->selection());
    m_finalPainter.setChannelFlags(m_initializationPainter->channelFlags());
    m_finalPainter.copyMirrorInformationFrom(m_initializationPainter);
 
    m_heightmapPainter.setCompositeOpId(COMPOSITE_OVER);
    m_heightmapPainter.setSelection(m_initializationPainter->selection());
    m_heightmapPainter.copyMirrorInformationFrom(m_initializationPainter);
 
}

References KisPainter::begin(), KisPainter::channelFlags(), KisColorSmudgeInterstrokeData::colorBlendDevice, KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), COMPOSITE_COPY, COMPOSITE_OVER, KisPainter::compositeOpId, KisPaintDevice::convertTo(), KisPainter::copyMirrorInformationFrom(), KisPaintDevice::defaultBounds(), KisPainter::device, KisColorSmudgeInterstrokeData::heightmapDevice, KoID::id(), KisColorSmudgeStrategyBase::initializePaintingImpl(), KoColorSpaceRegistry::instance(), Integer16BitsColorDepthID, KisPaintDevice::interstrokeData(), KIS_SAFE_ASSERT_RECOVER, m_colorOnlyDevice, m_finalPainter, m_heightmapDevice, m_heightmapPainter, m_initializationPainter, m_layerOverlayDevice, m_projectionDevice, m_smearAlpha, m_sourceWrapperDevice, KisColorSmudgeInterstrokeData::overlayDeviceWrapper, KoColorSpace::profile(), KisColorSmudgeInterstrokeData::projectionDevice, KisPainter::selection, KisPainter::setChannelFlags(), KisPainter::setCompositeOpId(), KisPaintDevice::setDefaultBounds(), KisPainter::setSelection(), KisPaintDevice::setSupportsWraparoundMode(), KisPaintDevice::supportsWraproundMode(), and toQShared().

◆ paintDab()

QVector< QRect > KisColorSmudgeStrategyLightness::paintDab	(	const QRect &	srcRect,
		const QRect &	dstRect,
		const KoColor &	currentPaintColor,
		qreal	opacity,
		qreal	colorRateValue,
		qreal	smudgeRateValue,
		qreal	maxPossibleSmudgeRateValue,
		qreal	lightnessStrengthValue,
		qreal	smudgeRadiusValue )

overridevirtual

Implements KisColorSmudgeStrategy.

Definition at line 138 of file KisColorSmudgeStrategyLightness.cpp.

{
    const int numPixels = dstRect.width() * dstRect.height();
 
    const QVector<QRect> mirroredRects = m_finalPainter.calculateAllMirroredRects(dstRect);
 
    QVector<QRect> readRects;
    readRects << mirroredRects;
    readRects << srcRect;
    m_sourceWrapperDevice->readRects(readRects);
 
 
    blendBrush({ &m_finalPainter },
        m_sourceWrapperDevice,
        m_maskDab, m_shouldPreserveOriginalDab,
        srcRect, dstRect,
        currentPaintColor,
        opacity,
        smudgeRateValue,
        maxPossibleSmudgeRateValue,
        colorRateValue,
        smudgeRadiusValue);
 
 
    const qreal overlaySmearRate = smudgeRateValue - 0.01; //adjust so minimum value is 0 instead of 1%
    const qreal overlayAdjustment =
        (m_thicknessMode == KisPaintThicknessOptionData::ThicknessMode::OVERWRITE) ?
        1.0 : KisAlgebra2D::lerp(overlaySmearRate, 1.0, paintThicknessValue);
    const qreal brushHeightmapOpacity = opacity * overlayAdjustment;
    m_heightmapPainter.setOpacityF(brushHeightmapOpacity);
    m_heightmapPainter.bltFixed(dstRect.topLeft(), m_origDab, m_origDab->bounds());
    m_heightmapPainter.renderMirrorMaskSafe(dstRect, m_origDab, m_shouldPreserveOriginalDab);
 
 
    KisFixedPaintDeviceSP tempColorDevice =
        new KisFixedPaintDevice(m_colorOnlyDevice->colorSpace(), m_memoryAllocator);
 
    KisFixedPaintDeviceSP tempHeightmapDevice =
        new KisFixedPaintDevice(m_heightmapDevice->colorSpace(), m_memoryAllocator);
 
    Q_FOREACH(const QRect& rc, mirroredRects) {
        tempColorDevice->setRect(rc);
        tempColorDevice->lazyGrowBufferWithoutInitialization();
 
        tempHeightmapDevice->setRect(rc);
        tempHeightmapDevice->lazyGrowBufferWithoutInitialization();
 
        m_colorOnlyDevice->readBytes(tempColorDevice->data(), rc);
        m_heightmapDevice->readBytes(tempHeightmapDevice->data(), rc);
        tempColorDevice->colorSpace()->
            modulateLightnessByGrayBrush(tempColorDevice->data(),
                reinterpret_cast<const QRgb*>(tempHeightmapDevice->data()),
                1.0,
                numPixels);
        m_projectionDevice->writeBytes(tempColorDevice->data(), tempColorDevice->bounds());
    }
 
    m_layerOverlayDevice->writeRects(mirroredRects);
 
    return mirroredRects;
}

References KisColorSmudgeStrategyBase::blendBrush(), KisPainter::bltFixed(), KisFixedPaintDevice::bounds(), KisPainter::calculateAllMirroredRects(), KisFixedPaintDevice::colorSpace(), KisPaintDevice::colorSpace(), KisFixedPaintDevice::data(), KisFixedPaintDevice::lazyGrowBufferWithoutInitialization(), KisAlgebra2D::lerp(), m_colorOnlyDevice, m_finalPainter, m_heightmapDevice, m_heightmapPainter, m_layerOverlayDevice, m_maskDab, KisColorSmudgeStrategy::m_memoryAllocator, m_origDab, m_projectionDevice, m_shouldPreserveOriginalDab, m_sourceWrapperDevice, m_thicknessMode, KisPaintDevice::readBytes(), KisPainter::renderMirrorMaskSafe(), KisPainter::setOpacityF(), KisFixedPaintDevice::setRect(), KisPaintDevice::writeBytes(), and KisOverlayPaintDeviceWrapper::writeRects().

◆ updateMask()

void KisColorSmudgeStrategyLightness::updateMask	(	KisDabCache *	dabCache,
		const KisPaintInformation &	info,
		const KisDabShape &	shape,
		const QPointF &	cursorPoint,
		QRect *	dstDabRect,
		qreal	lightnessStrength )

overridevirtual

Implements KisColorSmudgeStrategy.

Definition at line 90 of file KisColorSmudgeStrategyLightness.cpp.

{
    m_origDab = dabCache->fetchNormalizedImageDab(m_origDab->colorSpace(),
                                                  cursorPoint,
                                                  shape,
                                                  info,
                                                  1.0,
                                                  dstDabRect);
 
    m_shouldPreserveOriginalDab = !dabCache->needSeparateOriginal();
 
    const int numPixels = m_origDab->bounds().width() * m_origDab->bounds().height();
 
    if (paintThickness < 1.0) {
        if (m_shouldPreserveOriginalDab) {
            m_shouldPreserveOriginalDab = false;
            m_origDab = new KisFixedPaintDevice(*m_origDab);
        }
 
        const int denormedPaintThickness = qRound(paintThickness * 255.0);
        KoBgrU8Traits::Pixel *pixelPtr = reinterpret_cast<KoBgrU8Traits::Pixel *>(m_origDab->data());
        for (int i = 0; i < numPixels; i++) {
            int gray = pixelPtr->red - 127;
 
            if (gray >= 0) {
                gray = KoColorSpaceMaths<quint8>::multiply(gray, denormedPaintThickness);
            } else {
                gray = -KoColorSpaceMaths<quint8>::multiply(-gray, denormedPaintThickness);
            }
 
            gray = qBound(0, gray + 127, 255);
 
            pixelPtr->red = gray;
            pixelPtr->green = gray;
            pixelPtr->blue = gray;
 
            pixelPtr++;
        }
    }
 
    m_maskDab->setRect(m_origDab->bounds());
    m_maskDab->lazyGrowBufferWithoutInitialization();
    m_origDab->colorSpace()->copyOpacityU8(m_origDab->data(), m_maskDab->data(), numPixels);
}