SprayBrush Class Reference

#include <spray_brush.h>

Public Member Functions
void	paint (KisPaintDeviceSP dab, KisPaintDeviceSP source, const KisPaintInformation &info, qreal rotation, qreal scale, qreal additionalScale, const KoColor &color, const KoColor &bgColor)
void	setFixedDab (KisFixedPaintDeviceSP dab)
void	setProperties (KisSprayOpOptionData *properties, KisColorOptionData *colorProperties, KisSprayShapeOptionData *shapeProperties, KisSprayShapeDynamicsOptionData *shapeDynamicsProperties, KisBrushSP brush)
	SprayBrush ()
	~SprayBrush ()

Private Member Functions
qreal	deg2rad (quint16 deg) const
	convert degrees to radians
qreal	linearInterpolation (qreal a, qreal b, qreal weight) const
	mix a with b.b mix with weight and a with 1.0 - weight
void	paintCircle (KisPainter *painter, qreal x, qreal y, qreal radius)
void	paintEllipse (KisPainter *painter, qreal x, qreal y, qreal a, qreal b, qreal angle)
template<typename AngularDistribution >
void	paintImpl (KisPaintDeviceSP dab, KisPaintDeviceSP source, const KisPaintInformation &info, qreal rotation, qreal scale, qreal additionalScale, const KoColor &color, const KoColor &bgColor, const AngularDistribution &angularDistribution)
template<typename AngularDistribution , typename RadialDistribution >
void	paintImpl (KisPaintDeviceSP dab, KisPaintDeviceSP source, const KisPaintInformation &info, qreal rotation, qreal scale, qreal additionalScale, const KoColor &color, const KoColor &bgColor, const AngularDistribution &angularDistribution, const RadialDistribution &radialDistribution)
void	paintOutline (KisPaintDeviceSP dev, const KoColor &painterColor, qreal posX, qreal posY, qreal radius)
void	paintParticle (KisRandomAccessorSP &writeAccessor, const KoColor &color, qreal rx, qreal ry)
	Paints Wu Particle.
void	paintRectangle (KisPainter *painter, qreal x, qreal y, qreal width, qreal height, qreal angle)
qreal	rad2deg (qreal rad) const
	convert radians to degrees
qreal	rotationAngle (KisRandomSourceSP randomSource)
	rotation in radians according the settings (gauss distribution, uniform distribution or fixed angle)

Private Attributes
KisBrushSP	m_brush
QImage	m_brushQImage
const KisColorOptionData *	m_colorProperties {nullptr}
quint8	m_dabPixelSize {1}
int	m_dabSeqNo {0}
KisFixedPaintDeviceSP	m_fixedDab
KisPaintDeviceSP	m_imageDevice
KoColor	m_inkColor
KisPainter *	m_painter {nullptr}
quint32	m_particlesCount {1}
qreal	m_radius {1.0}
const KisSprayShapeDynamicsOptionData *	m_shapeDynamicsProperties {nullptr}
const KisSprayShapeOptionData *	m_shapeProperties {nullptr}
KisSprayOpOption *	m_sprayOpOption {nullptr}
const KisSprayOpOptionData *	m_sprayOpOptionData {nullptr}
KoColorTransformation *	m_transfo {nullptr}
QImage	m_transformed

Detailed Description

Definition at line 31 of file spray_brush.h.

Constructor & Destructor Documentation

SprayBrush()

SprayBrush::SprayBrush

(

)

Definition at line 39 of file spray_brush.cpp.

{
    m_painter = nullptr;
    m_transfo = nullptr;
}

References m_painter, and m_transfo.

~SprayBrush()

SprayBrush::~SprayBrush

(

)

Definition at line 45 of file spray_brush.cpp.

{
    delete m_painter;
    delete m_transfo;
}

References m_painter, and m_transfo.

Member Function Documentation

deg2rad()

qreal SprayBrush::deg2rad ( quint16 deg ) const

inlineprivate

convert degrees to radians

Definition at line 121 of file spray_brush.h.

                                            {
        return deg * (M_PI / 180.0);
    }

References M_PI.

linearInterpolation()

qreal SprayBrush::linearInterpolation ( qreal a, qreal b, qreal weight ) const

inlineprivate

mix a with b.b mix with weight and a with 1.0 - weight

Definition at line 110 of file spray_brush.h.

                                                                           {
        return (1.0 - weight) * a + weight * b;
    }

paint()

void SprayBrush::paint	(	KisPaintDeviceSP	dab,
		KisPaintDeviceSP	source,
		const KisPaintInformation &	info,
		qreal	rotation,
		qreal	scale,
		qreal	additionalScale,
		const KoColor &	color,
		const KoColor &	bgColor )

Definition at line 92 of file spray_brush.cpp.

{
    if (m_sprayOpOption->data.angularDistributionType == KisSprayOpOptionData::ParticleDistribution_Uniform) {
        paintImpl(dab, source, info, rotation, scale, additionalScale, color, bgColor, m_sprayOpOption->m_uniformDistribution);
    } else {
        paintImpl(dab, source, info, rotation, scale, additionalScale, color, bgColor, m_sprayOpOption->m_angularCurveBasedDistribution);
    }
}

References KisSprayOpOptionData::angularDistributionType, KisSprayOpOption::data, KisSprayOpOption::m_angularCurveBasedDistribution, m_sprayOpOption, KisSprayOpOption::m_uniformDistribution, paintImpl(), KisSprayOpOptionData::ParticleDistribution_Uniform, and source().

paintCircle()

void SprayBrush::paintCircle ( KisPainter * painter, qreal x, qreal y, qreal radius )

private

Definition at line 456 of file spray_brush.cpp.

{
    QPainterPath path;
    path.addEllipse(QPointF(x,y),radius,radius);
    painter->fillPainterPath(path);
}

References KisPainter::fillPainterPath().

paintEllipse()

void SprayBrush::paintEllipse ( KisPainter * painter, qreal x, qreal y, qreal a, qreal b, qreal angle )

private

Definition at line 464 of file spray_brush.cpp.

{
    QPainterPath path;
    path.addEllipse(QPointF(), a, b);
    QTransform t;
    t.translate(x, y);
    t.rotateRadians(angle);
    path = t.map(path);
    painter->fillPainterPath(path);
}

References KisPainter::fillPainterPath().

paintImpl() [1/2]

template<typename AngularDistribution >

void SprayBrush::paintImpl ( KisPaintDeviceSP dab, KisPaintDeviceSP source, const KisPaintInformation & info, qreal rotation, qreal scale, qreal additionalScale, const KoColor & color, const KoColor & bgColor, const AngularDistribution & angularDistribution )

private

Definition at line 106 of file spray_brush.cpp.

{
    if (m_sprayOpOption->data.radialDistributionType == KisSprayOpOptionData::ParticleDistribution_Uniform) {
        if (m_sprayOpOption->data.radialDistributionCenterBiased) {
            paintImpl(dab, source, info, rotation, scale, additionalScale, color, bgColor,
                      angularDistribution, m_sprayOpOption->m_uniformDistribution);
        } else {
            paintImpl(dab, source, info, rotation, scale, additionalScale, color, bgColor,
                      angularDistribution, m_sprayOpOption->m_uniformDistributionPolarDistance);
        }
    } else if (m_sprayOpOption->data.radialDistributionType == KisSprayOpOptionData::ParticleDistribution_Gaussian) {
        if (m_sprayOpOption->data.radialDistributionCenterBiased) {
            paintImpl(dab, source, info, rotation, scale, additionalScale, color, bgColor,
                      angularDistribution, m_sprayOpOption->m_normalDistribution);
        } else {
            paintImpl(dab, source, info, rotation, scale, additionalScale, color, bgColor,
                      angularDistribution, m_sprayOpOption->m_normalDistributionPolarDistance);
        }
    } else if (m_sprayOpOption->data.radialDistributionType == KisSprayOpOptionData::ParticleDistribution_ClusterBased) {
        paintImpl(dab, source, info, rotation, scale, additionalScale, color, bgColor,
                  angularDistribution, m_sprayOpOption->m_clusterBasedDistributionPolarDistance);
    } else {
        paintImpl(dab, source, info, rotation, scale, additionalScale, color, bgColor,
                  angularDistribution, m_sprayOpOption->m_radialCurveBasedDistributionPolarDistance);
    }
}

References KisSprayOpOption::data, KisSprayOpOption::m_clusterBasedDistributionPolarDistance, KisSprayOpOption::m_normalDistribution, KisSprayOpOption::m_normalDistributionPolarDistance, KisSprayOpOption::m_radialCurveBasedDistributionPolarDistance, m_sprayOpOption, KisSprayOpOption::m_uniformDistribution, KisSprayOpOption::m_uniformDistributionPolarDistance, paintImpl(), KisSprayOpOptionData::ParticleDistribution_ClusterBased, KisSprayOpOptionData::ParticleDistribution_Gaussian, KisSprayOpOptionData::ParticleDistribution_Uniform, KisSprayOpOptionData::radialDistributionCenterBiased, KisSprayOpOptionData::radialDistributionType, and source().

paintImpl() [2/2]

template<typename AngularDistribution , typename RadialDistribution >

void SprayBrush::paintImpl ( KisPaintDeviceSP dab, KisPaintDeviceSP source, const KisPaintInformation & info, qreal rotation, qreal scale, qreal additionalScale, const KoColor & color, const KoColor & bgColor, const AngularDistribution & angularDistribution, const RadialDistribution & radialDistribution )

private

Definition at line 140 of file spray_brush.cpp.

{
    if (!angularDistribution.isValid() || !radialDistribution.isValid()) {
        return;
    }
 
    KisRandomSourceSP randomSource = info.randomSource();
 
    const QSize effectiveSize = m_shapeProperties->effectiveSize(m_sprayOpOptionData->diameter, m_sprayOpOptionData->scale);
 
    // initializing painter
    if (!m_painter) {
        m_painter = new KisPainter(dab);
        m_painter->setFillStyle(KisPainter::FillStyleForegroundColor);
        m_painter->setMaskImageSize(effectiveSize.width(), effectiveSize.height());
        m_dabPixelSize = dab->colorSpace()->pixelSize();
        if (m_colorProperties->useRandomHSV) {
            m_transfo = dab->colorSpace()->createColorTransformation("hsv_adjustment", QHash<QString, QVariant>());
        }
 
        m_brushQImage = m_shapeProperties->image;
        if (!m_brushQImage.isNull()) {
            m_brushQImage = m_brushQImage.scaled(effectiveSize);
        }
        m_imageDevice = new KisPaintDevice(dab->colorSpace());
    }
 
 
    qreal x = info.pos().x();
    qreal y = info.pos().y();
    KisRandomAccessorSP accessor = dab->createRandomAccessorNG();
 
    Q_ASSERT(color.colorSpace()->pixelSize() == dab->pixelSize());
    m_inkColor = color;
    KisCrossDeviceColorSampler colorSampler(source, m_inkColor);
 
    // apply size sensor
    m_radius = m_sprayOpOption->data.diameter/2 * scale * additionalScale;
 
    // jitter movement
    if (m_sprayOpOption->data.jitterMovement) {
        x = x + ((2 * m_radius * randomSource->generateNormalized()) - m_radius) * m_sprayOpOption->data.jitterAmount;
        y = y + ((2 * m_radius * randomSource->generateNormalized()) - m_radius) * m_sprayOpOption->data.jitterAmount;
    }
 
    // this is wrong for every shape except pixel and anti-aliased pixel
 
 
    if (m_sprayOpOption->data.useDensity) {
        m_particlesCount = (m_sprayOpOption->data.coverage * (M_PI * pow2(m_radius)) / pow2(additionalScale));
    }
    else {
        m_particlesCount = m_sprayOpOption->data.particleCount;
    }
 
    QHash<QString, QVariant> params;
    qreal nx, ny;
    int ix, iy;
 
    qreal angle;
    qreal length;
    qreal rotationZ = 0.0;
    qreal particleScale = 1.0;
 
    bool shouldColor = true;
    if (m_colorProperties->fillBackground) {
        m_painter->setPaintColor(bgColor);
        paintCircle(m_painter, x, y, m_radius);
    }
 
    QTransform m;
    m.reset();
    m.rotateRadians(-rotation + deg2rad(m_sprayOpOption->data.brushRotation));
    m.scale(m_sprayOpOption->data.scale, m_sprayOpOption->data.scale);
 
    for (quint32 i = 0; i < m_particlesCount; i++) {
        // generate random angle
        angle = angularDistribution(randomSource) * M_PI * 2;
        // generate random length
        length = radialDistribution(randomSource);
 
        if (m_shapeDynamicsProperties->enabled) {
            // rotation
            rotationZ = rotationAngle(randomSource);
 
            if (m_shapeDynamicsProperties->followCursor) {
 
                rotationZ = linearInterpolation(rotationZ, angle, m_shapeDynamicsProperties->followCursorWeight);
            }
 
 
            if (m_shapeDynamicsProperties->followDrawingAngle) {
 
                rotationZ = linearInterpolation(rotationZ, info.drawingAngle(), m_shapeDynamicsProperties->followDrawingAngleWeight);
            }
 
            // random size - scale
            if (m_shapeDynamicsProperties->randomSize) {
                particleScale = randomSource->generateNormalized();
            }
        }
        // generate polar coordinate
        nx = (m_radius * cos(angle)  * length);
        ny = (m_radius * sin(angle)  * length);
 
        // compute the height of the ellipse
        ny *= m_sprayOpOption->data.aspect;
 
        // transform
        m.map(nx, ny, &nx, &ny);
 
        // color transformation
 
        if (shouldColor) {
            if (m_colorProperties->sampleInputColor) {
                colorSampler.sampleOldColor(nx + x, ny + y, m_inkColor.data());
            }
 
            // mix the color with background color
            if (m_colorProperties->mixBgColor) {
                KoMixColorsOp * mixOp = dab->colorSpace()->mixColorsOp();
 
                const quint8 *colors[2];
                colors[0] = m_inkColor.data();
                colors[1] = bgColor.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, m_inkColor.data());
            }
 
            if (m_colorProperties->useRandomHSV && m_transfo) {
                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();
                m_transfo->setParameters(params);
                m_transfo->setParameter(3, 1);//sets the type to HSV. For some reason 0 is not an option.
                m_transfo->setParameter(4, false);//sets the colorize to false.
                m_transfo->transform(m_inkColor.data(), m_inkColor.data() , 1);
            }
 
            if (m_colorProperties->useRandomOpacity) {
                const qreal alpha = randomSource->generateNormalized();
                m_inkColor.setOpacity(alpha);
                m_painter->setOpacityF(alpha);
            }
 
            if (!m_colorProperties->colorPerParticle) {
                shouldColor = false;
            }
 
            m_painter->setPaintColor(m_inkColor);
        }
 
        qreal jitteredWidth = qMax(1.0 * additionalScale, effectiveSize.width() * particleScale * additionalScale);
        qreal jitteredHeight = qMax(1.0 * additionalScale, effectiveSize.height() * particleScale * additionalScale);
 
        if (m_shapeProperties->enabled){
        switch (m_shapeProperties->shape){
            // ellipse
            case 0:
            {
                if (effectiveSize.width() == effectiveSize.height()){
                    paintCircle(m_painter, nx + x, ny + y, jitteredWidth * 0.5);
                }
                else {
                    paintEllipse(m_painter, nx + x, ny + y, jitteredWidth * 0.5 , jitteredHeight * 0.5, rotationZ);
                }
                break;
            }
            // rectangle
            case 1:
            {
                paintRectangle(m_painter, nx + x, ny + y, qRound(jitteredWidth) , qRound(jitteredHeight), rotationZ);
                break;
            }
            // wu-particle
            case 2: {
                paintParticle(accessor, m_inkColor, nx + x, ny + y);
                break;
            }
            // pixel
            case 3: {
                ix = qRound(nx + x);
                iy = qRound(ny + y);
                accessor->moveTo(ix, iy);
                memcpy(accessor->rawData(), m_inkColor.data(), m_dabPixelSize);
                break;
            }
            case 4: {
                if (!m_brushQImage.isNull()) {
 
                    QTransform m;
                    m.rotate(rad2deg(rotationZ));
                    m.scale(additionalScale, additionalScale);
 
                    if (m_shapeDynamicsProperties->randomSize) {
                        m.scale(particleScale, particleScale);
                    }
                    m_transformed = m_brushQImage.transformed(m, Qt::SmoothTransformation);
                    m_imageDevice->convertFromQImage(m_transformed, 0);
                    KisRandomAccessorSP ac = m_imageDevice->createRandomAccessorNG();
                    QRect rc = m_transformed.rect();
 
                    if (m_colorProperties->useRandomHSV && m_transfo) {
 
                        for (int y = rc.y(); y < rc.y() + rc.height(); y++) {
                            for (int x = rc.x(); x < rc.x() + rc.width(); x++) {
                                ac->moveTo(x, y);
                                m_transfo->transform(ac->rawData(), ac->rawData() , 1);
                            }
                        }
                    }
 
                    ix = qRound(nx + x - rc.width() * 0.5);
                    iy = qRound(ny + y - rc.height() * 0.5);
                    m_painter->bitBlt(QPoint(ix, iy), m_imageDevice, rc);
                    m_imageDevice->clear();
                    break;
                }
            }
            }
            // Auto-brush
        }
        else {
            KisDabShape shape(particleScale * additionalScale, 1.0, -rotationZ);
            QPointF hotSpot = m_brush->hotSpot(shape, info);
            QPointF pos(nx + x, ny + y);
            QPointF pt = pos - hotSpot;
 
            qint32 ix;
            qreal xFraction;
            qint32 iy;
            qreal yFraction;
 
            KisPaintOp::splitCoordinate(pt.x(), &ix, &xFraction);
            KisPaintOp::splitCoordinate(pt.y(), &iy, &yFraction);
 
            m_brush->prepareForSeqNo(info, m_dabSeqNo);
 
            //KisFixedPaintDeviceSP dab;
            if (m_brush->brushApplication() == IMAGESTAMP) {
                m_fixedDab = m_brush->paintDevice(m_fixedDab->colorSpace(),
                          shape, info, xFraction, yFraction);
 
                if (m_colorProperties->useRandomHSV && m_transfo) {
                    quint8 * dabPointer = m_fixedDab->data();
                    int pixelCount = m_fixedDab->bounds().width() * m_fixedDab->bounds().height();
                    m_transfo->transform(dabPointer, dabPointer, pixelCount);
                }
 
            }
            else {
                m_brush->mask(m_fixedDab, m_inkColor, shape,
                              info, xFraction, yFraction);
            }
            m_painter->bltFixed(QPoint(ix, iy), m_fixedDab, m_fixedDab->bounds());
        }
        if (m_colorProperties->colorPerParticle){
            m_inkColor=color;//reset color//
        }
    }
    // recover from jittering of color,
    // m_inkColor.opacity is recovered with every paint
}

References KisSprayOpOptionData::aspect, KisPainter::bitBlt(), KisPainter::bltFixed(), KisFixedPaintDevice::bounds(), KisSprayOpOptionData::brushRotation, KisPaintDevice::clear(), KisColorOptionData::colorPerParticle, KisFixedPaintDevice::colorSpace(), KisPaintDevice::colorSpace(), KoColor::colorSpace(), KisPaintDevice::convertFromQImage(), KisSprayOpOptionData::coverage, KoColorSpace::createColorTransformation(), KisPaintDevice::createRandomAccessorNG(), KisFixedPaintDevice::data(), KoColor::data(), KisSprayOpOption::data, deg2rad(), KisSprayOpOptionData::diameter, KisPaintInformation::drawingAngle(), KisSprayShapeOptionData::effectiveSize(), KisSprayShapeDynamicsOptionData::enabled, KisSprayShapeOptionData::enabled, KisColorOptionData::fillBackground, KisPainter::FillStyleForegroundColor, KisSprayShapeDynamicsOptionData::followCursor, KisSprayShapeDynamicsOptionData::followCursorWeight, KisSprayShapeDynamicsOptionData::followDrawingAngle, KisSprayShapeDynamicsOptionData::followDrawingAngleWeight, KisRandomSource::generateNormalized(), KisColorOptionData::hue, KisSprayShapeOptionData::image, IMAGESTAMP, KisSprayOpOptionData::jitterAmount, KisSprayOpOptionData::jitterMovement, length(), linearInterpolation(), m_brush, m_brushQImage, m_colorProperties, m_dabPixelSize, m_dabSeqNo, m_fixedDab, m_imageDevice, m_inkColor, m_painter, m_particlesCount, M_PI, m_radius, m_shapeDynamicsProperties, m_shapeProperties, m_sprayOpOption, m_sprayOpOptionData, m_transfo, m_transformed, KisColorOptionData::mixBgColor, KoMixColorsOp::mixColors(), KoColorSpace::mixColorsOp, KisRandomConstAccessorNG::moveTo(), paintCircle(), paintEllipse(), paintParticle(), paintRectangle(), KisSprayOpOptionData::particleCount, KisPaintDevice::pixelSize(), KoColorSpace::pixelSize(), KisPaintInformation::pos(), pow2(), KisPaintInformation::pressure(), rad2deg, KisSprayShapeDynamicsOptionData::randomSize, KisPaintInformation::randomSource(), KisBaseAccessor::rawData(), rotationAngle(), KisColorOptionData::sampleInputColor, KisCrossDeviceColorSamplerImpl< Traits >::sampleOldColor(), KisColorOptionData::saturation, KisSprayOpOptionData::scale, KisPainter::setFillStyle(), KisPainter::setMaskImageSize(), KoColor::setOpacity(), KisPainter::setOpacityF(), KisPainter::setPaintColor(), KoColorTransformation::setParameter(), KoColorTransformation::setParameters(), KisSprayShapeOptionData::shape, source(), KisPaintOp::splitCoordinate(), KoColorTransformation::transform(), KisSprayOpOptionData::useDensity, KisColorOptionData::useRandomHSV, KisColorOptionData::useRandomOpacity, and KisColorOptionData::value.

paintOutline()

void SprayBrush::paintOutline ( KisPaintDeviceSP dev, const KoColor & painterColor, qreal posX, qreal posY, qreal radius )

private

Definition at line 487 of file spray_brush.cpp.

{
    QList<QPointF> antiPixels;
    KisRandomAccessorSP accessor = dev->createRandomAccessorNG();
 
    for (int y = -radius + posY; y <= radius + posY; y++) {
        for (int x = -radius + posX; x <= radius + posX; x++) {
            accessor->moveTo(x, y);
            qreal alpha = dev->colorSpace()->opacityU8(accessor->rawData());
 
            if (alpha != 0) {
                // top left
                accessor->moveTo(x - 1, y - 1);
                if (dev->colorSpace()->opacityU8(accessor->rawData()) == 0) {
                    antiPixels.append(QPointF(x - 1, y - 1));
                    //continue;
                }
 
                // top
                accessor->moveTo(x, y - 1);
                if (dev->colorSpace()->opacityU8(accessor->rawData()) == 0) {
                    antiPixels.append(QPointF(x, y - 1));
                    //continue;
                }
 
                // top right
                accessor->moveTo(x + 1, y - 1);
                if (dev->colorSpace()->opacityU8(accessor->rawData()) == 0) {
                    antiPixels.append(QPointF(x + 1, y - 1));
                    //continue;
                }
 
                //left
                accessor->moveTo(x - 1, y);
                if (dev->colorSpace()->opacityU8(accessor->rawData()) == 0) {
                    antiPixels.append(QPointF(x - 1, y));
                    //continue;
                }
 
                //right
                accessor->moveTo(x + 1, y);
                if (dev->colorSpace()->opacityU8(accessor->rawData()) == 0) {
                    antiPixels.append(QPointF(x + 1, y));
                    //continue;
                }
 
                // bottom left
                accessor->moveTo(x - 1, y + 1);
                if (dev->colorSpace()->opacityU8(accessor->rawData()) == 0) {
                    antiPixels.append(QPointF(x - 1, y + 1));
                    //continue;
                }
 
                // bottom
                accessor->moveTo(x, y + 1);
                if (dev->colorSpace()->opacityU8(accessor->rawData()) == 0) {
                    antiPixels.append(QPointF(x, y + 1));
                    //continue;
                }
 
                // bottom right
                accessor->moveTo(x + 1, y + 1);
                if (dev->colorSpace()->opacityU8(accessor->rawData()) == 0) {
                    antiPixels.append(QPointF(x + 1, y + 1));
                    //continue;
                }
            }
 
        }
    }
 
    // anti-alias it
    int size = antiPixels.size();
    for (int i = 0; i < size; i++) {
        accessor->moveTo(antiPixels[i].x(), antiPixels[i].y());
        memcpy(accessor->rawData(), outlineColor.data(), dev->colorSpace()->pixelSize());
    }
}

References KisPaintDevice::colorSpace(), KisPaintDevice::createRandomAccessorNG(), KoColor::data(), KisRandomConstAccessorNG::moveTo(), KoColorSpace::opacityU8(), KoColorSpace::pixelSize(), and KisBaseAccessor::rawData().

paintParticle()

void SprayBrush::paintParticle ( KisRandomAccessorSP & writeAccessor, const KoColor & color, qreal rx, qreal ry )

private

Paints Wu Particle.

Definition at line 419 of file spray_brush.cpp.

{
    // opacity top left, right, bottom left, right
    KoColor pcolor(color);
    //int opacity = pcolor.opacityU8();
 
    int ipx = int (rx);
    int ipy = int (ry);
    qreal fx = rx - ipx;
    qreal fy = ry - ipy;
 
    qreal btl = (1 - fx) * (1 - fy);
    qreal btr = (fx)  * (1 - fy);
    qreal bbl = (1 - fx) * (fy);
    qreal bbr = (fx)  * (fy);
 
    // this version overwrite pixels, e.g. when it sprays two particle next
    // to each other, the pixel with lower opacity can override other pixel.
    // Maybe some kind of compositing using here would be cool
 
    pcolor.setOpacity(btl);
    writeAccessor->moveTo(ipx  , ipy);
    memcpy(writeAccessor->rawData(), pcolor.data(), m_dabPixelSize);
 
    pcolor.setOpacity(btr);
    writeAccessor->moveTo(ipx + 1, ipy);
    memcpy(writeAccessor->rawData(), pcolor.data(), m_dabPixelSize);
 
    pcolor.setOpacity(bbl);
    writeAccessor->moveTo(ipx, ipy + 1);
    memcpy(writeAccessor->rawData(), pcolor.data(), m_dabPixelSize);
 
    pcolor.setOpacity(bbr);
    writeAccessor->moveTo(ipx + 1, ipy + 1);
    memcpy(writeAccessor->rawData(), pcolor.data(), m_dabPixelSize);
}

References KoColor::data(), m_dabPixelSize, KisRandomConstAccessorNG::moveTo(), KisBaseAccessor::rawData(), and KoColor::setOpacity().

paintRectangle()

void SprayBrush::paintRectangle ( KisPainter * painter, qreal x, qreal y, qreal width, qreal height, qreal angle )

private

Definition at line 475 of file spray_brush.cpp.

{
    QPainterPath path;
    path.addRect(QRectF(-0.5 * width, -0.5 * height, width, height));
    QTransform t;
    t.translate(x, y);
    t.rotateRadians(angle);
    path = t.map(path);
    painter->fillPainterPath(path);
}

References KisPainter::fillPainterPath().

rad2deg()

qreal SprayBrush::rad2deg ( qreal rad ) const

inlineprivate

convert radians to degrees

Definition at line 116 of file spray_brush.h.

                                          {
        return rad * (180.0 / M_PI);
    }

References M_PI.

rotationAngle()

qreal SprayBrush::rotationAngle ( KisRandomSourceSP randomSource )

private

rotation in radians according the settings (gauss distribution, uniform distribution or fixed angle)

Definition at line 69 of file spray_brush.cpp.

{
    qreal rotation = 0.0;
 
    if (m_shapeDynamicsProperties->fixedRotation) {
        rotation = deg2rad(m_shapeDynamicsProperties->fixedAngle);
    }
 
    if (m_shapeDynamicsProperties->randomRotation) {
 
        qreal randomValue = 0.0;
 
        randomValue = randomSource->generateNormalized();
 
        rotation =
            linearInterpolation(rotation ,
                                M_PI * 2.0 * randomValue,
                                m_shapeDynamicsProperties->randomRotationWeight);
    }
 
    return rotation;
}

References deg2rad(), KisSprayShapeDynamicsOptionData::fixedAngle, KisSprayShapeDynamicsOptionData::fixedRotation, KisRandomSource::generateNormalized(), linearInterpolation(), M_PI, m_shapeDynamicsProperties, KisSprayShapeDynamicsOptionData::randomRotation, and KisSprayShapeDynamicsOptionData::randomRotationWeight.

setFixedDab()

void SprayBrush::setFixedDab

(

KisFixedPaintDeviceSP

dab

)

Definition at line 566 of file spray_brush.cpp.

{
    m_fixedDab = dab;
}

References m_fixedDab.

setProperties()

void SprayBrush::setProperties	(	KisSprayOpOptionData *	properties,
		KisColorOptionData *	colorProperties,
		KisSprayShapeOptionData *	shapeProperties,
		KisSprayShapeDynamicsOptionData *	shapeDynamicsProperties,
		KisBrushSP	brush )

Definition at line 51 of file spray_brush.cpp.

{
    m_sprayOpOptionData = properties;
    m_sprayOpOption = new KisSprayOpOption(*properties);
    m_sprayOpOption->updateDistributions();
    m_colorProperties = colorProperties;
    m_shapeProperties = shapeProperties;
    m_shapeDynamicsProperties = shapeDynamicsProperties;
    m_brush = brush;
    if (m_brush) {
        m_brush->notifyStrokeStarted();
    }
}

References m_brush, m_colorProperties, m_shapeDynamicsProperties, m_shapeProperties, m_sprayOpOption, m_sprayOpOptionData, and KisSprayOpOption::updateDistributions().

Member Data Documentation

m_brush

KisBrushSP SprayBrush::m_brush

private

Definition at line 74 of file spray_brush.h.

m_brushQImage

QImage SprayBrush::m_brushQImage

private

Definition at line 63 of file spray_brush.h.

m_colorProperties

const KisColorOptionData* SprayBrush::m_colorProperties {nullptr}

private

Definition at line 70 of file spray_brush.h.

{nullptr};

m_dabPixelSize

quint8 SprayBrush::m_dabPixelSize {1}

private

Definition at line 59 of file spray_brush.h.

{1};

m_dabSeqNo

int SprayBrush::m_dabSeqNo {0}

private

Definition at line 55 of file spray_brush.h.

{0};

m_fixedDab

KisFixedPaintDeviceSP SprayBrush::m_fixedDab

private

Definition at line 75 of file spray_brush.h.

m_imageDevice

KisPaintDeviceSP SprayBrush::m_imageDevice

private

Definition at line 62 of file spray_brush.h.

m_inkColor

KoColor SprayBrush::m_inkColor

private

Definition at line 56 of file spray_brush.h.

m_painter

KisPainter* SprayBrush::m_painter {nullptr}

private

Definition at line 61 of file spray_brush.h.

{nullptr};

m_particlesCount

quint32 SprayBrush::m_particlesCount {1}

private

Definition at line 58 of file spray_brush.h.

{1};

m_radius

qreal SprayBrush::m_radius {1.0}

private

Definition at line 57 of file spray_brush.h.

{1.0};

m_shapeDynamicsProperties

const KisSprayShapeDynamicsOptionData* SprayBrush::m_shapeDynamicsProperties {nullptr}

private

Definition at line 72 of file spray_brush.h.

{nullptr};

m_shapeProperties

const KisSprayShapeOptionData* SprayBrush::m_shapeProperties {nullptr}

private

Definition at line 71 of file spray_brush.h.

{nullptr};

m_sprayOpOption

KisSprayOpOption* SprayBrush::m_sprayOpOption {nullptr}

private

Definition at line 69 of file spray_brush.h.

{nullptr};

m_sprayOpOptionData

const KisSprayOpOptionData* SprayBrush::m_sprayOpOptionData {nullptr}

private

Definition at line 68 of file spray_brush.h.

{nullptr};

m_transfo

KoColorTransformation* SprayBrush::m_transfo {nullptr}

private

Definition at line 66 of file spray_brush.h.

{nullptr};

m_transformed

QImage SprayBrush::m_transformed

private

Definition at line 64 of file spray_brush.h.

---

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

• plugins/paintops/spray/spray_brush.h
• plugins/paintops/spray/spray_brush.cpp