#include <kis_colorsmudgeop.h>

Inheritance diagram for KisColorSmudgeOp:

Public Member Functions
	KisColorSmudgeOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)

	~KisColorSmudgeOp () override

Public Member Functions inherited from KisBrushBasedPaintOp
bool	canPaint () const override
	Reimplemented, false if brush is 0.

bool	checkSizeTooSmall (qreal scale)

KisSpacingInformation	effectiveSpacing (qreal scale) const

KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisAirbrushOptionData airbrushOption, const KisSpacingOption spacingOption, const KisPaintInformation &pi) const

KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisPaintInformation &pi) const

KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisSpacingOption &spacingOption, const KisPaintInformation &pi) const

	KisBrushBasedPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisBrushTextureFlags textureFlags=None)

	~KisBrushBasedPaintOp () override

Public Member Functions inherited from KisPaintOp
virtual std::pair< int, bool >	doAsynchronousUpdate (QVector< KisRunnableStrokeJobData * > &jobs)

	KisPaintOp (KisPainter *painter)

void	paintAt (const KisPaintInformation &info, KisDistanceInformation *currentDistance)

virtual void	paintBezierCurve (const KisPaintInformation &pi1, const QPointF &control1, const QPointF &control2, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)

virtual void	paintLine (const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)

	Private (KisPaintOp *_q)

void	updateSpacing (const KisPaintInformation &info, KisDistanceInformation &currentDistance) const

void	updateTiming (const KisPaintInformation &info, KisDistanceInformation &currentDistance) const

virtual	~KisPaintOp ()

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Member Functions inherited from KisShared
bool	deref ()

bool	ref ()

int	refCount ()

QAtomicInt *	sharedWeakReference ()

Static Public Member Functions
static KisInterstrokeDataFactory *	createInterstrokeDataFactory (const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface)

Static Public Member Functions inherited from KisBrushBasedPaintOp
static QList< KoResourceLoadResult >	prepareEmbeddedResources (const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface)

static QList< KoResourceLoadResult >	prepareLinkedResources (const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface)

Static Public Member Functions inherited from KisPaintOp
static void	splitCoordinate (qreal coordinate, qint32 whole, qreal fraction)

Protected Member Functions
KisSpacingInformation	paintAt (const KisPaintInformation &info) override

KisSpacingInformation	updateSpacingImpl (const KisPaintInformation &info) const override

KisTimingInformation	updateTimingImpl (const KisPaintInformation &info) const override

Protected Member Functions inherited from KisPaintOp
KisFixedPaintDeviceSP	cachedDab ()

KisFixedPaintDeviceSP	cachedDab (const KoColorSpace *cs)

KisPainter *	painter () const

KisPaintDeviceSP	source () const

Protected Member Functions inherited from KisShared
	KisShared ()

	~KisShared ()

Private Attributes
KisAirbrushOptionData	m_airbrushData

KisColorRateOption2	m_colorRateOption

QRect	m_dstDabRect

bool	m_firstRun

KoAbstractGradientSP	m_gradient

KisGradientOption	m_gradientOption

QList< KisHSVOption * >	m_hsvOptions

KoColorTransformation *	m_hsvTransform {0}

QPointF	m_lastPaintPos

KisOpacityOption	m_opacityOption

KisSmudgeOverlayModeOptionData	m_overlayModeData

KoColor	m_paintColor

KisPaintThicknessOption	m_paintThicknessOption

KisRateOption	m_rateOption

KisRatioOption	m_ratioOption

KisRotationOption	m_rotationOption

KisScatterOption	m_scatterOption

KisSizeOption	m_sizeOption

KisSmudgeRadiusOption2	m_smudgeRadiusOption

KisSmudgeLengthOption	m_smudgeRateOption

KisSpacingOption	m_spacingOption

QScopedPointer< KisColorSmudgeStrategy >	m_strategy

Additional Inherited Members
Public Attributes inherited from KisPaintOp
KisFixedPaintDeviceSP	dab

bool	fanCornersEnabled {false}

qreal	fanCornersStep {1.0}

KisPainter *	painter {nullptr}

KisPaintOp *	q {nullptr}

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Protected Attributes inherited from KisBrushBasedPaintOp
KisBrushSP	m_brush

KisDabCache *	m_dabCache

KisMirrorOption	m_mirrorOption

KisPrecisionOption	m_precisionOption

Detailed Description

Definition at line 41 of file kis_colorsmudgeop.h.

Constructor & Destructor Documentation

◆ KisColorSmudgeOp()

KisColorSmudgeOp::KisColorSmudgeOp	(	const KisPaintOpSettingsSP	settings,
		KisPainter *	painter,
		KisNodeSP	node,
		KisImageSP	image )

color transformation must be created after the color space of m_paintColor has been set up

Definition at line 48 of file kis_colorsmudgeop.cpp.

    : KisBrushBasedPaintOp(settings, painter)
    , m_firstRun(true)
    , m_sizeOption(settings.data())
    , m_ratioOption(settings.data())
    , m_opacityOption(settings.data(), node)
    , m_spacingOption(settings.data())
    , m_rateOption(settings.data())
    , m_rotationOption(settings.data())
    , m_scatterOption(settings.data())
    , m_paintThicknessOption(settings.data())
    , m_gradientOption(settings.data())
    , m_smudgeRateOption(settings.data())
    , m_colorRateOption(settings.data())
    , m_smudgeRadiusOption(settings.data())
{
    Q_UNUSED(node);
    Q_ASSERT(painter);
 
    m_airbrushData.read(settings.data());
    m_overlayModeData.read(settings.data());
 
    m_gradient = painter->gradient();
 
    // useNewEngine should be true if brushApplication is not ALPHAMASK
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_brush->brushApplication() == ALPHAMASK || m_smudgeRateOption.useNewEngine());
 
    const bool useSmearAlpha = m_smudgeRateOption.smearAlpha();
    const bool useDullingMode = m_smudgeRateOption.mode() == KisSmudgeLengthOptionData::DULLING_MODE;
    const bool useOverlayMode = m_overlayModeData.isChecked;
 
    m_rotationOption.applyFanCornersInfo(this);
 
    if (m_brush->brushApplication() == LIGHTNESSMAP) {
        KisPaintThicknessOptionData::ThicknessMode thicknessMode =
            m_paintThicknessOption.isChecked() ?
                m_paintThicknessOption.mode() :
                KisPaintThicknessOptionData::OVERWRITE;
 
        m_strategy.reset(new KisColorSmudgeStrategyLightness(painter,
                                                             useSmearAlpha,
                                                             useDullingMode,
                                                             thicknessMode));
    } else if (m_smudgeRateOption.useNewEngine() &&
               m_brush->brushApplication() == ALPHAMASK) {
        m_strategy.reset(new KisColorSmudgeStrategyMask(painter,
                                                        image,
                                                        useSmearAlpha,
                                                        useDullingMode,
                                                        useOverlayMode));
    } else if (m_brush->brushApplication() == IMAGESTAMP ||
               m_brush->brushApplication() == GRADIENTMAP) {
        m_strategy.reset(new KisColorSmudgeStrategyStamp(painter,
                                                         image,
                                                         useSmearAlpha,
                                                         useDullingMode,
                                                         useOverlayMode));
    } else {
        m_strategy.reset(new KisColorSmudgeStrategyMaskLegacy(painter,
                                                              image,
                                                              useSmearAlpha,
                                                              useDullingMode,
                                                              useOverlayMode));
    }
 
    m_strategy->initializePainting();
    m_paintColor = painter->paintColor().convertedTo(m_strategy->preciseColorSpace());
 
    m_hsvOptions.append(KisHSVOption::createHueOption(settings.data()));
    m_hsvOptions.append(KisHSVOption::createSaturationOption(settings.data()));
    m_hsvOptions.append(KisHSVOption::createValueOption(settings.data()));
 
    Q_FOREACH (KisHSVOption * option, m_hsvOptions) {
        if (option->isChecked() && !m_hsvTransform) {
            m_hsvTransform = m_paintColor.colorSpace()->createColorTransformation("hsv_adjustment", QHash<QString, QVariant>());
        }
    }
}

References ALPHAMASK, KisRotationOption::applyFanCornersInfo(), KoColor::colorSpace(), KoColor::convertedTo(), KoColorSpace::createColorTransformation(), KisHSVOption::createHueOption(), KisHSVOption::createSaturationOption(), KisHSVOption::createValueOption(), KisSharedPtr< T >::data(), KisPainter::gradient, GRADIENTMAP, IMAGESTAMP, KisSmudgeOverlayModeOptionData::isChecked, KisCurveOption::isChecked(), KIS_SAFE_ASSERT_RECOVER_NOOP, LIGHTNESSMAP, m_airbrushData, KisBrushBasedPaintOp::m_brush, m_gradient, m_hsvOptions, m_hsvTransform, m_overlayModeData, m_paintColor, m_paintThicknessOption, m_rotationOption, m_smudgeRateOption, m_strategy, KisPaintThicknessOption::mode(), KisSmudgeLengthOption::mode(), KisPainter::paintColor, KisPaintOp::painter, KisSmudgeOverlayModeOptionData::read(), KisAirbrushOptionData::read(), KisSmudgeLengthOption::smearAlpha(), and KisSmudgeLengthOption::useNewEngine().

◆ ~KisColorSmudgeOp()

KisColorSmudgeOp::~KisColorSmudgeOp ( )

override

Definition at line 129 of file kis_colorsmudgeop.cpp.

{
    qDeleteAll(m_hsvOptions);
    delete m_hsvTransform;
}

References m_hsvOptions, and m_hsvTransform.

Member Function Documentation

◆ createInterstrokeDataFactory()

KisInterstrokeDataFactory * KisColorSmudgeOp::createInterstrokeDataFactory	(	const KisPaintOpSettingsSP	settings,
		KisResourcesInterfaceSP	resourcesInterface )

static

Definition at line 242 of file kis_colorsmudgeop.cpp.

{
 
    KisBrushOptionProperties brushOption;
    const bool needsInterstrokeData =
        brushOption.brushApplication(settings.data(), resourcesInterface) == LIGHTNESSMAP;
 
    const bool needsNewEngine = settings->getBool(QString("SmudgeRate") + "UseNewEngine", false);
    KIS_SAFE_ASSERT_RECOVER_NOOP(!needsInterstrokeData || needsNewEngine);
 
    return needsInterstrokeData ? new ColorSmudgeInterstrokeDataFactory() : 0;
}

References KisBrushOptionProperties::brushApplication(), KisSharedPtr< T >::data(), KIS_SAFE_ASSERT_RECOVER_NOOP, and LIGHTNESSMAP.

◆ paintAt()

KisSpacingInformation KisColorSmudgeOp::paintAt ( const KisPaintInformation & info )

overrideprotectedvirtual

The implementation of painting of a dab and updating spacing. This does NOT need to update the timing information.

Disable handling of the subpixel precision. In the smudge op we should read from the aligned areas of the image, so having additional internal offsets, created by the subpixel precision, will worsen the quality (at least because QRectF(m_dstDabRect).center() will not point to the real center of the brush anymore). Of course, this only really matters with smearing_mode (bug:327235), and you only notice the lack of subpixel precision in the dulling methods.

Save the center of the current dab to know where to read the data during the next pass. We do not save scatteredPos here, because it may differ slightly from the real center of the brush (due to rounding effects), which will result in a really weird quality.

Implements KisPaintOp.

Definition at line 135 of file kis_colorsmudgeop.cpp.

{
    KisBrushSP brush = m_brush;
 
    // Simple error catching
    if (!painter()->device() || !brush || !brush->canPaintFor(info)) {
        return KisSpacingInformation(1.0);
    }
    if (m_smudgeRateOption.mode() == KisSmudgeLengthOptionData::SMEARING_MODE) {
        m_dabCache->disableSubpixelPrecision();
    }
 
    // get the scaling factor calculated by the size option
    qreal scale = m_sizeOption.apply(info);
    scale *= KisLodTransform::lodToScale(painter()->device());
    qreal rotation = m_rotationOption.apply(info);
    if (checkSizeTooSmall(scale)) return KisSpacingInformation();
 
    qreal ratio = m_ratioOption.apply(info);
 
    KisDabShape shape(scale, ratio, rotation);
 
    QPointF scatteredPos =
        m_scatterOption.apply(info,
                              brush->maskWidth(shape, 0, 0, info),
                              brush->maskHeight(shape, 0, 0, info));
 
    const qreal smudgeRadiusPortion = m_smudgeRadiusOption.isChecked() ? m_smudgeRadiusOption.computeSizeLikeValue(info) : 0.0;
 
    KisSpacingInformation spacingInfo =
            effectiveSpacing(scale, rotation,
                             &m_airbrushData, &m_spacingOption, info);
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_strategy, spacingInfo);
 
 
    const qreal paintThickness = m_paintThicknessOption.apply(info);
    m_strategy->updateMask(m_dabCache, info, shape, scatteredPos, &m_dstDabRect, paintThickness);
 
    QPointF newCenterPos = QRectF(m_dstDabRect).center();
    QRect srcDabRect = m_dstDabRect.translated((m_lastPaintPos - newCenterPos).toPoint());
 
    m_lastPaintPos = newCenterPos;
 
    if (m_firstRun) {
        m_firstRun = false;
        return spacingInfo;
    }
 
    const qreal colorRate = m_colorRateOption.isChecked() ? m_colorRateOption.computeSizeLikeValue(info) : 0.0;
    const qreal smudgeRate = m_smudgeRateOption.isChecked() ? m_smudgeRateOption.computeSizeLikeValue(info) : 1.0;
    const qreal maxSmudgeRate = m_smudgeRateOption.strengthValue();
    const qreal fpOpacity = m_opacityOption.apply(info);
 
    KoColor paintColor = m_paintColor;
 
    m_gradientOption.apply(paintColor, m_gradient, info);
    if (m_hsvTransform) {
        Q_FOREACH (KisHSVOption *option, m_hsvOptions) {
            option->apply(m_hsvTransform, info);
        }
        m_hsvTransform->transform(paintColor.data(), paintColor.data(), 1);
    }
 
    const QVector<QRect> dirtyRects =
            m_strategy->paintDab(srcDabRect, m_dstDabRect,
                                 paintColor,
                                 fpOpacity, colorRate,
                                 smudgeRate,
                                 maxSmudgeRate,
                                 paintThickness,
                                 smudgeRadiusPortion);
 
    painter()->addDirtyRects(dirtyRects);
 
    return spacingInfo;
}

References KisPainter::addDirtyRects(), KisPaintThicknessOption::apply(), KisRotationOption::apply(), KisStandardOption< Data >::apply(), KisScatterOption::apply(), KisOpacityOption::apply(), KisGradientOption::apply(), KisHSVOption::apply(), KisBrushBasedPaintOp::checkSizeTooSmall(), KisCurveOption::computeSizeLikeValue(), KoColor::data(), KisDabCacheBase::disableSubpixelPrecision(), KisBrushBasedPaintOp::effectiveSpacing(), KisCurveOption::isChecked(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisLodTransformBase::lodToScale(), m_airbrushData, KisBrushBasedPaintOp::m_brush, m_colorRateOption, KisBrushBasedPaintOp::m_dabCache, m_dstDabRect, m_firstRun, m_gradient, m_gradientOption, m_hsvOptions, m_hsvTransform, m_lastPaintPos, m_opacityOption, m_paintColor, m_paintThicknessOption, m_ratioOption, m_rotationOption, m_scatterOption, m_sizeOption, m_smudgeRadiusOption, m_smudgeRateOption, m_spacingOption, m_strategy, KisSmudgeLengthOption::mode(), KisPaintOp::painter, KisCurveOption::strengthValue(), and KoColorTransformation::transform().

◆ updateSpacingImpl()

KisSpacingInformation KisColorSmudgeOp::updateSpacingImpl ( const KisPaintInformation & info ) const

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 230 of file kis_colorsmudgeop.cpp.

{
    const qreal scale = m_sizeOption.apply(info) * KisLodTransform::lodToScale(painter()->device());
    const qreal rotation = m_rotationOption.apply(info);
    return effectiveSpacing(scale, rotation, &m_airbrushData, &m_spacingOption, info);
}

References KisRotationOption::apply(), KisStandardOption< Data >::apply(), KisBrushBasedPaintOp::effectiveSpacing(), KisLodTransformBase::lodToScale(), m_airbrushData, m_rotationOption, m_sizeOption, m_spacingOption, and KisPaintOp::painter.

◆ updateTimingImpl()

KisTimingInformation KisColorSmudgeOp::updateTimingImpl ( const KisPaintInformation & info ) const

overrideprotectedvirtual

Implementation of a timing update. The default implementation always disables timing. This is suitable for paintops that do not support airbrushing.

Reimplemented from KisPaintOp.

Definition at line 237 of file kis_colorsmudgeop.cpp.

{
    return KisPaintOpPluginUtils::effectiveTiming(&m_airbrushData, &m_rateOption, info);
}

References KisPaintOpPluginUtils::effectiveTiming(), m_airbrushData, and m_rateOption.

Member Data Documentation

◆ m_airbrushData

KisAirbrushOptionData KisColorSmudgeOp::m_airbrushData

private

Definition at line 74 of file kis_colorsmudgeop.h.

◆ m_colorRateOption

KisColorRateOption2 KisColorSmudgeOp::m_colorRateOption

private

Definition at line 70 of file kis_colorsmudgeop.h.

◆ m_dstDabRect

QRect KisColorSmudgeOp::m_dstDabRect

private

Definition at line 77 of file kis_colorsmudgeop.h.

◆ m_firstRun

bool KisColorSmudgeOp::m_firstRun

private

Definition at line 56 of file kis_colorsmudgeop.h.

◆ m_gradient

KoAbstractGradientSP KisColorSmudgeOp::m_gradient

private

Definition at line 59 of file kis_colorsmudgeop.h.

◆ m_gradientOption

KisGradientOption KisColorSmudgeOp::m_gradientOption

private

Definition at line 68 of file kis_colorsmudgeop.h.

◆ m_hsvOptions

QList<KisHSVOption*> KisColorSmudgeOp::m_hsvOptions

private

Definition at line 73 of file kis_colorsmudgeop.h.

◆ m_hsvTransform

KoColorTransformation* KisColorSmudgeOp::m_hsvTransform {0}

private

Definition at line 80 of file kis_colorsmudgeop.h.

80{0};

◆ m_lastPaintPos

QPointF KisColorSmudgeOp::m_lastPaintPos

private

Definition at line 78 of file kis_colorsmudgeop.h.

◆ m_opacityOption

KisOpacityOption KisColorSmudgeOp::m_opacityOption

private

Definition at line 62 of file kis_colorsmudgeop.h.

◆ m_overlayModeData

KisSmudgeOverlayModeOptionData KisColorSmudgeOp::m_overlayModeData

private

Definition at line 75 of file kis_colorsmudgeop.h.

◆ m_paintColor

KoColor KisColorSmudgeOp::m_paintColor

private

Definition at line 58 of file kis_colorsmudgeop.h.

◆ m_paintThicknessOption

KisPaintThicknessOption KisColorSmudgeOp::m_paintThicknessOption

private

Definition at line 67 of file kis_colorsmudgeop.h.

◆ m_rateOption

KisRateOption KisColorSmudgeOp::m_rateOption

private

Definition at line 64 of file kis_colorsmudgeop.h.

◆ m_ratioOption

KisRatioOption KisColorSmudgeOp::m_ratioOption

private

Definition at line 61 of file kis_colorsmudgeop.h.

◆ m_rotationOption

KisRotationOption KisColorSmudgeOp::m_rotationOption

private

Definition at line 65 of file kis_colorsmudgeop.h.

◆ m_scatterOption

KisScatterOption KisColorSmudgeOp::m_scatterOption

private

Definition at line 66 of file kis_colorsmudgeop.h.

◆ m_sizeOption

KisSizeOption KisColorSmudgeOp::m_sizeOption

private

Definition at line 60 of file kis_colorsmudgeop.h.

◆ m_smudgeRadiusOption

KisSmudgeRadiusOption2 KisColorSmudgeOp::m_smudgeRadiusOption

private

Definition at line 71 of file kis_colorsmudgeop.h.

◆ m_smudgeRateOption

KisSmudgeLengthOption KisColorSmudgeOp::m_smudgeRateOption

private

Definition at line 69 of file kis_colorsmudgeop.h.

◆ m_spacingOption

KisSpacingOption KisColorSmudgeOp::m_spacingOption

private

Definition at line 63 of file kis_colorsmudgeop.h.

◆ m_strategy

QScopedPointer<KisColorSmudgeStrategy> KisColorSmudgeOp::m_strategy

private

Definition at line 81 of file kis_colorsmudgeop.h.

The documentation for this class was generated from the following files:

plugins/paintops/colorsmudge/kis_colorsmudgeop.h
plugins/paintops/colorsmudge/kis_colorsmudgeop.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisColorSmudgeOp()

◆ ~KisColorSmudgeOp()

Member Function Documentation

◆ createInterstrokeDataFactory()

◆ paintAt()

◆ updateSpacingImpl()

◆ updateTimingImpl()

Member Data Documentation

◆ m_airbrushData

◆ m_colorRateOption

◆ m_dstDabRect

◆ m_firstRun

◆ m_gradient

◆ m_gradientOption

◆ m_hsvOptions

◆ m_hsvTransform

◆ m_lastPaintPos

◆ m_opacityOption

◆ m_overlayModeData

◆ m_paintColor

◆ m_paintThicknessOption

◆ m_rateOption

◆ m_ratioOption

◆ m_rotationOption

◆ m_scatterOption

◆ m_sizeOption

◆ m_smudgeRadiusOption

◆ m_smudgeRateOption

◆ m_spacingOption

◆ m_strategy