KisHatchingPaintOp Class Reference

#include <kis_hatching_paintop.h>

Inheritance diagram for KisHatchingPaintOp:

Public Member Functions
	KisHatchingPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
double	spinAngle (double spin)
	~KisHatchingPaintOp () override
Public Member Functions inherited from KisBrushBasedPaintOp
bool	canPaint () const override
	Reimplemented, false if brush is 0.
bool	checkSizeTooSmall (qreal scale)
KisSpacingInformation	effectiveSpacing (qreal scale) const
KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisAirbrushOptionData *airbrushOption, const KisSpacingOption *spacingOption, const KisPaintInformation &pi) const
KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisPaintInformation &pi) const
KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisSpacingOption &spacingOption, const KisPaintInformation &pi) const
	KisBrushBasedPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisBrushTextureFlags textureFlags=None)
	~KisBrushBasedPaintOp () override
Public Member Functions inherited from KisPaintOp
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 Attributes
KisAngleOption	m_angleOption
KisCrosshatchingOption	m_crosshatchingOption
KisPaintDeviceSP	m_hatchedDab
HatchingBrush *	m_hatchingBrush
KisHatchingOptionsData	m_hatchingOptions
KisHatchingPreferencesData	m_hatchingPreferences
KisOpacityOption	m_opacityOption
KisSeparationOption	m_separationOption
KisHatchingPaintOpSettingsSP	m_settings
KisSizeOption	m_sizeOption
KisThicknessOption	m_thicknessOption

Additional Inherited Members
Static Public Member Functions inherited from KisBrushBasedPaintOp
static QList< KoResourceLoadResult >	prepareEmbeddedResources (const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface)
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)
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
Protected Attributes inherited from KisBrushBasedPaintOp
KisBrushSP	m_brush
KisDabCache *	m_dabCache
KisMirrorOption	m_mirrorOption
KisPrecisionOption	m_precisionOption

Detailed Description

Definition at line 30 of file kis_hatching_paintop.h.

Constructor & Destructor Documentation

KisHatchingPaintOp()

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

Definition at line 35 of file kis_hatching_paintop.cpp.

    : KisBrushBasedPaintOp(settings, painter)
    , m_angleOption(settings.data())
    , m_crosshatchingOption(settings.data())
    , m_separationOption(settings.data())
    , m_thicknessOption(settings.data())
    , m_opacityOption(settings.data(), node)
    , m_sizeOption(settings.data())
{
    Q_UNUSED(node);
 
    m_settings = static_cast<KisHatchingPaintOpSettings*>(settings->clone().data());
    static_cast<const KisHatchingPaintOpSettings*>(settings.data())->initializeTwin(m_settings);
 
    m_hatchingBrush = new HatchingBrush(m_settings);
    m_hatchingOptions.read(settings.data());
    m_hatchingPreferences.read(settings.data());
 
}

References KisSharedPtr< T >::data(), m_hatchingBrush, m_hatchingOptions, m_hatchingPreferences, m_settings, KisHatchingOptionsData::read(), and KisHatchingPreferencesData::read().

~KisHatchingPaintOp()

KisHatchingPaintOp::~KisHatchingPaintOp ( )

override

Definition at line 55 of file kis_hatching_paintop.cpp.

{
    delete m_hatchingBrush;
}

References m_hatchingBrush.

Member Function Documentation

paintAt()

KisSpacingInformation KisHatchingPaintOp::paintAt ( const KisPaintInformation & info )

overrideprotectedvirtual

Paint a hatched dab around the mouse cursor according to sensor settings and user preferences.

Implements KisPaintOp.

Definition at line 60 of file kis_hatching_paintop.cpp.

{
    //------START SIMPLE ERROR CATCHING-------
    if (!painter()->device()) return KisSpacingInformation(1.0);
 
    if (!m_hatchedDab)
        m_hatchedDab = source()->createCompositionSourceDevice();
    else
        m_hatchedDab->clear();
 
    //Simple convenience renaming, I'm thinking of removing these inherited quirks
    KisBrushSP brush = m_brush;
    KisPaintDeviceSP device = painter()->device();
 
    //Macro to catch errors
    Q_ASSERT(brush);
 
    //----------SIMPLE error catching code, maybe it's not even needed------
    if (!brush) return KisSpacingInformation(1.0);
    if (!brush->canPaintFor(info)) return KisSpacingInformation(1.0);
 
    //SENSOR-depending settings
    m_settings->anglesensorvalue = m_angleOption.apply(info);
    m_settings->crosshatchingsensorvalue = m_crosshatchingOption.apply(info);
    m_settings->separationsensorvalue = m_separationOption.apply(info);
    m_settings->thicknesssensorvalue = m_thicknessOption.apply(info);
 
    const qreal additionalScale = KisLodTransform::lodToScale(painter()->device());
    const double scale = additionalScale * m_sizeOption.apply(info);
    if ((scale * brush->width()) <= 0.01 || (scale * brush->height()) <= 0.01) return KisSpacingInformation(1.0);
    KisDabShape shape(scale, 1.0, 0.0);
 
    m_opacityOption.apply(painter(), info);
 
    /*----Fetch the Dab----*/
    static const KoColorSpace *cs = KoColorSpaceRegistry::instance()->alpha8();
    static KoColor color(Qt::black, cs);
 
    QRect dstRect;
    KisFixedPaintDeviceSP maskDab =
        m_dabCache->fetchDab(cs, color, info.pos(),
                             shape,
                             info, 1.0, &dstRect);
 
    // sanity check
    KIS_ASSERT_RECOVER_NOOP(dstRect.size() == maskDab->bounds().size());
 
    /*-----Convenient renaming for the limits of the maskDab, this will be used
    to hatch a dab of just the right size------*/
    qint32 x, y, sw, sh;
    dstRect.getRect(&x, &y, &sw, &sh);
 
    //------This If_block pre-fills the future m_hatchedDab with a pretty backgroundColor
    if (m_hatchingPreferences.useOpaqueBackground) {
        KoColor aersh = painter()->backgroundColor();
        m_hatchedDab->fill(0, 0, (sw - 1), (sh - 1), aersh.data()); //this plus yellow background = french fry brush
    }
 
    /* If block describing how to stack hatching passes to generate
    crosshatching according to user specifications */
    if (m_crosshatchingOption.isChecked()) {
        if (m_hatchingOptions.crosshatchingStyle == CrosshatchingType::Perpendicular) {
            if (m_settings->crosshatchingsensorvalue > 0.5)
                m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(90), painter()->paintColor(), additionalScale);
        }
        else if (m_hatchingOptions.crosshatchingStyle == CrosshatchingType::MinusThenPlus) {
            if (m_settings->crosshatchingsensorvalue > 0.33)
                m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(-45), painter()->paintColor(), additionalScale);
            if (m_settings->crosshatchingsensorvalue > 0.67)
                m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(45), painter()->paintColor(), additionalScale);
        }
        else if (m_hatchingOptions.crosshatchingStyle == CrosshatchingType::PlusThenMinus) {
            if (m_settings->crosshatchingsensorvalue > 0.33)
                m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(45), painter()->paintColor(), additionalScale);
            if (m_settings->crosshatchingsensorvalue > 0.67)
                m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(-45), painter()->paintColor(), additionalScale);
        }
        else if (m_hatchingOptions.crosshatchingStyle == CrosshatchingType::MoirePattern) {
            m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle((m_settings->crosshatchingsensorvalue) * 360), painter()->paintColor(), additionalScale);
        }
    } else {
        if (m_hatchingOptions.crosshatchingStyle == CrosshatchingType::Perpendicular) {
            m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(90), painter()->paintColor(), additionalScale);
        }
        else if (m_hatchingOptions.crosshatchingStyle == CrosshatchingType::MinusThenPlus) {
            m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(-45), painter()->paintColor(), additionalScale);
            m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(45), painter()->paintColor(), additionalScale);
        }
        else if (m_hatchingOptions.crosshatchingStyle == CrosshatchingType::PlusThenMinus) {
            m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(45), painter()->paintColor(), additionalScale);
            m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(-45), painter()->paintColor(), additionalScale);
        }
        else if (m_hatchingOptions.crosshatchingStyle == CrosshatchingType::MoirePattern) {
            m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle(-10), painter()->paintColor(), additionalScale);
        }
    }
 
    if (m_angleOption.isChecked())
      m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, spinAngle((m_settings->anglesensorvalue)*360+m_hatchingOptions.angle), painter()->paintColor(), additionalScale);
 
    // The base hatch... unless moiré or angle
    if (m_hatchingOptions.crosshatchingStyle != CrosshatchingType::MoirePattern && !m_angleOption.isChecked())
        m_hatchingBrush->hatch(m_hatchedDab, x, y, sw, sh, m_hatchingOptions.angle, painter()->paintColor(), additionalScale);
 
 
    // The most important line, the one that paints to the screen.
    painter()->bitBltWithFixedSelection(x, y, m_hatchedDab, maskDab, sw, sh);
    painter()->renderMirrorMaskSafe(QRect(QPoint(x, y), QSize(sw, sh)), m_hatchedDab, 0, 0, maskDab,
                                    !m_dabCache->needSeparateOriginal());
 
    return effectiveSpacing(scale);
}

References KoColorSpaceRegistry::alpha8(), KisHatchingOptionsData::angle, KisHatchingPaintOpSettings::anglesensorvalue, KisStandardOption< Data >::apply(), KisOpacityOption::apply(), KisPainter::backgroundColor, KisPainter::bitBltWithFixedSelection(), KisFixedPaintDevice::bounds(), KisPaintDevice::clear(), KisPaintDevice::createCompositionSourceDevice(), KisHatchingPaintOpSettings::crosshatchingsensorvalue, KisHatchingOptionsData::crosshatchingStyle, KoColor::data(), KisPainter::device, KisBrushBasedPaintOp::effectiveSpacing(), KisDabCache::fetchDab(), KisPaintDevice::fill(), HatchingBrush::hatch(), KoColorSpaceRegistry::instance(), KisCurveOption::isChecked(), KIS_ASSERT_RECOVER_NOOP, KisLodTransformBase::lodToScale(), m_angleOption, KisBrushBasedPaintOp::m_brush, m_crosshatchingOption, KisBrushBasedPaintOp::m_dabCache, m_hatchedDab, m_hatchingBrush, m_hatchingOptions, m_hatchingPreferences, m_opacityOption, m_separationOption, m_settings, m_sizeOption, m_thicknessOption, MinusThenPlus, MoirePattern, KisDabCache::needSeparateOriginal(), KisPaintOp::painter, Perpendicular, PlusThenMinus, KisPaintInformation::pos(), KisPainter::renderMirrorMaskSafe(), KisHatchingPaintOpSettings::separationsensorvalue, KisPaintOp::source(), spinAngle(), KisHatchingPaintOpSettings::thicknesssensorvalue, and KisHatchingPreferencesData::useOpaqueBackground.

spinAngle()

double KisHatchingPaintOp::spinAngle

(

double

spin

)

Returns a number between -90 and 90, and corresponds to the angle that results from adding angle 'spin' to 'm_hatchingOptions.angle', corrected to coincide with the way the GUI operates.

Definition at line 179 of file kis_hatching_paintop.cpp.

{
    double tempangle = m_hatchingOptions.angle + spin;
    qint8 factor = 1;
 
    if (tempangle < 0)
        factor = -1;
 
    tempangle = fabs(fmod(tempangle, 180));
 
    if ((tempangle >= 0) && (tempangle <= 90))
        return factor * tempangle;
    else if ((tempangle > 90) && (tempangle <= 180))
        return factor * -(180 - tempangle);
 
    return 0;   // this should never be executed except if NAN
}

References KisHatchingOptionsData::angle, and m_hatchingOptions.

updateSpacingImpl()

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

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 173 of file kis_hatching_paintop.cpp.

{
    const qreal scale = KisLodTransform::lodToScale(painter()->device()) * m_sizeOption.apply(info);
    return effectiveSpacing(scale);
}

References KisStandardOption< Data >::apply(), KisBrushBasedPaintOp::effectiveSpacing(), KisLodTransformBase::lodToScale(), m_sizeOption, and KisPaintOp::painter.

Member Data Documentation

m_angleOption

KisAngleOption KisHatchingPaintOp::m_angleOption

private

Curve to control the hatching angle according to user preferences set in the GUI

Definition at line 70 of file kis_hatching_paintop.h.

m_crosshatchingOption

KisCrosshatchingOption KisHatchingPaintOp::m_crosshatchingOption

private

Curve to control the intensity of crosshatching according to user preferences set in the GUI

Definition at line 76 of file kis_hatching_paintop.h.

m_hatchedDab

KisPaintDeviceSP KisHatchingPaintOp::m_hatchedDab

private

PaintDevice that will be filled with a single pass of hatching by HatchingBrush::hatch

Definition at line 64 of file kis_hatching_paintop.h.

m_hatchingBrush

HatchingBrush* KisHatchingPaintOp::m_hatchingBrush

private

Definition at line 58 of file kis_hatching_paintop.h.

m_hatchingOptions

KisHatchingOptionsData KisHatchingPaintOp::m_hatchingOptions

private

Definition at line 56 of file kis_hatching_paintop.h.

m_hatchingPreferences

KisHatchingPreferencesData KisHatchingPaintOp::m_hatchingPreferences

private

Definition at line 57 of file kis_hatching_paintop.h.

m_opacityOption

KisOpacityOption KisHatchingPaintOp::m_opacityOption

private

Curve to control the opacity of the entire dab with device input

Definition at line 94 of file kis_hatching_paintop.h.

m_separationOption

KisSeparationOption KisHatchingPaintOp::m_separationOption

private

Curve to control the dynamics of separation with device input

Definition at line 82 of file kis_hatching_paintop.h.

m_settings

KisHatchingPaintOpSettingsSP KisHatchingPaintOp::m_settings

private

Definition at line 55 of file kis_hatching_paintop.h.

m_sizeOption

KisSizeOption KisHatchingPaintOp::m_sizeOption

private

Curve to control the size of the entire dab with device input

Definition at line 100 of file kis_hatching_paintop.h.

m_thicknessOption

KisThicknessOption KisHatchingPaintOp::m_thicknessOption

private

Curve to control the thickness of the hatching lines with device input

Definition at line 88 of file kis_hatching_paintop.h.

---

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

• plugins/paintops/hatching/kis_hatching_paintop.h
• plugins/paintops/hatching/kis_hatching_paintop.cpp