KisWatershedWorker Class Reference

#include <KisWatershedWorker.h>

Classes
struct	Private

Public Member Functions
void	addKeyStroke (KisPaintDeviceSP dev, const KoColor &color)
	Adds a key stroke to the worker.
	KisWatershedWorker (KisPaintDeviceSP heightMap, KisPaintDeviceSP dst, const QRect &boundingRect, KoUpdater *progress=0)
void	run (qreal cleanUpAmount=0.0)
	run the filling process using the passes height map, strokes, and write the result coloring into the destination device
int	testingGroupAllyEdge (qint32 group, quint8 level)
int	testingGroupConflicts (qint32 group, quint8 level, qint32 withGroup)
int	testingGroupForeignEdge (qint32 group, quint8 level)
int	testingGroupNegativeEdge (qint32 group, quint8 level)
int	testingGroupPositiveEdge (qint32 group, quint8 level)
void	testingTryRemoveGroup (qint32 group, quint8 level)
	~KisWatershedWorker ()

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Definition at line 17 of file KisWatershedWorker.h.

Constructor & Destructor Documentation

KisWatershedWorker()

KisWatershedWorker::KisWatershedWorker	(	KisPaintDeviceSP	heightMap,
		KisPaintDeviceSP	dst,
		const QRect &	boundingRect,
		KoUpdater *	progress = 0 )

Creates an empty watershed worker without any strokes attached. The strokes should be attached manually with addKeyStroke() call.

Parameters

heightMap	prefiltered height map in alpha8 colorspace, with "0" meaning background color and "255" meaning line art. Heightmap is never modified by the worker!
dst	destination device where the result will be written
boundingRect	the worker refuses to fill outside the bounding rect, considering that outer area as having +inf height
progress	the progress value

Definition at line 250 of file KisWatershedWorker.cpp.

    : m_d(new Private)
{
    KIS_SAFE_ASSERT_RECOVER_RETURN(heightMap->colorSpace()->pixelSize() == 1);
 
    m_d->progressUpdater = progress;
    m_d->heightMap = heightMap;
    m_d->dstDevice = dst;
    m_d->boundingRect = boundingRect;
 
    // Just the simplest color space with 4 bytes per pixel. We use it as
    // a storage for qint32-indexed group ids
    m_d->groupsMap = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
}

References KisPaintDevice::colorSpace(), KoColorSpaceRegistry::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and KoColorSpace::pixelSize().

~KisWatershedWorker()

KisWatershedWorker::~KisWatershedWorker

(

)

Definition at line 265 of file KisWatershedWorker.cpp.

{
}

Member Function Documentation

addKeyStroke()

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

Adds a key stroke to the worker.

The key strokes may intersect, in which case the lastly added stroke will have a priority over all the previous ones.

Parameters

dev	alpha8 paint device of the key stroke, may contain disjoint areas
color	the color of the stroke

Definition at line 269 of file KisWatershedWorker.cpp.

{
    m_d->keyStrokes << KeyStroke(new KisPaintDevice(*dev), color);
 
    KisPaintDeviceSP lastDev = m_d->keyStrokes.back().dev;
 
    for (auto it = m_d->keyStrokes.begin(); it != m_d->keyStrokes.end() - 1; ++it) {
        KisPaintDeviceSP dev = it->dev;
        const QRect rc = dev->exactBounds() & lastDev->exactBounds();
        if (rc.isEmpty()) continue;
 
        KisSequentialIterator devIt(dev, rc);
        KisSequentialConstIterator lastDevIt(lastDev, rc);
 
        while (devIt.nextPixel() &&
               lastDevIt.nextPixel()) {
 
            quint8 *devPtr = devIt.rawData();
            const quint8 *lastDevPtr = lastDevIt.rawDataConst();
 
            if (*devPtr > 0 && *lastDevPtr > 0) {
                *devPtr = 0;
            }
 
        }
    }
}

References KisPaintDevice::exactBounds(), m_d, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst().

run()

void KisWatershedWorker::run

(

qreal

cleanUpAmount = 0.0

)

run the filling process using the passes height map, strokes, and write the result coloring into the destination device

Parameters

cleanUpAmount

shows how aggressively we should try to clean up the final coloring. Should be in range [0.0...1.0]

Definition at line 297 of file KisWatershedWorker.cpp.

{
    if (!m_d->heightMap) return;
 
    m_d->groups << FillGroup(-1);
 
    for (int i = 0; i < m_d->keyStrokes.size(); i++) {
        parseColorIntoGroups(m_d->groups, m_d->groupsMap,
                             m_d->heightMap,
                             i, m_d->keyStrokes[i].dev,
                             m_d->boundingRect);
    }
 
//    m_d->dumpGroupMaps();
//    m_d->calcNumGroupMaps();
 
    const QRect initRect =
        m_d->boundingRect & m_d->groupsMap->nonDefaultPixelArea();
 
    m_d->initializeQueueFromGroupMap(initRect);
    m_d->processQueue(0);
 
    if (!m_d->progressUpdater || !m_d->progressUpdater->interrupted()) {
        //    m_d->dumpGroupMaps();
        //    m_d->calcNumGroupMaps();
 
        if (cleanUpAmount > 0) {
            m_d->cleanupForeignEdgeGroups(cleanUpAmount);
        }
 
        //    m_d->calcNumGroupMaps();
 
        m_d->writeColoring();
    }
}

References m_d.

testingGroupAllyEdge()

int KisWatershedWorker::testingGroupAllyEdge	(	qint32	group,
		quint8	level )

Definition at line 348 of file KisWatershedWorker.cpp.

{
    return m_d->groups[group].levels[level].allyEdgeSize;
}

References m_d.

testingGroupConflicts()

int KisWatershedWorker::testingGroupConflicts	(	qint32	group,
		quint8	level,
		qint32	withGroup )

Definition at line 353 of file KisWatershedWorker.cpp.

{
    return m_d->groups[group].levels[level].conflictWithGroup[withGroup].size();
}

References m_d.

testingGroupForeignEdge()

int KisWatershedWorker::testingGroupForeignEdge	(	qint32	group,
		quint8	level )

Definition at line 343 of file KisWatershedWorker.cpp.

{
    return m_d->groups[group].levels[level].foreignEdgeSize;
}

References m_d.

testingGroupNegativeEdge()

int KisWatershedWorker::testingGroupNegativeEdge	(	qint32	group,
		quint8	level )

Definition at line 338 of file KisWatershedWorker.cpp.

{
    return m_d->groups[group].levels[level].negativeEdgeSize;
}

References m_d.

testingGroupPositiveEdge()

int KisWatershedWorker::testingGroupPositiveEdge	(	qint32	group,
		quint8	level )

Definition at line 333 of file KisWatershedWorker.cpp.

{
    return m_d->groups[group].levels[level].positiveEdgeSize;
}

References m_d.

testingTryRemoveGroup()

void KisWatershedWorker::testingTryRemoveGroup	(	qint32	group,
		quint8	level )

Definition at line 358 of file KisWatershedWorker.cpp.

{
    QVector<TaskPoint> taskPoints =
        m_d->tryRemoveConflictingPlane(group, levelIndex);
 
    if (!taskPoints.isEmpty()) {
        Q_FOREACH (const TaskPoint &pt, taskPoints) {
            m_d->pointsQueue.push(pt);
        }
        m_d->processQueue(group);
    }
    m_d->dumpGroupMaps();
    m_d->calcNumGroupMaps();
}

References m_d.

Member Data Documentation

m_d

const QScopedPointer<Private> KisWatershedWorker::m_d

private

Definition at line 68 of file KisWatershedWorker.h.

---

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

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