KisPrescaledProjection Class Reference

#include <kis_prescaled_projection.h>

Inheritance diagram for KisPrescaledProjection:

Classes
struct	Private

Public Slots
void	notifyCanvasSizeChanged (const QSize &widgetSize)
void	notifyCanvasStateChanged (const KisCanvasState &state)
void	preScale ()
void	recalculateCache (KisUpdateInfoSP info)
void	setChannelFlags (const QBitArray &channelFlags)
void	setDisplayConfig (const KisDisplayConfig &config)
void	setDisplayFilter (QSharedPointer< KisDisplayFilter > displayFilter)
void	slotImageSizeChanged (qint32 w, qint32 h)
KisUpdateInfoSP	updateCache (const QRect &dirtyImageRect)
void	updateSettings ()

Public Member Functions
	KisPrescaledProjection ()
QImage	prescaledQImage () const
void	setCoordinatesConverter (KisCoordinatesConverter *coordinatesConverter)
void	setImage (KisImageWSP image)
	~KisPrescaledProjection () override
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Private Member Functions
void	drawUsingBackend (QPainter &gc, KisPPUpdateInfoSP info)
void	fillInUpdateInformation (const QRect &viewportRect, KisPPUpdateInfoSP info)
KisPPUpdateInfoSP	getInitialUpdateInformation (const QRect &dirtyImageRect)
	KisPrescaledProjection (const KisPrescaledProjection &)
KisPrescaledProjection	operator= (const KisPrescaledProjection &)
void	updateScaledImage (KisPPUpdateInfoSP info)
void	updateViewportSize ()
void	viewportMoved (const QPointF &offset)

Private Attributes
Private *const	m_d

Friends
class	KisPrescaledProjectionTest

Additional Inherited Members
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Detailed Description

KisPrescaledProjection is responsible for keeping around a prescaled QImage representation that is always suitable for painting onto the canvas.

Note: the export macro is only for the unittest.

Definition at line 37 of file kis_prescaled_projection.h.

Constructor & Destructor Documentation

KisPrescaledProjection() [1/2]

KisPrescaledProjection::KisPrescaledProjection

(

)

Definition at line 117 of file kis_prescaled_projection.cpp.

        : QObject(0)
        , m_d(new Private())
{
    updateSettings();
 
    // we disable building the pyramid with setting its height to 1
    // XXX: setting it higher than 1 is broken because it's not updated until you show/hide the layer
    m_d->projectionBackend = new KisImagePyramid(1);
 
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(updateSettings()));
}

References connect(), KisConfigNotifier::instance(), m_d, KisPrescaledProjection::Private::projectionBackend, and updateSettings().

~KisPrescaledProjection()

KisPrescaledProjection::~KisPrescaledProjection ( )

override

Definition at line 130 of file kis_prescaled_projection.cpp.

{
    delete m_d->projectionBackend;
    delete m_d;
}

References m_d, and KisPrescaledProjection::Private::projectionBackend.

KisPrescaledProjection() [2/2]

KisPrescaledProjection::KisPrescaledProjection ( const KisPrescaledProjection & )

private

Member Function Documentation

drawUsingBackend()

void KisPrescaledProjection::drawUsingBackend ( QPainter & gc, KisPPUpdateInfoSP info )

private

Actual drawing is done here

Parameters

info	prepared information
gc	The painter we draw on

Definition at line 426 of file kis_prescaled_projection.cpp.

{
    if (info->imageRect.isEmpty()) return;
 
    if (info->transfer == KisPPUpdateInfo::DIRECT) {
        m_d->projectionBackend->drawFromOriginalImage(gc, info);
    } else /* if info->transfer == KisPPUpdateInformation::PATCH */ {
        KisImagePatch patch = m_d->projectionBackend->getNearestPatch(info);
        // prescale the patch because otherwise we'd scale using QPainter, which gives
        // a crap result compared to QImage's smoothscale
        patch.preScale(info->viewportRect);
        patch.drawMe(gc, info->viewportRect, info->renderHints);
    }
}

References KisPPUpdateInfo::DIRECT, KisProjectionBackend::drawFromOriginalImage(), KisImagePatch::drawMe(), KisProjectionBackend::getNearestPatch(), m_d, KisImagePatch::preScale(), and KisPrescaledProjection::Private::projectionBackend.

fillInUpdateInformation()

void KisPrescaledProjection::fillInUpdateInformation ( const QRect & viewportRect, KisPPUpdateInfoSP info )

private

Prepare all the information about rects needed during projection updating.

Parameters

viewportRect	the part of the viewport that has to be updated
info	the structure to be filled in. It's member dirtyImageRect is supposed to have already been set up in the previous step of the update in getInitialUpdateInformation(). Though it is allowed to be null rect.

See also

getInitialUpdateInformation()

To avoid artifacts while scaling we use mechanism like changeRect/needRect for layers. Here we grow the rect to update pixels which depend on the dirty rect (like changeRect), and later we request a bit more pixels for the patch to make the scaling safe (like needRect).

Definition at line 365 of file kis_prescaled_projection.cpp.

{
    m_d->coordinatesConverter->imageScale(&info->scaleX, &info->scaleY);
 
    // first, crop the part of the view rect that is outside of the canvas
    QRect croppedViewRect = viewportRect.intersected(QRect(QPoint(0, 0), m_d->viewportSize));
 
    // second, align this rect to the KisImage's pixels and pixels
    // of projection backend.
    info->imageRect = m_d->coordinatesConverter->viewportToImage(QRectF(croppedViewRect)).toAlignedRect();
 
    const int borderSize = BORDER_SIZE(qMax(info->scaleX, info->scaleY));
    info->imageRect.adjust(-borderSize, -borderSize, borderSize, borderSize);
 
    info->imageRect = info->imageRect & m_d->image->bounds();
 
    m_d->projectionBackend->alignSourceRect(info->imageRect, info->scaleX);
 
    // finally, compute the dirty rect of the canvas
    info->viewportRect = m_d->coordinatesConverter->imageToViewport(info->imageRect);
 
    info->borderWidth = 0;
    if (SCALE_MORE_OR_EQUAL_TO(info->scaleX, info->scaleY, 1.0)) {
        if (SCALE_LESS_THAN(info->scaleX, info->scaleY, 2.0)) {
            dbgRender << "smoothBetween100And200Percent" << Qt::endl;
            info->renderHints = QPainter::SmoothPixmapTransform;
            info->borderWidth = borderSize;
        }
        info->transfer = KisPPUpdateInfo::DIRECT;
    } else { // <100%
        info->renderHints = QPainter::SmoothPixmapTransform;
        info->borderWidth = borderSize;
        info->transfer = KisPPUpdateInfo::PATCH;
    }
 
    dbgRender << "#####################################";
    dbgRender << ppVar(info->scaleX) << ppVar(info->scaleY);
    dbgRender << ppVar(info->borderWidth) << ppVar(info->renderHints);
    dbgRender << ppVar(info->transfer);
    dbgRender << ppVar(info->dirtyImageRectVar);
    dbgRender << "Not aligned rect of the canvas (raw):\t" << croppedViewRect;
    dbgRender << "Update rect in KisImage's pixels:\t" << info->imageRect;
    dbgRender << "Update rect in canvas' pixels:\t" << info->viewportRect;
    dbgRender << "#####################################";
}

References KisProjectionBackend::alignSourceRect(), BORDER_SIZE, KisImage::bounds(), KisPrescaledProjection::Private::coordinatesConverter, dbgRender, KisPPUpdateInfo::DIRECT, KisPrescaledProjection::Private::image, KisCoordinatesConverter::imageScale(), KisCoordinatesConverter::imageToViewport(), m_d, KisPPUpdateInfo::PATCH, ppVar, KisPrescaledProjection::Private::projectionBackend, SCALE_LESS_THAN, SCALE_MORE_OR_EQUAL_TO, KisPrescaledProjection::Private::viewportSize, and KisCoordinatesConverter::viewportToImage().

getInitialUpdateInformation()

KisPPUpdateInfoSP KisPrescaledProjection::getInitialUpdateInformation ( const QRect & dirtyImageRect )

private

This creates an empty update information and fills it with the only parameter: dirtyImageRect This function is supposed to be run in the context of the image threads, so it does no accesses to zoom or any UI specific values. All the needed information for zooming will be fetched in the context of the UI thread in fillInUpdateInformation().

See also

fillInUpdateInformation()

This update information has nothing more than an information about dirty image rect. All the other information used for scaling will be fetched in fillUpdateInformation() later, when we are working in the context of the UI thread

Definition at line 350 of file kis_prescaled_projection.cpp.

{
    KisPPUpdateInfoSP info = new KisPPUpdateInfo();
    info->dirtyImageRectVar = dirtyImageRect;
 
    return info;
}

notifyCanvasSizeChanged

void KisPrescaledProjection::notifyCanvasSizeChanged ( const QSize & widgetSize )

slot

Checks whether it is needed to resize the prescaled image and updates it. The size is given in canvas widget pixels.

Definition at line 343 of file kis_prescaled_projection.cpp.

{
    m_d->canvasSize = widgetSize;
    updateViewportSize();
    preScale();
}

References KisPrescaledProjection::Private::canvasSize, m_d, preScale(), and updateViewportSize().

notifyCanvasStateChanged

void KisPrescaledProjection::notifyCanvasStateChanged ( const KisCanvasState & state )

slot

Definition at line 162 of file kis_prescaled_projection.cpp.

{
    auto relevantState = RelevantCanvasState::fromCanvasState(state);
 
    if (m_d->currentRelevantCanvasState == relevantState) return;
 
    if (!m_d->currentRelevantCanvasState ||
        m_d->currentRelevantCanvasState->transformations() != relevantState.transformations()) {
 
        updateViewportSize();
        preScale();
    } else {
        const QPointF moveOffset = m_d->currentRelevantCanvasState->viewportOffsetF - relevantState.viewportOffsetF;
        viewportMoved(-moveOffset);
    }
 
    m_d->currentRelevantCanvasState = relevantState;
}

References KisPrescaledProjection::Private::currentRelevantCanvasState, m_d, preScale(), updateViewportSize(), and viewportMoved().

operator=()

KisPrescaledProjection KisPrescaledProjection::operator= ( const KisPrescaledProjection & )

private

preScale

void KisPrescaledProjection::preScale ( )

slot

Called whenever the zoom level changes or another chunk of the image becomes visible. The currently visible area of the image is complete scaled again.

Definition at line 286 of file kis_prescaled_projection.cpp.

{
    if (!m_d->image) return;
 
    m_d->prescaledQImage.fill(0);
 
    QRect viewportRect(QPoint(0, 0), m_d->viewportSize);
    QRect imageRect =
        m_d->coordinatesConverter->viewportToImage(viewportRect).toAlignedRect();
 
    QVector<QRect> patches =
        KritaUtils::splitRectIntoPatches(imageRect, m_d->updatePatchSize);
 
    Q_FOREACH (const QRect& rc, patches) {
        QRect viewportPatch = m_d->coordinatesConverter->imageToViewport(rc).toAlignedRect();
        KisPPUpdateInfoSP info = getInitialUpdateInformation(QRect());
        fillInUpdateInformation(viewportPatch, info);
        QPainter gc(&m_d->prescaledQImage);
        gc.setCompositionMode(QPainter::CompositionMode_Source);
        drawUsingBackend(gc, info);
    }
 
}

References KisPrescaledProjection::Private::coordinatesConverter, drawUsingBackend(), fillInUpdateInformation(), getInitialUpdateInformation(), KisPrescaledProjection::Private::image, KisCoordinatesConverter::imageToViewport(), m_d, KisPrescaledProjection::Private::prescaledQImage, KritaUtils::splitRectIntoPatches(), KisPrescaledProjection::Private::updatePatchSize, KisPrescaledProjection::Private::viewportSize, and KisCoordinatesConverter::viewportToImage().

prescaledQImage()

QImage KisPrescaledProjection::prescaledQImage

(

)

const

Return the prescaled QImage. The prescaled image is exactly as big as the canvas widget in pixels.

Definition at line 144 of file kis_prescaled_projection.cpp.

{
    return m_d->prescaledQImage;
}

References m_d, and KisPrescaledProjection::Private::prescaledQImage.

recalculateCache

void KisPrescaledProjection::recalculateCache ( KisUpdateInfoSP info )

slot

Updates the prescaled cache at current zoom level

Parameters

info	update structure returned by updateCache

See also

updateCache

Definition at line 269 of file kis_prescaled_projection.cpp.

{
    KisPPUpdateInfoSP ppInfo = dynamic_cast<KisPPUpdateInfo*>(info.data());
    if(!ppInfo) return;
 
    QRect rawViewRect =
        m_d->coordinatesConverter->
        imageToViewport(ppInfo->dirtyImageRectVar).toAlignedRect();
 
    fillInUpdateInformation(rawViewRect, ppInfo);
 
    m_d->projectionBackend->recalculateCache(ppInfo);
 
    if(!info->dirtyViewportRect().isEmpty())
        updateScaledImage(ppInfo);
}

References KisPrescaledProjection::Private::coordinatesConverter, KisSharedPtr< T >::data(), fillInUpdateInformation(), m_d, KisPrescaledProjection::Private::projectionBackend, KisProjectionBackend::recalculateCache(), and updateScaledImage().

setChannelFlags

void KisPrescaledProjection::setChannelFlags ( const QBitArray & channelFlags )

slot

Definition at line 315 of file kis_prescaled_projection.cpp.

{
    m_d->projectionBackend->setChannelFlags(channelFlags);
}

References m_d, KisPrescaledProjection::Private::projectionBackend, and KisProjectionBackend::setChannelFlags().

setCoordinatesConverter()

void KisPrescaledProjection::setCoordinatesConverter

(

KisCoordinatesConverter *

coordinatesConverter

)

Definition at line 149 of file kis_prescaled_projection.cpp.

{
    m_d->coordinatesConverter = coordinatesConverter;
    m_d->currentRelevantCanvasState = RelevantCanvasState::fromCanvasState(KisCanvasState::fromConverter(*coordinatesConverter));
}

References KisPrescaledProjection::Private::coordinatesConverter, KisPrescaledProjection::Private::currentRelevantCanvasState, KisCanvasState::fromConverter(), and m_d.

setDisplayConfig

void KisPrescaledProjection::setDisplayConfig ( const KisDisplayConfig & config )

slot

Set the current monitor profile

Definition at line 310 of file kis_prescaled_projection.cpp.

{
    m_d->projectionBackend->setMonitorProfile(config.profile, config.intent, config.conversionFlags);
}

References KisDisplayConfig::conversionFlags, KisDisplayConfig::intent, m_d, KisDisplayConfig::profile, KisPrescaledProjection::Private::projectionBackend, and KisProjectionBackend::setMonitorProfile().

setDisplayFilter

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

slot

Definition at line 320 of file kis_prescaled_projection.cpp.

{
    m_d->projectionBackend->setDisplayFilter(displayFilter);
}

References m_d, KisPrescaledProjection::Private::projectionBackend, and KisProjectionBackend::setDisplayFilter().

setImage()

void KisPrescaledProjection::setImage

(

KisImageWSP

image

)

Definition at line 137 of file kis_prescaled_projection.cpp.

{
    Q_ASSERT(image);
    m_d->image = image;
    m_d->projectionBackend->setImage(image);
}

References KisPrescaledProjection::Private::image, m_d, KisPrescaledProjection::Private::projectionBackend, and KisProjectionBackend::setImage().

slotImageSizeChanged

void KisPrescaledProjection::slotImageSizeChanged ( qint32 w, qint32 h )

slot

Called whenever the size of the KisImage changes. It is a part of a complex update ritual, when the size of the image changes. This method just resizes the storage for the image cache, it doesn't update any cached data.

Definition at line 240 of file kis_prescaled_projection.cpp.

{
    m_d->projectionBackend->setImageSize(w, h);
    // viewport size is cropped by the size of the image
    // so we need to update it as well
    updateViewportSize();
}

References m_d, KisPrescaledProjection::Private::projectionBackend, KisProjectionBackend::setImageSize(), and updateViewportSize().

updateCache

KisUpdateInfoSP KisPrescaledProjection::updateCache ( const QRect & dirtyImageRect )

slot

Retrieves image's data from KisImage object and updates internal cache

Parameters

dirtyImageRect

the rect changed on the image

See also

recalculateCache

We needn't this stuff outside KisImage's area. We're not displaying anything painted outside the image anyway.

Definition at line 248 of file kis_prescaled_projection.cpp.

{
    if (!m_d->image) {
        dbgRender.noquote() << "Calling updateCache without an image:" << kisBacktrace() << Qt::endl;
        // return invalid info
        return new KisPPUpdateInfo();
    }
 
    QRect croppedImageRect = dirtyImageRect & m_d->image->bounds();
    if (croppedImageRect.isEmpty()) return new KisPPUpdateInfo();
 
    KisPPUpdateInfoSP info = getInitialUpdateInformation(croppedImageRect);
    m_d->projectionBackend->updateCache(croppedImageRect);
 
    return info;
}

References KisImage::bounds(), dbgRender, getInitialUpdateInformation(), KisPrescaledProjection::Private::image, kisBacktrace(), m_d, KisPrescaledProjection::Private::projectionBackend, and KisProjectionBackend::updateCache().

updateScaledImage()

void KisPrescaledProjection::updateScaledImage ( KisPPUpdateInfoSP info )

private

Initiates the process of prescaled image update

Parameters

info	prepared information

Definition at line 419 of file kis_prescaled_projection.cpp.

{
    QPainter gc(&m_d->prescaledQImage);
    gc.setCompositionMode(QPainter::CompositionMode_Source);
    drawUsingBackend(gc, info);
}

References drawUsingBackend(), m_d, and KisPrescaledProjection::Private::prescaledQImage.

updateSettings

void KisPrescaledProjection::updateSettings ( )

slot

Called whenever the configuration settings change.

Definition at line 155 of file kis_prescaled_projection.cpp.

{
    KisImageConfig imageConfig(false);
    m_d->updatePatchSize.setWidth(imageConfig.updatePatchWidth());
    m_d->updatePatchSize.setHeight(imageConfig.updatePatchHeight());
}

References m_d, KisImageConfig::updatePatchHeight(), KisPrescaledProjection::Private::updatePatchSize, and KisImageConfig::updatePatchWidth().

updateViewportSize()

void KisPrescaledProjection::updateViewportSize ( )

private

Definition at line 326 of file kis_prescaled_projection.cpp.

{
    QRect imageRect = m_d->coordinatesConverter->imageRectInWidgetPixels().toAlignedRect();
    QSizeF minimalSize(qMin(imageRect.width(), m_d->canvasSize.width()),
                       qMin(imageRect.height(), m_d->canvasSize.height()));
    QRectF minimalRect(QPointF(0,0), minimalSize);
 
    m_d->viewportSize = m_d->coordinatesConverter->widgetToViewport(minimalRect).toAlignedRect().size();
 
    if (m_d->prescaledQImage.isNull() ||
        m_d->prescaledQImage.size() != m_d->viewportSize) {
 
        m_d->prescaledQImage = QImage(m_d->viewportSize, QImage::Format_ARGB32);
        m_d->prescaledQImage.fill(0);
    }
}

References KisPrescaledProjection::Private::canvasSize, KisPrescaledProjection::Private::coordinatesConverter, KisCoordinatesConverter::imageRectInWidgetPixels(), m_d, KisPrescaledProjection::Private::prescaledQImage, KisPrescaledProjection::Private::viewportSize, and KisCoordinatesConverter::widgetToViewport().

viewportMoved()

void KisPrescaledProjection::viewportMoved ( const QPointF & offset )

private

Called whenever the view widget needs to show a different part of the document

We can't optimize anything when offset is float :( Just prescale entire image.

TODO: viewport rects should be cropped by the borders of the image, because it may be requested to read/write outside QImage and copyQImage will not catch it

Definition at line 181 of file kis_prescaled_projection.cpp.

{
    // FIXME: \|/
    if (m_d->prescaledQImage.isNull()) return;
    if (offset.isNull()) return;
 
    QPoint alignedOffset = offset.toPoint();
 
    if(offset != alignedOffset) {
        dbgRender << "prescaling the entire image because the offset is float";
        preScale();
        return;
    }
 
    QImage newImage = QImage(m_d->viewportSize, QImage::Format_ARGB32);
    newImage.fill(0);
 
    QRect newViewportRect = QRect(QPoint(0,0), m_d->viewportSize);
    QRect oldViewportRect = newViewportRect.translated(alignedOffset);
 
    QRegion updateRegion = newViewportRect;
    QRect savedArea = newViewportRect & oldViewportRect;
    if(!savedArea.isEmpty()) {
        copyQImage(alignedOffset.x(), alignedOffset.y(), &newImage, m_d->prescaledQImage);
        updateRegion -= savedArea;
    }
 
    QPainter gc(&newImage);
    auto rc = updateRegion.begin();
    while (rc != updateRegion.end()) {
        QRect rect = *rc;
        QRect imageRect =
            m_d->coordinatesConverter->viewportToImage(rect).toAlignedRect();
        QVector<QRect> patches =
            KritaUtils::splitRectIntoPatches(imageRect, m_d->updatePatchSize);
 
        Q_FOREACH (const QRect& rc, patches) {
            QRect viewportPatch =
                m_d->coordinatesConverter->imageToViewport(rc).toAlignedRect();
 
            KisPPUpdateInfoSP info = getInitialUpdateInformation(QRect());
            fillInUpdateInformation(viewportPatch, info);
            drawUsingBackend(gc, info);
        }
        rc++;
    }
 
    m_d->prescaledQImage = newImage;
}

References KisPrescaledProjection::Private::coordinatesConverter, copyQImage(), dbgRender, drawUsingBackend(), fillInUpdateInformation(), getInitialUpdateInformation(), KisCoordinatesConverter::imageToViewport(), m_d, preScale(), KisPrescaledProjection::Private::prescaledQImage, KritaUtils::splitRectIntoPatches(), KisPrescaledProjection::Private::updatePatchSize, KisPrescaledProjection::Private::viewportSize, and KisCoordinatesConverter::viewportToImage().

Friends And Related Symbol Documentation

KisPrescaledProjectionTest

friend class KisPrescaledProjectionTest

friend

Definition at line 111 of file kis_prescaled_projection.h.

Member Data Documentation

m_d

Private* const KisPrescaledProjection::m_d

private

Definition at line 166 of file kis_prescaled_projection.h.

---

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

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