kis_transform_worker.cc File Reference

#include "kis_transform_worker.h"
#include <qmath.h>
#include <klocalizedstring.h>
#include <QTransform>
#include <KoColorSpace.h>
#include <KoCompositeOpRegistry.h>
#include <KoColor.h>
#include "kis_paint_device.h"
#include "kis_debug.h"
#include "kis_selection.h"
#include "kis_iterator_ng.h"
#include "kis_random_accessor_ng.h"
#include "kis_filter_strategy.h"
#include "kis_painter.h"
#include "kis_filter_weights_applicator.h"
#include "kis_progress_update_helper.h"
#include "kis_pixel_selection.h"
#include "kis_image.h"

Go to the source code of this file.

Functions
template<class iter >
void	calcDimensions (QRect rc, qint32 &srcStart, qint32 &srcLen, qint32 &firstLine, qint32 &numLines)
template<>
void	calcDimensions< KisHLineIteratorSP > (QRect rc, qint32 &srcStart, qint32 &srcLen, qint32 &firstLine, qint32 &numLines)
template<>
void	calcDimensions< KisVLineIteratorSP > (QRect rc, qint32 &srcStart, qint32 &srcLen, qint32 &firstLine, qint32 &numLines)
void	mirror_impl (KisPaintDeviceSP dev, qreal axis, bool isHorizontal)
QRect	rotateWithTf (int rotation, KisPaintDeviceSP dev, QRect boundRect, KoUpdaterPtr progressUpdater, int portion)
template<typename T >
void	swapValues (T *a, T *b)
template<class iter >
void	updateBounds (QRect &boundRect, const KisFilterWeightsApplicator::LinePos &newBounds)
template<>
void	updateBounds< KisHLineIteratorSP > (QRect &boundRect, const KisFilterWeightsApplicator::LinePos &newBounds)
template<>
void	updateBounds< KisVLineIteratorSP > (QRect &boundRect, const KisFilterWeightsApplicator::LinePos &newBounds)

Function Documentation

calcDimensions()

template<class iter >

void calcDimensions	(	QRect	rc,
		qint32 &	srcStart,
		qint32 &	srcLen,
		qint32 &	firstLine,
		qint32 &	numLines )

calcDimensions< KisHLineIteratorSP >()

template<>

void calcDimensions< KisHLineIteratorSP >	(	QRect	rc,
		qint32 &	srcStart,
		qint32 &	srcLen,
		qint32 &	firstLine,
		qint32 &	numLines )

Definition at line 155 of file kis_transform_worker.cc.

{
    srcStart = rc.x();
    srcLen = rc.width();
    firstLine = rc.y();
    numLines = rc.height();
}

calcDimensions< KisVLineIteratorSP >()

template<>

void calcDimensions< KisVLineIteratorSP >	(	QRect	rc,
		qint32 &	srcStart,
		qint32 &	srcLen,
		qint32 &	firstLine,
		qint32 &	numLines )

Definition at line 164 of file kis_transform_worker.cc.

{
    srcStart = rc.y();
    srcLen = rc.height();
    firstLine = rc.x();
    numLines = rc.width();
 
}

mirror_impl()

void mirror_impl	(	KisPaintDeviceSP	dev,
		qreal	axis,
		bool	isHorizontal )

We split the total mirror rect into two halves, which lay to the 'left' and 'right' from the axis. Effectively, these halves should be swapped, but there is a bit of optimization: some parts of these portions overlap and some don't. So former ones should be really swapped, but the latter ones just moved to the other side.

So the algorithm consists of two stages:

1) Move the non-overlapping portion of the mirror rect to the other side of the axis. The move may be either left-to-right or right-to-left.

2) Use slow 'swap' operation for the remaining portion of the mirrorRect.

NOTE: the algorithm works with (column, row) coordinates which are mapped to the real (x, y) depending on the value of 'isHorizontal' parameter.

If the axis is not aligned, that is crosses some pixel cell, we should just skip this column and not process it. Actually, how can we mirror the central single-pixel column?

Definition at line 444 of file kis_transform_worker.cc.

{
    KIS_ASSERT_RECOVER_RETURN(qFloor(axis) == axis || (axis - qFloor(axis) == 0.5));
 
    QRect mirrorRect = dev->exactBounds();
    if (mirrorRect.width() <= 1) return;
 
    int leftStart;
    int rightEnd;
 
    if (isHorizontal) {
        leftStart = mirrorRect.x();
        rightEnd = mirrorRect.x() + mirrorRect.width();
    } else {
        leftStart = mirrorRect.y();
        rightEnd = mirrorRect.y() + mirrorRect.height();
    }
 
    const bool axisNonAligned = qFloor(axis) < axis;
 
    int leftCenterPoint = qFloor(axis);
    int leftEnd = qMin(leftCenterPoint, rightEnd);
 
    int rightCenterPoint = axisNonAligned ? qCeil(axis) : qFloor(axis);
    int rightStart = qMax(rightCenterPoint, leftStart);
 
    int leftSize = qMax(0, leftEnd - leftStart);
    int rightSize = qMax(0, rightEnd - rightStart);
 
    int maxDistanceToAxis = qMax(leftCenterPoint - leftStart,
                           rightEnd - rightCenterPoint);
 
 
    // Main variables for controlling the stages of the algorithm
    bool moveLeftToRight = leftSize > rightSize;
    int moveAmount = qAbs(leftSize - rightSize);
    int swapAmount = qMin(leftSize, rightSize);
 
    // Initial position of 'left' and 'right' block iterators
    int initialLeftCol = leftCenterPoint - maxDistanceToAxis;
    int initialRightCol = rightCenterPoint + maxDistanceToAxis - 1;
 
 
    KisRandomAccessorSP leftIt = dev->createRandomAccessorNG();
    KisRandomAccessorSP rightIt = dev->createRandomAccessorNG();
    const KoColor defaultPixelObject = dev->defaultPixel();
    const quint8 *defaultPixel = defaultPixelObject.data();
 
    const int pixelSize = dev->pixelSize();
    QByteArray buf(pixelSize, 0);
 
    // Map (column, row) -> (x, y)
    int rowsRemaining;
    int row;
 
    if (isHorizontal) {
        rowsRemaining = mirrorRect.height();
        row = mirrorRect.y();
    } else {
        rowsRemaining = mirrorRect.width();
        row = mirrorRect.x();
    }
 
    int leftColPos = 0;
    int rightColPos = 0;
 
    const int &leftX = isHorizontal ? leftColPos : row;
    const int &leftY = isHorizontal ? row : leftColPos;
 
    const int &rightX = isHorizontal ? rightColPos : row;
    const int &rightY = isHorizontal ? row : rightColPos;
 
    while (rowsRemaining) {
        leftColPos = initialLeftCol;
        rightColPos = initialRightCol;
 
        int rows = qMin(rowsRemaining, isHorizontal ? leftIt->numContiguousRows(leftY) : leftIt->numContiguousColumns(leftX));
        int rowStride = isHorizontal ? leftIt->rowStride(leftX, leftY) : pixelSize;
 
        if (moveLeftToRight) {
            for (int i = 0; i < moveAmount; i++) {
                leftIt->moveTo(leftX, leftY);
                rightIt->moveTo(rightX, rightY);
 
                quint8 *leftPtr = leftIt->rawData();
                quint8 *rightPtr = rightIt->rawData();
 
                for (int j = 0; j < rows; j++) {
                    // left-to-right move
                    memcpy(rightPtr, leftPtr, pixelSize);
                    memcpy(leftPtr, defaultPixel, pixelSize);
 
                    leftPtr += rowStride;
                    rightPtr += rowStride;
                }
 
                leftColPos++;
                rightColPos--;
            }
        } else {
            for (int i = 0; i < moveAmount; i++) {
                leftIt->moveTo(leftX, leftY);
                rightIt->moveTo(rightX, rightY);
 
                quint8 *leftPtr = leftIt->rawData();
                quint8 *rightPtr = rightIt->rawData();
 
                for (int j = 0; j < rows; j++) {
                    // right-to-left move
                    memcpy(leftPtr, rightPtr, pixelSize);
                    memcpy(rightPtr, defaultPixel, pixelSize);
 
                    leftPtr += rowStride;
                    rightPtr += rowStride;
                }
 
                leftColPos++;
                rightColPos--;
            }
        }
 
        for (int i = 0; i < swapAmount; i++) {
            leftIt->moveTo(leftX, leftY);
            rightIt->moveTo(rightX, rightY);
 
            quint8 *leftPtr = leftIt->rawData();
            quint8 *rightPtr = rightIt->rawData();
 
            for (int j = 0; j < rows; j++) {
                // swap operation
                memcpy(buf.data(), leftPtr, pixelSize);
                memcpy(leftPtr, rightPtr, pixelSize);
                memcpy(rightPtr, buf.data(), pixelSize);
 
                leftPtr += rowStride;
                rightPtr += rowStride;
            }
 
            leftColPos++;
            rightColPos--;
        }
 
        rowsRemaining -= rows;
        row += rows;
    }
}

References KisPaintDevice::createRandomAccessorNG(), KoColor::data(), KisPaintDevice::defaultPixel(), KisPaintDevice::exactBounds(), KIS_ASSERT_RECOVER_RETURN, KisRandomConstAccessorNG::moveTo(), KisRandomConstAccessorNG::numContiguousColumns(), KisRandomConstAccessorNG::numContiguousRows(), KisPaintDevice::pixelSize(), KisBaseAccessor::rawData(), and KisRandomConstAccessorNG::rowStride().

rotateWithTf()

QRect rotateWithTf	(	int	rotation,
		KisPaintDeviceSP	dev,
		QRect	boundRect,
		KoUpdaterPtr	progressUpdater,
		int	portion )

Definition at line 77 of file kis_transform_worker.cc.

{
    qint32 pixelSize = dev->pixelSize();
    QRect r(boundRect);
 
    KisPaintDeviceSP tmp = new KisPaintDevice(dev->colorSpace());
    tmp->prepareClone(dev);
 
    KisRandomAccessorSP devAcc = dev->createRandomAccessorNG();
    KisRandomAccessorSP tmpAcc = tmp->createRandomAccessorNG();
    KisProgressUpdateHelper progressHelper(progressUpdater, portion, r.height());
 
    QTransform tf;
    tf = tf.rotate(rotation);
 
    int ty = 0;
    int tx = 0;
 
    for (qint32 y = r.y(); y <= r.height() + r.y(); ++y) {
        for (qint32 x = r.x(); x <= r.width() + r.x(); ++x) {
            tf.map(x, y, &tx, &ty);
            devAcc->moveTo(x, y);
            tmpAcc->moveTo(tx, ty);
 
            memcpy(tmpAcc->rawData(), devAcc->rawData(), pixelSize);
        }
        progressHelper.step();
    }
 
    dev->makeCloneFrom(tmp, tmp->region().boundingRect());
    return r;
}

References KisPaintDevice::colorSpace(), KisPaintDevice::createRandomAccessorNG(), KisPaintDevice::makeCloneFrom(), KisRandomConstAccessorNG::moveTo(), KisPaintDevice::pixelSize(), KisBaseAccessor::rawData(), and KisProgressUpdateHelper::step().

swapValues()

template<typename T >

void swapValues	(	T *	a,
		T *	b )

Definition at line 223 of file kis_transform_worker.cc.

                            {
    T c = *a;
    *a = *b;
    *b = c;
}

updateBounds()

template<class iter >

void updateBounds	(	QRect &	boundRect,
		const KisFilterWeightsApplicator::LinePos &	newBounds )

updateBounds< KisHLineIteratorSP >()

template<>

void updateBounds< KisHLineIteratorSP >	(	QRect &	boundRect,
		const KisFilterWeightsApplicator::LinePos &	newBounds )

Definition at line 179 of file kis_transform_worker.cc.

{
    boundRect.setLeft(newBounds.start());
    boundRect.setWidth(newBounds.size());
}

References KisFilterWeightsApplicator::LinePos::size(), and KisFilterWeightsApplicator::LinePos::start().

updateBounds< KisVLineIteratorSP >()

template<>

void updateBounds< KisVLineIteratorSP >	(	QRect &	boundRect,
		const KisFilterWeightsApplicator::LinePos &	newBounds )

Definition at line 186 of file kis_transform_worker.cc.

{
    boundRect.setTop(newBounds.start());
    boundRect.setHeight(newBounds.size());
}

References KisFilterWeightsApplicator::LinePos::size(), and KisFilterWeightsApplicator::LinePos::start().