Classes
class	PenBrushSaver

Functions
QColor	blendColors (const QColor &c1, const QColor &c2, qreal r1)

qreal	colorDifference (const QColor &c1, const QColor &c2)

void	dragColor (QColor *color, const QColor &baseColor, qreal threshold)

void	initAntsPen (QPen antsPen, QPen outlinePen, int antLength, int antSpace)

qreal	luminosityCoarse (const QColor &c, bool sRGBtrc=true)
	luminosityCoarse This calculates the luminosity of the given QColor. It uses a very coarse (10 step) lut to linearize the sRGB trc, and then uses rec709 values to calculate the luminosity. Because of the effect of linearization, this is still more precise than one that just calculates based on coefficients.

void	rectToTexCoords (QVector2D *texCoords, const QRectF &rc)

void	rectToVertices (QVector3D *vertices, const QRectF &rc)

QRect	safeClipBoundingRect (const QPainter &painter)

QRegion	safeClipRegion (const QPainter &painter)

Variables
static QMap< qreal, qreal >	linearToSRGBTRC

static QMap< qreal, qreal >	sRgbTRCToLinear

Function Documentation

◆ blendColors()

QColor KRITAGLOBAL_EXPORT KisPaintingTweaks::blendColors	(	const QColor &	c1,
		const QColor &	c2,
		qreal	r1 )

Definition at line 97 of file kis_painting_tweaks.cpp.

{
    const qreal r2 = 1.0 - r1;
 
    return QColor::fromRgbF(
        c1.redF() * r1 + c2.redF() * r2,
        c1.greenF() * r1 + c2.greenF() * r2,
        c1.blueF() * r1 + c2.blueF() * r2);
}

References r1, and r2.

◆ colorDifference()

qreal KRITAGLOBAL_EXPORT KisPaintingTweaks::colorDifference	(	const QColor &	c1,
		const QColor &	c2 )

Returns: an approximate difference between c1 and c2 in a (nonlinear) range [0, 3]

The colors are compared using the formula: difference = sqrt(2 * diff_R^2 + 4 * diff_G^2 + 3 * diff_B^2)

Definition at line 107 of file kis_painting_tweaks.cpp.

{
    const qreal dr = c1.redF() - c2.redF();
    const qreal dg = c1.greenF() - c2.greenF();
    const qreal db = c1.blueF() - c2.blueF();
 
    return std::sqrt(2 * pow2(dr) + 4 * pow2(dg) + 3 * pow2(db));
}

References pow2().

◆ dragColor()

void KRITAGLOBAL_EXPORT KisPaintingTweaks::dragColor	(	QColor *	color,
		const QColor &	baseColor,
		qreal	threshold )

Make the color color differ from baseColor for at least threshold value

Definition at line 116 of file kis_painting_tweaks.cpp.

{
    while (colorDifference(*color, baseColor) < threshold) {
 
        QColor newColor = *color;
 
        if (newColor.lightnessF() > baseColor.lightnessF()) {
            newColor = newColor.lighter(120);
        } else {
            newColor = newColor.darker(120);
        }
 
        if (newColor == *color) {
            break;
        }
 
        *color = newColor;
    }
}

References colorDifference().

◆ initAntsPen()

KRITAGLOBAL_EXPORT void KisPaintingTweaks::initAntsPen	(	QPen *	antsPen,
		QPen *	outlinePen,
		int	antLength,
		int	antSpace )

Definition at line 41 of file kis_painting_tweaks.cpp.

{
    QVector<qreal> antDashPattern;
    antDashPattern << antLength << antSpace;
 
    *antsPen = QPen(Qt::CustomDashLine);
    antsPen->setDashPattern(antDashPattern);
    antsPen->setCosmetic(true);
    antsPen->setColor(Qt::black);
 
    *outlinePen = QPen(Qt::SolidLine);
    outlinePen->setCosmetic(true);
    outlinePen->setColor(Qt::white);
}

◆ luminosityCoarse()

qreal KRITAGLOBAL_EXPORT KisPaintingTweaks::luminosityCoarse	(	const QColor &	c,
		bool	sRGBtrc = true )

luminosityCoarse This calculates the luminosity of the given QColor. It uses a very coarse (10 step) lut to linearize the sRGB trc, and then uses rec709 values to calculate the luminosity. Because of the effect of linearization, this is still more precise than one that just calculates based on coefficients.

Parameters

c	the color to calculate the luminosity of.
sRGBtrc	whether to linearize the sRGB trc.

Returns: a delinearized luminosity value, quantized to steps of 0.1.

Definition at line 168 of file kis_painting_tweaks.cpp.

{
    qreal r = c.redF();
    qreal g = c.greenF();
    qreal b = c.blueF();
    if (sRGBtrc) {
        if (r < 1.0) {
            r = sRgbTRCToLinear.upperBound(r).value();
        }
        if (g < 1.0) {
            g = sRgbTRCToLinear.upperBound(g).value();
        }
        if (b < 1.0) {
            b = sRgbTRCToLinear.upperBound(b).value();
        }
    }
    qreal lumi = (r * .2126) + (g * .7152) + (b * .0722);
    if (sRGBtrc && lumi < 1.0) {
        lumi = linearToSRGBTRC.lowerBound(lumi).value();
    }
    return lumi;
}

References linearToSRGBTRC, and sRgbTRCToLinear.

◆ rectToTexCoords()

void KisPaintingTweaks::rectToTexCoords	(	QVector2D *	texCoords,
		const QRectF &	rc )

inline

Definition at line 126 of file kis_painting_tweaks.h.

    {
        texCoords[0] = QVector2D(rc.left(), rc.bottom());
        texCoords[1] = QVector2D(rc.left(), rc.top());
        texCoords[2] = QVector2D(rc.right(), rc.bottom());
        texCoords[3] = QVector2D(rc.left(), rc.top());
        texCoords[4] = QVector2D(rc.right(), rc.top());
        texCoords[5] = QVector2D(rc.right(), rc.bottom());
    }

◆ rectToVertices()

void KisPaintingTweaks::rectToVertices	(	QVector3D *	vertices,
		const QRectF &	rc )

inline

Definition at line 116 of file kis_painting_tweaks.h.

    {
        vertices[0] = QVector3D(rc.left(),  rc.bottom(), 0.f);
        vertices[1] = QVector3D(rc.left(),  rc.top(),    0.f);
        vertices[2] = QVector3D(rc.right(), rc.bottom(), 0.f);
        vertices[3] = QVector3D(rc.left(),  rc.top(), 0.f);
        vertices[4] = QVector3D(rc.right(), rc.top(), 0.f);
        vertices[5] = QVector3D(rc.right(), rc.bottom(),    0.f);
    }

◆ safeClipBoundingRect()

KRITAGLOBAL_EXPORT QRect KisPaintingTweaks::safeClipBoundingRect ( const QPainter & painter )

See also: safeClipRegion()

Definition at line 36 of file kis_painting_tweaks.cpp.

{
    return painter.clipBoundingRect().toAlignedRect();
}

◆ safeClipRegion()

KRITAGLOBAL_EXPORT QRegion KisPaintingTweaks::safeClipRegion ( const QPainter & painter )

This is a workaround for QPainter::clipRegion() bug. When zoom is about 2000% and rotation is in a range[-5;5] degrees, the generated region will have about 20k+ rectangles inside. Their processing will be really slow. These functions work around the issue.

Definition at line 20 of file kis_painting_tweaks.cpp.

{
    const QTransform t = painter.transform();
 
    QRegion region = t.type() <= QTransform::TxScale ?
        painter.clipRegion() :
        QRegion(painter.clipBoundingRect().toAlignedRect());
 
    if (region.rectCount() > 1000) {
        qWarning() << "WARNING: KisPaintingTweaks::safeClipRegion: too many rectangles in the region!" << ppVar(region.rectCount());
        region = QRegion(painter.clipBoundingRect().toAlignedRect());
    }
 
    return region;
}

References ppVar.

Variable Documentation

◆ linearToSRGBTRC

QMap<qreal, qreal> KisPaintingTweaks::linearToSRGBTRC

static

Initial value:

{
    {0.0, 0.0},
    {0.01002, 0.1},
    {0.0331, 0.2},
    {0.07324, 0.3},
    {0.13287, 0.4},
    {0.21404, 0.5},
    {0.31855, 0.6},
    {0.44799, 0.7},
    {0.60383, 0.8},
    {0.78741, 0.9},
    {1.0, 1.0}
}

Definition at line 154 of file kis_painting_tweaks.cpp.

                                          {
    {0.0, 0.0},
    {0.01002, 0.1},
    {0.0331, 0.2},
    {0.07324, 0.3},
    {0.13287, 0.4},
    {0.21404, 0.5},
    {0.31855, 0.6},
    {0.44799, 0.7},
    {0.60383, 0.8},
    {0.78741, 0.9},
    {1.0, 1.0}
};

◆ sRgbTRCToLinear

QMap<qreal, qreal> KisPaintingTweaks::sRgbTRCToLinear