KisExperimentPaintOp Class Reference

#include <kis_experiment_paintop.h>

Inheritance diagram for KisExperimentPaintOp:

Public Member Functions
	KisExperimentPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
void	paintLine (const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance) override
	~KisExperimentPaintOp () override
Public Member Functions inherited from KisPaintOp
virtual bool	canPaint () const
virtual std::pair< int, bool >	doAsynchronousUpdate (QVector< KisRunnableStrokeJobData * > &jobs)
	KisPaintOp (KisPainter *painter)
void	paintAt (const KisPaintInformation &info, KisDistanceInformation *currentDistance)
virtual void	paintBezierCurve (const KisPaintInformation &pi1, const QPointF &control1, const QPointF &control2, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)
	Private (KisPaintOp *_q)
void	updateSpacing (const KisPaintInformation &info, KisDistanceInformation &currentDistance) const
void	updateTiming (const KisPaintInformation &info, KisDistanceInformation &currentDistance) const
virtual	~KisPaintOp ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Protected Member Functions
KisSpacingInformation	paintAt (const KisPaintInformation &info) override
KisSpacingInformation	updateSpacingImpl (const KisPaintInformation &info) const override
Protected Member Functions inherited from KisPaintOp
KisFixedPaintDeviceSP	cachedDab ()
KisFixedPaintDeviceSP	cachedDab (const KoColorSpace *cs)
KisPainter *	painter () const
KisPaintDeviceSP	source () const
virtual KisTimingInformation	updateTimingImpl (const KisPaintInformation &info) const
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Private Member Functions
void	paintRegion (const KisRegion &changedRegion)
QPointF	speedCorrectedPosition (const KisPaintInformation &pi1, const KisPaintInformation &pi2)

Static Private Member Functions
static QPainterPath	applyDisplace (const QPainterPath &path, int speed)
static QPointF	getAngle (const QPointF &p1, const QPointF &p2, qreal distance)
static qreal	simplifyThreshold (const QRectF &bounds)

Private Attributes
QPointF	m_center
int	m_displaceCoeff {0}
bool	m_displaceEnabled {false}
KisExperimentOpOptionData	m_experimentOption
KisPainter::FillStyle	m_fillStyle {KisPainter::FillStyleNone}
bool	m_firstRun {true}
bool	m_hardEdge {false}
QPainterPath	m_lastPaintedPath
int	m_lastPaintTime {0}
KisPaintDeviceSP	m_originalDevice
KisPainter *	m_originalPainter {0}
QPainterPath	m_path
QVector< QPointF >	m_savedPoints
int	m_savedSmoothingDistance {1}
QPointF	m_savedSmoothingPoint
qreal	m_savedSpeedCoeff {1.0}
QPointF	m_savedSpeedPoint
int	m_savedUpdateDistance {1}
bool	m_smoothingEnabled {false}
int	m_smoothingThreshold {1}
bool	m_speedEnabled {false}
int	m_speedMultiplier {1}
bool	m_useMirroring {false}
bool	m_windingFill {false}

Additional Inherited Members
Static Public Member Functions inherited from KisPaintOp
static void	splitCoordinate (qreal coordinate, qint32 *whole, qreal *fraction)
Public Attributes inherited from KisPaintOp
KisFixedPaintDeviceSP	dab
bool	fanCornersEnabled {false}
qreal	fanCornersStep {1.0}
KisPainter *	painter {nullptr}
KisPaintOp *	q {nullptr}
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Detailed Description

Definition at line 25 of file kis_experiment_paintop.h.

Constructor & Destructor Documentation

KisExperimentPaintOp()

KisExperimentPaintOp::KisExperimentPaintOp	(	const KisPaintOpSettingsSP	settings,
		KisPainter *	painter,
		KisNodeSP	node,
		KisImageSP	image )

Definition at line 27 of file kis_experiment_paintop.cpp.

    : KisPaintOp(painter)
{
    Q_UNUSED(image);
    Q_UNUSED(node);
 
    m_firstRun = true;
 
    m_experimentOption.read(settings.data());
 
    m_displaceEnabled = m_experimentOption.isDisplacementEnabled;
    m_displaceCoeff = (m_experimentOption.displacement * 0.01 * 14) + 1; // 1..15 [7 default according alchemy]
 
    m_speedEnabled = m_experimentOption.isSpeedEnabled;
    m_speedMultiplier = (m_experimentOption.speed * 0.01 * 35); // 0..35 [15 default according alchemy]
    m_smoothingEnabled = m_experimentOption.isSmoothingEnabled;
    m_smoothingThreshold = m_experimentOption.smoothing;
 
    m_useMirroring = painter->hasMirroring();
    m_windingFill = m_experimentOption.windingFill;
    m_hardEdge = m_experimentOption.hardEdge;
 
    //Sets the brush to pattern or foregroundColor
    if (m_experimentOption.fillType == ExperimentFillType::Pattern) {
        m_fillStyle = KisPainter::FillStylePattern;
    } else {
        m_fillStyle = KisPainter::FillStyleForegroundColor;
    }
 
    // Mirror options set with appropriate color, pattern, and fillStyle
    if (m_useMirroring) {
        m_originalDevice = source()->createCompositionSourceDevice();        
        m_originalPainter = new KisPainter(m_originalDevice);
        m_originalPainter->setCompositeOpId(COMPOSITE_COPY);
        m_originalPainter->setPaintColor(painter->paintColor());
        m_originalPainter->setPattern(painter->pattern());        
        m_originalPainter->setFillStyle(m_fillStyle);
 
    }
    else {
        m_originalPainter = 0;
    }
}

References COMPOSITE_COPY, KisPaintDevice::createCompositionSourceDevice(), KisSharedPtr< T >::data(), KisExperimentOpOptionData::displacement, KisPainter::FillStyleForegroundColor, KisPainter::FillStylePattern, KisExperimentOpOptionData::fillType, KisExperimentOpOptionData::hardEdge, KisPainter::hasMirroring(), KisExperimentOpOptionData::isDisplacementEnabled, KisExperimentOpOptionData::isSmoothingEnabled, KisExperimentOpOptionData::isSpeedEnabled, m_displaceCoeff, m_displaceEnabled, m_experimentOption, m_fillStyle, m_firstRun, m_hardEdge, m_originalDevice, m_originalPainter, m_smoothingEnabled, m_smoothingThreshold, m_speedEnabled, m_speedMultiplier, m_useMirroring, m_windingFill, KisPainter::paintColor, KisPaintOp::painter, KisPainter::pattern, Pattern, KisExperimentOpOptionData::read(), KisPainter::setCompositeOpId(), KisPainter::setFillStyle(), KisPainter::setPaintColor(), KisPainter::setPattern(), KisExperimentOpOptionData::smoothing, KisPaintOp::source(), KisExperimentOpOptionData::speed, and KisExperimentOpOptionData::windingFill.

~KisExperimentPaintOp()

KisExperimentPaintOp::~KisExperimentPaintOp ( )

override

Definition at line 71 of file kis_experiment_paintop.cpp.

{
    delete m_originalPainter;
}

References m_originalPainter.

Member Function Documentation

applyDisplace()

QPainterPath KisExperimentPaintOp::applyDisplace ( const QPainterPath & path, int speed )

staticprivate

Definition at line 302 of file kis_experiment_paintop.cpp.

{
    QPointF lastPoint = path.currentPosition();
 
    QPainterPath newPath;
    int count = path.elementCount();
    int curveElementCounter = 0;
    QPointF ctrl1;
    QPointF ctrl2;
    QPointF endPoint;
    for (int i = 0; i < count; i++) {
        QPainterPath::Element e = path.elementAt(i);
        switch (e.type) {
        case QPainterPath::MoveToElement: {
            newPath.moveTo(getAngle(QPointF(e.x, e.y), lastPoint, speed));
            break;
        }
        case QPainterPath::LineToElement: {
            newPath.lineTo(getAngle(QPointF(e.x, e.y), lastPoint, speed));
            break;
        }
        case QPainterPath::CurveToElement: {
            curveElementCounter = 0;
            endPoint = getAngle(QPointF(e.x, e.y), lastPoint, speed);
            break;
        }
        case QPainterPath::CurveToDataElement: {
            curveElementCounter++;
 
            if (curveElementCounter == 1) {
                ctrl1 = getAngle(QPointF(e.x, e.y), lastPoint, speed);
            }
            else if (curveElementCounter == 2) {
                ctrl2 = getAngle(QPointF(e.x, e.y), lastPoint, speed);
                newPath.cubicTo(ctrl1, ctrl2, endPoint);
            }
            break;
        }
        }
 
    }// for
 
    return newPath;
}

References getAngle().

getAngle()

QPointF KisExperimentPaintOp::getAngle ( const QPointF & p1, const QPointF & p2, qreal distance )

staticprivate

Definition at line 295 of file kis_experiment_paintop.cpp.

{
    QPointF diff = p1 - p2;
    qreal realLength = sqrt(diff.x() * diff.x() + diff.y() * diff.y());
    return realLength > 0.5 ? p1 + diff * distance / realLength : p1;
}

References distance(), p1, and p2.

paintAt()

KisSpacingInformation KisExperimentPaintOp::paintAt ( const KisPaintInformation & info )

overrideprotectedvirtual

The implementation of painting of a dab and updating spacing. This does NOT need to update the timing information.

Implements KisPaintOp.

Definition at line 251 of file kis_experiment_paintop.cpp.

{
    return updateSpacingImpl(info);
}

References updateSpacingImpl().

paintLine()

void KisExperimentPaintOp::paintLine ( const KisPaintInformation & pi1, const KisPaintInformation & pi2, KisDistanceInformation * currentDistance )

overridevirtual

Draw a line between pos1 and pos2 using the currently set brush and color. If savedDist is less than zero, the brush is painted at pos1 before being painted along the line using the spacing setting.

Returns

the drag distance, that is the remains of the distance between p1 and p2 not covered because the currently set brush has a spacing greater than that distance.

Refresh rate at least 25fps

Rendering the path with diff'ed rects is up to two times more efficient for really huge shapes (tested on 2000+ px shapes), however for smaller ones doing paths arithmetics eats too much time. That's why we choose the method on the base of the size of the shape.

Reimplemented from KisPaintOp.

Definition at line 122 of file kis_experiment_paintop.cpp.

{
    Q_UNUSED(currentDistance);
    if (!painter()) return;
 
    if (m_firstRun) {
        m_firstRun = false;
 
        m_path.moveTo(pi1.pos());
        m_path.lineTo(pi2.pos());
 
        m_center = pi1.pos();
 
        m_savedUpdateDistance = 0;
        m_lastPaintTime = 0;
 
        m_savedSpeedCoeff = 0;
        m_savedSpeedPoint = m_center;
 
        m_savedSmoothingDistance = 0;
        m_savedSmoothingPoint = m_center;
 
    }
    else {
 
        const QPointF pos1 = pi1.pos();
        QPointF pos2 = pi2.pos();
 
        if (m_speedEnabled) {
            pos2 = speedCorrectedPosition(pi1, pi2);
        }
 
        int length = (pos2 - pos1).manhattanLength();
        m_savedUpdateDistance += length;
 
        if (m_smoothingEnabled) {
            m_savedSmoothingDistance += length;
 
            if (m_savedSmoothingDistance > m_smoothingThreshold) {
                QPointF pt = (m_savedSmoothingPoint + pos2) * 0.5;
 
                // for updates approximate curve with two lines
                m_savedPoints << m_path.currentPosition();
                m_savedPoints << m_savedSmoothingPoint;
                m_savedPoints << m_savedSmoothingPoint;
                m_savedPoints << pt;
 
                m_path.quadTo(m_savedSmoothingPoint, pt);
                m_savedSmoothingPoint = pos2;
 
                m_savedSmoothingDistance = 0;
            }
        }
        else {
            m_path.lineTo(pos2);
            m_savedPoints << pos1;
            m_savedPoints << pos2;
        }
 
        if (m_displaceEnabled) {
            if (m_path.elementCount() % 16 == 0) {
                QRectF bounds = m_path.boundingRect();
                m_path = applyDisplace(m_path, m_displaceCoeff - length);
                bounds |= m_path.boundingRect();
 
                qreal threshold = simplifyThreshold(bounds);
                m_path = KisAlgebra2D::trySimplifyPath(m_path, threshold);
            }
            else {
                m_path = applyDisplace(m_path, m_displaceCoeff - length);
            }
        }
 
        const int timeThreshold = 40;
        const int elapsedTime = pi2.currentTime() - m_lastPaintTime;
 
        QRect pathBounds = m_path.boundingRect().toRect();
        int distanceMetric = qMax(pathBounds.width(), pathBounds.height());
 
        if (elapsedTime > timeThreshold ||
                (!m_displaceEnabled &&
                 m_savedUpdateDistance > distanceMetric / 8)) {
 
            if (m_displaceEnabled) {
                const int pathSizeThreshold = 128;
 
                KisRegion changedRegion;
                if (distanceMetric < pathSizeThreshold) {
 
                    QRectF changedRect = m_path.boundingRect().toRect() |
                                         m_lastPaintedPath.boundingRect().toRect();
                    changedRect.adjust(-1, -1, 1, 1);
 
                    changedRegion = changedRect.toRect();
                }
                else {
                    QPainterPath diff1 = m_path - m_lastPaintedPath;
                    QPainterPath diff2 = m_lastPaintedPath - m_path;
 
                    changedRegion = KritaUtils::splitPath(diff1 | diff2);
                }
 
                paintRegion(changedRegion);
                m_lastPaintedPath = m_path;
            }
            else if (!m_savedPoints.isEmpty()) {
                KisRegion changedRegion = KritaUtils::splitTriangles(m_center, m_savedPoints);
                paintRegion(changedRegion);
            }
 
            m_savedPoints.clear();
            m_savedUpdateDistance = 0;
            m_lastPaintTime = pi2.currentTime();
        }
    }
}

References applyDisplace(), KisRegion::boundingRect(), bounds, KisPaintInformation::currentTime(), length(), m_center, m_displaceCoeff, m_displaceEnabled, m_firstRun, m_lastPaintedPath, m_lastPaintTime, m_path, m_savedPoints, m_savedSmoothingDistance, m_savedSmoothingPoint, m_savedSpeedCoeff, m_savedSpeedPoint, m_savedUpdateDistance, m_smoothingEnabled, m_smoothingThreshold, m_speedEnabled, KisPaintOp::painter, paintRegion(), KisPaintInformation::pos(), simplifyThreshold(), speedCorrectedPosition(), KritaUtils::splitPath(), KritaUtils::splitTriangles(), and KisAlgebra2D::trySimplifyPath().

paintRegion()

void KisExperimentPaintOp::paintRegion ( const KisRegion & changedRegion )

private

Definition at line 76 of file kis_experiment_paintop.cpp.

{
    if (m_windingFill) {
        m_path.setFillRule(Qt::WindingFill);
    }
 
    if (m_useMirroring) {
        m_originalPainter->setAntiAliasPolygonFill(!m_hardEdge);
 
        Q_FOREACH (const QRect & rect, changedRegion.rects()) {
            m_originalPainter->fillPainterPath(m_path, rect);
            painter()->renderDabWithMirroringNonIncremental(rect, m_originalDevice);
 
        }
    }
    else {
        //Sets options when mirror is not selected
        painter()->setFillStyle(m_fillStyle);
 
        painter()->setCompositeOpId(COMPOSITE_COPY);
        painter()->setAntiAliasPolygonFill(!m_hardEdge);
 
        Q_FOREACH (const QRect & rect, changedRegion.rects()) {
            painter()->fillPainterPath(m_path, rect);
        }
    }
}

References COMPOSITE_COPY, KisPainter::fillPainterPath(), m_fillStyle, m_hardEdge, m_originalDevice, m_originalPainter, m_path, m_useMirroring, m_windingFill, KisPaintOp::painter, KisRegion::rects(), KisPainter::renderDabWithMirroringNonIncremental(), KisPainter::setAntiAliasPolygonFill(), KisPainter::setCompositeOpId(), and KisPainter::setFillStyle().

simplifyThreshold()

qreal KisExperimentPaintOp::simplifyThreshold ( const QRectF & bounds )

staticprivate

Definition at line 289 of file kis_experiment_paintop.cpp.

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

References bounds.

speedCorrectedPosition()

QPointF KisExperimentPaintOp::speedCorrectedPosition ( const KisPaintInformation & pi1, const KisPaintInformation & pi2 )

private

Definition at line 104 of file kis_experiment_paintop.cpp.

{
    const qreal fadeFactor = 0.6;
 
    QPointF diff = pi2.pos() - pi1.pos();
    qreal realLength = sqrt(diff.x() * diff.x() + diff.y() * diff.y());
 
    if (realLength < 0.1) return pi2.pos();
 
    qreal coeff = 0.5 * realLength * m_speedMultiplier;
    m_savedSpeedCoeff = fadeFactor * m_savedSpeedCoeff + (1 - fadeFactor) * coeff;
    QPointF newPoint = pi1.pos() + diff * m_savedSpeedCoeff / realLength;
    m_savedSpeedPoint = fadeFactor * m_savedSpeedPoint + (1 - fadeFactor) * newPoint;
 
    return m_savedSpeedPoint;
}

References m_savedSpeedCoeff, m_savedSpeedPoint, m_speedMultiplier, and KisPaintInformation::pos().

updateSpacingImpl()

KisSpacingInformation KisExperimentPaintOp::updateSpacingImpl ( const KisPaintInformation & info ) const

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 256 of file kis_experiment_paintop.cpp.

{
    Q_UNUSED(info);
    return KisSpacingInformation(1.0);
}

Member Data Documentation

m_center

QPointF KisExperimentPaintOp::m_center

private

Definition at line 73 of file kis_experiment_paintop.h.

m_displaceCoeff

int KisExperimentPaintOp::m_displaceCoeff {0}

private

Definition at line 52 of file kis_experiment_paintop.h.

{0};

m_displaceEnabled

bool KisExperimentPaintOp::m_displaceEnabled {false}

private

Definition at line 51 of file kis_experiment_paintop.h.

{false};

m_experimentOption

KisExperimentOpOptionData KisExperimentPaintOp::m_experimentOption

private

Definition at line 76 of file kis_experiment_paintop.h.

m_fillStyle

KisPainter::FillStyle KisExperimentPaintOp::m_fillStyle {KisPainter::FillStyleNone}

private

Definition at line 82 of file kis_experiment_paintop.h.

{KisPainter::FillStyleNone};

m_firstRun

bool KisExperimentPaintOp::m_firstRun {true}

private

Definition at line 72 of file kis_experiment_paintop.h.

{true};

m_hardEdge

bool KisExperimentPaintOp::m_hardEdge {false}

private

Definition at line 56 of file kis_experiment_paintop.h.

{false};

m_lastPaintedPath

QPainterPath KisExperimentPaintOp::m_lastPaintedPath

private

Definition at line 53 of file kis_experiment_paintop.h.

m_lastPaintTime

int KisExperimentPaintOp::m_lastPaintTime {0}

private

Definition at line 70 of file kis_experiment_paintop.h.

{0};

m_originalDevice

KisPaintDeviceSP KisExperimentPaintOp::m_originalDevice

private

Definition at line 80 of file kis_experiment_paintop.h.

m_originalPainter

KisPainter* KisExperimentPaintOp::m_originalPainter {0}

private

Definition at line 79 of file kis_experiment_paintop.h.

{0};

m_path

QPainterPath KisExperimentPaintOp::m_path

private

Definition at line 75 of file kis_experiment_paintop.h.

m_savedPoints

QVector<QPointF> KisExperimentPaintOp::m_savedPoints

private

Definition at line 69 of file kis_experiment_paintop.h.

m_savedSmoothingDistance

int KisExperimentPaintOp::m_savedSmoothingDistance {1}

private

Definition at line 66 of file kis_experiment_paintop.h.

{1};

m_savedSmoothingPoint

QPointF KisExperimentPaintOp::m_savedSmoothingPoint

private

Definition at line 65 of file kis_experiment_paintop.h.

m_savedSpeedCoeff

qreal KisExperimentPaintOp::m_savedSpeedCoeff {1.0}

private

Definition at line 60 of file kis_experiment_paintop.h.

{1.0};

m_savedSpeedPoint

QPointF KisExperimentPaintOp::m_savedSpeedPoint

private

Definition at line 61 of file kis_experiment_paintop.h.

m_savedUpdateDistance

int KisExperimentPaintOp::m_savedUpdateDistance {1}

private

Definition at line 68 of file kis_experiment_paintop.h.

{1};

m_smoothingEnabled

bool KisExperimentPaintOp::m_smoothingEnabled {false}

private

Definition at line 63 of file kis_experiment_paintop.h.

{false};

m_smoothingThreshold

int KisExperimentPaintOp::m_smoothingThreshold {1}

private

Definition at line 64 of file kis_experiment_paintop.h.

{1};

m_speedEnabled

bool KisExperimentPaintOp::m_speedEnabled {false}

private

Definition at line 58 of file kis_experiment_paintop.h.

{false};

m_speedMultiplier

int KisExperimentPaintOp::m_speedMultiplier {1}

private

Definition at line 59 of file kis_experiment_paintop.h.

{1};

m_useMirroring

bool KisExperimentPaintOp::m_useMirroring {false}

private

Definition at line 78 of file kis_experiment_paintop.h.

{false};

m_windingFill

bool KisExperimentPaintOp::m_windingFill {false}

private

Definition at line 55 of file kis_experiment_paintop.h.

{false};

---

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

• plugins/paintops/experiment/kis_experiment_paintop.h
• plugins/paintops/experiment/kis_experiment_paintop.cpp