KisColorizeStrokeStrategy Class Reference

#include <kis_colorize_stroke_strategy.h>

Inheritance diagram for KisColorizeStrokeStrategy:

Classes
struct	Private

Signals
void	sigCancelled ()
void	sigFinished (bool prefilterOnly)

Public Member Functions
void	addKeyStroke (KisPaintDeviceSP dev, const KoColor &color)
void	cancelStrokeCallback () override
KisStrokeStrategy *	createLodClone (int levelOfDetail) override
KisLazyFillTools::FilteringOptions	filteringOptions () const
void	initStrokeCallback () override
	KisColorizeStrokeStrategy (const KisColorizeStrokeStrategy &rhs, int levelOfDetail)
	KisColorizeStrokeStrategy (KisPaintDeviceSP src, KisPaintDeviceSP dst, KisPaintDeviceSP filteredSource, bool filteredSourceValid, const QRect &boundingRect, KisNodeSP progressNode, bool prefilterOnly=false)
void	setFilteringOptions (const KisLazyFillTools::FilteringOptions &value)
void	tryCancelCurrentStrokeJobAsync () override
	tryCancelCurrentStrokeJobAsync is called by the strokes queue when the stroke is being cancelled. The stroke strategy may or may not handle this request and cancel the currently running long action.
	~KisColorizeStrokeStrategy () override
Public Member Functions inherited from KisRunnableBasedStrokeStrategy
void	doStrokeCallback (KisStrokeJobData *data) override
	KisRunnableBasedStrokeStrategy (const KisRunnableBasedStrokeStrategy &rhs)
	KisRunnableBasedStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())
KisRunnableStrokeJobsInterface *	runnableJobsInterface () const
	~KisRunnableBasedStrokeStrategy ()
Public Member Functions inherited from KisSimpleStrokeStrategy
KisStrokeJobData *	createCancelData () override
KisStrokeJobStrategy *	createCancelStrategy () override
KisStrokeJobStrategy *	createDabStrategy () override
KisStrokeJobData *	createFinishData () override
KisStrokeJobStrategy *	createFinishStrategy () override
KisStrokeJobData *	createInitData () override
KisStrokeJobStrategy *	createInitStrategy () override
KisStrokeJobData *	createResumeData () override
KisStrokeJobStrategy *	createResumeStrategy () override
KisStrokeJobData *	createSuspendData () override
KisStrokeJobStrategy *	createSuspendStrategy () override
virtual void	finishStrokeCallback ()
	KisSimpleStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())
virtual void	resumeStrokeCallback ()
virtual void	suspendStrokeCallback ()
Public Member Functions inherited from KisStrokeStrategy
qreal	balancingRatioOverride () const
bool	canForgetAboutMe () const
bool	clearsRedoOnStart () const
KisLodPreferences	currentLodPreferences () const
bool	forceLodModeIfPossible () const
QString	id () const
bool	isAsynchronouslyCancellable () const
bool	isExclusive () const
	KisStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())
KUndo2MagicString	name () const
bool	needsExplicitCancel () const
virtual void	notifyUserEndedStroke ()
virtual void	notifyUserStartedStroke ()
bool	requestsOtherStrokesToEnd () const
void	setForceLodModeIfPossible (bool forceLodModeIfPossible)
void	setMutatedJobsInterface (KisStrokesQueueMutatedJobInterface *mutatedJobsInterface, KisStrokeId strokeId)
bool	supportsWrapAroundMode () const
virtual	~KisStrokeStrategy ()

Private Attributes
const QScopedPointer< Private >	m_d

Additional Inherited Members
Public Types inherited from KisSimpleStrokeStrategy
enum	JobType {   JOB_INIT = 0 , JOB_CANCEL , JOB_FINISH , JOB_DOSTROKE ,   JOB_SUSPEND , JOB_RESUME , NJOBS }
Static Public Member Functions inherited from KisSimpleStrokeStrategy
static QLatin1String	jobTypeToString (JobType type)
Protected Member Functions inherited from KisSimpleStrokeStrategy
void	enableJob (JobType type, bool enable=true, KisStrokeJobData::Sequentiality sequentiality=KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::Exclusivity exclusivity=KisStrokeJobData::NORMAL)
	KisSimpleStrokeStrategy (const KisSimpleStrokeStrategy &rhs)
Protected Member Functions inherited from KisStrokeStrategy
void	addMutatedJob (KisStrokeJobData *data)
void	addMutatedJobs (const QVector< KisStrokeJobData * > list)
	KisStrokeStrategy (const KisStrokeStrategy &rhs)
void	setAsynchronouslyCancellable (bool value)
void	setBalancingRatioOverride (qreal value)
void	setCanForgetAboutMe (bool value)
void	setClearsRedoOnStart (bool value)
void	setExclusive (bool value)
void	setNeedsExplicitCancel (bool value)
void	setRequestsOtherStrokesToEnd (bool value)
void	setSupportsWrapAroundMode (bool value)

Detailed Description

Definition at line 23 of file kis_colorize_stroke_strategy.h.

Constructor & Destructor Documentation

KisColorizeStrokeStrategy() [1/2]

KisColorizeStrokeStrategy::KisColorizeStrokeStrategy	(	KisPaintDeviceSP	src,
		KisPaintDeviceSP	dst,
		KisPaintDeviceSP	filteredSource,
		bool	filteredSourceValid,
		const QRect &	boundingRect,
		KisNodeSP	progressNode,
		bool	prefilterOnly = false )

Definition at line 67 of file kis_colorize_stroke_strategy.cpp.

    : KisRunnableBasedStrokeStrategy(QLatin1String("colorize-stroke"), prefilterOnly ? kundo2_i18n("Prefilter Colorize Mask") : kundo2_i18n("Colorize")),
      m_d(new Private)
{
    m_d->progressNode = progressNode;
    m_d->src = src;
    m_d->dst = dst;
    m_d->filteredSource = filteredSource;
    m_d->boundingRect = boundingRect;
    m_d->filteredSourceValid = filteredSourceValid;
    m_d->prefilterOnly = prefilterOnly;
 
    enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
    enableJob(JOB_DOSTROKE, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
    enableJob(JOB_CANCEL, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
    setNeedsExplicitCancel(true);
    setRequestsOtherStrokesToEnd(false);
    setClearsRedoOnStart(false);
}

References KisSimpleStrokeStrategy::enableJob(), KisStrokeJobData::EXCLUSIVE, KisSimpleStrokeStrategy::JOB_CANCEL, KisSimpleStrokeStrategy::JOB_DOSTROKE, KisSimpleStrokeStrategy::JOB_INIT, m_d, KisStrokeJobData::SEQUENTIAL, KisStrokeStrategy::setClearsRedoOnStart(), KisStrokeStrategy::setNeedsExplicitCancel(), and KisStrokeStrategy::setRequestsOtherStrokesToEnd().

KisColorizeStrokeStrategy() [2/2]

KisColorizeStrokeStrategy::KisColorizeStrokeStrategy	(	const KisColorizeStrokeStrategy &	rhs,
		int	levelOfDetail )

Definition at line 94 of file kis_colorize_stroke_strategy.cpp.

    : KisRunnableBasedStrokeStrategy(rhs),
      m_d(new Private(*rhs.m_d, levelOfDetail))
{
    KisLodTransform t(levelOfDetail);
    m_d->boundingRect = t.map(rhs.m_d->boundingRect);
}

References m_d, and KisLodTransform::map().

~KisColorizeStrokeStrategy()

KisColorizeStrokeStrategy::~KisColorizeStrokeStrategy ( )

override

Definition at line 102 of file kis_colorize_stroke_strategy.cpp.

{
}

Member Function Documentation

addKeyStroke()

void KisColorizeStrokeStrategy::addKeyStroke	(	KisPaintDeviceSP	dev,
		const KoColor &	color )

Definition at line 116 of file kis_colorize_stroke_strategy.cpp.

{
    KoColor convertedColor(color);
    convertedColor.convertTo(m_d->dst->colorSpace());
 
    m_d->keyStrokes << KeyStroke(dev, convertedColor);
}

References KoColor::convertTo(), and m_d.

cancelStrokeCallback()

void KisColorizeStrokeStrategy::cancelStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 263 of file kis_colorize_stroke_strategy.cpp.

{
    Q_EMIT sigCancelled();
}

References sigCancelled().

createLodClone()

KisStrokeStrategy * KisColorizeStrokeStrategy::createLodClone ( int levelOfDetail )

overridevirtual

Reimplemented from KisStrokeStrategy.

Definition at line 277 of file kis_colorize_stroke_strategy.cpp.

{
    KisImageConfig cfg(true);
    if (!cfg.useLodForColorizeMask()) return 0;
 
    KisColorizeStrokeStrategy *clone = new KisColorizeStrokeStrategy(*this, levelOfDetail);
    return clone;
}

References KisColorizeStrokeStrategy(), and KisImageConfig::useLodForColorizeMask().

filteringOptions()

FilteringOptions KisColorizeStrokeStrategy::filteringOptions

(

)

const

Definition at line 111 of file kis_colorize_stroke_strategy.cpp.

{
    return m_d->filteringOptions;
}

References m_d.

initStrokeCallback()

void KisColorizeStrokeStrategy::initStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 124 of file kis_colorize_stroke_strategy.cpp.

{
    using namespace KritaUtils;
 
    QVector<KisRunnableStrokeJobData*> jobs;
 
    const QVector<QRect> patchRects =
        splitRectIntoPatches(m_d->boundingRect, optimalPatchSize());
 
    if (!m_d->filteredSourceValid) {
        // TODO: make this conversion concurrent!!!
        KisPaintDeviceSP filteredMainDev = KisPainter::convertToAlphaAsAlpha(m_d->src);
        filteredMainDev->setDefaultBounds(m_d->src->defaultBounds());
 
        struct PrefilterSharedState {
            QRect boundingRect;
            KisPaintDeviceSP filteredMainDev;
            KisPaintDeviceSP filteredMainDevSavedCopy;
            QScopedPointer<KisTransaction> activeTransaction;
            FilteringOptions filteringOptions;
        };
 
        QSharedPointer<PrefilterSharedState> state(new PrefilterSharedState());
        state->boundingRect = m_d->boundingRect;
        state->filteredMainDev = filteredMainDev;
        state->filteringOptions = m_d->filteringOptions;
 
        if (m_d->filteringOptions.useEdgeDetection &&
            m_d->filteringOptions.edgeDetectionSize > 0.0) {
 
            addJobSequential(jobs, [state] () {
                state->activeTransaction.reset(new KisTransaction(state->filteredMainDev));
            });
 
            Q_FOREACH (const QRect &rc, patchRects) {
                addJobConcurrent(jobs, [state, rc] () {
                    KisLodTransformScalar t(state->filteredMainDev);
                    KisGaussianKernel::applyLoG(state->filteredMainDev,
                                                rc,
                                                t.scale(0.5 * state->filteringOptions.edgeDetectionSize),
                                                -1.0,
                                                QBitArray(), 0);
                });
            }
 
            addJobSequential(jobs, [state] () {
                state->activeTransaction.reset();
                normalizeAlpha8Device(state->filteredMainDev, state->boundingRect);
                state->activeTransaction.reset(new KisTransaction(state->filteredMainDev));
            });
 
            Q_FOREACH (const QRect &rc, patchRects) {
                addJobConcurrent(jobs, [state, rc] () {
                    KisLodTransformScalar t(state->filteredMainDev);
                    KisGaussianKernel::applyGaussian(state->filteredMainDev,
                                                     rc,
                                                     t.scale(state->filteringOptions.edgeDetectionSize),
                                                     t.scale(state->filteringOptions.edgeDetectionSize),
                                                     QBitArray(), 0);
                });
            }
 
            addJobSequential(jobs, [state] () {
                state->activeTransaction.reset();
            });
        }
 
        if (m_d->filteringOptions.fuzzyRadius > 0) {
 
            addJobSequential(jobs, [state] () {
                state->filteredMainDevSavedCopy = new KisPaintDevice(*state->filteredMainDev);
                state->activeTransaction.reset(new KisTransaction(state->filteredMainDev));
            });
 
            Q_FOREACH (const QRect &rc, patchRects) {
                addJobConcurrent(jobs, [state, rc] () {
                    KisLodTransformScalar t(state->filteredMainDev);
                    KisGaussianKernel::applyGaussian(state->filteredMainDev,
                                                     rc,
                                                     t.scale(state->filteringOptions.fuzzyRadius),
                                                     t.scale(state->filteringOptions.fuzzyRadius),
                                                     QBitArray(), 0);
                    KisPainter gc(state->filteredMainDev);
                    gc.bitBlt(rc.topLeft(), state->filteredMainDevSavedCopy, rc);
                });
            }
 
            addJobSequential(jobs, [state] () {
                state->activeTransaction.reset();
            });
        }
 
        addJobSequential(jobs, [this, state] () {
            normalizeAndInvertAlpha8Device(state->filteredMainDev, state->boundingRect);
 
            KisDefaultBoundsBaseSP oldBounds = m_d->filteredSource->defaultBounds();
            m_d->filteredSource->makeCloneFrom(state->filteredMainDev, m_d->boundingRect);
            m_d->filteredSource->setDefaultBounds(oldBounds);
            m_d->filteredSourceValid = true;
        });
    }
 
    if (!m_d->prefilterOnly) {
        addJobSequential(jobs, [this] () {
            m_d->heightMap = new KisPaintDevice(*m_d->filteredSource);
        });
 
        Q_FOREACH (const QRect &rc, patchRects) {
            addJobConcurrent(jobs, [this, rc] () {
                KritaUtils::filterAlpha8Device(m_d->heightMap, rc,
                                               [](quint8 pixel) {
                                                   return quint8(255 - pixel);
                                               });
            });
        }
 
        addJobSequential(jobs, [this] () {
            m_d->progressHelper.reset(new KisProcessingVisitor::ProgressHelper(m_d->progressNode));
 
            KisWatershedWorker worker(m_d->heightMap, m_d->dst, m_d->boundingRect, m_d->progressHelper->updater());
            Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
                KoColor color =
                    !stroke.isTransparent ?
                    stroke.color : KoColor::createTransparent(m_d->dst->colorSpace());
 
                worker.addKeyStroke(stroke.dev, color);
            }
            worker.run(m_d->filteringOptions.cleanUpAmount);
            m_d->progressHelper.reset();
        });
    }
 
    addJobSequential(jobs, [this] () {
        Q_EMIT sigFinished(m_d->prefilterOnly);
    });
 
    runnableJobsInterface()->addRunnableJobs(jobs);
}

References KisWatershedWorker::addKeyStroke(), KisRunnableStrokeJobsInterface::addRunnableJobs(), KisGaussianKernel::applyGaussian(), KisGaussianKernel::applyLoG(), KisPainter::bitBlt(), KisLazyFillTools::KeyStroke::color, KisPainter::convertToAlphaAsAlpha(), KoColor::createTransparent(), KisLazyFillTools::KeyStroke::dev, KritaUtils::filterAlpha8Device(), KisLazyFillTools::KeyStroke::isTransparent, m_d, KisLazyFillTools::normalizeAlpha8Device(), KisLazyFillTools::normalizeAndInvertAlpha8Device(), KisWatershedWorker::run(), KisRunnableBasedStrokeStrategy::runnableJobsInterface(), KisLodTransformScalar::scale(), KisPaintDevice::setDefaultBounds(), and sigFinished().

setFilteringOptions()

void KisColorizeStrokeStrategy::setFilteringOptions

(

const KisLazyFillTools::FilteringOptions &

value

)

Definition at line 106 of file kis_colorize_stroke_strategy.cpp.

{
    m_d->filteringOptions = value;
}

References m_d, and value().

sigCancelled

void KisColorizeStrokeStrategy::sigCancelled ( )

signal

sigFinished

void KisColorizeStrokeStrategy::sigFinished ( bool prefilterOnly )

signal

tryCancelCurrentStrokeJobAsync()

void KisColorizeStrokeStrategy::tryCancelCurrentStrokeJobAsync ( )

overridevirtual

tryCancelCurrentStrokeJobAsync is called by the strokes queue when the stroke is being cancelled. The stroke strategy may or may not handle this request and cancel the currently running long action.

Reimplemented from KisStrokeStrategy.

Definition at line 268 of file kis_colorize_stroke_strategy.cpp.

{
    // NOTE: this method may be called by the GUI thread asynchronously!
    QSharedPointer<KisProcessingVisitor::ProgressHelper> helper = m_d->progressHelper;
    if (helper) {
        helper->cancel();
    }
}

References m_d.

Member Data Documentation

m_d

const QScopedPointer<Private> KisColorizeStrokeStrategy::m_d

private

Definition at line 56 of file kis_colorize_stroke_strategy.h.

---

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

• libs/image/lazybrush/kis_colorize_stroke_strategy.h
• libs/image/lazybrush/kis_colorize_stroke_strategy.cpp