KisGridPaintOp Class Reference

#include <kis_grid_paintop.h>

Inheritance diagram for KisGridPaintOp:

Public Member Functions
	KisGridPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
	~KisGridPaintOp () 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)
virtual void	paintLine (const KisPaintInformation &pi1, 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
KisSpacingInformation	computeSpacing (qreal lodScale) const

Private Attributes
KisColorOptionData	m_colorProperties
KisPaintDeviceSP	m_dab
KisNodeSP	m_node
KisPainter *	m_painter
KisGridOpOptionData	m_properties
KisGridPaintOpSettingsSP	m_settings
KisGridShapeOptionData	m_shapeProperties
qreal	m_spacing
qreal	m_xSpacing
qreal	m_ySpacing

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 24 of file kis_grid_paintop.h.

Constructor & Destructor Documentation

KisGridPaintOp()

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

Definition at line 37 of file kis_grid_paintop.cpp.

    : KisPaintOp(painter)
    , m_settings(static_cast<KisGridPaintOpSettings*>(const_cast<KisPaintOpSettings*>(settings.data())))
    , m_node(node)
{
 
    m_properties.read(settings.data());
    m_colorProperties.read(settings.data());
    m_shapeProperties.read(settings.data());
 
    m_xSpacing = m_properties.grid_width * m_properties.grid_scale;
    m_ySpacing = m_properties.grid_height * m_properties.grid_scale;
    m_spacing = m_xSpacing;
 
    m_dab = source()->createCompositionSourceDevice();
    m_painter = new KisPainter(m_dab);
    m_painter->setPaintColor(painter->paintColor());
    m_painter->setFillStyle(KisPainter::FillStyleForegroundColor);
#ifdef BENCHMARK
    m_count = m_total = 0;
#endif
 
}

References KisPaintDevice::createCompositionSourceDevice(), KisSharedPtr< T >::data(), KisPainter::FillStyleForegroundColor, KisGridOpOptionData::grid_height, KisGridOpOptionData::grid_scale, KisGridOpOptionData::grid_width, m_colorProperties, m_dab, m_painter, m_properties, m_shapeProperties, m_spacing, m_xSpacing, m_ySpacing, KisPainter::paintColor, KisPaintOp::painter, KisGridOpOptionData::read(), KisGridShapeOptionData::read(), KisColorOptionData::read(), KisPainter::setFillStyle(), KisPainter::setPaintColor(), and KisPaintOp::source().

~KisGridPaintOp()

KisGridPaintOp::~KisGridPaintOp ( )

override

Definition at line 61 of file kis_grid_paintop.cpp.

{
    delete m_painter;
}

References m_painter.

Member Function Documentation

computeSpacing()

KisSpacingInformation KisGridPaintOp::computeSpacing ( qreal lodScale ) const

private

Definition at line 244 of file kis_grid_paintop.cpp.

{
    return KisSpacingInformation(m_spacing * lodScale);
}

References m_spacing.

paintAt()

KisSpacingInformation KisGridPaintOp::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 66 of file kis_grid_paintop.cpp.

{
#ifdef BENCHMARK
    QTime time;
    time.start();
#endif
 
    KisRandomSourceSP randomSource = info.randomSource();
    const qreal additionalScale = KisLodTransform::lodToScale(painter()->device());
 
    m_dab->clear();
 
    qreal gridWidth = m_properties.diameter * m_properties.grid_scale * additionalScale;
    qreal gridHeight = m_properties.diameter * m_properties.grid_scale * additionalScale;
 
    qreal cellWidth = m_properties.grid_width * m_properties.grid_scale * additionalScale;
    qreal cellHeight = m_properties.grid_height * m_properties.grid_scale * additionalScale;
 
    qreal horizontalOffset = m_properties.horizontal_offset;
    qreal verticalOffset = m_properties.vertical_offset;
 
    int divide;
    if (m_properties.grid_pressure_division) {
        divide = m_properties.grid_division_level * info.pressure();
    }
    else {
        divide = m_properties.grid_division_level;
    }
 
    divide = qRound(m_properties.grid_scale * divide);
 
    //Adjust the start position of the drawn grid to the top left of the brush instead of in the center
    qreal posX = info.pos().x() - (gridWidth/2) + (cellWidth/2) - horizontalOffset;
    qreal posY = info.pos().y() - (gridHeight/2) + (cellHeight/2) - verticalOffset;
 
    //Lock the grid alignment
    posX = posX - std::fmod(posX, cellWidth) + horizontalOffset;
    posY = posY - std::fmod(posY, cellHeight) + verticalOffset;
    const QRectF dabRect(posX , posY , cellWidth, cellHeight);
    const QRect dabRectAligned = dabRect.toAlignedRect();
 
    divide = qMax(1, divide);
    const qreal yStep = cellHeight / (qreal)divide;
    const qreal xStep = cellWidth / (qreal)divide;
 
    QRectF tile;
    KoColor color(painter()->paintColor());
 
    QScopedPointer<KisCrossDeviceColorSampler> colorSampler;
    if (m_node) {
        colorSampler.reset(new KisCrossDeviceColorSampler(m_node->paintDevice(), color));
    }
 
    qreal vertBorder = m_properties.grid_vertical_border * additionalScale;
    qreal horzBorder = m_properties.grid_horizontal_border * additionalScale;
    if (m_properties.grid_random_border) {
        if (vertBorder == horzBorder) {
            vertBorder = horzBorder = vertBorder * randomSource->generateNormalized();
        }
        else {
            vertBorder *= randomSource->generateNormalized();
            horzBorder *= randomSource->generateNormalized();
        }
    }
 
    bool shouldColor = true;
    // fill the tile
    if (m_colorProperties.fillBackground) {
        m_dab->fill(dabRectAligned, painter()->backgroundColor());
    }
    for (int y = 0; y < (gridHeight)/yStep; y++) {
        for (int x = 0; x < (gridWidth)/xStep; x++) {
            // determine the tile size
            tile = QRectF(dabRect.x() + x * xStep, dabRect.y() + y * yStep, xStep, yStep);
            tile.adjust(vertBorder, horzBorder, -vertBorder, -horzBorder);
            tile = tile.normalized();
 
            // do color transformation
            if (shouldColor) {
                if (colorSampler && m_colorProperties.sampleInputColor) {
                    colorSampler->sampleOldColor(tile.center().x(), tile.center().y(), color.data());
                }
 
                // mix the color with background color
                if (m_colorProperties.mixBgColor) {
                    KoMixColorsOp * mixOp = source()->colorSpace()->mixColorsOp();
 
                    const quint8 *colors[2];
                    colors[0] = color.data();
                    colors[1] = painter()->backgroundColor().data();
 
                    qint16 colorWeights[2];
                    int MAX_16BIT = 255;
                    qreal blend = info.pressure();
 
                    colorWeights[0] = static_cast<quint16>(blend * MAX_16BIT);
                    colorWeights[1] = static_cast<quint16>((1.0 - blend) * MAX_16BIT);
                    mixOp->mixColors(colors, colorWeights, 2, color.data());
                }
 
                if (m_colorProperties.useRandomHSV) {
                    QHash<QString, QVariant> params;
                    params["h"] = (m_colorProperties.hue / 180.0) * randomSource->generateNormalized();
                    params["s"] = (m_colorProperties.saturation / 100.0) * randomSource->generateNormalized();
                    params["v"] = (m_colorProperties.value / 100.0) * randomSource->generateNormalized();
                    KoColorTransformation* transfo;
                    transfo = m_dab->colorSpace()->createColorTransformation("hsv_adjustment", params);
                    transfo->setParameter(3, 1);//sets the type to HSV. For some reason 0 is not an option.
                    transfo->setParameter(4, false);//sets the colorize to false.
                    transfo->transform(color.data(), color.data() , 1);
                }
 
                if (m_colorProperties.useRandomOpacity) {
                    const qreal alpha = randomSource->generateNormalized();
                    color.setOpacity(alpha);
                    m_painter->setOpacityF(alpha);
                }
 
                if (!m_colorProperties.colorPerParticle) {
                    shouldColor = false;
                }
                m_painter->setPaintColor(color);
            }
 
            // paint some element
            switch (m_shapeProperties.shape) {
            case 0: {
                m_painter->paintEllipse(tile);
                break;
            }
            case 1: {
                // anti-aliased version
                //m_painter->paintRect(tile);
                m_dab->fill(tile.topLeft().x(), tile.topLeft().y(), tile.width(), tile.height(), color.data());
                break;
            }
            case 2: {
                m_painter->drawDDALine(tile.topRight(), tile.bottomLeft());
                break;
            }
            case 3: {
                m_painter->drawLine(tile.topRight(), tile.bottomLeft());
                break;
            }
            case 4: {
                m_painter->drawThickLine(tile.topRight(), tile.bottomLeft() , 1, 10);
                break;
            }
            default: {
                break;
            }
            }
 
            if (m_colorProperties.colorPerParticle){
                color=painter()->paintColor();//reset color//
            }
        }
    }
 
    QRect rc = m_dab->extent();
    painter()->bitBlt(rc.topLeft(), m_dab, rc);
    painter()->renderMirrorMask(rc, m_dab);
 
#ifdef BENCHMARK
    int msec = time.elapsed();
    dbgKrita << msec << " ms/dab " << "[average: " << m_total / (qreal)m_count << "]";
    m_total += msec;
    m_count++;
#endif
    return computeSpacing(additionalScale);
}

References KisPainter::backgroundColor, KisPainter::bitBlt(), KisPaintDevice::clear(), KisColorOptionData::colorPerParticle, KisPaintDevice::colorSpace(), computeSpacing(), KoColorSpace::createColorTransformation(), KoColor::data(), dbgKrita, KisGridOpOptionData::diameter, KisPainter::drawDDALine(), KisPainter::drawLine(), KisPainter::drawThickLine(), KisPaintDevice::extent(), KisPaintDevice::fill(), KisColorOptionData::fillBackground, KisRandomSource::generateNormalized(), KisGridOpOptionData::grid_division_level, KisGridOpOptionData::grid_height, KisGridOpOptionData::grid_horizontal_border, KisGridOpOptionData::grid_pressure_division, KisGridOpOptionData::grid_random_border, KisGridOpOptionData::grid_scale, KisGridOpOptionData::grid_vertical_border, KisGridOpOptionData::grid_width, KisGridOpOptionData::horizontal_offset, KisColorOptionData::hue, KisLodTransformBase::lodToScale(), m_colorProperties, m_dab, m_node, m_painter, m_properties, m_shapeProperties, KisColorOptionData::mixBgColor, KoMixColorsOp::mixColors(), KoColorSpace::mixColorsOp, KisPainter::paintColor, KisBaseNode::paintDevice(), KisPainter::paintEllipse(), KisPaintOp::painter, KisPaintInformation::pos(), KisPaintInformation::pressure(), KisPaintInformation::randomSource(), KisPainter::renderMirrorMask(), KisColorOptionData::sampleInputColor, KisColorOptionData::saturation, KoColor::setOpacity(), KisPainter::setOpacityF(), KisPainter::setPaintColor(), KoColorTransformation::setParameter(), KisGridShapeOptionData::shape, KisPaintOp::source(), KoColorTransformation::transform(), KisColorOptionData::useRandomHSV, KisColorOptionData::useRandomOpacity, KisColorOptionData::value, and KisGridOpOptionData::vertical_offset.

updateSpacingImpl()

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

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 238 of file kis_grid_paintop.cpp.

{
    Q_UNUSED(info);
    return computeSpacing(KisLodTransform::lodToScale(painter()->device()));
}

References computeSpacing(), KisLodTransformBase::lodToScale(), and KisPaintOp::painter.

Member Data Documentation

m_colorProperties

KisColorOptionData KisGridPaintOp::m_colorProperties

private

Definition at line 48 of file kis_grid_paintop.h.

m_dab

KisPaintDeviceSP KisGridPaintOp::m_dab

private

Definition at line 42 of file kis_grid_paintop.h.

m_node

KisNodeSP KisGridPaintOp::m_node

private

Definition at line 50 of file kis_grid_paintop.h.

m_painter

KisPainter* KisGridPaintOp::m_painter

private

Definition at line 43 of file kis_grid_paintop.h.

m_properties

KisGridOpOptionData KisGridPaintOp::m_properties

private

Definition at line 47 of file kis_grid_paintop.h.

m_settings

KisGridPaintOpSettingsSP KisGridPaintOp::m_settings

private

Definition at line 41 of file kis_grid_paintop.h.

m_shapeProperties

KisGridShapeOptionData KisGridPaintOp::m_shapeProperties

private

Definition at line 49 of file kis_grid_paintop.h.

m_spacing

qreal KisGridPaintOp::m_spacing

private

Definition at line 46 of file kis_grid_paintop.h.

m_xSpacing

qreal KisGridPaintOp::m_xSpacing

private

Definition at line 44 of file kis_grid_paintop.h.

m_ySpacing

qreal KisGridPaintOp::m_ySpacing

private

Definition at line 45 of file kis_grid_paintop.h.

---

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

• plugins/paintops/gridbrush/kis_grid_paintop.h
• plugins/paintops/gridbrush/kis_grid_paintop.cpp