KisImagePyramid Class Reference

#include <kis_image_pyramid.h>

Inheritance diagram for KisImagePyramid:

Public Member Functions
void	alignSourceRect (QRect &rect, qreal scale) override
QImage	convertToQImage (qreal scale, const QRect &unscaledRect, enum Qt::TransformationMode transformMode)
QImage	convertToQImage (qreal scale, qint32 unscaledX, qint32 unscaledY, qint32 unscaledWidth, qint32 unscaledHeight)
void	drawFromOriginalImage (QPainter &gc, KisPPUpdateInfoSP info) override
void	drawImage (qreal scale, QPainter &gc, const QPoint &topLeftScaled, const QRect &unscaledSourceRect)
KisImagePatch	getNearestPatch (KisPPUpdateInfoSP info) override
	KisImagePyramid (qint32 pyramidHeight)
void	recalculateCache (KisPPUpdateInfoSP info) override
void	setChannelFlags (const QBitArray &channelFlags) override
void	setDisplayFilter (QSharedPointer< KisDisplayFilter > displayFilter) override
void	setImage (KisImageWSP newImage) override
void	setImageSize (qint32 w, qint32 h) override
void	setMonitorProfile (const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) override
void	updateCache (const QRect &dirtyImageRect) override
	~KisImagePyramid () override
Public Member Functions inherited from KisProjectionBackend
virtual	~KisProjectionBackend ()

Private Slots
void	configChanged ()

Private Member Functions
void	clearPyramid ()
QImage	convertToQImageFast (KisPaintDeviceSP paintDevice, const QRect &unscaledRect)
QRect	downsampleByFactor2 (const QRect &srcRect, KisPaintDevice *src, KisPaintDevice *dst)
void	downsamplePixels (const quint8 *srcRow0, const quint8 *srcRow1, quint8 *dstRow, qint32 numSrcPixels)
int	findFirstGoodPlaneIndex (qreal scale, QSize originalSize)
void	rebuildPyramid ()
void	retrieveImageData (const QRect &rect)

Private Attributes
bool	m_allChannelsSelected {false}
QBitArray	m_channelFlags
KoColorConversionTransformation::ConversionFlags	m_conversionFlags { KoColorConversionTransformation::Empty }
QSharedPointer< KisDisplayFilter >	m_displayFilter
const KoColorSpace *	m_monitorColorSpace {0}
const KoColorProfile *	m_monitorProfile {0}
bool	m_onlyOneChannelSelected {false}
KisImageWSP	m_originalImage
QVector< KisPaintDeviceSP >	m_pyramid
qint32	m_pyramidHeight {0}
KoColorConversionTransformation::Intent	m_renderingIntent { KoColorConversionTransformation::IntentPerceptual }
int	m_selectedChannelIndex {-1}
bool	m_useOcio {false}

Detailed Description

Definition at line 20 of file kis_image_pyramid.h.

Constructor & Destructor Documentation

KisImagePyramid()

KisImagePyramid::KisImagePyramid

(

qint32

pyramidHeight

)

Definition at line 89 of file kis_image_pyramid.cpp.

        : m_monitorProfile(0)
        , m_monitorColorSpace(0)
        , m_pyramidHeight(pyramidHeight)
{
    configChanged();
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
}

References configChanged(), and KisConfigNotifier::instance().

~KisImagePyramid()

KisImagePyramid::~KisImagePyramid ( )

override

Definition at line 98 of file kis_image_pyramid.cpp.

{
    setImage(0);
}

References setImage().

Member Function Documentation

alignSourceRect()

void KisImagePyramid::alignSourceRect ( QRect & rect, qreal scale )

overridevirtual

Some backends cannot work with arbitrary areas due to scaling stuff. That's why KisPrescaledProjection asks a backend to align an image rect before any operations.

Assume that KisImage pixels are always positive It allows us to use binary op-s for aligning

Here is a workaround of Qt's QRect::right()/bottom() "historical reasons". It should be one pixel smaller than actual right/bottom position

Reimplemented from KisProjectionBackend.

Definition at line 420 of file kis_image_pyramid.cpp.

{
    qint32 index = findFirstGoodPlaneIndex(scale, rect.size());
    qint32 alignment = 1 << index;
 
    dbgRender << "Before alignment:\t" << rect;
 
    Q_ASSERT(rect.left() >= 0 && rect.top() >= 0);
 
    qint32 x1, y1, x2, y2;
    rect.getCoords(&x1, &y1, &x2, &y2);
 
    alignByPow2Lo(x1, alignment);
    alignByPow2Lo(y1, alignment);
    alignByPow2ButOneHi(x2, alignment);
    alignByPow2ButOneHi(y2, alignment);
 
    rect.setCoords(x1, y1, x2, y2);
 
    dbgRender << "After alignment:\t" << rect;
}

References alignByPow2ButOneHi(), alignByPow2Lo(), dbgRender, and findFirstGoodPlaneIndex().

clearPyramid()

void KisImagePyramid::clearPyramid ( )

private

Definition at line 153 of file kis_image_pyramid.cpp.

{
    for (qint32 i = 0; i < m_pyramidHeight; i++) {
        m_pyramid[i]->clear();
    }
}

References m_pyramid, and m_pyramidHeight.

configChanged

void KisImagePyramid::configChanged ( )

privateslot

Definition at line 487 of file kis_image_pyramid.cpp.

{
    KisConfig cfg(true);
    m_useOcio = cfg.useOcio();
}

References m_useOcio, and KisConfig::useOcio().

convertToQImage() [1/2]

QImage KisImagePyramid::convertToQImage	(	qreal	scale,
		const QRect &	unscaledRect,
		enum Qt::TransformationMode	transformMode )

Render the projection onto a QImage. Color profiling occurs here

convertToQImage() [2/2]

QImage KisImagePyramid::convertToQImage	(	qreal	scale,
		qint32	unscaledX,
		qint32	unscaledY,
		qint32	unscaledWidth,
		qint32	unscaledHeight )

convertToQImageFast()

QImage KisImagePyramid::convertToQImageFast ( KisPaintDeviceSP paintDevice, const QRect & unscaledRect )

private

Fast workaround for converting paintDevices

Definition at line 474 of file kis_image_pyramid.cpp.

{
    qint32 x, y, w, h;
    unscaledRect.getRect(&x, &y, &w, &h);
 
    QImage image = QImage(w, h, QImage::Format_ARGB32);
 
    paintDevice->dataManager()->readBytes(image.bits(), x, y, w, h);
 
    return image;
}

References KisPaintDevice::dataManager(), and KisDataManager::readBytes().

downsampleByFactor2()

QRect KisImagePyramid::downsampleByFactor2 ( const QRect & srcRect, KisPaintDevice * src, KisPaintDevice * dst )

private

Downsamples @srcRect from @src paint device and writes result into proper place of @dst paint device Returns modified rect of @dst paintDevice

Definition at line 318 of file kis_image_pyramid.cpp.

{
    qint32 srcX, srcY, srcWidth, srcHeight;
    srcRect.getRect(&srcX, &srcY, &srcWidth, &srcHeight);
    alignRectBy2(srcX, srcY, srcWidth, srcHeight);
 
    // Nothing to do
    if (srcWidth < 1) return QRect();
    if (srcHeight < 1) return QRect();
 
    qint32 dstX = srcX / 2;
    qint32 dstY = srcY / 2;
    qint32 dstWidth = srcWidth / 2;
    qint32 dstHeight = srcHeight / 2;
 
    KisHLineConstIteratorSP srcIt0 = src->createHLineConstIteratorNG(srcX, srcY, srcWidth);
    KisHLineConstIteratorSP srcIt1 = src->createHLineConstIteratorNG(srcX, srcY + 1, srcWidth);
    KisHLineIteratorSP dstIt = dst->createHLineIteratorNG(dstX, dstY, dstWidth);
 
    int conseqPixels = 0;
    for (int row = 0; row < dstHeight; ++row) {
        do {
            int srcItConseq = srcIt0->nConseqPixels();
            int dstItConseq = dstIt->nConseqPixels();
            conseqPixels = qMin(srcItConseq, dstItConseq * 2);
 
            Q_ASSERT(!isOdd(conseqPixels));
 
            downsamplePixels(srcIt0->oldRawData(), srcIt1->oldRawData(),
                             dstIt->rawData(), conseqPixels);
 
 
            srcIt1->nextPixels(conseqPixels);
            dstIt->nextPixels(conseqPixels / 2);
        } while (srcIt0->nextPixels(conseqPixels));
        srcIt0->nextRow();
        srcIt0->nextRow();
        srcIt1->nextRow();
        srcIt1->nextRow();
        dstIt->nextRow();
    }
    return QRect(dstX, dstY, dstWidth, dstHeight);
}

References alignRectBy2(), KisPaintDevice::createHLineIteratorNG(), downsamplePixels(), isOdd, KisBaseConstIteratorNG::nConseqPixels(), KisBaseConstIteratorNG::nextPixels(), KisHLineConstIteratorNG::nextRow(), and KisBaseConstAccessor::oldRawData().

downsamplePixels()

void KisImagePyramid::downsamplePixels ( const quint8 * srcRow0, const quint8 * srcRow1, quint8 * dstRow, qint32 numSrcPixels )

private

Auxiliary function. Downsamples two lines in @srcRow0 and @srcRow1 into one line @dstRow Note: @numSrcPixels must be EVEN

FIXME (mandatory): Use SSE and friends here.

Definition at line 364 of file kis_image_pyramid.cpp.

{
    qint16 b = 0;
    qint16 g = 0;
    qint16 r = 0;
    qint16 a = 0;
 
    static const qint32 pixelSize = 4; // This is preview argb8 mode
 
    for (qint32 i = 0; i < numSrcPixels / 2; i++) {
        b = srcRow0[0] + srcRow1[0] + srcRow0[4] + srcRow1[4];
        g = srcRow0[1] + srcRow1[1] + srcRow0[5] + srcRow1[5];
        r = srcRow0[2] + srcRow1[2] + srcRow0[6] + srcRow1[6];
        a = srcRow0[3] + srcRow1[3] + srcRow0[7] + srcRow1[7];
 
        dstRow[0] = b / 4;
        dstRow[1] = g / 4;
        dstRow[2] = r / 4;
        dstRow[3] = a / 4;
 
        dstRow += pixelSize;
        srcRow0 += 2 * pixelSize;
        srcRow1 += 2 * pixelSize;
    }
}

drawFromOriginalImage()

void KisImagePyramid::drawFromOriginalImage ( QPainter & gc, KisPPUpdateInfoSP info )

overridevirtual

Draws a piece of original image onto gc 's canvas info.imageRect - area in KisImage pixels where to read from info.viewportRect - area in canvas pixels where to write to If info.imageRect and info.viewportRect don't agree, the image will be scaled info.borderWidth has the same meaning as in getNearestPatch info.renderHints - hints, transmitted to QPainter during drawing

Implements KisProjectionBackend.

Definition at line 468 of file kis_image_pyramid.cpp.

{
    KisImagePatch patch = getNearestPatch(info);
    patch.drawMe(gc, info->viewportRect, info->renderHints);
}

References KisImagePatch::drawMe(), and getNearestPatch().

drawImage()

void KisImagePyramid::drawImage	(	qreal	scale,
		QPainter &	gc,
		const QPoint &	topLeftScaled,
		const QRect &	unscaledSourceRect )

Draw the projection onto a QPainter. Color profiling occurs here

findFirstGoodPlaneIndex()

int KisImagePyramid::findFirstGoodPlaneIndex ( qreal scale, QSize originalSize )

private

Searches for the last pyramid plane that can cover canvas on current zoom level

Definition at line 397 of file kis_image_pyramid.cpp.

{
    qint32 nearest = 0;
 
    for (qint32 i = 0; i < m_pyramidHeight; i++) {
        qreal planeScale = SCALE_FROM_INDEX(i);
        if (planeScale < scale) {
            if (originalSize*scale == originalSize*planeScale)
                nearest = i;
            break;
        }
        nearest = i;
    }
 
    // FOR DEBUGGING
    //nearest = 0;
    //nearest = qMin(1, nearest);
 
    dbgRender << "First good plane:" << nearest << "(sc:" << scale << ")";
    return nearest;
}

References dbgRender, m_pyramidHeight, and SCALE_FROM_INDEX.

getNearestPatch()

KisImagePatch KisImagePyramid::getNearestPatch ( KisPPUpdateInfoSP info )

overridevirtual

Gets a patch from a backend that can draw a info.imageRect on some QPainter in future. info.scaleX and info.scaleY are the scales of planned drawing, btw, it doesn't mean that an QImage inside the patch will have these scales - it'll have the nearest suitable scale or even original scale (e.g. KisProjectionCache)

If info.borderWidth is non-zero, info.requestedRect will be expended by info.borderWidth pixels to all directions and image of this rect will actually be written to the patch's QImage. That is done to eliminate border effects in smooth scaling.

Implements KisProjectionBackend.

Definition at line 451 of file kis_image_pyramid.cpp.

{
    qint32 index = findFirstGoodPlaneIndex(qMax(info->scaleX, info->scaleY),
                                           info->imageRect.size());
    qreal planeScale = SCALE_FROM_INDEX(index);
    qint32 alignment = 1 << index;
 
    alignByPow2Hi(info->borderWidth, alignment);
 
    KisImagePatch patch(info->imageRect, info->borderWidth,
                        planeScale, planeScale);
 
    patch.setImage(convertToQImageFast(m_pyramid[index],
                                       patch.patchRect()));
    return patch;
}

References alignByPow2Hi(), convertToQImageFast(), findFirstGoodPlaneIndex(), m_pyramid, KisImagePatch::patchRect(), SCALE_FROM_INDEX, and KisImagePatch::setImage().

rebuildPyramid()

void KisImagePyramid::rebuildPyramid ( )

private

Definition at line 145 of file kis_image_pyramid.cpp.

{
    m_pyramid.clear();
    for (qint32 i = 0; i < m_pyramidHeight; i++) {
        m_pyramid.append(new KisPaintDevice(m_monitorColorSpace));
    }
}

References m_monitorColorSpace, m_pyramid, and m_pyramidHeight.

recalculateCache()

void KisImagePyramid::recalculateCache ( KisPPUpdateInfoSP info )

overridevirtual

Prescales the cache of the backend. It is intended to be called from a separate thread where you can easily do the calculations. No data transfers with KisImage should happen during this phase

Implements KisProjectionBackend.

Definition at line 290 of file kis_image_pyramid.cpp.

{
    KisPaintDevice *src;
    KisPaintDevice *dst;
    QRect currentSrcRect = info->dirtyImageRectVar;
 
    for (int i = FIRST_NOT_ORIGINAL_INDEX; i < m_pyramidHeight; i++) {
        src = m_pyramid[i-1].data();
        dst = m_pyramid[i].data();
        if (!currentSrcRect.isEmpty()) {
            currentSrcRect = downsampleByFactor2(currentSrcRect, src, dst);
        }
    }
 
#ifdef DEBUG_PYRAMID
    QImage image = m_pyramid[ORIGINAL_INDEX]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
    image.save("./PYRAMID_BASE.png");
 
    image = m_pyramid[1]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
    image.save("./LEVEL1.png");
 
    image = m_pyramid[2]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
    image.save("./LEVEL2.png");
    image = m_pyramid[3]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
    image.save("./LEVEL3.png");
#endif
}

References downsampleByFactor2(), FIRST_NOT_ORIGINAL_INDEX, m_conversionFlags, m_monitorProfile, m_pyramid, m_pyramidHeight, m_renderingIntent, and ORIGINAL_INDEX.

retrieveImageData()

void KisImagePyramid::retrieveImageData ( const QRect & rect )

private

Definition at line 213 of file kis_image_pyramid.cpp.

{
    // XXX: use QThreadStorage to cache the two patches (512x512) of pixels. Note
    // that when we do that, we need to reset that cache when the projection's
    // colorspace changes.
    const KoColorSpace *projectionCs = m_originalImage->projection()->colorSpace();
    KisPaintDeviceSP originalProjection = m_originalImage->projection();
    quint32 numPixels = rect.width() * rect.height();
 
    std::unique_ptr<quint8[]> originalBytes(
        new quint8[originalProjection->colorSpace()->pixelSize() * numPixels]);
 
    originalProjection->readBytes(originalBytes.get(), rect);
 
    if (m_displayFilter &&
        m_useOcio &&
        projectionCs->colorModelId() == RGBAColorModelID) {
 
#ifdef HAVE_OCIO
        const KoColorProfile *destinationProfile =
            m_displayFilter->useInternalColorManagement() ?
            m_monitorProfile : projectionCs->profile();
 
        const KoColorSpace *floatCs =
            KoColorSpaceRegistry::instance()->colorSpace(
                RGBAColorModelID.id(),
                Float32BitsColorDepthID.id(),
                destinationProfile);
 
        const KoColorSpace *modifiedMonitorCs =
            KoColorSpaceRegistry::instance()->colorSpace(
                RGBAColorModelID.id(),
                Integer8BitsColorDepthID.id(),
                destinationProfile);
 
        if (projectionCs->colorDepthId() == Float32BitsColorDepthID) {
            m_displayFilter->filter(originalBytes.get(), numPixels);
        } else {
            std::unique_ptr<quint8[]> dst(new quint8[floatCs->pixelSize() * numPixels]);
            projectionCs->convertPixelsTo(originalBytes.get(), dst.get(), floatCs, numPixels, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
            m_displayFilter->filter(dst.get(), numPixels);
            originalBytes.swap(dst);
        }
 
        {
            std::unique_ptr<quint8[]> dst(new quint8[modifiedMonitorCs->pixelSize() * numPixels]);
            floatCs->convertPixelsTo(originalBytes.get(), dst.get(), modifiedMonitorCs, numPixels, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
            originalBytes.swap(dst);
        }
#endif
    }
    else {
        if (m_channelFlags.size() != projectionCs->channelCount()) {
            setChannelFlags(QBitArray());
        }
        if (!m_channelFlags.isEmpty() && !m_allChannelsSelected) {
            std::unique_ptr<quint8[]> dst(new quint8[projectionCs->pixelSize() * numPixels]);
 
            KisConfig cfg(true);
 
            if (m_onlyOneChannelSelected && !cfg.showSingleChannelAsColor()) {
                projectionCs->convertChannelToVisualRepresentation(originalBytes.get(), dst.get(), numPixels, m_selectedChannelIndex);
            }
            else {
                projectionCs->convertChannelToVisualRepresentation(originalBytes.get(), dst.get(), numPixels, m_channelFlags);
            }
            originalBytes.swap(dst);
        }
 
        std::unique_ptr<quint8[]> dst(new quint8[m_monitorColorSpace->pixelSize() * numPixels]);
        projectionCs->convertPixelsTo(originalBytes.get(), dst.get(), m_monitorColorSpace, numPixels, m_renderingIntent, m_conversionFlags);
        originalBytes.swap(dst);
    }
 
    m_pyramid[ORIGINAL_INDEX]->writeBytes(originalBytes.get(), rect);
}

References KoColorSpace::channelCount(), KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), KoColorSpaceRegistry::colorSpace(), KoColorSpace::convertChannelToVisualRepresentation(), KoColorSpace::convertPixelsTo(), Float32BitsColorDepthID, KoID::id(), KoColorSpaceRegistry::instance(), Integer8BitsColorDepthID, KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), m_allChannelsSelected, m_channelFlags, m_conversionFlags, m_displayFilter, m_monitorColorSpace, m_monitorProfile, m_onlyOneChannelSelected, m_originalImage, m_pyramid, m_renderingIntent, m_selectedChannelIndex, m_useOcio, ORIGINAL_INDEX, KoColorSpace::pixelSize(), KoColorSpace::profile(), KisImage::projection(), KisPaintDevice::readBytes(), RGBAColorModelID, setChannelFlags(), and KisConfig::showSingleChannelAsColor().

setChannelFlags()

void KisImagePyramid::setChannelFlags ( const QBitArray & channelFlags )

overridevirtual

Implements KisProjectionBackend.

Definition at line 119 of file kis_image_pyramid.cpp.

{
    m_channelFlags = channelFlags;
    int selectedChannels = 0;
    const KoColorSpace *projectionCs = m_originalImage->projection()->colorSpace();
    const QList<KoChannelInfo*> channelInfo = projectionCs->channels();
 
    if (channelInfo.size() != m_channelFlags.size()) {
        m_channelFlags = QBitArray();
    }
 
    for (int i = 0; i < m_channelFlags.size(); ++i) {
        if (m_channelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
            selectedChannels++;
            m_selectedChannelIndex = i;
        }
    }
    m_allChannelsSelected = (selectedChannels == m_channelFlags.size());
    m_onlyOneChannelSelected = (selectedChannels == 1);
}

References KoColorSpace::channels, KoChannelInfo::COLOR, KisPaintDevice::colorSpace(), m_allChannelsSelected, m_channelFlags, m_onlyOneChannelSelected, m_originalImage, m_selectedChannelIndex, and KisImage::projection().

setDisplayFilter()

void KisImagePyramid::setDisplayFilter ( QSharedPointer< KisDisplayFilter > displayFilter )

overridevirtual

Implements KisProjectionBackend.

Definition at line 140 of file kis_image_pyramid.cpp.

{
    m_displayFilter = displayFilter;
}

References m_displayFilter.

setImage()

void KisImagePyramid::setImage ( KisImageWSP image )

overridevirtual

Those methods are related to KisPrescaledProjection's equivalents

Implements KisProjectionBackend.

Definition at line 160 of file kis_image_pyramid.cpp.

{
    if (newImage) {
        m_originalImage = newImage;
 
        clearPyramid();
        setImageSize(m_originalImage->width(), m_originalImage->height());
 
        // Get the full image size
        QRect rc = m_originalImage->projection()->exactBounds();
 
        KisImageConfig config(true);
 
        int patchWidth = config.updatePatchWidth();
        int patchHeight = config.updatePatchHeight();
 
        if (rc.width() * rc.height() <= patchWidth * patchHeight) {
            retrieveImageData(rc);
        }
        else {
            qint32 firstCol = rc.x() / patchWidth;
            qint32 firstRow = rc.y() / patchHeight;
 
            qint32 lastCol = (rc.x() + rc.width()) / patchWidth;
            qint32 lastRow = (rc.y() + rc.height()) / patchHeight;
 
            for(qint32 i = firstRow; i <= lastRow; i++) {
                for(qint32 j = firstCol; j <= lastCol; j++) {
                    QRect maxPatchRect(j * patchWidth,
                                       i * patchHeight,
                                       patchWidth, patchHeight);
                    QRect patchRect = rc & maxPatchRect;
                    retrieveImageData(patchRect);
                }
            }
 
        }
        //TODO: check whether there is needed recalculateCache()
    }
}

References clearPyramid(), KisPaintDevice::exactBounds(), KisImage::height(), m_originalImage, KisImage::projection(), retrieveImageData(), setImageSize(), KisImageConfig::updatePatchHeight(), KisImageConfig::updatePatchWidth(), and KisImage::width().

setImageSize()

void KisImagePyramid::setImageSize ( qint32 w, qint32 h )

overridevirtual

Implements KisProjectionBackend.

Definition at line 201 of file kis_image_pyramid.cpp.

{
    Q_UNUSED(w);
    Q_UNUSED(h);
    /* nothing interesting */
}

setMonitorProfile()

void KisImagePyramid::setMonitorProfile ( const KoColorProfile * monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags )

overridevirtual

If you change pixel size here, don't forget to change it in optimized function downsamplePixels()

Implements KisProjectionBackend.

Definition at line 103 of file kis_image_pyramid.cpp.

{
    m_monitorProfile = monitorProfile;
    m_monitorColorSpace = KoColorSpaceRegistry::instance()->rgb8(monitorProfile);
    m_renderingIntent = renderingIntent;
    m_conversionFlags = conversionFlags;
 
    rebuildPyramid();
}

References KoColorSpaceRegistry::instance(), m_conversionFlags, m_monitorColorSpace, m_monitorProfile, m_renderingIntent, rebuildPyramid(), and KoColorSpaceRegistry::rgb8().

updateCache()

void KisImagePyramid::updateCache ( const QRect & dirtyImageRect )

overridevirtual

Updates the cache of the backend by reading from an associated image. All data transfers with KisImage should happen here

Implements KisProjectionBackend.

Definition at line 208 of file kis_image_pyramid.cpp.

{
    retrieveImageData(dirtyImageRect);
}

References retrieveImageData().

Member Data Documentation

m_allChannelsSelected

bool KisImagePyramid::m_allChannelsSelected {false}

private

Definition at line 126 of file kis_image_pyramid.h.

{false};

m_channelFlags

QBitArray KisImagePyramid::m_channelFlags

private

Definition at line 125 of file kis_image_pyramid.h.

m_conversionFlags

KoColorConversionTransformation::ConversionFlags KisImagePyramid::m_conversionFlags { KoColorConversionTransformation::Empty }

private

Definition at line 115 of file kis_image_pyramid.h.

{ KoColorConversionTransformation::Empty };

m_displayFilter

QSharedPointer<KisDisplayFilter> KisImagePyramid::m_displayFilter

private

Definition at line 112 of file kis_image_pyramid.h.

m_monitorColorSpace

const KoColorSpace* KisImagePyramid::m_monitorColorSpace {0}

private

Definition at line 110 of file kis_image_pyramid.h.

{0};

m_monitorProfile

const KoColorProfile* KisImagePyramid::m_monitorProfile {0}

private

Definition at line 109 of file kis_image_pyramid.h.

{0};

m_onlyOneChannelSelected

bool KisImagePyramid::m_onlyOneChannelSelected {false}

private

Definition at line 127 of file kis_image_pyramid.h.

{false};

m_originalImage

KisImageWSP KisImagePyramid::m_originalImage

private

Definition at line 107 of file kis_image_pyramid.h.

m_pyramid

QVector<KisPaintDeviceSP> KisImagePyramid::m_pyramid

private

Definition at line 106 of file kis_image_pyramid.h.

m_pyramidHeight

qint32 KisImagePyramid::m_pyramidHeight {0}

private

Number of planes inside pyramid

Definition at line 121 of file kis_image_pyramid.h.

{0};

m_renderingIntent

KoColorConversionTransformation::Intent KisImagePyramid::m_renderingIntent { KoColorConversionTransformation::IntentPerceptual }

private

Definition at line 114 of file kis_image_pyramid.h.

{ KoColorConversionTransformation::IntentPerceptual };

m_selectedChannelIndex

int KisImagePyramid::m_selectedChannelIndex {-1}

private

Definition at line 128 of file kis_image_pyramid.h.

{-1};

m_useOcio

bool KisImagePyramid::m_useOcio {false}

private

Definition at line 123 of file kis_image_pyramid.h.

{false};

---

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

• libs/ui/canvas/kis_image_pyramid.h
• libs/ui/canvas/kis_image_pyramid.cpp