KisWatershedWorker::Private Struct Reference

Public Member Functions
void	calcNumGroupMaps ()
QVector< GroupLevelPair >	calculateConflictingPairs ()
void	cleanupForeignEdgeGroups (qreal cleanUpAmount)
void	dumpGroupInfo (qint32 groupIndex, quint8 levelIndex)
void	dumpGroupMaps ()
void	initializeQueueFromGroupMap (const QRect &rc)
	Private ()
void	processQueue (qint32 _backgroundGroupId)
QVector< TaskPoint >	tryRemoveConflictingPlane (qint32 group, quint8 level)
ALWAYS_INLINE void	updateGroupLastDistance (FillGroup::LevelData &levelData, int distance)
void	updateNarrowRegionMetrics ()
ALWAYS_INLINE void	visitNeighbour (const QPoint &currPt, const QPoint &prevPt, quint8 fromDirection, int prevDistance, quint8 prevLevel, qint32 prevGroupId, FillGroup &prevGroup, FillGroup::LevelData &prevLevelData, qint32 prevPrevGroupId, FillGroup &prevPrevGroup, bool statsOnly=false)
void	writeColoring ()

Public Attributes
int	backgroundGroupColor = -1
qint32	backgroundGroupId = 0
QRect	boundingRect
KisPaintDeviceSP	dstDevice
KisRandomAccessorSP	groupIt
QVector< FillGroup >	groups
KisPaintDeviceSP	groupsMap
KisPaintDeviceSP	heightMap
QVector< KeyStroke >	keyStrokes
KisRandomConstAccessorSP	levelIt
quint64	numFilledPixels = 0
CompareTaskPoints	pointsComparator
PointsPriorityQueue	pointsQueue
KoUpdater *	progressUpdater = 0
bool	recolorMode = false
quint64	totalPixelsToFill = 0

Detailed Description

Definition at line 195 of file KisWatershedWorker.cpp.

Constructor & Destructor Documentation

Private()

KisWatershedWorker::Private::Private ( )

inline

Definition at line 197 of file KisWatershedWorker.cpp.

: pointsQueue(pointsComparator) {}

Member Function Documentation

calcNumGroupMaps()

void KisWatershedWorker::Private::calcNumGroupMaps

(

)

Definition at line 957 of file KisWatershedWorker.cpp.

{
    KisSequentialConstIterator groupIt(groupsMap, boundingRect);
    KisSequentialConstIterator levelIt(heightMap, boundingRect);
 
    QSet<QPair<qint32, quint8>> groups;
 
    while (groupIt.nextPixel() && levelIt.nextPixel()) {
 
        const qint32 group = *reinterpret_cast<const qint32*>(groupIt.rawDataConst());
        const quint8 level = *reinterpret_cast<const quint8*>(levelIt.rawDataConst());
 
        groups.insert(qMakePair(group, level));
    }
 
    for (auto it = groups.begin(); it != groups.end(); ++it) {
        dumpGroupInfo(it->first, it->second);
    }
 
    ENTER_FUNCTION() << ppVar(groups.size());
}

References ENTER_FUNCTION, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), ppVar, and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst().

calculateConflictingPairs()

QVector< GroupLevelPair > KisWatershedWorker::Private::calculateConflictingPairs

(

)

Definition at line 778 of file KisWatershedWorker.cpp.

{
    QVector<GroupLevelPair> result;
 
 
    for (qint32 i = 0; i < groups.size(); i++) {
        FillGroup &group = groups[i];
 
        for (auto levelIt = group.levels.begin(); levelIt != group.levels.end(); ++levelIt) {
            FillGroup::LevelData &l = levelIt.value();
 
            for (auto conflictIt = l.conflictWithGroup.begin(); conflictIt != l.conflictWithGroup.end(); ++conflictIt) {
                if (!conflictIt->empty()) {
                    result.append(GroupLevelPair(i, levelIt.key()));
                    break;
                }
            }
        }
    }
 
    return result;
}

cleanupForeignEdgeGroups()

void KisWatershedWorker::Private::cleanupForeignEdgeGroups

(

qreal

cleanUpAmount

)

Definition at line 806 of file KisWatershedWorker.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(cleanUpAmount > 0.0);
 
    // convert into the threshold range [0.05...0.5]
    const qreal foreignEdgePortionThreshold = 0.05 + 0.45 * (1.0 - qBound(0.0, cleanUpAmount, 1.0));
 
    QVector<GroupLevelPair> conflicts = calculateConflictingPairs();
 
    // sort the pairs by the total edge size
    QMap<qreal, GroupLevelPair> sortedPairs;
    Q_FOREACH (const GroupLevelPair &pair, conflicts) {
        const qint32 groupIndex = pair.first;
        const quint8 levelIndex = pair.second;
        FillGroup::LevelData &level = groups[groupIndex].levels[levelIndex];
 
        sortedPairs.insert(level.totalEdgeSize(), pair);
    }
 
    // remove sequentially from the smallest to the biggest
    for (auto pairIt = sortedPairs.begin(); pairIt != sortedPairs.end(); ++pairIt) {
        const qint32 groupIndex = pairIt->first;
        const quint8 levelIndex = pairIt->second;
        FillGroup::LevelData &level = groups[groupIndex].levels[levelIndex];
 
        const int thisLength = pairIt.key();
        const qreal thisForeignPortion = qreal(level.foreignEdgeSize) / thisLength;
 
        using namespace boost::accumulators;
        accumulator_set<int, stats<tag::count, tag::mean, tag::min>> lengthStats;
 
        for (auto it = level.conflictWithGroup.begin(); it != level.conflictWithGroup.end(); ++it) {
            const FillGroup::LevelData &otherLevel = groups[it.key()].levels[levelIndex];
            lengthStats(otherLevel.totalEdgeSize());
        }
 
        KIS_SAFE_ASSERT_RECOVER_BREAK(count(lengthStats));
 
        const qreal minMetric = min(lengthStats) / qreal(thisLength);
        const qreal meanMetric = mean(lengthStats) / qreal(thisLength);
 
//        qDebug() << "G" << groupIndex
//                 << "L" << levelIndex
//                 << "con" << level.conflictWithGroup.size()
//                 << "FRP" << thisForeignPortion
//                 << "S" << level.numFilledPixels
//                 << ppVar(thisLength)
//                 << ppVar(min(lengthStats))
//                 << ppVar(mean(lengthStats))
//                 << ppVar(minMetric)
//                 << ppVar(meanMetric);
 
        if (!(thisForeignPortion > foreignEdgePortionThreshold)) continue;
 
        if (minMetric > 1.0 && meanMetric > 1.2) {
//            qDebug() << "   * removing...";
 
            QVector<TaskPoint> taskPoints =
                tryRemoveConflictingPlane(groupIndex, levelIndex);
 
            if (!taskPoints.isEmpty()) {
                // dump before
                // dumpGroupInfo(groupIndex, levelIndex);
 
                Q_FOREACH (const TaskPoint &pt, taskPoints) {
                    pointsQueue.push(pt);
                }
                processQueue(groupIndex);
 
                // dump after: should become empty!
                // dumpGroupInfo(groupIndex, levelIndex);
 
                // the areas might be disjoint, so that removing one "conflicting"
                // part will not remove the whole group+level pair
 
                // KIS_SAFE_ASSERT_RECOVER_NOOP(level.totalEdgeSize() == 0);
            }
 
            //dumpGroupMaps();
            //calcNumGroupMaps();
 
        }
    }
 
}

References KIS_SAFE_ASSERT_RECOVER_BREAK, and KIS_SAFE_ASSERT_RECOVER_NOOP.

dumpGroupInfo()

void KisWatershedWorker::Private::dumpGroupInfo	(	qint32	groupIndex,
		quint8	levelIndex )

Definition at line 979 of file KisWatershedWorker.cpp.

{
    FillGroup::LevelData &level = groups[groupIndex].levels[levelIndex];
 
    qDebug() << "G" << groupIndex << "L" << levelIndex << "CI" << this->groups[groupIndex].colorIndex;
    qDebug() << "   P" << level.positiveEdgeSize;
    qDebug() << "   N" << level.negativeEdgeSize;
    qDebug() << "   F" << level.foreignEdgeSize;
    qDebug() << "   A" << level.allyEdgeSize;
    qDebug() << " (S)" << level.numFilledPixels;
 
    auto &c = level.conflictWithGroup;
 
    for (auto cIt = c.begin(); cIt != c.end(); ++cIt) {
        qDebug() << "   C" << cIt.key() << cIt.value().size();
    }
}

dumpGroupMaps()

void KisWatershedWorker::Private::dumpGroupMaps

(

)

Definition at line 892 of file KisWatershedWorker.cpp.

{
    KisPaintDeviceSP groupDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
    KisPaintDeviceSP colorDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
    KisPaintDeviceSP pedgeDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
    KisPaintDeviceSP nedgeDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
    KisPaintDeviceSP fedgeDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
 
    KisSequentialConstIterator heightIt(heightMap, boundingRect);
    KisSequentialConstIterator srcIt(groupsMap, boundingRect);
    KisSequentialIterator dstGroupIt(groupDevice, boundingRect);
    KisSequentialIterator dstColorIt(colorDevice, boundingRect);
    KisSequentialIterator dstPedgeIt(pedgeDevice, boundingRect);
    KisSequentialIterator dstNedgeIt(nedgeDevice, boundingRect);
    KisSequentialIterator dstFedgeIt(fedgeDevice, boundingRect);
 
 
    QVector<KoColor> colors;
    for (auto it = keyStrokes.begin(); it != keyStrokes.end(); ++it) {
        KoColor color = it->color;
        color.convertTo(colorDevice->colorSpace());
        colors << color;
    }
    const int colorPixelSize = colorDevice->pixelSize();
 
 
 
    while (dstGroupIt.nextPixel() &&
           heightIt.nextPixel() &&
           srcIt.nextPixel() &&
           dstColorIt.nextPixel() &&
           dstPedgeIt.nextPixel() &&
           dstNedgeIt.nextPixel() &&
           dstFedgeIt.nextPixel()) {
 
        const qint32 *srcPtr = reinterpret_cast<const qint32*>(srcIt.rawDataConst());
 
        *dstGroupIt.rawData() = quint8(*srcPtr);
        memcpy(dstColorIt.rawData(), colors[groups[*srcPtr].colorIndex].data(), colorPixelSize);
 
        quint8 level = *heightIt.rawDataConst();
 
        if (groups[*srcPtr].levels.contains(level)) {
            const FillGroup::LevelData &l = groups[*srcPtr].levels[level];
 
            const int edgeLength = l.totalEdgeSize();
 
            *dstPedgeIt.rawData() = 255.0 * qreal(l.positiveEdgeSize) / (edgeLength);
            *dstNedgeIt.rawData() = 255.0 * qreal(l.negativeEdgeSize) / (edgeLength);
            *dstFedgeIt.rawData() = 255.0 * qreal(l.foreignEdgeSize) / (edgeLength);
        } else {
            *dstPedgeIt.rawData() = 0;
            *dstNedgeIt.rawData() = 0;
            *dstFedgeIt.rawData() = 0;
        }
    }
 
 
    KIS_DUMP_DEVICE_2(groupDevice, boundingRect, "01_groupMap", "dd");
    KIS_DUMP_DEVICE_2(colorDevice, boundingRect, "02_colorMap", "dd");
    KIS_DUMP_DEVICE_2(pedgeDevice, boundingRect, "03_pedgeMap", "dd");
    KIS_DUMP_DEVICE_2(nedgeDevice, boundingRect, "04_nedgeMap", "dd");
    KIS_DUMP_DEVICE_2(fedgeDevice, boundingRect, "05_fedgeMap", "dd");
}

References KisPaintDevice::colorSpace(), KoColor::convertTo(), KoColorSpaceRegistry::instance(), KIS_DUMP_DEVICE_2, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisPaintDevice::pixelSize(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst().

initializeQueueFromGroupMap()

void KisWatershedWorker::Private::initializeQueueFromGroupMap

(

const QRect &

rc

)

Definition at line 373 of file KisWatershedWorker.cpp.

{
    KisSequentialIterator groupMapIt(groupsMap, rc);
    KisSequentialConstIterator heightMapIt(heightMap, rc);
 
    while (groupMapIt.nextPixel() &&
           heightMapIt.nextPixel()) {
 
        qint32 *groupPtr = reinterpret_cast<qint32*>(groupMapIt.rawData());
        const quint8 *heightPtr = heightMapIt.rawDataConst();
 
        if (*groupPtr > 0) {
            TaskPoint pt;
            pt.x = groupMapIt.x();
            pt.y = groupMapIt.y();
            pt.group = *groupPtr;
            pt.level = *heightPtr;
 
            pointsQueue.push(pt);
 
            // we must clear the pixel to make sure foreign metric is calculated correctly
            *groupPtr = 0;
        }
 
    }
}

References groupsMap, heightMap, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), pointsQueue, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

processQueue()

void KisWatershedWorker::Private::processQueue

(

qint32

_backgroundGroupId

)

Definition at line 623 of file KisWatershedWorker.cpp.

{
    QElapsedTimer tt; tt.start();
 
 
    // TODO: lazy initialization of the iterator's position
    // TODO: reuse iterators if possible!
    groupIt = groupsMap->createRandomAccessorNG();
    levelIt = heightMap->createRandomConstAccessorNG();
    backgroundGroupId = _backgroundGroupId;
    backgroundGroupColor = groups[backgroundGroupId].colorIndex;
    recolorMode = backgroundGroupId > 1;
 
    totalPixelsToFill = qint64(boundingRect.width()) * boundingRect.height();
    numFilledPixels = 0;
    const int progressReportingMask = (1 << 18) - 1; // report every 512x512 patch
 
 
    if (recolorMode) {
        updateNarrowRegionMetrics();
    }
 
    while (!pointsQueue.empty()) {
        TaskPoint pt = pointsQueue.top();
        pointsQueue.pop();
 
        groupIt->moveTo(pt.x, pt.y);
        qint32 *groupPtr = reinterpret_cast<qint32*>(groupIt->rawData());
 
        const qint32 prevGroupId = *groupPtr;
        FillGroup &prevGroup = groups[prevGroupId];
 
        if (prevGroupId == backgroundGroupId ||
            (recolorMode &&
             prevGroup.colorIndex == backgroundGroupColor)) {
 
            FillGroup &currGroup = groups[pt.group];
            FillGroup::LevelData &currLevelData = currGroup.levels[pt.level];
            currLevelData.numFilledPixels++;
 
            if (prevGroupId > 0) {
                FillGroup::LevelData &prevLevelData = prevGroup.levels[pt.level];
                prevLevelData.numFilledPixels--;
            } else {
                numFilledPixels++;
            }
 
            const NeighbourStaticOffset *offsets = staticOffsets[pt.prevDirection];
            const QPoint currPt(pt.x, pt.y);
 
            for (int i = 0; i < 4; i++) {
                const NeighbourStaticOffset &offset = offsets[i];
 
                const QPoint nextPt = currPt + offset.offset;
                visitNeighbour(nextPt, currPt,
                               offset.from, pt.distance, pt.level,
                               pt.group, currGroup, currLevelData,
                               prevGroupId, prevGroup,
                               offset.statsOnly);
            }
 
            *groupPtr = pt.group;
 
            if (progressUpdater && !(numFilledPixels & progressReportingMask)) {
                const int progressPercent =
                    qBound(0, qRound(100.0 * numFilledPixels / totalPixelsToFill), 100);
                progressUpdater->setProgress(progressPercent);
                if (progressUpdater->interrupted()) {
                    break;
                }
 
            }
 
        } else {
            // nothing to do?
        }
 
    }
 
    // cleanup iterators
    groupIt.clear();
    levelIt.clear();
    backgroundGroupId = 0;
    backgroundGroupColor = -1;
    recolorMode = false;
 
//    ENTER_FUNCTION() << ppVar(tt.elapsed());
}

References KisPaintDevice::createRandomConstAccessorNG().

tryRemoveConflictingPlane()

QVector< TaskPoint > KisWatershedWorker::Private::tryRemoveConflictingPlane	(	qint32	group,
		quint8	level )

Definition at line 737 of file KisWatershedWorker.cpp.

{
    QVector<TaskPoint> result;
 
    FillGroup &g = groups[group];
    FillGroup::LevelData &l = g.levels[level];
 
    for (auto conflictIt = l.conflictWithGroup.begin(); conflictIt != l.conflictWithGroup.end(); ++conflictIt) {
 
        std::vector<QPoint> uniquePoints;
        std::unique_copy(conflictIt->begin(), conflictIt->end(), std::back_inserter(uniquePoints));
 
        for (auto pointIt = uniquePoints.begin(); pointIt != uniquePoints.end(); ++pointIt) {
            TaskPoint pt;
            pt.x = pointIt->x();
            pt.y = pointIt->y();
            pt.group = conflictIt.key();
            pt.level = level;
 
            result.append(pt);
            // no writing to the group map!
        }
    }
 
    return result;
}

updateGroupLastDistance()

ALWAYS_INLINE void KisWatershedWorker::Private::updateGroupLastDistance	(	FillGroup::LevelData &	levelData,
		int	distance )

updateNarrowRegionMetrics()

void KisWatershedWorker::Private::updateNarrowRegionMetrics

(

)

Definition at line 764 of file KisWatershedWorker.cpp.

{
    for (qint32 i = 0; i < groups.size(); i++) {
        FillGroup &group = groups[i];
 
        for (auto levelIt = group.levels.begin(); levelIt != group.levels.end(); ++levelIt) {
            FillGroup::LevelData &l = levelIt.value();
 
            const qreal areaToPerimeterRatio = qreal(l.numFilledPixels) / l.totalEdgeSize();
            l.narrowRegion = areaToPerimeterRatio < 2.0;
        }
    }
}

visitNeighbour()

void KisWatershedWorker::Private::visitNeighbour	(	const QPoint &	currPt,
		const QPoint &	prevPt,
		quint8	fromDirection,
		int	prevDistance,
		quint8	prevLevel,
		qint32	prevGroupId,
		FillGroup &	prevGroup,
		FillGroup::LevelData &	prevLevelData,
		qint32	prevPrevGroupId,
		FillGroup &	prevPrevGroup,
		bool	statsOnly = false )

Definition at line 487 of file KisWatershedWorker.cpp.

{
    if (!boundingRect.contains(currPt)) {
        prevLevelData.positiveEdgeSize++;
 
        if (prevPrevGroupId > 0) {
            FillGroup::LevelData &prevPrevLevelData = prevPrevGroup.levels[prevLevel];
            prevPrevLevelData.positiveEdgeSize--;
        }
        return;
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(prevGroupId != backgroundGroupId);
 
    groupIt->moveTo(currPt.x(), currPt.y());
    levelIt->moveTo(currPt.x(), currPt.y());
 
    const qint32 currGroupId = *reinterpret_cast<const qint32*>(groupIt->rawDataConst());
    const quint8 newLevel = *levelIt->rawDataConst();
 
    FillGroup &currGroup = groups[currGroupId];
    FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
 
    const bool needsAddTaskPoint =
        !currGroupId ||
        (recolorMode &&
         ((newLevel == prevLevel &&
           currGroupId == backgroundGroupId) ||
          (newLevel >= prevLevel &&
           currGroup.colorIndex == backgroundGroupColor &&
           currLevelData.narrowRegion)));
 
    if (needsAddTaskPoint && !statsOnly) {
        TaskPoint pt;
        pt.x = currPt.x();
        pt.y = currPt.y();
        pt.group = prevGroupId;
        pt.level = newLevel;
        pt.distance = newLevel == prevLevel ? prevDistance + 1 : 0;
        pt.prevDirection = fromDirection;
 
        pointsQueue.push(pt);
    }
 
    // we can never clear the pixel!
    KIS_SAFE_ASSERT_RECOVER_RETURN(prevGroupId > 0);
    KIS_SAFE_ASSERT_RECOVER_RETURN(prevGroupId != prevPrevGroupId);
 
    if (currGroupId) {
        const bool isSameLevel = prevLevel == newLevel;
 
 
        if ((!prevPrevGroupId ||
             prevPrevGroupId == currGroupId) &&
            prevGroupId != currGroupId) {
 
            // we have added a foreign/ally group
 
            FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
 
            addForeignAlly(currGroupId, prevGroupId,
                           currGroup, prevGroup,
                           currLevelData, prevLevelData,
                           currPt, prevPt,
                           isSameLevel);
 
        } else if (prevPrevGroupId &&
                   prevPrevGroupId != currGroupId &&
                   prevGroupId == currGroupId) {
 
            // we have removed a foreign/ally group
 
            FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
            FillGroup::LevelData &prevPrevLevelData = prevPrevGroup.levels[prevLevel];
 
            removeForeignAlly(currGroupId, prevPrevGroupId,
                              currGroup, prevPrevGroup,
                              currLevelData, prevPrevLevelData,
                              currPt, prevPt,
                              isSameLevel);
 
        } else if (prevPrevGroupId &&
                   prevPrevGroupId != currGroupId &&
                   prevGroupId != currGroupId) {
 
            // this pixel has become an foreign/ally pixel of a different group
 
            FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
 
            FillGroup &prevPrevGroup = groups[prevPrevGroupId];
            FillGroup::LevelData &prevPrevLevelData = prevPrevGroup.levels[prevLevel];
 
            removeForeignAlly(currGroupId, prevPrevGroupId,
                              currGroup, prevPrevGroup,
                              currLevelData, prevPrevLevelData,
                              currPt, prevPt,
                              isSameLevel);
 
            addForeignAlly(currGroupId, prevGroupId,
                           currGroup, prevGroup,
                           currLevelData, prevLevelData,
                           currPt, prevPt,
                           isSameLevel);
        }
 
        if (!isSameLevel) {
 
            if (prevGroupId == currGroupId) {
                // we connected with our own disjoint area
 
                FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
 
                incrementLevelEdge(currLevelData, prevLevelData,
                                   newLevel, prevLevel);
            }
 
            if (prevPrevGroupId == currGroupId) {
                // we removed a pixel for the borderline
                // (now it is registered as foreign/ally pixel)
 
                FillGroup::LevelData &currLevelData = currGroup.levels[newLevel];
                FillGroup::LevelData &prevPrevLevelData = currGroup.levels[prevLevel];
 
                decrementLevelEdge(currLevelData, prevPrevLevelData,
                                   newLevel, prevLevel);
            }
        }
    }
}

References addForeignAlly(), decrementLevelEdge(), incrementLevelEdge(), KIS_SAFE_ASSERT_RECOVER_RETURN, and removeForeignAlly().

writeColoring()

void KisWatershedWorker::Private::writeColoring

(

)

Definition at line 712 of file KisWatershedWorker.cpp.

{
    KisSequentialConstIterator srcIt(groupsMap, boundingRect);
    KisSequentialIterator dstIt(dstDevice, boundingRect);
 
    QVector<KoColor> colors;
    for (auto it = keyStrokes.begin(); it != keyStrokes.end(); ++it) {
        KoColor color = it->color;
        color.convertTo(dstDevice->colorSpace());
        colors << color;
    }
    const int colorPixelSize = dstDevice->pixelSize();
 
 
    while (srcIt.nextPixel() && dstIt.nextPixel()) {
        const qint32 *srcPtr = reinterpret_cast<const qint32*>(srcIt.rawDataConst());
 
        const int colorIndex = groups[*srcPtr].colorIndex;
        if (colorIndex >= 0) {
            memcpy(dstIt.rawData(), colors[colorIndex].data(), colorPixelSize);
        }
 
    }
}

References KoColor::convertTo(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst().

Member Data Documentation

backgroundGroupColor

int KisWatershedWorker::Private::backgroundGroupColor = -1

Definition at line 215 of file KisWatershedWorker.cpp.

backgroundGroupId

qint32 KisWatershedWorker::Private::backgroundGroupId = 0

Definition at line 214 of file KisWatershedWorker.cpp.

boundingRect

QRect KisWatershedWorker::Private::boundingRect

Definition at line 202 of file KisWatershedWorker.cpp.

dstDevice

KisPaintDeviceSP KisWatershedWorker::Private::dstDevice

Definition at line 200 of file KisWatershedWorker.cpp.

groupIt

KisRandomAccessorSP KisWatershedWorker::Private::groupIt

Definition at line 212 of file KisWatershedWorker.cpp.

groups

QVector<FillGroup> KisWatershedWorker::Private::groups

Definition at line 205 of file KisWatershedWorker.cpp.

groupsMap

KisPaintDeviceSP KisWatershedWorker::Private::groupsMap

Definition at line 206 of file KisWatershedWorker.cpp.

heightMap

KisPaintDeviceSP KisWatershedWorker::Private::heightMap

Definition at line 199 of file KisWatershedWorker.cpp.

keyStrokes

QVector<KeyStroke> KisWatershedWorker::Private::keyStrokes

Definition at line 203 of file KisWatershedWorker.cpp.

levelIt

KisRandomConstAccessorSP KisWatershedWorker::Private::levelIt

Definition at line 213 of file KisWatershedWorker.cpp.

numFilledPixels

quint64 KisWatershedWorker::Private::numFilledPixels = 0

Definition at line 219 of file KisWatershedWorker.cpp.

pointsComparator

CompareTaskPoints KisWatershedWorker::Private::pointsComparator

Definition at line 208 of file KisWatershedWorker.cpp.

pointsQueue

PointsPriorityQueue KisWatershedWorker::Private::pointsQueue

Definition at line 209 of file KisWatershedWorker.cpp.

progressUpdater

KoUpdater* KisWatershedWorker::Private::progressUpdater = 0

Definition at line 221 of file KisWatershedWorker.cpp.

recolorMode

bool KisWatershedWorker::Private::recolorMode = false

Definition at line 216 of file KisWatershedWorker.cpp.

totalPixelsToFill

quint64 KisWatershedWorker::Private::totalPixelsToFill = 0

Definition at line 218 of file KisWatershedWorker.cpp.

---

The documentation for this struct was generated from the following file:

• libs/image/lazybrush/KisWatershedWorker.cpp