KisSketchPaintOp Class Reference

#include <kis_sketch_paintop.h>

Inheritance diagram for KisSketchPaintOp:

Public Member Functions
	KisSketchPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
void	paintLine (const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance) override
	~KisSketchPaintOp () 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 ()

Static Public Member Functions
static QList< KoResourceLoadResult >	prepareLinkedResources (const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface)
Static Public Member Functions inherited from KisPaintOp
static void	splitCoordinate (qreal coordinate, qint32 *whole, qreal *fraction)

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

Private Member Functions
void	doPaintLine (const KisPaintInformation &pi1, const KisPaintInformation &pi2)
void	drawConnection (const QPointF &start, const QPointF &end, double lineWidth)
void	updateBrushMask (const KisPaintInformation &info, qreal scale, qreal rotation)

Private Attributes
KisAirbrushOptionData	m_airbrushOption
KisBrushSP	m_brush
QRectF	m_brushBoundingBox
KisBrushOptionProperties	m_brushOption
int	m_count {0}
KisPaintDeviceSP	m_dab
KisDabCache *	m_dabCache {nullptr}
KisDensityOption	m_densityOption
QPointF	m_hotSpot
KisLineWidthOption	m_lineWidthOption
KisFixedPaintDeviceSP	m_maskDab
KisOffsetScaleOption	m_offsetScaleOption
KisOpacityOption	m_opacityOption
KisPainter *	m_painter {nullptr}
QVector< QPointF >	m_points
qreal	m_radius {1.0}
KisRateOption	m_rateOption
KisRotationOption	m_rotationOption
KisSizeOption	m_sizeOption
KisSketchOpOptionData	m_sketchProperties

Additional Inherited Members
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 27 of file kis_sketch_paintop.h.

Constructor & Destructor Documentation

KisSketchPaintOp()

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

Definition at line 54 of file kis_sketch_paintop.cpp.

    : KisPaintOp(painter)
    , m_opacityOption(settings.data(), node)
    , m_sizeOption(settings.data())
    , m_rotationOption(settings.data())
    , m_rateOption(settings.data())
    , m_densityOption(settings.data())
    , m_lineWidthOption(settings.data())
    , m_offsetScaleOption(settings.data())
{
    Q_UNUSED(image);
    Q_UNUSED(node);
 
    m_airbrushOption.read(settings.data());
    m_sketchProperties.read(settings.data());
    m_brushOption.readOptionSetting(settings, settings->resourcesInterface(), settings->canvasResourcesInterface());
 
    m_brush = m_brushOption.brush();
    m_dabCache = new KisDabCache(m_brush);
 
    m_painter = 0;
    m_count = 0;
}

References KisBrushOptionProperties::brush(), KisSharedPtr< T >::data(), m_airbrushOption, m_brush, m_brushOption, m_count, m_dabCache, m_painter, m_sketchProperties, KisAirbrushOptionData::read(), KisSketchOpOptionData::read(), and KisPaintopPropertiesCanvasResourcesBase::readOptionSetting().

~KisSketchPaintOp()

KisSketchPaintOp::~KisSketchPaintOp ( )

override

Definition at line 78 of file kis_sketch_paintop.cpp.

{
    delete m_painter;
    delete m_dabCache;
}

References m_dabCache, and m_painter.

Member Function Documentation

doPaintLine()

void KisSketchPaintOp::doPaintLine ( const KisPaintInformation & pi1, const KisPaintInformation & pi2 )

private

Since the order of calculation of function parameters is not defined by C++ standard, we should generate values in an external code snippet which has a definite order of execution.

Definition at line 138 of file kis_sketch_paintop.cpp.

{
    if (!m_brush || !painter()) return;
 
    if (!m_dab) {
        m_dab = source()->createCompositionSourceDevice();
        m_painter = new KisPainter(m_dab);
        m_painter->setPaintColor(painter()->paintColor());
    }
    else {
        m_dab->clear();
    }
 
    QPointF prevMouse = pi1.pos();
    QPointF mousePosition = pi2.pos();
    m_points.append(mousePosition);
 
 
    const qreal lodAdditionalScale = KisLodTransform::lodToScale(painter()->device());
    const qreal scale = lodAdditionalScale * m_sizeOption.apply(pi2);
    if ((scale * m_brush->width()) <= 0.01 || (scale * m_brush->height()) <= 0.01) return;
 
    const qreal currentLineWidth = qMax(0.9, lodAdditionalScale * m_lineWidthOption.apply(pi2) * m_sketchProperties.lineWidth);
 
    const qreal currentOffsetScale = m_offsetScaleOption.apply(pi2) * m_sketchProperties.offset * 0.01;
    const double rotation = m_rotationOption.apply(pi2);
    const double currentProbability = m_densityOption.apply(pi2) * m_sketchProperties.probability;
 
    // shaded: does not draw this line, chrome does, fur does
    if (m_sketchProperties.makeConnection) {
        drawConnection(prevMouse, mousePosition, currentLineWidth);
    }
 
 
    qreal thresholdDistance = 0.0;
 
    // update the mask for simple mode only once
    // determine the radius
    if (m_count == 0 && m_sketchProperties.simpleMode) {
        updateBrushMask(pi2, 1.0, 0.0);
        //m_radius = qMax(m_maskDab->bounds().width(),m_maskDab->bounds().height()) * 0.5;
        m_radius = 0.5 * qMax(m_brush->width(), m_brush->height());
    }
 
    if (!m_sketchProperties.simpleMode) {
        updateBrushMask(pi2, scale, rotation);
        m_radius = qMax(m_maskDab->bounds().width(), m_maskDab->bounds().height()) * 0.5;
        thresholdDistance = pow(m_radius, 2);
    }
 
    if (m_sketchProperties.simpleMode) {
        // update the radius according scale in simple mode
        thresholdDistance = pow(m_radius * scale, 2);
    }
 
    // determine density
    const qreal density = thresholdDistance * currentProbability;
 
    // probability behaviour
    qreal probability = 1.0 - currentProbability;
 
    QColor painterColor = painter()->paintColor().toQColor();
    QColor randomColor;
    KoColor color(m_dab->colorSpace());
 
    int w = m_maskDab->bounds().width();
    quint8 opacityU8 = 0;
    quint8 * pixel;
    qreal distance;
    QPoint  positionInMask;
    QPointF diff;
 
    int size = m_points.size();
    // MAIN LOOP
    for (int i = 0; i < size; i++) {
        diff = m_points.at(i) - mousePosition;
        distance = diff.x() * diff.x() + diff.y() * diff.y();
 
        // circle test
        bool makeConnection = false;
        if (m_sketchProperties.simpleMode) {
            if (distance < thresholdDistance) {
                makeConnection = true;
            }
            // mask test
        }
        else {
            if (m_brushBoundingBox.contains(m_points.at(i))) {
                positionInMask = (diff + m_hotSpot).toPoint();
                uint pos = ((positionInMask.y() * w + positionInMask.x()) * m_maskDab->pixelSize());
                if (pos < m_maskDab->allocatedPixels() * m_maskDab->pixelSize()) {
                    pixel = m_maskDab->data() + pos;
                    opacityU8 = m_maskDab->colorSpace()->opacityU8(pixel);
                    if (opacityU8 != 0) {
                        makeConnection = true;
                    }
                }
            }
 
        }
 
        if (!makeConnection) {
            // check next point
            continue;
        }
 
        if (m_sketchProperties.distanceDensity) {
            probability =  distance / density;
        }
 
        KisRandomSourceSP randomSource = pi2.randomSource();
 
        // density check
        if (randomSource->generateNormalized() >= probability) {
            QPointF offsetPt = diff * currentOffsetScale;
 
            if (m_sketchProperties.randomRGB) {
                qreal r1 = randomSource->generateNormalized();
                qreal r2 = randomSource->generateNormalized();
                qreal r3 = randomSource->generateNormalized();
 
                // some color transformation per line goes here
                randomColor.setRgbF(r1 * painterColor.redF(),
                                    r2 * painterColor.greenF(),
                                    r3 * painterColor.blueF());
                color.fromQColor(randomColor);
                m_painter->setPaintColor(color);
            }
 
            // distance based opacity
            qreal opacity = OPACITY_OPAQUE_F;
            if (m_sketchProperties.distanceOpacity) {
                // TODO: check if the formula is correct, do we actually
                //       need rounding here?
                opacity *= qRound((1.0 - (distance / thresholdDistance)));
            }
 
            if (m_sketchProperties.randomOpacity) {
                opacity *= randomSource->generateNormalized();
            }
 
            m_painter->setOpacityF(opacity);
 
            if (m_sketchProperties.magnetify) {
                drawConnection(mousePosition + offsetPt, m_points.at(i) - offsetPt, currentLineWidth);
            }
            else {
                drawConnection(mousePosition + offsetPt, mousePosition - offsetPt, currentLineWidth);
            }
 
 
 
        }
    }// end of MAIN LOOP
 
    m_count++;
 
    QRect rc = m_dab->extent();
    m_opacityOption.apply(painter(), pi2);
 
    painter()->bitBlt(rc.x(), rc.y(), m_dab, rc.x(), rc.y(), rc.width(), rc.height());
    painter()->renderMirrorMask(rc, m_dab);
}

References KisRotationOption::apply(), KisStandardOption< Data >::apply(), KisOpacityOption::apply(), KisPainter::bitBlt(), KisFixedPaintDevice::bounds(), KisPaintDevice::clear(), KisFixedPaintDevice::colorSpace(), KisPaintDevice::colorSpace(), KisPaintDevice::createCompositionSourceDevice(), KisFixedPaintDevice::data(), distance(), KisSketchOpOptionData::distanceDensity, KisSketchOpOptionData::distanceOpacity, drawConnection(), KisPaintDevice::extent(), KoColor::fromQColor(), KisRandomSource::generateNormalized(), KisSketchOpOptionData::lineWidth, KisLodTransformBase::lodToScale(), m_brush, m_brushBoundingBox, m_count, m_dab, m_densityOption, m_hotSpot, m_lineWidthOption, m_maskDab, m_offsetScaleOption, m_opacityOption, m_painter, m_points, m_radius, m_rotationOption, m_sizeOption, m_sketchProperties, KisSketchOpOptionData::magnetify, KisSketchOpOptionData::makeConnection, KisSketchOpOptionData::offset, OPACITY_OPAQUE_F, KoColorSpace::opacityU8(), KisPainter::paintColor, KisPaintOp::painter, KisFixedPaintDevice::pixelSize(), KisPaintInformation::pos(), KisSketchOpOptionData::probability, r1, r2, r3, KisSketchOpOptionData::randomOpacity, KisSketchOpOptionData::randomRGB, KisPaintInformation::randomSource(), KisPainter::renderMirrorMask(), KisPainter::setOpacityF(), KisPainter::setPaintColor(), KisSketchOpOptionData::simpleMode, KisPaintOp::source(), KoColor::toQColor(), and updateBrushMask().

drawConnection()

void KisSketchPaintOp::drawConnection ( const QPointF & start, const QPointF & end, double lineWidth )

private

Definition at line 90 of file kis_sketch_paintop.cpp.

{
    //Both drawWuLine() and the drawDDALine produce nicer 1px lines than the drawLine()
    if (m_sketchProperties.antiAliasing) {
        if (lineWidth == 1.0) {
            m_painter->drawWuLine(start, end);
        }
        else {
            m_painter->drawLine(start, end, lineWidth, true);
        }
    }
    else {
        if (lineWidth == 1.0) {
            m_painter->drawDDALine(start, end);
        }
        else {
            m_painter->drawLine(start, end, lineWidth, false);
        }
    }
}

References KisSketchOpOptionData::antiAliasing, KisPainter::drawDDALine(), KisPainter::drawLine(), KisPainter::drawWuLine(), m_painter, and m_sketchProperties.

paintAt()

KisSpacingInformation KisSketchPaintOp::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 310 of file kis_sketch_paintop.cpp.

{
    doPaintLine(info, info);
    return updateSpacingImpl(info);
}

References doPaintLine(), and updateSpacingImpl().

paintLine()

void KisSketchPaintOp::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.

Reimplemented from KisPaintOp.

Definition at line 126 of file kis_sketch_paintop.cpp.

{
    // Use superclass behavior for lines of zero length. Otherwise, airbrushing can happen faster
    // than it is supposed to.
    if (pi1.pos() == pi2.pos()) {
        KisPaintOp::paintLine(pi1, pi2, currentDistance);
    }
    else {
        doPaintLine(pi1, pi2);
    }
}

References doPaintLine(), KisPaintOp::paintLine(), and KisPaintInformation::pos().

prepareLinkedResources()

QList< KoResourceLoadResult > KisSketchPaintOp::prepareLinkedResources ( const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface )

static

Definition at line 84 of file kis_sketch_paintop.cpp.

{
    KisBrushOptionProperties brushOption;
    return brushOption.prepareLinkedResources(settings, resourcesInterface);
}

References KisPaintopPropertiesCanvasResourcesBase::prepareLinkedResources().

updateBrushMask()

void KisSketchPaintOp::updateBrushMask ( const KisPaintInformation & info, qreal scale, qreal rotation )

private

Definition at line 111 of file kis_sketch_paintop.cpp.

{
    QRect dstRect;
    m_maskDab = m_dabCache->fetchDab(m_dab->colorSpace(),
                                     painter()->paintColor(),
                                     info.pos(),
                                     KisDabShape(scale, 1.0, rotation),
                                     info, 1.0,
                                     &dstRect);
 
    m_brushBoundingBox = dstRect;
    m_hotSpot = QPointF(0.5 * m_brushBoundingBox.width(),
                        0.5 * m_brushBoundingBox.height());
}

References KisPaintDevice::colorSpace(), KisDabCache::fetchDab(), m_brushBoundingBox, m_dab, m_dabCache, m_hotSpot, m_maskDab, KisPaintOp::painter, and KisPaintInformation::pos().

updateSpacingImpl()

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

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 316 of file kis_sketch_paintop.cpp.

{
    return KisPaintOpPluginUtils::effectiveSpacing(0.0, 0.0, true, 0.0, false, 0.0, false, 0.0,
                                                   KisLodTransform::lodToScale(painter()->device()),
                                                   &m_airbrushOption, nullptr, info);
}

References KisPaintOpPluginUtils::effectiveSpacing(), KisLodTransformBase::lodToScale(), m_airbrushOption, and KisPaintOp::painter.

updateTimingImpl()

KisTimingInformation KisSketchPaintOp::updateTimingImpl ( const KisPaintInformation & info ) const

overrideprotectedvirtual

Implementation of a timing update. The default implementation always disables timing. This is suitable for paintops that do not support airbrushing.

Reimplemented from KisPaintOp.

Definition at line 323 of file kis_sketch_paintop.cpp.

{
    return KisPaintOpPluginUtils::effectiveTiming(&m_airbrushOption, &m_rateOption, info);
}

References KisPaintOpPluginUtils::effectiveTiming(), m_airbrushOption, and m_rateOption.

Member Data Documentation

m_airbrushOption

KisAirbrushOptionData KisSketchPaintOp::m_airbrushOption

private

Definition at line 65 of file kis_sketch_paintop.h.

m_brush

KisBrushSP KisSketchPaintOp::m_brush

private

Definition at line 73 of file kis_sketch_paintop.h.

m_brushBoundingBox

QRectF KisSketchPaintOp::m_brushBoundingBox

private

Definition at line 52 of file kis_sketch_paintop.h.

m_brushOption

KisBrushOptionProperties KisSketchPaintOp::m_brushOption

private

Definition at line 67 of file kis_sketch_paintop.h.

m_count

int KisSketchPaintOp::m_count {0}

private

Definition at line 71 of file kis_sketch_paintop.h.

{0};

m_dab

KisPaintDeviceSP KisSketchPaintOp::m_dab

private

Definition at line 48 of file kis_sketch_paintop.h.

m_dabCache

KisDabCache* KisSketchPaintOp::m_dabCache {nullptr}

private

Definition at line 74 of file kis_sketch_paintop.h.

{nullptr};

m_densityOption

KisDensityOption KisSketchPaintOp::m_densityOption

private

Definition at line 62 of file kis_sketch_paintop.h.

m_hotSpot

QPointF KisSketchPaintOp::m_hotSpot

private

Definition at line 53 of file kis_sketch_paintop.h.

m_lineWidthOption

KisLineWidthOption KisSketchPaintOp::m_lineWidthOption

private

Definition at line 63 of file kis_sketch_paintop.h.

m_maskDab

KisFixedPaintDeviceSP KisSketchPaintOp::m_maskDab

private

Definition at line 51 of file kis_sketch_paintop.h.

m_offsetScaleOption

KisOffsetScaleOption KisSketchPaintOp::m_offsetScaleOption

private

Definition at line 64 of file kis_sketch_paintop.h.

m_opacityOption

KisOpacityOption KisSketchPaintOp::m_opacityOption

private

Definition at line 58 of file kis_sketch_paintop.h.

m_painter

KisPainter* KisSketchPaintOp::m_painter {nullptr}

private

Definition at line 72 of file kis_sketch_paintop.h.

{nullptr};

m_points

QVector<QPointF> KisSketchPaintOp::m_points

private

Definition at line 70 of file kis_sketch_paintop.h.

m_radius

qreal KisSketchPaintOp::m_radius {1.0}

private

Definition at line 56 of file kis_sketch_paintop.h.

{1.0};

m_rateOption

KisRateOption KisSketchPaintOp::m_rateOption

private

Definition at line 61 of file kis_sketch_paintop.h.

m_rotationOption

KisRotationOption KisSketchPaintOp::m_rotationOption

private

Definition at line 60 of file kis_sketch_paintop.h.

m_sizeOption

KisSizeOption KisSketchPaintOp::m_sizeOption

private

Definition at line 59 of file kis_sketch_paintop.h.

m_sketchProperties

KisSketchOpOptionData KisSketchPaintOp::m_sketchProperties

private

Definition at line 68 of file kis_sketch_paintop.h.

---

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

• plugins/paintops/sketch/kis_sketch_paintop.h
• plugins/paintops/sketch/kis_sketch_paintop.cpp