KisPaintOpUtils Namespace Reference

Classes
class	PositionHistory

Functions
QPointF	calcAutoSpacing (const QPointF &pt, qreal coeff, qreal lodScale)
qreal	calcAutoSpacing (qreal value, qreal coeff)
bool	checkSizeTooSmall (qreal scale, qreal width, qreal height)
KisSpacingInformation	effectiveSpacing (qreal dabWidth, qreal dabHeight, qreal extraScale, bool distanceSpacingEnabled, bool isotropicSpacing, qreal rotation, bool axesFlipped, qreal spacingVal, bool autoSpacingActive, qreal autoSpacingCoeff, qreal lodScale)
KisTimingInformation	effectiveTiming (bool timingEnabled, qreal timingInterval, qreal rateExtraScale)
template<class PaintOp >
bool	paintFan (PaintOp &op, const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance, qreal fanCornersStep)
template<class PaintOp >
void	paintLine (PaintOp &op, const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance, bool fanCornersEnabled, qreal fanCornersStep)
QVector< QRect >	splitAndFilterDabRect (const QRect &totalRect, const QVector< QRect > &dabRects, int idealPatchSize)
QVector< QRect >	splitDabsIntoRects (const QVector< QRect > &dabRects, int idealNumRects, int diameter, qreal spacing)

Variables
const char	MaskingBrushCompositeOpTag [] = "MaskingBrush/MaskingCompositeOp"
const char	MaskingBrushEnabledTag [] = "MaskingBrush/Enabled"
const char	MaskingBrushMasterSizeCoeffTag [] = "MaskingBrush/MasterSizeCoeff"
const char	MaskingBrushPaintOpId [] = "paintbrush"
const char	MaskingBrushPresetPrefix [] = "MaskingBrush/Preset/"
const char	MaskingBrushUseMasterSizeTag [] = "MaskingBrush/UseMasterSize"

Function Documentation

calcAutoSpacing() [1/2]

QPointF KisPaintOpUtils::calcAutoSpacing ( const QPointF & pt, qreal coeff, qreal lodScale )

inline

Definition at line 167 of file kis_paintop_utils.h.

{
    const qreal invLodScale = 1.0 / lodScale;
    const QPointF lod0Point = invLodScale * pt;
 
    return lodScale * QPointF(calcAutoSpacing(lod0Point.x(), coeff), calcAutoSpacing(lod0Point.y(), coeff));
}

References calcAutoSpacing().

calcAutoSpacing() [2/2]

qreal KisPaintOpUtils::calcAutoSpacing ( qreal value, qreal coeff )

inline

Definition at line 162 of file kis_paintop_utils.h.

{
    return coeff * (value < 1.0 ? value : sqrt(value));
}

References value().

checkSizeTooSmall()

bool KisPaintOpUtils::checkSizeTooSmall ( qreal scale, qreal width, qreal height )

inline

Definition at line 157 of file kis_paintop_utils.h.

{
    return scale * width < 0.01 || scale * height < 0.01;
}

effectiveSpacing()

KRITAIMAGE_EXPORT KisSpacingInformation KisPaintOpUtils::effectiveSpacing	(	qreal	dabWidth,
		qreal	dabHeight,
		qreal	extraScale,
		bool	distanceSpacingEnabled,
		bool	isotropicSpacing,
		qreal	rotation,
		bool	axesFlipped,
		qreal	spacingVal,
		bool	autoSpacingActive,
		qreal	autoSpacingCoeff,
		qreal	lodScale )

Definition at line 18 of file kis_paintop_utils.cpp.

{
    QPointF spacing;
 
    if (!isotropicSpacing) {
        if (autoSpacingActive) {
            spacing = calcAutoSpacing(QPointF(dabWidth, dabHeight), autoSpacingCoeff, lodScale);
        } else {
            spacing = QPointF(dabWidth, dabHeight);
            spacing *= spacingVal;
        }
    }
    else {
        qreal significantDimension = qMax(dabWidth, dabHeight);
        if (autoSpacingActive) {
            significantDimension = calcAutoSpacing(significantDimension, autoSpacingCoeff);
        } else {
            significantDimension *= spacingVal;
        }
        spacing = QPointF(significantDimension, significantDimension);
        rotation = 0.0;
        axesFlipped = false;
    }
 
    spacing *= extraScale;
 
    return KisSpacingInformation(distanceSpacingEnabled, spacing, rotation, axesFlipped);
}

References calcAutoSpacing().

effectiveTiming()

KRITAIMAGE_EXPORT KisTimingInformation KisPaintOpUtils::effectiveTiming	(	bool	timingEnabled,
		qreal	timingInterval,
		qreal	rateExtraScale )

Definition at line 47 of file kis_paintop_utils.cpp.

{
 
    if (!timingEnabled) {
        return KisTimingInformation();
    }
    else {
        qreal scaledInterval = rateExtraScale <= 0.0 ? LONG_TIME : timingInterval / rateExtraScale;
        return KisTimingInformation(scaledInterval);
    }
}

References LONG_TIME.

paintFan()

template<class PaintOp >

bool KisPaintOpUtils::paintFan	(	PaintOp &	op,
		const KisPaintInformation &	pi1,
		const KisPaintInformation &	pi2,
		KisDistanceInformation *	currentDistance,
		qreal	fanCornersStep )

Definition at line 23 of file kis_paintop_utils.h.

{
    const qreal angleStep = fanCornersStep;
    const qreal initialAngle = currentDistance->lastDrawingAngle();
    const qreal finalAngle = pi2.drawingAngleSafe(*currentDistance);
    const qreal fullDistance = shortestAngularDistance(initialAngle,
                                                       finalAngle);
    qreal lastAngle = initialAngle;
 
    int i = 0;
 
    while (shortestAngularDistance(lastAngle, finalAngle) > angleStep) {
        lastAngle = incrementInDirection(lastAngle, angleStep, finalAngle);
 
        qreal t = angleStep * i++ / fullDistance;
 
        QPointF pt = pi1.pos() + t * (pi2.pos() - pi1.pos());
        KisPaintInformation pi = KisPaintInformation::mix(pt, t, pi1, pi2);
        pi.overrideDrawingAngle(lastAngle);
        pi.paintAt(op, currentDistance);
    }
 
    return i;
}

References KisPaintInformation::drawingAngleSafe(), incrementInDirection(), KisDistanceInformation::lastDrawingAngle(), KisPaintInformation::mix(), KisPaintInformation::pos(), and shortestAngularDistance().

paintLine()

template<class PaintOp >

void KisPaintOpUtils::paintLine	(	PaintOp &	op,
		const KisPaintInformation &	pi1,
		const KisPaintInformation &	pi2,
		KisDistanceInformation *	currentDistance,
		bool	fanCornersEnabled,
		qreal	fanCornersStep )

A bit complicated part to ensure the registration of the distance information is done in right order

Definition at line 54 of file kis_paintop_utils.h.

{
    QPointF end = pi2.pos();
    qreal endTime = pi2.currentTime();
 
    KisPaintInformation pi = pi1;
    qreal t = 0.0;
 
    while ((t = currentDistance->getNextPointPosition(pi.pos(), end, pi.currentTime(), endTime)) >= 0.0) {
        pi = KisPaintInformation::mix(t, pi, pi2);
 
        if (fanCornersEnabled &&
            currentDistance->hasLastPaintInformation()) {
 
            paintFan(op,
                     currentDistance->lastPaintInformation(),
                     pi,
                     currentDistance,
                     fanCornersStep);
        }
 
        pi.paintAt(op, currentDistance);
    }
 
    /*
     * Perform spacing and/or timing updates between dabs if appropriate. Typically, this will not
     * happen if the above loop actually painted anything. This is because the
     * getNextPointPosition() call before the paint operation will reset the accumulators in
     * currentDistance and therefore make needsSpacingUpdate() and needsTimingUpdate() false. The
     * temporal distance between pi1 and pi2 is typically too small for the accumulators to build
     * back up enough to require a spacing or timing update after that. (The accumulated time values
     * are updated not during the paint operation, but during the call to getNextPointPosition(),
     * that is, updated during every paintLine() call.)
     */
    if (currentDistance->needsSpacingUpdate()) {
        op.updateSpacing(pi2, *currentDistance);
    }
    if (currentDistance->needsTimingUpdate()) {
        op.updateTiming(pi2, *currentDistance);
    }
}

References KisPaintInformation::currentTime(), KisDistanceInformation::getNextPointPosition(), KisDistanceInformation::hasLastPaintInformation(), KisDistanceInformation::lastPaintInformation, KisPaintInformation::mix(), KisDistanceInformation::needsSpacingUpdate(), KisDistanceInformation::needsTimingUpdate(), KisPaintInformation::paintAt(), paintFan(), and KisPaintInformation::pos().

splitAndFilterDabRect()

KRITAIMAGE_EXPORT QVector< QRect > KisPaintOpUtils::splitAndFilterDabRect	(	const QRect &	totalRect,
		const QVector< QRect > &	dabRects,
		int	idealPatchSize )

Definition at line 59 of file kis_paintop_utils.cpp.

{
    QVector<QRect> rects = KritaUtils::splitRectIntoPatches(totalRect, QSize(idealPatchSize,idealPatchSize));
 
    KritaUtils::filterContainer(rects,
        [dabRects] (const QRect &rc) {
            Q_FOREACH (const QRect &dab, dabRects) {
                if (dab.intersects(rc)) {
                    return true;
                }
            }
            return false;
        });
    return rects;
}

References KritaUtils::filterContainer(), and KritaUtils::splitRectIntoPatches().

splitDabsIntoRects()

KRITAIMAGE_EXPORT QVector< QRect > KisPaintOpUtils::splitDabsIntoRects	(	const QVector< QRect > &	dabRects,
		int	idealNumRects,
		int	diameter,
		qreal	spacing )

Definition at line 75 of file kis_paintop_utils.cpp.

{
    const QRect totalRect =
        std::accumulate(dabRects.begin(), dabRects.end(), QRect(), std::bit_or<QRect>());
 
    constexpr int minPatchSize = 128;
    constexpr int maxPatchSize = 512;
    constexpr int patchStep = 64;
    constexpr int halfPatchStep = patchStep >> 1;
 
 
    int idealPatchSize = qBound(minPatchSize,
                                (int(diameter * (2.0 - spacing)) + halfPatchStep) & ~(patchStep - 1),
                                maxPatchSize);
 
 
    QVector<QRect> rects = splitAndFilterDabRect(totalRect, dabRects, idealPatchSize);
 
    while (rects.size() < idealNumRects && idealPatchSize >minPatchSize) {
        idealPatchSize = qMax(minPatchSize, idealPatchSize - patchStep);
        rects = splitAndFilterDabRect(totalRect, dabRects, idealPatchSize);
    }
 
    return rects;
}

References splitAndFilterDabRect().

Variable Documentation

MaskingBrushCompositeOpTag

KRITAIMAGE_EXPORT const char KisPaintOpUtils::MaskingBrushCompositeOpTag = "MaskingBrush/MaskingCompositeOp"

Definition at line 13 of file KisPaintopSettingsIds.cpp.

MaskingBrushEnabledTag

KRITAIMAGE_EXPORT const char KisPaintOpUtils::MaskingBrushEnabledTag = "MaskingBrush/Enabled"

Definition at line 12 of file KisPaintopSettingsIds.cpp.

MaskingBrushMasterSizeCoeffTag

KRITAIMAGE_EXPORT const char KisPaintOpUtils::MaskingBrushMasterSizeCoeffTag = "MaskingBrush/MasterSizeCoeff"

Definition at line 15 of file KisPaintopSettingsIds.cpp.

MaskingBrushPaintOpId

KRITAIMAGE_EXPORT const char KisPaintOpUtils::MaskingBrushPaintOpId = "paintbrush"

Definition at line 11 of file KisPaintopSettingsIds.cpp.

MaskingBrushPresetPrefix

KRITAIMAGE_EXPORT const char KisPaintOpUtils::MaskingBrushPresetPrefix = "MaskingBrush/Preset/"

Definition at line 16 of file KisPaintopSettingsIds.cpp.

MaskingBrushUseMasterSizeTag

KRITAIMAGE_EXPORT const char KisPaintOpUtils::MaskingBrushUseMasterSizeTag = "MaskingBrush/UseMasterSize"

Definition at line 14 of file KisPaintopSettingsIds.cpp.