KisOverlayPaintDeviceWrapper Class Reference

#include <KisOverlayPaintDeviceWrapper.h>

Classes
struct	Private

Public Types
enum	OverlayMode { NormalMode = 0 , PreciseMode , LazyPreciseMode }

Public Member Functions
void	beginTransaction (KUndo2Command *parent=0)
KisPaintDeviceSP	createPreciseCompositionSourceDevice ()
KUndo2Command *	endTransaction ()
KisPaintDeviceSP	externalDestination () const
	KisOverlayPaintDeviceWrapper (KisPaintDeviceSP source, int numOverlays=1, OverlayMode mode=NormalMode, const KoColorSpace *forcedOverlayColorSpace=nullptr)
KisPaintDeviceSP	overlay (int index=0) const
const KoColorSpace *	overlayColorSpace () const
void	readRect (const QRect &rc)
void	readRects (const QVector< QRect > &rects)
void	setExternalDestination (KisPaintDeviceSP device)
KisPaintDeviceSP	source () const
void	writeRect (const QRect &rc, int index=0)
void	writeRects (const QVector< QRect > &rects, int index=0)
	~KisOverlayPaintDeviceWrapper ()

Private Attributes
const QScopedPointer< Private >	m_d

Friends
struct	KisChangeOverlayWrapperCommand

Detailed Description

A special wrapper class for a paint device that allows working with parts of the source paint device using an overlay, that is without modifying the device itself. The overlay may have higher bit depth if PreciseMode or LazyPreciseMode is used.

For example, you have an RGBA8 paint device, but you want all the blending happen in higher bit depth. You wrap your paint device (source paint device) into KisOverlayPaintDeviceWrapper, and the wrapper creates a temporary device (precise overlay paint device) in RGBA16 colorspace. Then you work with this precise paint device as usual, uploading and downloading pixel data to/from the source paint device using readRect() and writeRect()

In LazyPreciseMode, if the source device is already "precise", that is having the bit depth higher than 8 bit per channel, no temporary device is created. All the operations are forwarded directly to the source device.

In some cases (e.g. when trying to maintain a separate heightmap channel), you may want to have multiple overlays.

When doing conversions between U8 and U16 color spaces, the overlay will try to use AVX2-optimized algorithms.

Example:

// initialize the wrapper with the source device,
// it creates a precise device if needed
KisOverlayPaintDeviceWrapper wrapper(sourceDevice, 1, KisOverlayPaintDeviceWrapper::LazyPreciseMode);
 
// Download the data from the source device. The rects
// that have already been read will be cached and will
// never be read twice.
wrapper.readRect(accessRect);
 
// start modifying the data
KisPainter gc(wrapper.overlay());
 
// low opacity might be handled incorrectly in the original
// color space, but we work in a precise one!
gc.setOpacity(1);
gc.bitBlt(accessRect.topLeft(), someOtherDevice, accessRect);
 
// ... repeat multiple times if needed ...
 
// upload the data back to the original source device
wrapper.writeRect(accessRect);

Definition at line 67 of file KisOverlayPaintDeviceWrapper.h.

Member Enumeration Documentation

OverlayMode

enum KisOverlayPaintDeviceWrapper::OverlayMode

Enumerator
NormalMode
PreciseMode
LazyPreciseMode

Definition at line 70 of file KisOverlayPaintDeviceWrapper.h.

                     {
        NormalMode = 0,
        PreciseMode,
        LazyPreciseMode
    };

Constructor & Destructor Documentation

KisOverlayPaintDeviceWrapper()

KisOverlayPaintDeviceWrapper::KisOverlayPaintDeviceWrapper	(	KisPaintDeviceSP	source,
		int	numOverlays = 1,
		KisOverlayPaintDeviceWrapper::OverlayMode	mode = NormalMode,
		const KoColorSpace *	forcedOverlayColorSpace = nullptr )

Create an overlay wrapper and attach it to device.

If mode is NormalMode, then numOverlays are created. All overlays will have the same (possible "imprecise") colorspace as source.

If mode is PreciseMode, then numOverlays are created. If source has "imprecise" color space (U8), then overlays will be upgraded to a "precise" color space (U16).

If mode is LazyPreciseMode and numOverlays is 1, then the overlay will be created only in case when precise color space is needed. Otherwise, the mode behaves like PreciseMode

Parameters

device	source device
numOverlays	the number of overlays to create
mode	mode to use
forcedOverlayColorSpace	forced color space to use for overlay. Passing non- null as forcedOverlayColorSpace will override precise color space decision process. This argument is useful for cases when two overlay devices need to have exactly the same color space (e.g. in colorsmudge overlay mode).

Definition at line 66 of file KisOverlayPaintDeviceWrapper.cpp.

    : m_d(new Private())
{
    m_d->source = source;
 
    const KoColorSpace *overlayColorSpace = source->compositionSourceColorSpace();
 
    if (forcedOverlayColorSpace) {
        overlayColorSpace = forcedOverlayColorSpace;
    } else {
        const bool usePreciseMode = mode == PreciseMode || mode == LazyPreciseMode;
 
        if (usePreciseMode &&
            overlayColorSpace->colorDepthId() == Integer8BitsColorDepthID) {
 
            overlayColorSpace =
                    KoColorSpaceRegistry::instance()->colorSpace(
                        overlayColorSpace->colorModelId().id(),
                        Integer16BitsColorDepthID.id(),
                        overlayColorSpace->profile());
        }
    }
 
    m_d->usePreciseMode = *source->colorSpace() != *overlayColorSpace;
 
    if (source->colorSpace()->colorModelId() == RGBAColorModelID &&
        source->colorSpace()->colorDepthId() == Integer8BitsColorDepthID &&
        overlayColorSpace->colorModelId() == RGBAColorModelID &&
        overlayColorSpace->colorDepthId() == Integer16BitsColorDepthID &&
        *source->colorSpace()->profile() == *overlayColorSpace->profile()) {
 
        m_d->scaler.reset(KoOptimizedPixelDataScalerU8ToU16Factory::createRgbaScaler());
 
    } else if (source->colorSpace()->colorModelId() == CMYKAColorModelID &&
        source->colorSpace()->colorDepthId() == Integer8BitsColorDepthID &&
        overlayColorSpace->colorModelId() == CMYKAColorModelID &&
        overlayColorSpace->colorDepthId() == Integer16BitsColorDepthID &&
        *source->colorSpace()->profile() == *overlayColorSpace->profile()) {
 
        m_d->scaler.reset(KoOptimizedPixelDataScalerU8ToU16Factory::createCmykaScaler());
 
    } else if (source->colorSpace()->colorModelId() == YCbCrAColorModelID &&
               source->colorSpace()->colorDepthId() == Integer8BitsColorDepthID &&
               overlayColorSpace->colorModelId() == YCbCrAColorModelID &&
               overlayColorSpace->colorDepthId() == Integer16BitsColorDepthID &&
               *source->colorSpace()->profile() == *overlayColorSpace->profile()) {
 
        m_d->scaler.reset(KoOptimizedPixelDataScalerU8ToU16Factory::createRgbaScaler());
 
    }
 
    if (!m_d->usePreciseMode && mode == LazyPreciseMode && numOverlays == 1) {
        return;
    }
 
    for (int i = 0; i < numOverlays; i++) {
        KisPaintDeviceSP overlay = new KisPaintDevice(overlayColorSpace);
        overlay->setDefaultPixel(source->defaultPixel().convertedTo(overlayColorSpace));
        overlay->setDefaultBounds(source->defaultBounds());
        overlay->setSupportsWraparoundMode(source->supportsWraproundMode());
        overlay->moveTo(source->offset());
 
        m_d->overlays.append(overlay);
    }
}

References CMYKAColorModelID, KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), KoColorSpaceRegistry::colorSpace(), KisPaintDevice::compositionSourceColorSpace(), KoColor::convertedTo(), KoOptimizedPixelDataScalerU8ToU16Factory::createCmykaScaler(), KoOptimizedPixelDataScalerU8ToU16Factory::createRgbaScaler(), KisPaintDevice::defaultBounds(), KisPaintDevice::defaultPixel(), KoID::id(), KoColorSpaceRegistry::instance(), Integer16BitsColorDepthID, Integer8BitsColorDepthID, LazyPreciseMode, m_d, KisPaintDevice::moveTo(), KisPaintDevice::offset(), overlay(), overlayColorSpace(), PreciseMode, KoColorSpace::profile(), RGBAColorModelID, KisPaintDevice::setDefaultBounds(), KisPaintDevice::setDefaultPixel(), KisPaintDevice::setSupportsWraparoundMode(), source(), KisPaintDevice::supportsWraproundMode(), and YCbCrAColorModelID.

~KisOverlayPaintDeviceWrapper()

KisOverlayPaintDeviceWrapper::~KisOverlayPaintDeviceWrapper

(

)

Definition at line 132 of file KisOverlayPaintDeviceWrapper.cpp.

{
}

Member Function Documentation

beginTransaction()

void KisOverlayPaintDeviceWrapper::beginTransaction

(

KUndo2Command *

parent = 0

)

Definition at line 306 of file KisOverlayPaintDeviceWrapper.cpp.

{
    KIS_SAFE_ASSERT_RECOVER(!m_d->rootTransactionData) {
        m_d->rootTransactionData.reset();
    }
 
    if (!m_d->previousGrid) {
        m_d->previousGrid.reset(new KisRectsGrid(m_d->grid));
    }
 
    m_d->rootTransactionData.reset(new KUndo2Command(parent));
 
    m_d->changeOverlayCommand = new KisChangeOverlayWrapperCommand(m_d.data());
    (void) new KisCommandUtils::SkipFirstRedoWrapper(m_d->changeOverlayCommand, m_d->rootTransactionData.data());
    m_d->changeOverlayCommand->m_oldRectsGrid = m_d->previousGrid;
 
    for (const auto &overlayDevice : m_d->overlays) {
        m_d->overlayTransactions.emplace_back(new KisTransaction(overlayDevice, m_d->rootTransactionData.data()));
    }
}

References KIS_SAFE_ASSERT_RECOVER, KisChangeOverlayWrapperCommand, m_d, and void().

createPreciseCompositionSourceDevice()

KisPaintDeviceSP KisOverlayPaintDeviceWrapper::createPreciseCompositionSourceDevice

(

)

Create a composite source device for being used over overlay().

Please note that one cannot use overlay()->createCompositeSourceDevice() for this purpose because overlay() is just a copy of sourceDevice() and doesn't have overloaded methods for this color space.

TODO: make KisPaintDevice::compositeSourceColorSpace() not a virtual method, but let is be assigned during the lifetime of the paint device. It'll let us remove this extra function.

TODO: this function has rather vague meaning when forcedOverlayColorSpace feature is used

Definition at line 277 of file KisOverlayPaintDeviceWrapper.cpp.

{
    KisPaintDeviceSP result;
 
    if (!m_d->usePreciseMode) {
        result = source()->createCompositionSourceDevice();
    } else {
        const KoColorSpace *compositionColorSpace =
            m_d->source->compositionSourceColorSpace();
 
        const KoColorSpace *preciseCompositionColorSpace =
                KoColorSpaceRegistry::instance()->colorSpace(
                    compositionColorSpace->colorModelId().id(),
                    Integer16BitsColorDepthID.id(),
                    compositionColorSpace->profile());
 
        KisPaintDeviceSP device = new KisPaintDevice(preciseCompositionColorSpace);
        device->setDefaultBounds(m_d->source->defaultBounds());
        result = device;
    }
 
    return result;
}

References KoColorSpace::colorModelId(), KoColorSpaceRegistry::colorSpace(), KisPaintDevice::createCompositionSourceDevice(), KoID::id(), KoColorSpaceRegistry::instance(), Integer16BitsColorDepthID, m_d, KoColorSpace::profile(), KisPaintDevice::setDefaultBounds(), and source().

endTransaction()

KUndo2Command * KisOverlayPaintDeviceWrapper::endTransaction

(

)

Definition at line 327 of file KisOverlayPaintDeviceWrapper.cpp.

{
    KUndo2Command *result = nullptr;
 
    KIS_SAFE_ASSERT_RECOVER(m_d->rootTransactionData) {
        m_d->overlayTransactions.clear();
        return result;
    }
 
    m_d->previousGrid.reset(new KisRectsGrid(m_d->grid));
 
    m_d->changeOverlayCommand->m_newRectsGrid = m_d->previousGrid;
    result = m_d->rootTransactionData.take();
 
    for (auto &transactionPtr : m_d->overlayTransactions) {
        // the transactions are assigned as children to m_d->changeOverlayCommand
        (void) transactionPtr->endAndTake();
    }
    m_d->overlayTransactions.clear();
 
    return result;
}

References KIS_SAFE_ASSERT_RECOVER, m_d, and void().

externalDestination()

KisPaintDeviceSP KisOverlayPaintDeviceWrapper::externalDestination

(

)

const

Definition at line 141 of file KisOverlayPaintDeviceWrapper.cpp.

{
    return m_d->externalDestination;
}

References m_d.

overlay()

KisPaintDeviceSP KisOverlayPaintDeviceWrapper::overlay

(

int

index = 0

)

const

Definition at line 151 of file KisOverlayPaintDeviceWrapper.cpp.

{
    return !m_d->overlays.isEmpty() ? m_d->overlays[index] : m_d->source;
}

References m_d.

overlayColorSpace()

const KoColorSpace * KisOverlayPaintDeviceWrapper::overlayColorSpace

(

)

const

Definition at line 272 of file KisOverlayPaintDeviceWrapper.cpp.

{
    return !m_d->overlays.isEmpty() ? m_d->overlays.first()->colorSpace() : m_d->source->colorSpace();
}

References m_d.

readRect()

void KisOverlayPaintDeviceWrapper::readRect

(

const QRect &

rc

)

Definition at line 156 of file KisOverlayPaintDeviceWrapper.cpp.

{
    readRects({rc});
}

References readRects().

readRects()

void KisOverlayPaintDeviceWrapper::readRects

(

const QVector< QRect > &

rects

)

Definition at line 166 of file KisOverlayPaintDeviceWrapper.cpp.

{
    if (rects.isEmpty()) return;
    if (m_d->overlays.isEmpty()) return;
 
    QRect cropRect = m_d->source->extent();
    QVector<QRect> rectsToRead;
 
    Q_FOREACH (const QRect &rc, rects) {
        if (m_d->source->defaultBounds()->wrapAroundMode()) {
            const QRect wrapRect = m_d->source->defaultBounds()->imageBorderRect();
            KisWrappedRect wrappedRect(rc, wrapRect, m_d->source->defaultBounds()->wrapAroundModeAxis());
            Q_FOREACH (const QRect &wrc, wrappedRect) {
                rectsToRead += m_d->grid.addRect(wrc);
            }
            cropRect &= wrapRect;
        } else {
            rectsToRead += m_d->grid.addRect(rc);
        }
    }
 
    KisRegion::makeGridLikeRectsUnique(rectsToRead);
 
    //TODO: implement synchronization of the offset between the grid and devices
 
    if (!m_d->scaler) {
        Q_FOREACH (KisPaintDeviceSP overlay, m_d->overlays) {
            Q_FOREACH (const QRect &rect, rectsToRead) {
                const QRect croppedRect = rect & cropRect;
                if (croppedRect.isEmpty()) continue;
 
                KisPainter::copyAreaOptimized(croppedRect.topLeft(), m_d->source, overlay, croppedRect);
            }
        }
    } else {
        KisPaintDeviceSP overlay = m_d->overlays.first();
 
        KisRandomConstAccessorSP srcIt = m_d->source->createRandomConstAccessorNG();
        KisRandomAccessorSP dstIt = overlay->createRandomAccessorNG();
 
        auto rectIter = rectsToRead.begin();
        while (rectIter != rectsToRead.end()) {
            const QRect croppedRect = *rectIter & cropRect;
 
            if (!croppedRect.isEmpty()) {
 
                KritaUtils::processTwoDevicesWithStrides(croppedRect,
                                                         srcIt, dstIt,
                    [this] (const quint8 *src, int srcRowStride,
                            quint8 *dst, int dstRowStride,
                            int numRows, int numColumns) {
 
                    m_d->scaler->convertU8ToU16(src, srcRowStride,
                                                dst, dstRowStride,
                                                numRows, numColumns);
                });
 
                for (auto it = std::next(m_d->overlays.begin()); it != m_d->overlays.end(); ++it) {
                    KisPaintDeviceSP otherOverlay = *it;
                    KisPainter::copyAreaOptimized(croppedRect.topLeft(), overlay, otherOverlay, croppedRect);
                }
            }
 
            rectIter++;
        }
    }
}

References KisPainter::copyAreaOptimized(), KisPaintDevice::createRandomAccessorNG(), KisPaintDevice::extent(), m_d, KisRegion::makeGridLikeRectsUnique(), overlay(), and KritaUtils::processTwoDevicesWithStrides().

setExternalDestination()

void KisOverlayPaintDeviceWrapper::setExternalDestination

(

KisPaintDeviceSP

device

)

Definition at line 136 of file KisOverlayPaintDeviceWrapper.cpp.

{
    m_d->externalDestination = device;
}

References m_d.

source()

KisPaintDeviceSP KisOverlayPaintDeviceWrapper::source

(

)

const

Definition at line 146 of file KisOverlayPaintDeviceWrapper.cpp.

{
    return m_d->source;
}

References m_d.

writeRect()

void KisOverlayPaintDeviceWrapper::writeRect	(	const QRect &	rc,
		int	index = 0 )

Definition at line 161 of file KisOverlayPaintDeviceWrapper.cpp.

{
    writeRects({rc}, index);
}

References writeRects().

writeRects()

void KisOverlayPaintDeviceWrapper::writeRects	(	const QVector< QRect > &	rects,
		int	index = 0 )

Definition at line 234 of file KisOverlayPaintDeviceWrapper.cpp.

{
    if (rects.isEmpty()) return;
    if (m_d->overlays.isEmpty()) return;
 
    KisPaintDeviceSP destinationDevice =
        m_d->externalDestination ? m_d->externalDestination : m_d->source;
 
    if (!m_d->scaler ||
        (destinationDevice != m_d->source &&
         *destinationDevice->colorSpace() != *m_d->source->colorSpace())) {
 
        Q_FOREACH (const QRect &rc, rects) {
            KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->grid.contains(rc));
            KisPainter::copyAreaOptimized(rc.topLeft(), m_d->overlays[index], destinationDevice, rc);
        }
    } else {
        KisPaintDeviceSP overlay = m_d->overlays[index];
 
 
        KisRandomConstAccessorSP srcIt = overlay->createRandomConstAccessorNG();
        KisRandomAccessorSP dstIt = destinationDevice->createRandomAccessorNG();
 
        Q_FOREACH (const QRect &rc, rects) {
            KritaUtils::processTwoDevicesWithStrides(rc,
                                                     srcIt, dstIt,
                [this] (const quint8 *src, int srcRowStride,
                        quint8 *dst, int dstRowStride,
                        int numRows, int numColumns) {
 
                m_d->scaler->convertU16ToU8(src, srcRowStride,
                                            dst, dstRowStride,
                                            numRows, numColumns);
            });
        }
    }
}

References KisPaintDevice::colorSpace(), KisPainter::copyAreaOptimized(), KisPaintDevice::createRandomAccessorNG(), KisPaintDevice::createRandomConstAccessorNG(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, overlay(), and KritaUtils::processTwoDevicesWithStrides().

Friends And Related Symbol Documentation

KisChangeOverlayWrapperCommand

friend struct KisChangeOverlayWrapperCommand

friend

Definition at line 136 of file KisOverlayPaintDeviceWrapper.h.

Member Data Documentation

m_d

const QScopedPointer<Private> KisOverlayPaintDeviceWrapper::m_d

private

Definition at line 138 of file KisOverlayPaintDeviceWrapper.h.

---

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

• libs/image/KisOverlayPaintDeviceWrapper.h
• libs/image/KisOverlayPaintDeviceWrapper.cpp