KritaUtils Namespace Reference

Classes
struct	ExportFileJob
struct	is_appendable_container
struct	is_container

Enumerations
enum	BackgroudSavingStartResult { Success = 0 , Failure = 1 , AnotherSavingInProgress = 2 , ImageLockFailure = 3 }
enum	DeviceCopyMode { CopySnapshot = 0 , CopyAllFrames }
enum	SaveFlag { SaveNone = 0 , SaveShowWarnings = 0x1 , SaveIsExporting = 0x2 , SaveInAutosaveMode = 0x4 }
enum	ThresholdMode { ThresholdNone = 0 , ThresholdFloor , ThresholdCeil , ThresholdMaxOut }

Functions
template<typename Func , typename Job >
void	addJobBarrier (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobBarrier (QVector< Job * > &jobs, int lod, Func func)
template<typename Func , typename Job >
void	addJobBarrierExclusive (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobBarrierExclusiveNoCancel (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobBarrierNoCancel (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobConcurrent (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobConcurrent (QVector< Job * > &jobs, int lod, Func func)
template<typename Func , typename Job >
void	addJobConcurrentNoCancel (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobSequential (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobSequential (QVector< Job * > &jobs, int lod, Func func)
template<typename Func , typename Job >
void	addJobSequentialExclusive (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobSequentialExclusive (QVector< Job * > &jobs, int lod, Func func)
template<typename Func , typename Job >
void	addJobSequentialExclusiveNoCancel (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobSequentialNoCancel (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobUniquelyConcurrent (QVector< Job * > &jobs, Func func)
template<typename Func , typename Job >
void	addJobUniquelyConcurrent (QVector< Job * > &jobs, int lod, Func func)
template<typename Func , typename Job >
void	addJobUniquelyConcurrentNoCancel (QVector< Job * > &jobs, Func func)
void	applyToAlpha8Device (KisPaintDeviceSP dev, const QRect &rc, std::function< void(quint8)> func)
bool	checkInTriangle (const QRectF &rect, const QPolygonF &triangle)
bool	compareChannelFlags (QBitArray f1, QBitArray f2)
template<class T >
bool	compareListsUnordered (const QList< T > &a, const QList< T > &b)
QImage	convertQImageToGrayA (const QImage &image)
qreal	estimatePortionOfTransparentPixels (KisPaintDeviceSP dev, const QRect &rect, qreal samplePortion)
boost::optional< QPointF >	fetchControlPoint (KoPathPoint *pt, bool takeFirst)
void	filterAlpha8Device (KisPaintDeviceSP dev, const QRect &rc, std::function< quint8(quint8)> func)
template<class C , typename KeepIfFunction >
auto	filterContainer (C &container, KeepIfFunction keepIf) -> decltype(bool(keepIf(container[0])), void())
template<class C >
void	makeContainerUnique (C &container)
void	makeSymmetric (KoPathPoint *pt, bool copyFromFirst)
qreal KRITAIMAGE_EXPORT	maxDimensionPortion (const QRectF &bounds, qreal portion, qreal minValue)
QBitArray	mergeChannelFlags (const QBitArray &childFlags, const QBitArray &parentFlags)
qreal	mergeOpacityF (qreal opacity, qreal parentOpacity)
quint8	mergeOpacityU8 (quint8 opacity, quint8 parentOpacity)
void	mirrorDab (Qt::Orientation dir, const QPoint &center, KisRenderedDab *dab, bool skipMirrorPixels)
void	mirrorDab (Qt::Orientation dir, const QPointF &center, KisRenderedDab *dab, bool skipMirrorPixels)
void	mirrorPoint (Qt::Orientation dir, const QPoint &center, QPointF *pt)
void	mirrorPoint (Qt::Orientation dir, const QPointF &center, QPointF *pt)
void	mirrorRect (Qt::Orientation dir, const QPoint &center, QRect *rc)
void	mirrorRect (Qt::Orientation dir, const QPointF &center, QRect *rc)
KisNodeSP	nearestNodeAfterRemoval (KisNodeSP node)
QSize	optimalPatchSize ()
QTransform	pathShapeBooleanSpaceWorkaround (KisImageSP image)
QString KRITAIMAGE_EXPORT	prettyFormatReal (qreal value)
template<class PixelProcessor >
void	processTwoDevices (const QRect &rc, KisRandomConstAccessorSP srcIt, KisRandomAccessorSP dstIt, const int srcPixelSize, const int dstPixelSize, PixelProcessor pixelProcessor)
template<class PixelProcessor >
void	processTwoDevicesWithStrides (const QRect &rc, KisRandomConstAccessorSP srcIt, KisRandomAccessorSP dstIt, PixelProcessor pixelProcessor)
QVector< QPoint >	rasterizeHLine (const QPoint &startPoint, const QPoint &endPoint)
template<typename Visitor >
void	rasterizeHLine (const QPoint &startPoint, const QPoint &endPoint, Visitor visitor)
QVector< QPoint >	rasterizeLineDDA (const QPoint &startPoint, const QPoint &endPoint)
template<typename Visitor >
void	rasterizeLineDDA (const QPoint &startPoint, const QPoint &endPoint, Visitor visitor)
QVector< QPoint >	rasterizePolygonDDA (const QVector< QPoint > &polygonPoints)
template<typename Visitor >
void	rasterizePolygonDDA (const QVector< QPoint > &polygonPoints, Visitor visitor)
QVector< QPoint >	rasterizePolylineDDA (const QVector< QPoint > &polylinePoints)
template<typename Visitor >
void	rasterizePolylineDDA (const QVector< QPoint > &polylinePoints, Visitor visitor)
QVector< QPoint >	rasterizeVLine (const QPoint &startPoint, const QPoint &endPoint)
template<typename Visitor >
void	rasterizeVLine (const QPoint &startPoint, const QPoint &endPoint, Visitor visitor)
void	renderExactRect (QPainter *p, const QRect &rc)
void	renderExactRect (QPainter *p, const QRect &rc, const QPen &pen)
QString	resolveAbsoluteFilePath (const QString &baseDir, const QString &filePath)
	Resolve absolute file path from a file path and base dir.
void	restoreControlPoint (KoPathPoint *pt, bool restoreFirst, boost::optional< QPointF > savedPoint)
QList< QPainterPath >	splitDisjointPaths (const QPainterPath &path)
KisRegion	splitPath (const QPainterPath &path)
QVector< QRect >	splitRectIntoPatches (const QRect &rc, const QSize &patchSize)
QVector< QRect >	splitRectIntoPatchesTight (const QRect &rc, const QSize &patchSize)
QVector< QRect >	splitRegionIntoPatches (const KisRegion &region, const QSize &patchSize)
QVector< QRect > KRITAIMAGE_EXPORT	splitRegionIntoPatches (const QRegion &region, const QSize &patchSize)
KisRegion	splitTriangles (const QPointF &center, const QVector< QPointF > &points)
void	thresholdOpacity (KisPaintDeviceSP device, const QRect &rect, ThresholdMode mode)
void	thresholdOpacityAlpha8 (KisPaintDeviceSP device, const QRect &rect, ThresholdMode mode)
QString KRITAIMAGE_EXPORT	toLocalizedOnOff (bool value)
QPainterPath	tryCloseTornSubpathsAfterIntersection (QPainterPath path)
bool	tryMergePoints (QPainterPath &path, const QPointF &startPoint, const QPointF &endPoint, qreal &distance, qreal distanceThreshold, bool lastSegment)
QPainterPath	trySimplifyPath (const QPainterPath &path, qreal lengthThreshold)
KisImportExportErrorCode	workaroundUnsuitableImageColorSpace (KisImageSP image, KisImportUserFeedbackInterface *feedbackInterface, KisImageBarrierLock &lock)

Enumeration Type Documentation

BackgroudSavingStartResult

enum KritaUtils::BackgroudSavingStartResult

Enumerator
Success
Failure
AnotherSavingInProgress
ImageLockFailure

Definition at line 31 of file KisImportExportUtils.h.

                                {
    Success = 0,
    Failure = 1,
    AnotherSavingInProgress = 2,
    ImageLockFailure = 3
};

DeviceCopyMode

enum KritaUtils::DeviceCopyMode

Enumerator
CopySnapshot
CopyAllFrames

Definition at line 51 of file kis_paint_device.h.

                    {
    CopySnapshot = 0,
    CopyAllFrames
};

SaveFlag

enum KritaUtils::SaveFlag

Enumerator
SaveNone
SaveShowWarnings
SaveIsExporting
SaveInAutosaveMode

Definition at line 24 of file KisImportExportUtils.h.

              {
    SaveNone = 0,
    SaveShowWarnings = 0x1,
    SaveIsExporting = 0x2,
    SaveInAutosaveMode = 0x4
};

ThresholdMode

enum KritaUtils::ThresholdMode

Enumerator
ThresholdNone
ThresholdFloor
ThresholdCeil
ThresholdMaxOut

Definition at line 131 of file krita_utils.h.

                       {
        ThresholdNone = 0,
        ThresholdFloor,
        ThresholdCeil,
        ThresholdMaxOut
    };

Function Documentation

addJobBarrier() [1/2]

template<typename Func , typename Job >

void KritaUtils::addJobBarrier	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 35 of file KisRunnableStrokeJobUtils.h.

                                                   {
    jobs.append(new KisRunnableStrokeJobData(func, KisStrokeJobData::BARRIER));
}

References KisStrokeJobData::BARRIER.

addJobBarrier() [2/2]

template<typename Func , typename Job >

void KritaUtils::addJobBarrier	(	QVector< Job * > &	jobs,
		int	lod,
		Func	func )

Definition at line 71 of file KisRunnableStrokeJobUtils.h.

                                                            {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::BARRIER);
    data->setLevelOfDetailOverride(lod);
    jobs.append(data);
}

References KisStrokeJobData::BARRIER.

addJobBarrierExclusive()

template<typename Func , typename Job >

void KritaUtils::addJobBarrierExclusive	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 40 of file KisRunnableStrokeJobUtils.h.

                                                            {
    jobs.append(new KisRunnableStrokeJobData(func, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE));
}

References KisStrokeJobData::BARRIER, and KisStrokeJobData::EXCLUSIVE.

addJobBarrierExclusiveNoCancel()

template<typename Func , typename Job >

void KritaUtils::addJobBarrierExclusiveNoCancel	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 115 of file KisRunnableStrokeJobUtils.h.

                                                                    {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
    data->setCancellable(false);
    jobs.append(data);
}

References KisStrokeJobData::BARRIER, and KisStrokeJobData::EXCLUSIVE.

addJobBarrierNoCancel()

template<typename Func , typename Job >

void KritaUtils::addJobBarrierNoCancel	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 108 of file KisRunnableStrokeJobUtils.h.

                                                           {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::BARRIER);
    data->setCancellable(false);
    jobs.append(data);
}

References KisStrokeJobData::BARRIER.

addJobConcurrent() [1/2]

template<typename Func , typename Job >

void KritaUtils::addJobConcurrent	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 30 of file KisRunnableStrokeJobUtils.h.

                                                      {
    jobs.append(new KisRunnableStrokeJobData(func, KisStrokeJobData::CONCURRENT));
}

References KisStrokeJobData::CONCURRENT.

addJobConcurrent() [2/2]

template<typename Func , typename Job >

void KritaUtils::addJobConcurrent	(	QVector< Job * > &	jobs,
		int	lod,
		Func	func )

Definition at line 64 of file KisRunnableStrokeJobUtils.h.

                                                               {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::CONCURRENT);
    data->setLevelOfDetailOverride(lod);
    jobs.append(data);
}

References KisStrokeJobData::CONCURRENT.

addJobConcurrentNoCancel()

template<typename Func , typename Job >

void KritaUtils::addJobConcurrentNoCancel	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 101 of file KisRunnableStrokeJobUtils.h.

                                                              {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::CONCURRENT);
    data->setCancellable(false);
    jobs.append(data);
}

References KisStrokeJobData::CONCURRENT.

addJobSequential() [1/2]

template<typename Func , typename Job >

void KritaUtils::addJobSequential	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 19 of file KisRunnableStrokeJobUtils.h.

                                                      {
    jobs.append(new KisRunnableStrokeJobData(func, KisStrokeJobData::SEQUENTIAL));
}

References KisStrokeJobData::SEQUENTIAL.

addJobSequential() [2/2]

template<typename Func , typename Job >

void KritaUtils::addJobSequential	(	QVector< Job * > &	jobs,
		int	lod,
		Func	func )

Definition at line 50 of file KisRunnableStrokeJobUtils.h.

                                                               {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::SEQUENTIAL);
    data->setLevelOfDetailOverride(lod);
    jobs.append(data);
}

References KisStrokeJobData::SEQUENTIAL.

addJobSequentialExclusive() [1/2]

template<typename Func , typename Job >

void KritaUtils::addJobSequentialExclusive	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 24 of file KisRunnableStrokeJobUtils.h.

                                                               {
    jobs.append(new KisRunnableStrokeJobData(func, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE));
}

References KisStrokeJobData::EXCLUSIVE, and KisStrokeJobData::SEQUENTIAL.

addJobSequentialExclusive() [2/2]

template<typename Func , typename Job >

void KritaUtils::addJobSequentialExclusive	(	QVector< Job * > &	jobs,
		int	lod,
		Func	func )

Definition at line 57 of file KisRunnableStrokeJobUtils.h.

                                                                        {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
    data->setLevelOfDetailOverride(lod);
    jobs.append(data);
}

References KisStrokeJobData::EXCLUSIVE, and KisStrokeJobData::SEQUENTIAL.

addJobSequentialExclusiveNoCancel()

template<typename Func , typename Job >

void KritaUtils::addJobSequentialExclusiveNoCancel	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 93 of file KisRunnableStrokeJobUtils.h.

                                                                       {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
    data->setCancellable(false);
    jobs.append(data);
}

References KisStrokeJobData::EXCLUSIVE, and KisStrokeJobData::SEQUENTIAL.

addJobSequentialNoCancel()

template<typename Func , typename Job >

void KritaUtils::addJobSequentialNoCancel	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 86 of file KisRunnableStrokeJobUtils.h.

                                                              {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::SEQUENTIAL);
    data->setCancellable(false);
    jobs.append(data);
}

References KisStrokeJobData::SEQUENTIAL.

addJobUniquelyConcurrent() [1/2]

template<typename Func , typename Job >

void KritaUtils::addJobUniquelyConcurrent	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 45 of file KisRunnableStrokeJobUtils.h.

                                                              {
    jobs.append(new KisRunnableStrokeJobData(func, KisStrokeJobData::UNIQUELY_CONCURRENT));
}

References KisStrokeJobData::UNIQUELY_CONCURRENT.

addJobUniquelyConcurrent() [2/2]

template<typename Func , typename Job >

void KritaUtils::addJobUniquelyConcurrent	(	QVector< Job * > &	jobs,
		int	lod,
		Func	func )

Definition at line 78 of file KisRunnableStrokeJobUtils.h.

                                                                       {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::UNIQUELY_CONCURRENT);
    data->setLevelOfDetailOverride(lod);
    jobs.append(data);
}

References KisStrokeJobData::UNIQUELY_CONCURRENT.

addJobUniquelyConcurrentNoCancel()

template<typename Func , typename Job >

void KritaUtils::addJobUniquelyConcurrentNoCancel	(	QVector< Job * > &	jobs,
		Func	func )

Definition at line 122 of file KisRunnableStrokeJobUtils.h.

                                                                      {
    Job* data = new KisRunnableStrokeJobData(func, KisStrokeJobData::UNIQUELY_CONCURRENT);
    data->setCancellable(false);
    jobs.append(data);
}

References KisStrokeJobData::UNIQUELY_CONCURRENT.

applyToAlpha8Device()

void KRITAIMAGE_EXPORT KritaUtils::applyToAlpha8Device	(	KisPaintDeviceSP	dev,
		const QRect &	rc,
		std::function< void(quint8)>	func )

Definition at line 407 of file krita_utils.cpp.

                                                                                                    {
        KisSequentialConstIterator dstIt(dev, rc);
        while (dstIt.nextPixel()) {
            const quint8 *dstPtr = dstIt.rawDataConst();
            func(*dstPtr);
        }
    }

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

checkInTriangle()

bool KritaUtils::checkInTriangle	(	const QRectF &	rect,
		const QPolygonF &	triangle )

Definition at line 97 of file krita_utils.cpp.

    {
        return triangle.intersected(rect).boundingRect().isValid();
    }

compareChannelFlags()

bool KRITAIMAGE_EXPORT KritaUtils::compareChannelFlags	(	QBitArray	f1,
		QBitArray	f2 )

Definition at line 343 of file krita_utils.cpp.

    {
        if (f1.isNull() && f2.isNull()) return true;
 
        if (f1.isNull()) {
            f1.fill(true, f2.size());
        }
 
        if (f2.isNull()) {
            f2.fill(true, f1.size());
        }
 
        return f1 == f2;
    }

compareListsUnordered()

template<class T >

bool KritaUtils::compareListsUnordered	(	const QList< T > &	a,
		const QList< T > &	b )

Definition at line 17 of file krita_container_utils.h.

                                                                     {
    if (a.size() != b.size()) return false;
 
    Q_FOREACH(const T &t, a) {
        if (!b.contains(t)) return false;
    }
 
    return true;
}

convertQImageToGrayA()

QImage KRITAIMAGE_EXPORT KritaUtils::convertQImageToGrayA

(

const QImage &

image

)

Definition at line 390 of file krita_utils.cpp.

    {
        QImage dstImage(image.size(), QImage::Format_ARGB32);
 
        // TODO: if someone feel bored, a more optimized version of this would be welcome
        const QSize size = image.size();
        for(int y = 0; y < size.height(); ++y) {
            for(int x = 0; x < size.width(); ++x) {
                const QRgb pixel = image.pixel(x,y);
                const int gray = qGray(pixel);
                dstImage.setPixel(x, y, qRgba(gray, gray, gray, qAlpha(pixel)));
            }
        }
 
        return dstImage;
    }

estimatePortionOfTransparentPixels()

qreal KRITAIMAGE_EXPORT KritaUtils::estimatePortionOfTransparentPixels	(	KisPaintDeviceSP	dev,
		const QRect &	rect,
		qreal	samplePortion )

Definition at line 423 of file krita_utils.cpp.

                                                                                                           {
        const KoColorSpace *cs = dev->colorSpace();
 
        const qreal linearPortion = std::sqrt(samplePortion);
        const qreal ratio = qreal(rect.width()) / rect.height();
        const int xStep = qMax(1, qRound(1.0 / linearPortion * ratio));
        const int yStep = qMax(1, qRound(1.0 / linearPortion / ratio));
 
        int numTransparentPixels = 0;
        int numPixels = 0;
 
        KisRandomConstAccessorSP it = dev->createRandomConstAccessorNG();
        for (int y = rect.y(); y <= rect.bottom(); y += yStep) {
            for (int x = rect.x(); x <= rect.right(); x += xStep) {
                it->moveTo(x, y);
                const quint8 alpha = cs->opacityU8(it->rawDataConst());
 
                if (alpha != OPACITY_OPAQUE_U8) {
                    numTransparentPixels++;
                }
 
                numPixels++;
            }
        }
 
        if (numPixels == 0) {
            return 0; // avoid dividing by 0
        }
        return qreal(numTransparentPixels) / numPixels;
    }

References KisPaintDevice::colorSpace(), KisPaintDevice::createRandomConstAccessorNG(), KisRandomConstAccessorNG::moveTo(), OPACITY_OPAQUE_U8, KoColorSpace::opacityU8(), and KisBaseConstAccessor::rawDataConst().

fetchControlPoint()

boost::optional< QPointF > KritaUtils::fetchControlPoint	(	KoPathPoint *	pt,
		bool	takeFirst )

Definition at line 11 of file KoPathMergeUtils.cpp.

{
    boost::optional<QPointF> result;
 
    if (takeFirst) {
        if (pt->activeControlPoint1()) {
            result = pt->controlPoint1();
        }
    } else {
        if (pt->activeControlPoint2()) {
            result = pt->controlPoint2();
        }
    }
 
    return result;
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathPoint::controlPoint1, and KoPathPoint::controlPoint2.

filterAlpha8Device()

void KRITAIMAGE_EXPORT KritaUtils::filterAlpha8Device	(	KisPaintDeviceSP	dev,
		const QRect &	rc,
		std::function< quint8(quint8)>	func )

Definition at line 415 of file krita_utils.cpp.

                                                                                                     {
        KisSequentialIterator dstIt(dev, rc);
        while (dstIt.nextPixel()) {
            quint8 *dstPtr = dstIt.rawData();
            *dstPtr = func(*dstPtr);
        }
    }

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

filterContainer()

template<class C , typename KeepIfFunction >

auto KritaUtils::filterContainer	(	C &	container,
		KeepIfFunction	keepIf ) -> decltype(bool(keepIf(container[0])), void())

Definition at line 39 of file krita_container_utils.h.

                                                        {
 
        auto newEnd = std::remove_if(container.begin(), container.end(), [keepIf] (typename C::reference p) { return !keepIf(p); });
        while (newEnd != container.end()) {
           newEnd = container.erase(newEnd);
        }
}

References p.

makeContainerUnique()

template<class C >

void KritaUtils::makeContainerUnique

(

C &

container

)

Definition at line 28 of file krita_container_utils.h.

                                           {
    std::sort(container.begin(), container.end());
    auto newEnd = std::unique(container.begin(), container.end());
 
    while (newEnd != container.end()) {
        newEnd = container.erase(newEnd);
    }
}

makeSymmetric()

void KritaUtils::makeSymmetric	(	KoPathPoint *	pt,
		bool	copyFromFirst )

Definition at line 28 of file KoPathMergeUtils.cpp.

{
    if (copyFromFirst) {
        if (pt->activeControlPoint1()) {
            pt->setControlPoint2(2.0 * pt->point() - pt->controlPoint1());
        }
    } else {
        if (pt->activeControlPoint2()) {
            pt->setControlPoint1(2.0 * pt->point() - pt->controlPoint2());
        }
    }
 
    pt->setProperty(KoPathPoint::IsSymmetric);
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, KoPathPoint::IsSymmetric, KoPathPoint::point, KoPathPoint::setControlPoint1(), KoPathPoint::setControlPoint2(), and KoPathPoint::setProperty().

maxDimensionPortion()

qreal KRITAIMAGE_EXPORT KritaUtils::maxDimensionPortion	(	const QRectF &	bounds,
		qreal	portion,
		qreal	minValue )

Definition at line 190 of file krita_utils.cpp.

    {
        qreal maxDimension = qMax(bounds.width(), bounds.height());
        return qMax(portion * maxDimension, minValue);
    }

References bounds.

mergeChannelFlags()

QBitArray KRITAIMAGE_EXPORT KritaUtils::mergeChannelFlags	(	const QBitArray &	childFlags,
		const QBitArray &	parentFlags )

Definition at line 326 of file krita_utils.cpp.

    {
        QBitArray flags = childFlags;
 
        if (!flags.isEmpty() &&
            !parentFlags.isEmpty() &&
            flags.size() == parentFlags.size()) {
 
            flags &= parentFlags;
 
        } else if (!parentFlags.isEmpty()) {
            flags = parentFlags;
        }
 
        return flags;
    }

mergeOpacityF()

qreal KRITAIMAGE_EXPORT KritaUtils::mergeOpacityF	(	qreal	opacity,
		qreal	parentOpacity )

Definition at line 318 of file krita_utils.cpp.

    {
        if (!qFuzzyCompare(parentOpacity, OPACITY_OPAQUE_F)) {
            opacity *= parentOpacity;
        }
        return opacity;
    }

References OPACITY_OPAQUE_F, and qFuzzyCompare().

mergeOpacityU8()

quint8 KRITAIMAGE_EXPORT KritaUtils::mergeOpacityU8	(	quint8	opacity,
		quint8	parentOpacity )

Definition at line 310 of file krita_utils.cpp.

    {
        if (parentOpacity != OPACITY_OPAQUE_U8) {
            opacity = (int(opacity) * parentOpacity) / OPACITY_OPAQUE_U8;
        }
        return opacity;
    }

References OPACITY_OPAQUE_U8.

mirrorDab() [1/2]

void KRITAIMAGE_EXPORT KritaUtils::mirrorDab	(	Qt::Orientation	dir,
		const QPoint &	center,
		KisRenderedDab *	dab,
		bool	skipMirrorPixels )

Definition at line 454 of file krita_utils.cpp.

    {
        const QRect rc = dab->realBounds();
 
        if (dir == Qt::Horizontal) {
            const int mirrorX = -((rc.x() + rc.width()) - center.x()) + center.x();
 
            if (!skipMirrorPixels) {
                dab->device->mirror(true, false);
            }
            dab->offset.rx() = mirrorX;
        } else /* if (dir == Qt::Vertical) */ {
            const int mirrorY = -((rc.y() + rc.height()) - center.y()) + center.y();
 
            if (!skipMirrorPixels) {
                dab->device->mirror(false, true);
            }
            dab->offset.ry() = mirrorY;
        }
    }

References KisRenderedDab::device, KisFixedPaintDevice::mirror(), KisRenderedDab::offset, and KisRenderedDab::realBounds().

mirrorDab() [2/2]

void KRITAIMAGE_EXPORT KritaUtils::mirrorDab	(	Qt::Orientation	dir,
		const QPointF &	center,
		KisRenderedDab *	dab,
		bool	skipMirrorPixels )

Definition at line 475 of file krita_utils.cpp.

    {
        const QRect rc = dab->realBounds();
 
        if (dir == Qt::Horizontal) {
            const int mirrorX = -((rc.x() + rc.width()) - center.x()) + center.x();
 
            if (!skipMirrorPixels) {
                dab->device->mirror(true, false);
            }
            dab->offset.rx() = mirrorX;
        } else /* if (dir == Qt::Vertical) */ {
            const int mirrorY = -((rc.y() + rc.height()) - center.y()) + center.y();
 
            if (!skipMirrorPixels) {
                dab->device->mirror(false, true);
            }
            dab->offset.ry() = mirrorY;
        }
    }

References KisRenderedDab::device, KisFixedPaintDevice::mirror(), KisRenderedDab::offset, and KisRenderedDab::realBounds().

mirrorPoint() [1/2]

void KRITAIMAGE_EXPORT KritaUtils::mirrorPoint	(	Qt::Orientation	dir,
		const QPoint &	center,
		QPointF *	pt )

Definition at line 518 of file krita_utils.cpp.

    {
        if (dir == Qt::Horizontal) {
            pt->rx() = -(pt->x() - qreal(center.x())) + center.x();
        } else /* if (dir == Qt::Vertical) */ {
            pt->ry() = -(pt->y() - qreal(center.y())) + center.y();
        }
    }

mirrorPoint() [2/2]

void KRITAIMAGE_EXPORT KritaUtils::mirrorPoint	(	Qt::Orientation	dir,
		const QPointF &	center,
		QPointF *	pt )

Definition at line 527 of file krita_utils.cpp.

    {
        if (dir == Qt::Horizontal) {
            pt->rx() = -(pt->x() - qreal(center.x())) + center.x();
        } else /* if (dir == Qt::Vertical) */ {
            pt->ry() = -(pt->y() - qreal(center.y())) + center.y();
        }
    }

mirrorRect() [1/2]

void KRITAIMAGE_EXPORT KritaUtils::mirrorRect	(	Qt::Orientation	dir,
		const QPoint &	center,
		QRect *	rc )

Definition at line 496 of file krita_utils.cpp.

    {
        if (dir == Qt::Horizontal) {
            const int mirrorX = -((rc->x() + rc->width()) - center.x()) + center.x();
            rc->moveLeft(mirrorX);
        } else /* if (dir == Qt::Vertical) */ {
            const int mirrorY = -((rc->y() + rc->height()) - center.y()) + center.y();
            rc->moveTop(mirrorY);
        }
    }

mirrorRect() [2/2]

void KRITAIMAGE_EXPORT KritaUtils::mirrorRect	(	Qt::Orientation	dir,
		const QPointF &	center,
		QRect *	rc )

Definition at line 507 of file krita_utils.cpp.

    {
        if (dir == Qt::Horizontal) {
            const int mirrorX = -((rc->x() + rc->width()) - center.x()) + center.x();
            rc->moveLeft(mirrorX);
        } else /* if (dir == Qt::Vertical) */ {
            const int mirrorY = -((rc->y() + rc->height()) - center.y()) + center.y();
            rc->moveTop(mirrorY);
        }
    }

nearestNodeAfterRemoval()

KisNodeSP KRITAIMAGE_EXPORT KritaUtils::nearestNodeAfterRemoval

(

KisNodeSP

node

)

Definition at line 362 of file krita_utils.cpp.

    {
        KisNodeSP newNode = node->nextSibling();
 
        if (!newNode) {
            newNode = node->prevSibling();
        }
 
        if (!newNode) {
            newNode = node->parent();
        }
 
        return newNode;
    }

References KisNode::nextSibling(), KisNode::parent, and KisNode::prevSibling().

optimalPatchSize()

QSize KRITAIMAGE_EXPORT KritaUtils::optimalPatchSize

(

)

Definition at line 35 of file krita_utils.cpp.

    {
        KisImageConfig cfg(true);
        return QSize(cfg.updatePatchWidth(),
                     cfg.updatePatchHeight());
    }

References KisImageConfig::updatePatchHeight(), and KisImageConfig::updatePatchWidth().

pathShapeBooleanSpaceWorkaround()

QTransform KRITAIMAGE_EXPORT KritaUtils::pathShapeBooleanSpaceWorkaround

(

KisImageSP

image

)

Returns a special transformation that converts vector shape coordinates ('pt') into a special coordinate space, where all path boolean operations should happen.

The problem is that Qt's path boolean operation do not support curves, therefore all the curves are converted into lines (see QPathSegments::addPath()). The curves are split into lines using absolute size of the curve for the threshold. Therefore, when applying boolean operations we should convert them into 'image pixel' coordinate space first.

See https://bugs.kde.org/show_bug.cgi?id=411056

Definition at line 536 of file krita_utils.cpp.

    {
        return QTransform::fromScale(image->xRes(), image->yRes());
    }

References KisImage::xRes(), and KisImage::yRes().

prettyFormatReal()

QString KRITAIMAGE_EXPORT KritaUtils::prettyFormatReal

(

qreal

value

)

Definition at line 185 of file krita_utils.cpp.

    {
        return QLocale().toString(value, 'f', 1);
    }

References value().

processTwoDevices()

template<class PixelProcessor >

void KritaUtils::processTwoDevices	(	const QRect &	rc,
		KisRandomConstAccessorSP	srcIt,
		KisRandomAccessorSP	dstIt,
		const int	srcPixelSize,
		const int	dstPixelSize,
		PixelProcessor	pixelProcessor )

this is a special helper function for iterating through pixels in an extremely efficient way. One should either pass a functor or a lambda to it.

Definition at line 22 of file KisFastDeviceProcessingUtils.h.

{
    qint32 dstY = rc.y();
    qint32 rowsRemaining = rc.height();
 
    while (rowsRemaining > 0) {
        qint32 dstX = rc.x();
 
        qint32 numContiguousSrcRows = srcIt->numContiguousRows(dstY);
        qint32 numContiguousDstRows = dstIt->numContiguousRows(dstY);
        qint32 rows = std::min({rowsRemaining, numContiguousSrcRows, numContiguousDstRows});
 
        qint32 columnsRemaining = rc.width();
 
        while (columnsRemaining > 0) {
 
            qint32 numContiguousSrcColumns = srcIt->numContiguousColumns(dstX);
            qint32 numContiguousDstColumns = dstIt->numContiguousColumns(dstX);
            qint32 columns = std::min({columnsRemaining, numContiguousSrcColumns, numContiguousDstColumns});
 
            qint32 dstRowStride = dstIt->rowStride(dstX, dstY);
            qint32 srcRowStride = srcIt->rowStride(dstX, dstY);
 
            dstIt->moveTo(dstX, dstY);
            srcIt->moveTo(dstX, dstY);
 
            quint8 *dstRowStart = dstIt->rawData();
            const quint8 *srcRowStart = srcIt->rawDataConst();
 
            for (int i = 0; i < rows; i++) {
                const quint8 *srcPtr = reinterpret_cast<const quint8*>(srcRowStart);
                quint8 *dstPtr = reinterpret_cast<quint8*>(dstRowStart);
 
                for (int j = 0; j < columns; j++) {
                    pixelProcessor(srcPtr, dstPtr);
 
                    srcPtr += srcPixelSize;
                    dstPtr += dstPixelSize;
                }
 
                srcRowStart += srcRowStride;
                dstRowStart += dstRowStride;
            }
 
            dstX += columns;
            columnsRemaining -= columns;
        }
 
        dstY += rows;
        rowsRemaining -= rows;
    }
}

References KisRandomConstAccessorNG::moveTo(), KisRandomConstAccessorNG::numContiguousColumns(), KisRandomConstAccessorNG::numContiguousRows(), KisBaseAccessor::rawData(), KisBaseConstAccessor::rawDataConst(), and KisRandomConstAccessorNG::rowStride().

processTwoDevicesWithStrides()

template<class PixelProcessor >

void KritaUtils::processTwoDevicesWithStrides	(	const QRect &	rc,
		KisRandomConstAccessorSP	srcIt,
		KisRandomAccessorSP	dstIt,
		PixelProcessor	pixelProcessor )

this is a special helper function for iterating through pixels in an extremely efficient way using strides. One should either pass a functor or a lambda to it.

Definition at line 86 of file KisFastDeviceProcessingUtils.h.

{
    qint32 dstY = rc.y();
    qint32 rowsRemaining = rc.height();
 
    while (rowsRemaining > 0) {
        qint32 dstX = rc.x();
 
        qint32 numContiguousSrcRows = srcIt->numContiguousRows(dstY);
        qint32 numContiguousDstRows = dstIt->numContiguousRows(dstY);
        qint32 rows = std::min({rowsRemaining, numContiguousSrcRows, numContiguousDstRows});
 
        qint32 columnsRemaining = rc.width();
 
        while (columnsRemaining > 0) {
 
            qint32 numContiguousSrcColumns = srcIt->numContiguousColumns(dstX);
            qint32 numContiguousDstColumns = dstIt->numContiguousColumns(dstX);
            qint32 columns = std::min({columnsRemaining, numContiguousSrcColumns, numContiguousDstColumns});
 
            qint32 dstRowStride = dstIt->rowStride(dstX, dstY);
            qint32 srcRowStride = srcIt->rowStride(dstX, dstY);
 
            dstIt->moveTo(dstX, dstY);
            srcIt->moveTo(dstX, dstY);
 
            quint8 *dstRowStart = dstIt->rawData();
            const quint8 *srcRowStart = srcIt->rawDataConst();
 
            pixelProcessor(srcRowStart, srcRowStride,
                           dstRowStart, dstRowStride,
                           rows, columns);
 
            dstX += columns;
            columnsRemaining -= columns;
        }
 
        dstY += rows;
        rowsRemaining -= rows;
    }
}

References KisRandomConstAccessorNG::moveTo(), KisRandomConstAccessorNG::numContiguousColumns(), KisRandomConstAccessorNG::numContiguousRows(), KisBaseAccessor::rawData(), KisBaseConstAccessor::rawDataConst(), and KisRandomConstAccessorNG::rowStride().

rasterizeHLine() [1/2]

QVector< QPoint > KRITAIMAGE_EXPORT KritaUtils::rasterizeHLine	(	const QPoint &	startPoint,
		const QPoint &	endPoint )

Definition at line 603 of file krita_utils.cpp.

    {
        QVector<QPoint> points;
        rasterizeHLine(startPoint, endPoint, [&points](const QPoint &point) { points.append(point); });
        return points;
    }

References rasterizeHLine().

rasterizeHLine() [2/2]

template<typename Visitor >

void KritaUtils::rasterizeHLine	(	const QPoint &	startPoint,
		const QPoint &	endPoint,
		Visitor	visitor )

Definition at line 142 of file krita_utils.h.

    {
        QVector<QPoint> points;
        int startX, endX;
        if (startPoint.x() < endPoint.x()) {
            startX = startPoint.x();
            endX = endPoint.x();
        } else {
            startX = endPoint.x();
            endX = startPoint.x();
        }
        for (int x = startX; x <= endX; ++x) {
            visitor(QPoint(x, startPoint.y()));
        }
    }

rasterizeLineDDA() [1/2]

QVector< QPoint > KRITAIMAGE_EXPORT KritaUtils::rasterizeLineDDA	(	const QPoint &	startPoint,
		const QPoint &	endPoint )

Definition at line 617 of file krita_utils.cpp.

    {
        QVector<QPoint> points;
        rasterizeLineDDA(startPoint, endPoint, [&points](const QPoint &point) { points.append(point); });
        return points;
    }

References rasterizeLineDDA().

rasterizeLineDDA() [2/2]

template<typename Visitor >

void KritaUtils::rasterizeLineDDA	(	const QPoint &	startPoint,
		const QPoint &	endPoint,
		Visitor	visitor )

Definition at line 176 of file krita_utils.h.

    {
        QVector<QPoint> points;
 
        if (startPoint == endPoint) {
            visitor(startPoint);
            return;
        }
        if (startPoint.y() == endPoint.y()) {
            rasterizeHLine(startPoint, endPoint, visitor);
            return;
        }
        if (startPoint.x() == endPoint.x()) {
            rasterizeVLine(startPoint, endPoint, visitor);
            return;
        }
 
        const QPoint delta = endPoint - startPoint;
        QPoint currentPosition = startPoint;
        QPointF currentPositionF = startPoint;
        qreal m = static_cast<qreal>(delta.y()) / static_cast<qreal>(delta.x());
        int increment;
 
        if (std::abs(m) > 1.0) {
            if (delta.y() > 0) {
                m = 1.0 / m;
                increment = 1;
            } else {
                m = -1.0 / m;
                increment = -1;
            }
            while (currentPosition.y() != endPoint.y()) {
                currentPositionF.setX(currentPositionF.x() + m);
                currentPosition = QPoint(static_cast<int>(qRound(currentPositionF.x())),
                                        currentPosition.y() + increment);
                visitor(currentPosition);
            }
        } else {
            if (delta.x() > 0) {
                increment = 1;
            } else {
                increment = -1;
                m = -m;
            }
            while (currentPosition.x() != endPoint.x()) {
                currentPositionF.setY(currentPositionF.y() + m);
                currentPosition = QPoint(currentPosition.x() + increment,
                                        static_cast<int>(qRound(currentPositionF.y())));
                visitor(currentPosition);
            }
        }
    }

References rasterizeHLine(), and rasterizeVLine().

rasterizePolygonDDA() [1/2]

QVector< QPoint > KRITAIMAGE_EXPORT KritaUtils::rasterizePolygonDDA

(

const QVector< QPoint > &

polygonPoints

)

Definition at line 631 of file krita_utils.cpp.

    {
        QVector<QPoint> points;
        rasterizePolygonDDA(polygonPoints, [&points](const QPoint &point) { points.append(point); });
        return points;
    }

References rasterizePolygonDDA().

rasterizePolygonDDA() [2/2]

template<typename Visitor >

void KritaUtils::rasterizePolygonDDA	(	const QVector< QPoint > &	polygonPoints,
		Visitor	visitor )

Definition at line 260 of file krita_utils.h.

    {
        // this is a line
        if (polygonPoints.size() < 3) {
            rasterizeLineDDA(polygonPoints.first(), polygonPoints.last(), visitor);
            return;
        }
        // rasterize all segments except the last one
        QPoint lastSegmentStart;
        if (polygonPoints.first() == polygonPoints.last()) {
            rasterizePolylineDDA(polygonPoints.mid(0, polygonPoints.size() - 1), visitor);
            lastSegmentStart = polygonPoints[polygonPoints.size() - 2];
        } else {
            rasterizePolylineDDA(polygonPoints, visitor);
            lastSegmentStart = polygonPoints[polygonPoints.size() - 1];
        }
        // close the polygon
        {
            QVector<QPoint> points;
            auto addPoint = [&points](const QPoint &point) -> void { points.append(point); };
            rasterizeLineDDA(lastSegmentStart, polygonPoints.first(), addPoint);
            for (int i = 1; i < points.size() - 1; ++i) {
                visitor(points[i]);
            }
        }
    }

References rasterizeLineDDA(), and rasterizePolylineDDA().

rasterizePolylineDDA() [1/2]

QVector< QPoint > KRITAIMAGE_EXPORT KritaUtils::rasterizePolylineDDA

(

const QVector< QPoint > &

polylinePoints

)

Definition at line 624 of file krita_utils.cpp.

    {
        QVector<QPoint> points;
        rasterizePolylineDDA(polylinePoints, [&points](const QPoint &point) { points.append(point); });
        return points;
    }

References rasterizePolylineDDA().

rasterizePolylineDDA() [2/2]

template<typename Visitor >

void KritaUtils::rasterizePolylineDDA	(	const QVector< QPoint > &	polylinePoints,
		Visitor	visitor )

Definition at line 230 of file krita_utils.h.

    {
        if (polylinePoints.size() == 0) {
            return;
        }
        if (polylinePoints.size() == 1) {
            visitor(polylinePoints.first());
            return;
        }
 
        // copy all points from the first segment
        rasterizeLineDDA(polylinePoints[0], polylinePoints[1], visitor);
        // for the rest of the segments, copy all points except the first one
        // (it is the same as the last point in the previous segment)
        for (int i = 1; i < polylinePoints.size() - 1; ++i) {
            int pointIndex = 0;
            rasterizeLineDDA(
                polylinePoints[i], polylinePoints[i + 1],
                [&pointIndex, &visitor](const QPoint &point) -> void
                {
                    if (pointIndex > 0) {
                        visitor(point);
                    }
                    ++pointIndex;
                }
            );
        }
    }

References rasterizeLineDDA().

rasterizeVLine() [1/2]

QVector< QPoint > KRITAIMAGE_EXPORT KritaUtils::rasterizeVLine	(	const QPoint &	startPoint,
		const QPoint &	endPoint )

Definition at line 610 of file krita_utils.cpp.

    {
        QVector<QPoint> points;
        rasterizeVLine(startPoint, endPoint, [&points](const QPoint &point) { points.append(point); });
        return points;
    }

References rasterizeVLine().

rasterizeVLine() [2/2]

template<typename Visitor >

void KritaUtils::rasterizeVLine	(	const QPoint &	startPoint,
		const QPoint &	endPoint,
		Visitor	visitor )

Definition at line 159 of file krita_utils.h.

    {
        QVector<QPoint> points;
        int startY, endY;
        if (startPoint.y() < endPoint.y()) {
            startY = startPoint.y();
            endY = endPoint.y();
        } else {
            startY = endPoint.y();
            endY = startPoint.y();
        }
        for (int y = startY; y <= endY; ++y) {
            visitor(QPoint(startPoint.x(), y));
        }
    }

renderExactRect() [1/2]

void KRITAIMAGE_EXPORT KritaUtils::renderExactRect	(	QPainter *	p,
		const QRect &	rc )

When drawing a rect Qt uses quite a weird algorithm. It draws 4 lines: o at X-es: rect.x() and rect.right() + 1 o at Y-s: rect.y() and rect.bottom() + 1

Which means that bottom and right lines of the rect are painted outside the virtual rectangle the rect defines. This methods overcome this issue by painting the adjusted rect.

Definition at line 377 of file krita_utils.cpp.

    {
        p->drawRect(rc.adjusted(0,0,-1,-1));
    }

References p.

renderExactRect() [2/2]

void KRITAIMAGE_EXPORT KritaUtils::renderExactRect	(	QPainter *	p,
		const QRect &	rc,
		const QPen &	pen )

See also

renderExactRect(QPainter *p, const QRect &rc)

Definition at line 382 of file krita_utils.cpp.

    {
        QPen oldPen = p->pen();
        p->setPen(pen);
        renderExactRect(p, rc);
        p->setPen(oldPen);
    }

References p, and renderExactRect().

resolveAbsoluteFilePath()

QString KRITAGLOBAL_EXPORT KritaUtils::resolveAbsoluteFilePath	(	const QString &	baseDir,
		const QString &	filePath )

Resolve absolute file path from a file path and base dir.

If the filePath is absolute, just return this path, otherwise try to merge baseDir and filePath to form an absolute file path

Definition at line 15 of file KisFileUtils.cpp.

{
    if (QFileInfo(fileName).isAbsolute()) {
        return fileName;
    }
 
    QFileInfo fallbackBaseDirInfo(baseDir);
 
    return QFileInfo(QDir(fallbackBaseDirInfo.isDir() ?
                              fallbackBaseDirInfo.absoluteFilePath() :
                              fallbackBaseDirInfo.absolutePath()),
                     fileName).absoluteFilePath();
}

restoreControlPoint()

void KritaUtils::restoreControlPoint	(	KoPathPoint *	pt,
		bool	restoreFirst,
		boost::optional< QPointF >	savedPoint )

Definition at line 43 of file KoPathMergeUtils.cpp.

{
    if (restoreFirst) {
        if (savedPoint) {
            pt->setControlPoint1(*savedPoint);
        } else {
            pt->removeControlPoint1();
        }
    } else {
        if (savedPoint) {
            pt->setControlPoint2(*savedPoint);
        } else {
            pt->removeControlPoint2();
        }
    }
}

References KoPathPoint::removeControlPoint1(), KoPathPoint::removeControlPoint2(), KoPathPoint::setControlPoint1(), and KoPathPoint::setControlPoint2().

splitDisjointPaths()

QList< QPainterPath > KRITAIMAGE_EXPORT KritaUtils::splitDisjointPaths

(

const QPainterPath &

path

)

Split a path path into a set of disjoint (non-intersectable) paths if possible.

It tries to follow odd-even fill rule, but has a small problem: If you have three selections included into each other twice, then the smallest selection will be included into the final subpath, although it shouldn't according to odd-even-fill rule. It is still to be fixed.

Definition at line 279 of file krita_utils.cpp.

    {
        QList<QPainterPath> resultList;
        QList<QPolygonF> inputPolygons = path.toSubpathPolygons();
 
        Q_FOREACH (const QPolygonF &poly, inputPolygons) {
            QPainterPath testPath;
            testPath.addPolygon(poly);
 
            if (resultList.isEmpty()) {
                resultList.append(testPath);
                continue;
            }
 
            QPainterPath mergedPath = testPath;
 
            for (auto it = resultList.begin(); it != resultList.end(); /*noop*/) {
                if (it->intersects(testPath)) {
                    mergedPath.addPath(*it);
                    it = resultList.erase(it);
                } else {
                    ++it;
                }
            }
 
            resultList.append(mergedPath);
        }
 
        return resultList;
    }

splitPath()

KRITAIMAGE_EXPORT KisRegion KritaUtils::splitPath

(

const QPainterPath &

path

)

Definition at line 153 of file krita_utils.cpp.

    {
        QVector<QRect> dirtyRects;
        QRect totalRect = path.boundingRect().toAlignedRect();
 
        // adjust the rect for antialiasing to work
        totalRect = totalRect.adjusted(-1,-1,1,1);
 
        const int step = 64;
        const int right = totalRect.x() + totalRect.width();
        const int bottom = totalRect.y() + totalRect.height();
 
        for (int y = totalRect.y(); y < bottom;) {
            int nextY = qMin((y + step) & ~(step-1), bottom);
 
            for (int x = totalRect.x(); x < right;) {
                int nextX = qMin((x + step) & ~(step-1), right);
 
                QRect rect(x, y, nextX - x, nextY - y);
 
                if(path.intersects(rect)) {
                    dirtyRects << rect;
                }
 
                x = nextX;
            }
            y = nextY;
        }
 
        return KisRegion(std::move(dirtyRects));
    }

splitRectIntoPatches()

QVector< QRect > KRITAIMAGE_EXPORT KritaUtils::splitRectIntoPatches	(	const QRect &	rc,
		const QSize &	patchSize )

Definition at line 42 of file krita_utils.cpp.

    {
        using namespace KisAlgebra2D;
 
 
        QVector<QRect> patches;
 
        const qint32 firstCol = divideFloor(rc.x(), patchSize.width());
        const qint32 firstRow = divideFloor(rc.y(), patchSize.height());
 
        // TODO: check if -1 is needed here
        const qint32 lastCol = divideFloor(rc.x() + rc.width(), patchSize.width());
        const qint32 lastRow = divideFloor(rc.y() + rc.height(), patchSize.height());
 
        for(qint32 i = firstRow; i <= lastRow; i++) {
            for(qint32 j = firstCol; j <= lastCol; j++) {
                QRect maxPatchRect(j * patchSize.width(), i * patchSize.height(),
                                   patchSize.width(), patchSize.height());
                QRect patchRect = rc & maxPatchRect;
 
                if (!patchRect.isEmpty()) {
                    patches.append(patchRect);
                }
            }
        }
 
        return patches;
    }

splitRectIntoPatchesTight()

QVector< QRect > KRITAIMAGE_EXPORT KritaUtils::splitRectIntoPatchesTight	(	const QRect &	rc,
		const QSize &	patchSize )

Definition at line 71 of file krita_utils.cpp.

    {
        QVector<QRect> patches;
 
        for (qint32 y = rc.y(); y < rc.y() + rc.height(); y += patchSize.height()) {
            for (qint32 x = rc.x(); x < rc.x() + rc.width(); x += patchSize.width()) {
                patches << QRect(x, y,
                                 qMin(rc.x() + rc.width() - x, patchSize.width()),
                                 qMin(rc.y() + rc.height() - y, patchSize.height()));
            }
        }
 
        return patches;
    }

splitRegionIntoPatches() [1/2]

QVector< QRect > KRITAIMAGE_EXPORT KritaUtils::splitRegionIntoPatches	(	const KisRegion &	region,
		const QSize &	patchSize )

Definition at line 86 of file krita_utils.cpp.

    {
        QVector<QRect> patches;
 
        Q_FOREACH (const QRect rect, region.rects()) {
            patches << KritaUtils::splitRectIntoPatches(rect, patchSize);
        }
 
        return patches;
    }

References KisRegion::rects(), and splitRectIntoPatches().

splitRegionIntoPatches() [2/2]

QVector< QRect > KRITAIMAGE_EXPORT KritaUtils::splitRegionIntoPatches	(	const QRegion &	region,
		const QSize &	patchSize )

splitTriangles()

KRITAIMAGE_EXPORT KisRegion KritaUtils::splitTriangles	(	const QPointF &	center,
		const QVector< QPointF > &	points )

Definition at line 104 of file krita_utils.cpp.

    {
 
        Q_ASSERT(points.size());
        Q_ASSERT(!(points.size() & 1));
 
        QVector<QPolygonF> triangles;
        QRect totalRect;
 
        for (int i = 0; i < points.size(); i += 2) {
            QPolygonF triangle;
            triangle << center;
            triangle << points[i];
            triangle << points[i+1];
 
            totalRect |= triangle.boundingRect().toAlignedRect();
            triangles << triangle;
        }
 
 
        const int step = 64;
        const int right = totalRect.x() + totalRect.width();
        const int bottom = totalRect.y() + totalRect.height();
 
        QVector<QRect> dirtyRects;
 
        for (int y = totalRect.y(); y < bottom;) {
            int nextY = qMin((y + step) & ~(step-1), bottom);
 
            for (int x = totalRect.x(); x < right;) {
                int nextX = qMin((x + step) & ~(step-1), right);
 
                QRect rect(x, y, nextX - x, nextY - y);
 
                Q_FOREACH (const QPolygonF &triangle, triangles) {
                    if(checkInTriangle(rect, triangle)) {
                        dirtyRects << rect;
                        break;
                    }
                }
 
                x = nextX;
            }
            y = nextY;
        }
        return KisRegion(std::move(dirtyRects));
    }

References checkInTriangle().

thresholdOpacity()

void KritaUtils::thresholdOpacity	(	KisPaintDeviceSP	device,
		const QRect &	rect,
		ThresholdMode	mode )

Definition at line 558 of file krita_utils.cpp.

    {
        const KoColorSpace *cs = device->colorSpace();
 
        if (mode == ThresholdCeil) {
            KisSequentialIterator it(device, rect);
            while (it.nextPixel()) {
                if (cs->opacityU8(it.rawDataConst()) > 0) {
                    cs->setOpacity(it.rawData(), quint8(255), 1);
                }
            }
        } else if (mode == ThresholdFloor) {
            KisSequentialIterator it(device, rect);
            while (it.nextPixel()) {
                if (cs->opacityU8(it.rawDataConst()) < 255) {
                    cs->setOpacity(it.rawData(), quint8(0), 1);
                }
            }
        } else if (mode == ThresholdMaxOut) {
            KisSequentialIterator it(device, rect);
            int numConseqPixels = it.nConseqPixels();
            while (it.nextPixels(numConseqPixels)) {
                numConseqPixels = it.nConseqPixels();
                cs->setOpacity(it.rawData(), quint8(255), numConseqPixels);
            }
        }
    }

References KisPaintDevice::colorSpace(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nConseqPixels(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixels(), KoColorSpace::opacityU8(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst(), KoColorSpace::setOpacity(), ThresholdCeil, ThresholdFloor, and ThresholdMaxOut.

thresholdOpacityAlpha8()

void KritaUtils::thresholdOpacityAlpha8	(	KisPaintDeviceSP	device,
		const QRect &	rect,
		ThresholdMode	mode )

Definition at line 586 of file krita_utils.cpp.

    {
        if (mode == ThresholdCeil) {
            filterAlpha8Device(device, rect,
                [] (quint8 value) {
                    return value > 0 ? 255 : value;
                });
        } else if (mode == ThresholdFloor) {
            filterAlpha8Device(device, rect,
                [] (quint8 value) {
                    return value < 255 ? 0 : value;
                });
        } else if (mode == ThresholdMaxOut) {
            device->fill(rect, KoColor(Qt::white, device->colorSpace()));
        }
    }

References KisPaintDevice::colorSpace(), KisPaintDevice::fill(), filterAlpha8Device(), ThresholdCeil, ThresholdFloor, ThresholdMaxOut, and value().

toLocalizedOnOff()

QString KRITAIMAGE_EXPORT KritaUtils::toLocalizedOnOff

(

bool

value

)

Definition at line 358 of file krita_utils.cpp.

                                                           {
        return value ? i18n("on") : i18n("off");
    }

References value().

tryCloseTornSubpathsAfterIntersection()

QPainterPath KRITAIMAGE_EXPORT KritaUtils::tryCloseTornSubpathsAfterIntersection

(

QPainterPath

path

)

Sometimes, when intersecting two paths, QPainterPath does not close some of the subpaths. It causes glitches when rendering them on screen. So we should just close them explicitly.

Note: after intersecting the paths all bezier curves are already converted to polylines, so it should be safe to go through the polygons.

See: https://bugs.kde.org/show_bug.cgi?id=408369

Definition at line 541 of file krita_utils.cpp.

    {
        path.setFillRule(Qt::WindingFill);
        QList<QPolygonF> polys = path.toSubpathPolygons();
 
        path = QPainterPath();
        path.setFillRule(Qt::WindingFill);
        Q_FOREACH (QPolygonF poly, polys) {
            ENTER_FUNCTION() << ppVar(poly.isClosed());
            if (!poly.isClosed()) {
                poly.append(poly.first());
            }
            path.addPolygon(poly);
        }
        return path;
    }

References ENTER_FUNCTION, and ppVar.

tryMergePoints()

bool KritaUtils::tryMergePoints	(	QPainterPath &	path,
		const QPointF &	startPoint,
		const QPointF &	endPoint,
		qreal &	distance,
		qreal	distanceThreshold,
		bool	lastSegment )

Definition at line 196 of file krita_utils.cpp.

    {
        qreal length = (endPoint - startPoint).manhattanLength();
 
        if (lastSegment || length > distanceThreshold) {
            if (lastSegment) {
                qreal wrappedLength =
                    (endPoint - QPointF(path.elementAt(0))).manhattanLength();
 
                if (length < distanceThreshold ||
                    wrappedLength < distanceThreshold) {
 
                    return true;
                }
            }
 
            distance = 0;
            return false;
        }
 
        distance += length;
 
        if (distance > distanceThreshold) {
            path.lineTo(endPoint);
            distance = 0;
        }
 
        return true;
    }

References distance(), and length().

trySimplifyPath()

QPainterPath KRITAIMAGE_EXPORT KritaUtils::trySimplifyPath	(	const QPainterPath &	path,
		qreal	lengthThreshold )

Definition at line 231 of file krita_utils.cpp.

    {
        QPainterPath newPath;
        QPointF startPoint;
        qreal distance = 0;
 
        int count = path.elementCount();
        for (int i = 0; i < count; i++) {
            QPainterPath::Element e = path.elementAt(i);
            QPointF endPoint = QPointF(e.x, e.y);
 
            switch (e.type) {
            case QPainterPath::MoveToElement:
                newPath.moveTo(endPoint);
                break;
            case QPainterPath::LineToElement:
                if (!tryMergePoints(newPath, startPoint, endPoint,
                                    distance, lengthThreshold, i == count - 1)) {
 
                    newPath.lineTo(endPoint);
                }
                break;
            case QPainterPath::CurveToElement: {
                Q_ASSERT(i + 2 < count);
 
                if (!tryMergePoints(newPath, startPoint, endPoint,
                                    distance, lengthThreshold, i == count - 1)) {
 
                    e = path.elementAt(i + 1);
                    Q_ASSERT(e.type == QPainterPath::CurveToDataElement);
                    QPointF ctrl1 = QPointF(e.x, e.y);
                    e = path.elementAt(i + 2);
                    Q_ASSERT(e.type == QPainterPath::CurveToDataElement);
                    QPointF ctrl2 = QPointF(e.x, e.y);
                    newPath.cubicTo(ctrl1, ctrl2, endPoint);
                }
 
                i += 2;
            }
            default:
                ;
            }
            startPoint = endPoint;
        }
 
        return newPath;
    }

References distance(), and tryMergePoints().

workaroundUnsuitableImageColorSpace()

KisImportExportErrorCode KRITAUI_EXPORT KritaUtils::workaroundUnsuitableImageColorSpace	(	KisImageSP	image,
		KisImportUserFeedbackInterface *	feedbackInterface,
		KisImageBarrierLock &	lock )

When the image has a colorspace that is not suitable for displaying, Krita should convert that into something more useful. This tool function asks the user about the desired working color space and converts into it.

The profile has no reverse mapping into for the described color space, so we cannot use it in Krita. We need to ask the user to convert the image right on loading

Here is an extremely tricky part! First we start the conversion stroke, and only after that we unlock the image. The point is that KisDelayedUpdateNodeInterface-based nodes are forbidden to start their update jobs while the image is locked, so this guarantees that no stroke will be started before we actually convert the image into something usable

Definition at line 18 of file KisImportExportUtils.cpp.

{
    const KoColorSpace *replacementColorSpace = 0;
    KoColorConversionTransformation::Intent replacementColorSpaceIntent = KoColorConversionTransformation::internalRenderingIntent();
    KoColorConversionTransformation::ConversionFlags replacementColorSpaceConversionFlags = KoColorConversionTransformation::internalConversionFlags();
 
    const KoColorSpace *colorSpace = image->colorSpace();
    const KoColorProfile *profile = colorSpace->profile();
 
    if (profile && !profile->isSuitableForOutput()) {
 
        KIS_SAFE_ASSERT_RECOVER_NOOP(feedbackInterface);
        if (feedbackInterface) {
            KisImportUserFeedbackInterface::Result result =
                feedbackInterface->askUser([&] (QWidget *parent) {
 
                    KisColorSpaceConversionDialog * dlgColorSpaceConversion = new KisColorSpaceConversionDialog(parent, "ColorSpaceConversion");
                    Q_CHECK_PTR(dlgColorSpaceConversion);
 
                    const KoColorSpace* fallbackColorSpace =
                        KoColorSpaceRegistry::instance()->colorSpace(
                            colorSpace->colorModelId().id(),
                            colorSpace->colorDepthId().id(),
                            nullptr);
 
                    dlgColorSpaceConversion->setCaption(i18n("Convert image color space on import"));
                    dlgColorSpaceConversion->m_page->lblHeadlineWarning->setText(
                        i18nc("the argument is the ICC profile name",
                              "The image has a profile attached that Krita cannot edit images "
                              "in (\"%1\"), please select a space to convert to for editing: \n"
                              , profile->name()));
                    dlgColorSpaceConversion->m_page->lblHeadlineWarning->setVisible(true);
 
                    dlgColorSpaceConversion->setInitialColorSpace(fallbackColorSpace, 0);
 
                    if (dlgColorSpaceConversion->exec() == QDialog::Accepted) {
 
                        replacementColorSpace = dlgColorSpaceConversion->colorSpace();
                        replacementColorSpaceIntent = dlgColorSpaceConversion->conversionIntent();
                        replacementColorSpaceConversionFlags= dlgColorSpaceConversion->conversionFlags();
                    } else {
                        return false;
                    }
 
                    return true;
                });
 
            if (result == KisImportUserFeedbackInterface::SuppressedByBatchMode) {
                return ImportExportCodes::FormatColorSpaceUnsupported;
            } else if (result == KisImportUserFeedbackInterface::UserCancelled) {
                return ImportExportCodes::Cancelled;
            }
        }
    }
 
    if (replacementColorSpace) {
        image->convertImageColorSpace(replacementColorSpace,
                                        replacementColorSpaceIntent,
                                        replacementColorSpaceConversionFlags);
        lock.unlock();
        image->waitForDone();
    }
 
    return ImportExportCodes::OK;
}

References KisImportUserFeedbackInterface::askUser(), ImportExportCodes::Cancelled, KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisImage::colorSpace(), KisColorSpaceConversionDialog::colorSpace(), KoColorSpaceRegistry::colorSpace(), KisColorSpaceConversionDialog::conversionFlags(), KisColorSpaceConversionDialog::conversionIntent(), KisImage::convertImageColorSpace(), ImportExportCodes::FormatColorSpaceUnsupported, KoID::id(), KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KoColorProfile::isSuitableForOutput(), KIS_SAFE_ASSERT_RECOVER_NOOP, KisColorSpaceConversionDialog::m_page, KoColorProfile::name, ImportExportCodes::OK, KoColorSpace::profile(), KoDialog::setCaption(), KisColorSpaceConversionDialog::setInitialColorSpace(), KisImportUserFeedbackInterface::SuppressedByBatchMode, KisImportUserFeedbackInterface::UserCancelled, and KisImage::waitForDone().