KisDuplicateOp Class Reference

#include <kis_duplicateop.h>

Inheritance diagram for KisDuplicateOp:

Public Member Functions
	KisDuplicateOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
	~KisDuplicateOp () 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 Member Functions
qreal	minimizeEnergy (const qreal *m, qreal *sol, int w, int h)

Private Attributes
KisDuplicateOptionData	m_duplicateOptionData
QPointF	m_duplicateStart {QPointF(0.0, 0.0)}
bool	m_duplicateStartIsSet {false}
KisImageSP	m_image
KisNodeSP	m_node
KisOpacityOption	m_opacityOption
KisRotationOption	m_rotationOption
KisDuplicateOpSettingsSP	m_settings
KisSizeOption	m_sizeOption
KisPaintDeviceSP	m_srcdev
KisPaintDeviceSP	m_target

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 36 of file kis_duplicateop.h.

Constructor & Destructor Documentation

KisDuplicateOp()

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

Definition at line 50 of file kis_duplicateop.cpp.

    : KisBrushBasedPaintOp(settings, painter)
    , m_image(image)
    , m_node(node)
    , m_settings(static_cast<KisDuplicateOpSettings*>(const_cast<KisPaintOpSettings*>(settings.data())))
    , m_sizeOption(settings.data())
    , m_opacityOption(settings.data(), node)
    , m_rotationOption(settings.data())
{
    Q_ASSERT(settings);
    Q_ASSERT(painter);
 
    m_duplicateOptionData.read(settings.data());
    m_srcdev = source()->createCompositionSourceDevice();
}

References KisPaintDevice::createCompositionSourceDevice(), KisSharedPtr< T >::data(), m_duplicateOptionData, m_srcdev, KisPaintOp::painter, KisDuplicateOptionData::read(), and KisPaintOp::source().

~KisDuplicateOp()

KisDuplicateOp::~KisDuplicateOp ( )

override

Definition at line 66 of file kis_duplicateop.cpp.

{
}

Member Function Documentation

minimizeEnergy()

qreal KisDuplicateOp::minimizeEnergy ( const qreal * m, qreal * sol, int w, int h )

private

paintAt()

KisSpacingInformation KisDuplicateOp::paintAt ( const KisPaintInformation & info )

overrideprotectedvirtual

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

The saved layer might have been deleted by then, so check if it still belongs to a graph

Implements KisPaintOp.

Definition at line 72 of file kis_duplicateop.cpp.

{
    if (!painter()->device()) return KisSpacingInformation(1.0);
 
    KisBrushSP brush = m_brush;
    if (!brush)
        return KisSpacingInformation(1.0);
 
    if (!brush->canPaintFor(info))
        return KisSpacingInformation(1.0);
 
    if (!m_duplicateStartIsSet) {
        m_duplicateStartIsSet = true;
        m_duplicateStart = info.pos();
    }
 
    KisPaintDeviceSP realSourceDevice;
 
    if (m_duplicateOptionData.cloneFromProjection && m_image) {
        realSourceDevice = m_image->projection();
    }
    else {
        KisNodeSP externalSourceNode = m_settings->sourceNode();
 
        if (!externalSourceNode || !externalSourceNode->graphListener()) {
            externalSourceNode = m_node;
        }
 
        realSourceDevice = externalSourceNode->projection();
    }
 
    qreal rotation = m_rotationOption.apply(info);
 
    m_opacityOption.apply(painter(),info);
 
    qreal scale = m_sizeOption.apply(info);
 
    if (checkSizeTooSmall(scale)) return KisSpacingInformation();
    KisDabShape shape(scale, 1.0, rotation);
 
 
    static const KoColorSpace *cs = KoColorSpaceRegistry::instance()->alpha8();
    static KoColor color(Qt::black, cs);
 
    QRect dstRect;
    KisFixedPaintDeviceSP dab =
        m_dabCache->fetchDab(cs, color, info.pos(),
                             shape,
                             info, 1.0,
                             &dstRect);
 
    if (dstRect.isEmpty()) return KisSpacingInformation(1.0);
 
 
    QPoint srcPoint;
 
    if (m_duplicateOptionData.moveSourcePoint) {
        srcPoint = (dstRect.topLeft() - m_settings->offset()).toPoint();
    }
    else {
        QPointF hotSpot = brush->hotSpot(shape, info);
        srcPoint = (m_settings->position() - hotSpot).toPoint();
    }
 
    qint32 sw = dstRect.width();
    qint32 sh = dstRect.height();
 
    // Perspective correction ?
 
 
    // if (m_perspectiveCorrection && m_image && m_image->perspectiveGrid()->countSubGrids() == 1) {
    //     Matrix3qreal startM = Matrix3qreal::Identity();
    //     Matrix3qreal endM = Matrix3qreal::Identity();
 
    //     // First look for the grid corresponding to the start point
    //     KisSubPerspectiveGrid* subGridStart = *m_image->perspectiveGrid()->begin();
    //     QRect r = QRect(0, 0, m_image->width(), m_image->height());
 
    //     if (subGridStart) {
    //         startM = KisPerspectiveMath::computeMatrixTransfoFromPerspective(r, *subGridStart->topLeft(), *subGridStart->topRight(), *subGridStart->bottomLeft(), *subGridStart->bottomRight());
    //     }
 
    //     // Second look for the grid corresponding to the end point
    //     KisSubPerspectiveGrid* subGridEnd = *m_image->perspectiveGrid()->begin();
    //     if (subGridEnd) {
    //         endM = KisPerspectiveMath::computeMatrixTransfoToPerspective(*subGridEnd->topLeft(), *subGridEnd->topRight(), *subGridEnd->bottomLeft(), *subGridEnd->bottomRight(), r);
    //     }
 
    //     // Compute the translation in the perspective transformation space:
    //     QPointF positionStartPaintingT = KisPerspectiveMath::matProd(endM, QPointF(m_duplicateStart));
    //     QPointF duplicateStartPositionT = KisPerspectiveMath::matProd(endM, QPointF(m_duplicateStart) - QPointF(m_settings->offset()));
    //     QPointF translate = duplicateStartPositionT - positionStartPaintingT;
 
    //     KisSequentialIterator dstIt(m_srcdev, QRect(0, 0, sw, sh));
    //     KisRandomSubAccessorSP srcAcc = realSourceDevice->createRandomSubAccessor();
 
    //     //Action
    //     while (dstIt.nextPixel()) {
    //         QPointF p =  KisPerspectiveMath::matProd(startM, KisPerspectiveMath::matProd(endM, QPointF(dstIt.x() + dstRect.x(), dstIt.y() + dstRect.y())) + translate);
    //         srcAcc->moveTo(p);
    //         srcAcc->sampledOldRawData(dstIt.rawData());
    //     }
 
 
    // }
    // else
    {
        KisPainter copyPainter(m_srcdev);
        copyPainter.setCompositeOpId(COMPOSITE_COPY);
        copyPainter.bitBltOldData(0, 0, realSourceDevice, srcPoint.x(), srcPoint.y(), sw, sh);
        copyPainter.end();
    }
 
    // heal ?
    if (m_duplicateOptionData.healing) {
        QRect healRect(dstRect);
 
        const bool smallWidth = healRect.width() < 3;
        const bool smallHeight = healRect.height() < 3;
 
        if (smallWidth || smallHeight) {
            healRect.adjust(-1, -1, 1, 1);
        }
 
        const int healSW = healRect.width();
        const int healSH = healRect.height();
 
 
        quint16 srcData[4];
        quint16 tmpData[4];
        QScopedArrayPointer<qreal> matrix(new qreal[ 3 * healSW * healSH ]);
        // First divide
        const KoColorSpace* srcCs = realSourceDevice->colorSpace();
        const KoColorSpace* tmpCs = m_srcdev->colorSpace();
        KisHLineConstIteratorSP srcIt = realSourceDevice->createHLineConstIteratorNG(healRect.x(), healRect.y() , healSW);
        KisHLineIteratorSP tmpIt = m_srcdev->createHLineIteratorNG(0, 0, healSW);
        qreal* matrixIt = matrix.data();
        for (int j = 0; j < healSH; j++) {
            for (int i = 0; i < healSW; i++) {
                srcCs->toLabA16(srcIt->oldRawData(), (quint8*)srcData, 1);
                tmpCs->toLabA16(tmpIt->rawData(), (quint8*)tmpData, 1);
                // Division
                for (int k = 0; k < 3; k++) {
                    matrixIt[k] = srcData[k] / (qreal)qMax((int)tmpData [k], 1);
                }
                srcIt->nextPixel();
                tmpIt->nextPixel();
                matrixIt += 3;
            }
            srcIt->nextRow();
            tmpIt->nextRow();
        }
        // Minimize energy
        {
            int iter = 0;
            qreal err;
            QScopedArrayPointer<qreal> solution(new qreal[ 3 * healSW * healSH ]);
 
            do {
                err = DuplicateOpUtils::minimizeEnergy(matrix.data(), solution.data(), healSW, healSH);
 
                solution.swap(matrix);
 
                iter++;
            } while (err > 0.00001 && iter < 100);
        }
 
        // Finally multiply
        KisHLineIteratorSP tmpIt2 = m_srcdev->createHLineIteratorNG(0, 0, healSW);
        matrixIt = &matrix[0];
        for (int j = 0; j < healSH; j++) {
            for (int i = 0; i < healSW; i++) {
                tmpCs->toLabA16(tmpIt2->rawData(), (quint8*)tmpData, 1);
                // Multiplication
                for (int k = 0; k < 3; k++) {
                    tmpData[k] = (int)CLAMP(matrixIt[k] * qMax((int) tmpData[k], 1), 0, 65535);
                }
                tmpCs->fromLabA16((quint8*)tmpData, tmpIt2->rawData(), 1);
                tmpIt2->nextPixel();
                matrixIt += 3;
            }
            tmpIt2->nextRow();
        }
    }
 
    painter()->bitBltWithFixedSelection(dstRect.x(), dstRect.y(),
                                        m_srcdev, dab,
                                        dstRect.width(),
                                        dstRect.height());
 
    painter()->renderMirrorMaskSafe(dstRect, m_srcdev, 0, 0, dab,
                                    !m_dabCache->needSeparateOriginal());
 
    return effectiveSpacing(scale);
}

References KoColorSpaceRegistry::alpha8(), KisRotationOption::apply(), KisStandardOption< Data >::apply(), KisOpacityOption::apply(), KisPainter::bitBltOldData(), KisPainter::bitBltWithFixedSelection(), KisBrushBasedPaintOp::checkSizeTooSmall(), CLAMP, KisDuplicateOptionData::cloneFromProjection, KisPaintDevice::colorSpace(), COMPOSITE_COPY, KisPaintDevice::createHLineConstIteratorNG(), KisPaintDevice::createHLineIteratorNG(), KisPaintOp::dab, KisSharedPtr< T >::data(), KisBrushBasedPaintOp::effectiveSpacing(), KisPainter::end(), KisDabCache::fetchDab(), KoColorSpace::fromLabA16(), KisNode::graphListener, KisDuplicateOptionData::healing, KoColorSpaceRegistry::instance(), KisBrushBasedPaintOp::m_brush, KisBrushBasedPaintOp::m_dabCache, m_duplicateOptionData, m_duplicateStart, m_duplicateStartIsSet, m_image, m_node, m_opacityOption, m_rotationOption, m_settings, m_sizeOption, m_srcdev, DuplicateOpUtils::minimizeEnergy(), KisDuplicateOptionData::moveSourcePoint, KisDabCache::needSeparateOriginal(), KisBaseConstIteratorNG::nextPixel(), KisHLineConstIteratorNG::nextRow(), KisDuplicateOpSettings::offset(), KisBaseConstAccessor::oldRawData(), KisPaintOp::painter, KisPaintInformation::pos(), KisDuplicateOpSettings::position(), KisImage::projection(), KisBaseNode::projection(), KisPainter::renderMirrorMaskSafe(), KisPainter::setCompositeOpId(), KisDuplicateOpSettings::sourceNode(), and KoColorSpace::toLabA16().

updateSpacingImpl()

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

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 272 of file kis_duplicateop.cpp.

{
    return effectiveSpacing(m_sizeOption.apply(info));
}

References KisStandardOption< Data >::apply(), KisBrushBasedPaintOp::effectiveSpacing(), and m_sizeOption.

Member Data Documentation

m_duplicateOptionData

KisDuplicateOptionData KisDuplicateOp::m_duplicateOptionData

private

Definition at line 58 of file kis_duplicateop.h.

m_duplicateStart

QPointF KisDuplicateOp::m_duplicateStart {QPointF(0.0, 0.0)}

private

Definition at line 62 of file kis_duplicateop.h.

{QPointF(0.0, 0.0)};

m_duplicateStartIsSet

bool KisDuplicateOp::m_duplicateStartIsSet {false}

private

Definition at line 63 of file kis_duplicateop.h.

{false};

m_image

KisImageSP KisDuplicateOp::m_image

private

Definition at line 55 of file kis_duplicateop.h.

m_node

KisNodeSP KisDuplicateOp::m_node

private

Definition at line 56 of file kis_duplicateop.h.

m_opacityOption

KisOpacityOption KisDuplicateOp::m_opacityOption

private

Definition at line 65 of file kis_duplicateop.h.

m_rotationOption

KisRotationOption KisDuplicateOp::m_rotationOption

private

Definition at line 66 of file kis_duplicateop.h.

m_settings

KisDuplicateOpSettingsSP KisDuplicateOp::m_settings

private

Definition at line 59 of file kis_duplicateop.h.

m_sizeOption

KisSizeOption KisDuplicateOp::m_sizeOption

private

Definition at line 64 of file kis_duplicateop.h.

m_srcdev

KisPaintDeviceSP KisDuplicateOp::m_srcdev

private

Definition at line 60 of file kis_duplicateop.h.

m_target

KisPaintDeviceSP KisDuplicateOp::m_target

private

Definition at line 61 of file kis_duplicateop.h.

---

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

• plugins/paintops/defaultpaintops/duplicate/kis_duplicateop.h
• plugins/paintops/defaultpaintops/duplicate/kis_duplicateop.cpp