#include <HistogramComputationStrokeStrategy.h>

Inheritance diagram for HistogramComputationStrokeStrategy:

Classes
struct	Private

Signals
void	computationResultReady (HistogramData data)

Signals inherited from KisIdleTaskStrokeStrategy
void	sigIdleTaskFinished ()

Public Member Functions
	HistogramComputationStrokeStrategy (KisImageSP image)

	~HistogramComputationStrokeStrategy () override

Public Member Functions inherited from KisIdleTaskStrokeStrategy
KisStrokeStrategy *	createLodClone (int levelOfDetail) override

QWeakPointer< boost::none_t >	idleTaskCookie ()

	KisIdleTaskStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())

	~KisIdleTaskStrokeStrategy ()

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
virtual void	cancelStrokeCallback ()

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

	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 void	tryCancelCurrentStrokeJobAsync ()
	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.

virtual	~KisStrokeStrategy ()

Private Member Functions
void	doStrokeCallback (KisStrokeJobData *data) override

void	finishStrokeCallback () override

void	initiateVector (HistVector &vec, const KoColorSpace *colorSpace)

void	initStrokeCallback () override

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 KisIdleTaskStrokeStrategy
static int	preferredIdleTaskMaximumTime ()

static int	preferredIdleWatcherInterval ()

Static Public Member Functions inherited from KisSimpleStrokeStrategy
static QLatin1String	jobTypeToString (JobType type)

Protected Member Functions inherited from KisIdleTaskStrokeStrategy
void	finishStrokeCallback () override

void	initStrokeCallback () override

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 28 of file HistogramComputationStrokeStrategy.h.

Constructor & Destructor Documentation

◆ HistogramComputationStrokeStrategy()

HistogramComputationStrokeStrategy::HistogramComputationStrokeStrategy ( KisImageSP image )

Definition at line 38 of file HistogramComputationStrokeStrategy.cpp.

    : KisIdleTaskStrokeStrategy(QLatin1String("ComputeHistogram"), kundo2_i18n("Update histogram"))
    , m_d(new Private)
{
    m_d->image = image;
}

References m_d.

◆ ~HistogramComputationStrokeStrategy()

HistogramComputationStrokeStrategy::~HistogramComputationStrokeStrategy ( )

override

Definition at line 45 of file HistogramComputationStrokeStrategy.cpp.

46{

47}

Member Function Documentation

◆ computationResultReady

void HistogramComputationStrokeStrategy::computationResultReady ( HistogramData data )

signal

◆ doStrokeCallback()

void HistogramComputationStrokeStrategy::doStrokeCallback ( KisStrokeJobData * data )

overrideprivatevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 66 of file HistogramComputationStrokeStrategy.cpp.

{
    Private::ProcessData *d_pd = dynamic_cast<Private::ProcessData*>(data);
 
    if (!d_pd) {
        KisIdleTaskStrokeStrategy::doStrokeCallback(data);
        return;
    }
 
    QRect calculate = d_pd->rectToCalculate;
 
    KisPaintDeviceSP m_dev = m_d->image->projection();
    QRect imageBounds = m_d->image->bounds();
 
    const KoColorSpace *cs = m_dev->colorSpace();
    quint32 channelCount = m_dev->channelCount();
    quint32 pixelSize = m_dev->pixelSize();
 
    int imageSize = imageBounds.width() * imageBounds.height();
    int nSkip = 1 + (imageSize >> 20); //for speed use about 1M pixels for computing histograms
 
    if (calculate.isEmpty())
        return;
 
    initiateVector(m_d->results[d_pd->jobId], cs);
    initiateVector(m_d->resultsLog[d_pd->jobId], cs);
 
    quint32 toSkip = nSkip;
 
    float maximum = 1.0;
    QVector<float> channelValues(channelCount);
    if (cs->hasHighDynamicRange()) {
        KisSequentialConstIterator it(m_dev, calculate);
 
        int numConseqPixels = it.nConseqPixels();
        while (it.nextPixels(numConseqPixels)) {
            numConseqPixels = it.nConseqPixels();
            const quint8* pixel = it.rawDataConst();
            for (int k = 0; k < numConseqPixels; ++k) {
                cs->normalisedChannelsValue(pixel, channelValues);
                for (int chan = 0; chan < (int)channelCount; ++chan) {
                    maximum = qMax(maximum, channelValues.at(chan));
                }
                pixel += pixelSize;
            }
        }
    }
    m_d->maximumValue = maximum;
 
    const double maximumMultiplier = 255.0/maximum;
    const double logMaxMultiplier = 255.0/(std::log10(maximum*10)*0.1);
 
 
    KisSequentialConstIterator it(m_dev, calculate);
 
    int numConseqPixels = it.nConseqPixels();
    while (it.nextPixels(numConseqPixels)) {
 
        numConseqPixels = it.nConseqPixels();
        const quint8* pixel = it.rawDataConst();
        for (int k = 0; k < numConseqPixels; ++k) {
            cs->normalisedChannelsValue(pixel, channelValues);
            if (--toSkip == 0) {
 
                for (int chan = 0; chan < (int)channelCount; ++chan) {
                    m_d->results[d_pd->jobId][chan][ qBound(0, qRound(channelValues.at(chan)*maximumMultiplier), 255) ]++;
                    m_d->resultsLog[d_pd->jobId][chan][ qBound(0, qRound(std::log10(channelValues.at(chan)*10)*0.1*logMaxMultiplier), 255) ]++;
                }
                toSkip = nSkip;
            }
            pixel += pixelSize;
        }
    }
}

References KisPaintDevice::channelCount(), KisPaintDevice::colorSpace(), KisSimpleStrokeStrategy::doStrokeCallback(), KoColorSpace::hasHighDynamicRange(), initiateVector(), HistogramComputationStrokeStrategy::Private::ProcessData::jobId, m_d, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nConseqPixels(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixels(), KoColorSpace::normalisedChannelsValue(), KisPaintDevice::pixelSize(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst(), and HistogramComputationStrokeStrategy::Private::ProcessData::rectToCalculate.

◆ finishStrokeCallback()

void HistogramComputationStrokeStrategy::finishStrokeCallback ( )

overrideprivatevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 141 of file HistogramComputationStrokeStrategy.cpp.

{
    HistogramData hisData;
    hisData.colorSpace = m_d->image->projection()->colorSpace();
    hisData.maximumValue = m_d->maximumValue;
 
    if (m_d->results.size() == 1) {
        hisData.bins = m_d->results[0];
        hisData.binsLog = m_d->resultsLog[0];
        Q_EMIT computationResultReady(hisData);
    } else {
 
        quint32 channelCount = m_d->image->projection()->channelCount();
 
        initiateVector(hisData.bins, hisData.colorSpace);
        initiateVector(hisData.binsLog, hisData.colorSpace);
 
        for (int chan = 0; chan < (int)channelCount; chan++) {
            int bsize = hisData.bins[chan].size();
 
            for (int bi = 0; bi < bsize; bi++) {
                hisData.bins[chan][bi] = 0;
                for (int i = 0; i < (int)m_d->results.size(); i++) {
                    hisData.bins[chan][bi] += m_d->results[i][chan][bi];
                }
            }
            int b2size = hisData.binsLog[chan].size();
 
            for (int bi = 0; bi < b2size; bi++) {
                hisData.binsLog[chan][bi] = 0;
                for (int i = 0; i < (int)m_d->resultsLog.size(); i++) {
                    hisData.binsLog[chan][bi] += m_d->resultsLog[i][chan][bi];
                }
            }
        }
 
        Q_EMIT computationResultReady(hisData);
    }
 
    KisIdleTaskStrokeStrategy::finishStrokeCallback();
}

References HistogramData::bins, HistogramData::binsLog, HistogramData::colorSpace, computationResultReady(), KisIdleTaskStrokeStrategy::finishStrokeCallback(), initiateVector(), m_d, and HistogramData::maximumValue.

◆ initiateVector()

void HistogramComputationStrokeStrategy::initiateVector	(	HistVector &	vec,
		const KoColorSpace *	colorSpace )

private

Definition at line 183 of file HistogramComputationStrokeStrategy.cpp.

{
    vec.resize(colorSpace->channelCount());
    for (auto &bin : vec) {
        bin.resize(std::numeric_limits<quint8>::max() + 1);
    }
}

References KoColorSpace::channelCount().

◆ initStrokeCallback()

void HistogramComputationStrokeStrategy::initStrokeCallback ( )

overrideprivatevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 49 of file HistogramComputationStrokeStrategy.cpp.

{
    KisIdleTaskStrokeStrategy::initStrokeCallback();
 
    QVector<KisStrokeJobData*> jobsData;
    int i = 0;
    QVector<QRect> tileRects = KritaUtils::splitRectIntoPatches(m_d->image->bounds(), KritaUtils::optimalPatchSize());
    m_d->results.resize(tileRects.size());
    m_d->resultsLog.resize(tileRects.size());
 
    Q_FOREACH (const QRect &tileRectangle, tileRects) {
        jobsData << new HistogramComputationStrokeStrategy::Private::ProcessData(tileRectangle, i);
        i++;
    }
    addMutatedJobs(jobsData);
}

References KisStrokeStrategy::addMutatedJobs(), KisIdleTaskStrokeStrategy::initStrokeCallback(), m_d, KritaUtils::optimalPatchSize(), and KritaUtils::splitRectIntoPatches().

Member Data Documentation

◆ m_d

const QScopedPointer<Private> HistogramComputationStrokeStrategy::m_d

private

Definition at line 48 of file HistogramComputationStrokeStrategy.h.

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

plugins/dockers/histogram/HistogramComputationStrokeStrategy.h
plugins/dockers/histogram/HistogramComputationStrokeStrategy.cpp

Classes

Signals

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HistogramComputationStrokeStrategy()

◆ ~HistogramComputationStrokeStrategy()

Member Function Documentation

◆ computationResultReady

◆ doStrokeCallback()

◆ finishStrokeCallback()

◆ initiateVector()

◆ initStrokeCallback()

Member Data Documentation

◆ m_d