KisTransformWorker Class Reference

#include <kis_transform_worker.h>

Public Member Functions
bool	forceSubPixelTranslation () const
	KisTransformWorker (KisPaintDeviceSP dev, double xscale, double yscale, double xshear, double yshear, double rotation, qreal xtranslate, qreal ytranslate, KoUpdaterPtr progress, KisFilterStrategy *filter)
bool	run ()
bool	runPartial (const QRect &processRect)
void	setForceSubPixelTranslation (bool value)
QTransform	transform () const
void	transformPixelSelectionOutline (KisPixelSelectionSP pixelSelection) const
	~KisTransformWorker ()

Static Public Member Functions
static void	mirror (KisPaintDeviceSP dev, qreal axis, Qt::Orientation orientation)
static void	mirrorX (KisPaintDeviceSP dev)
static void	mirrorX (KisPaintDeviceSP dev, qreal axis)
static void	mirrorY (KisPaintDeviceSP dev)
static void	mirrorY (KisPaintDeviceSP dev, qreal axis)
static void	offset (KisPaintDeviceSP device, const QPoint &offsetPosition, const QRect &wrapRect)

Private Member Functions
template<class T >
void	transformPass (KisPaintDevice *src, KisPaintDevice *dst, double xscale, double shear, double dx, KisFilterStrategy *filterStrategy, int portion)

Static Private Member Functions
static QRect	rotate180 (KisPaintDeviceSP dev, QRect boundRect, KoUpdaterPtr progressUpdater, int portion)
static QRect	rotateLeft90 (KisPaintDeviceSP dev, QRect boundRect, KoUpdaterPtr progressUpdater, int portion)
static QRect	rotateRight90 (KisPaintDeviceSP dev, QRect boundRect, KoUpdaterPtr progressUpdater, int portion)

Private Attributes
QRect	m_boundRect
KisPaintDeviceSP	m_dev
KisFilterStrategy *	m_filter
bool	m_forceSubPixelTranslation {false}
KoUpdaterPtr	m_progressUpdater
double	m_rotation
double	m_xscale
double	m_xshear
double	m_xshearOrigin
qreal	m_xtranslate
double	m_yscale
double	m_yshear
double	m_yshearOrigin
qreal	m_ytranslate

Friends
class	KisTransformWorkerTest

Detailed Description

Definition at line 22 of file kis_transform_worker.h.

Constructor & Destructor Documentation

KisTransformWorker()

KisTransformWorker::KisTransformWorker	(	KisPaintDeviceSP	dev,
		double	xscale,
		double	yscale,
		double	xshear,
		double	yshear,
		double	rotation,
		qreal	xtranslate,
		qreal	ytranslate,
		KoUpdaterPtr	progress,
		KisFilterStrategy *	filter )

Definition at line 35 of file kis_transform_worker.cc.

{
    m_dev = dev;
    m_xscale = xscale;
    m_yscale = yscale;
    m_xshear = xshear;
    m_yshear = yshear;
    m_rotation = rotation,
    m_xtranslate = xtranslate;
    m_ytranslate = ytranslate;
    m_progressUpdater = progress;
    m_filter = filter;
}

References m_dev, m_filter, m_progressUpdater, m_rotation, m_xscale, m_xshear, m_xtranslate, m_yscale, m_yshear, and m_ytranslate.

~KisTransformWorker()

KisTransformWorker::~KisTransformWorker

(

)

Definition at line 55 of file kis_transform_worker.cc.

{
}

Member Function Documentation

forceSubPixelTranslation()

bool KisTransformWorker::forceSubPixelTranslation

(

)

const

Definition at line 143 of file kis_transform_worker.cc.

{
    return m_forceSubPixelTranslation;
}

References m_forceSubPixelTranslation.

mirror()

void KisTransformWorker::mirror ( KisPaintDeviceSP dev, qreal axis, Qt::Orientation orientation )

static

Mirror the specified device along the X or Y axis at the coordinate axis.

Definition at line 639 of file kis_transform_worker.cc.

{
    mirror_impl(dev, axis, orientation == Qt::Horizontal);
}

References mirror_impl().

mirrorX() [1/2]

void KisTransformWorker::mirrorX ( KisPaintDeviceSP dev )

static

Mirror the device relative to the center of its exactBounds()

Definition at line 627 of file kis_transform_worker.cc.

{
    QRect bounds = dev->exactBounds();
    mirrorX(dev, bounds.x() + 0.5 * bounds.width());
}

References bounds, KisPaintDevice::exactBounds(), and mirrorX().

mirrorX() [2/2]

void KisTransformWorker::mirrorX ( KisPaintDeviceSP dev, qreal axis )

static

Convenience methods for mirror(dev, axis, orientation)

Definition at line 617 of file kis_transform_worker.cc.

{
    mirror_impl(dev, axis, true);
}

References mirror_impl().

mirrorY() [1/2]

void KisTransformWorker::mirrorY ( KisPaintDeviceSP dev )

static

Definition at line 633 of file kis_transform_worker.cc.

{
    QRect bounds = dev->exactBounds();
    mirrorY(dev, bounds.y() + 0.5 * bounds.height());
}

References bounds, KisPaintDevice::exactBounds(), and mirrorY().

mirrorY() [2/2]

void KisTransformWorker::mirrorY ( KisPaintDeviceSP dev, qreal axis )

static

Definition at line 622 of file kis_transform_worker.cc.

{
    mirror_impl(dev, axis, false);
}

References mirror_impl().

offset()

void KisTransformWorker::offset ( KisPaintDeviceSP device, const QPoint & offsetPosition, const QRect & wrapRect )

static

Offset the specified device with wrapping around edges of rect specified as QRect(0,0,wrapSize.width, wrapSize.height)*

Parameters

device	device to be offset
offsetPosition	position where the new origin will be
wrapRect	width and height of the wrap edge, usual scenario is to use canvas width&height

Definition at line 644 of file kis_transform_worker.cc.

{
    Q_ASSERT(wrapRect == wrapRect.normalized());
 
    // inspired by gimp offset code, only wrap mode supported
    int sx = wrapRect.x();
    int sy = wrapRect.y();
 
    int width = wrapRect.width();
    int height = wrapRect.height();
 
    // offset coords are relative to space wrapRect
    int offsetX = offsetPosition.x();
    int offsetY = offsetPosition.y();
 
    while (offsetX < 0)
    {
        offsetX += width;
    }
 
    while (offsetY < 0)
    {
        offsetY += height;
    }
 
    if ((offsetX == 0) && (offsetY == 0))
    {
        return;
    }
 
    KisPaintDeviceSP offsetDevice = new KisPaintDevice(device->colorSpace());
 
    int srcX = 0;
    int srcY = 0;
 
    int destX = offsetX;
    int destY = offsetY;
 
    width = qBound<int>(0, width - offsetX, width);
    height = qBound<int>(0, height - offsetY, height);
 
    if ((width != 0) && (height != 0)) {
        // convert back to paint device space
        KisPainter::copyAreaOptimized(QPoint(destX + sx, destY + sy), device, offsetDevice, QRect(srcX + sx, srcY + sy, width, height));
    }
 
    srcX = wrapRect.width() - offsetX;
    srcY = wrapRect.height() - offsetY;
 
    destX = (srcX + offsetX) % wrapRect.width();
    destY = (srcY + offsetY) % wrapRect.height();
 
    if (offsetX != 0 && offsetY != 0) {
          KisPainter::copyAreaOptimized(QPoint(destX + sx, destY + sy), device, offsetDevice, QRect(srcX + sx, srcY + sy, offsetX, offsetY));
    }
 
    if (offsetX != 0) {
        KisPainter::copyAreaOptimized(QPoint(destX + sx, (destY + offsetY) + sy), device, offsetDevice, QRect(srcX + sx, 0 + sy, offsetX, wrapRect.height() - offsetY));
    }
 
    if (offsetY != 0) {
        KisPainter::copyAreaOptimized(QPoint((destX + offsetX) + sx, destY + sy), device, offsetDevice, QRect(0 + sx, srcY + sy, wrapRect.width() - offsetX, offsetY));
    }
 
    // bitblt the result back
    QRect resultRect(sx, sy, wrapRect.width(), wrapRect.height());
    KisPainter::copyAreaOptimized(resultRect.topLeft(), offsetDevice, device, resultRect);
}

References KisPaintDevice::colorSpace(), and KisPainter::copyAreaOptimized().

rotate180()

QRect KisTransformWorker::rotate180 ( KisPaintDeviceSP dev, QRect boundRect, KoUpdaterPtr progressUpdater, int portion )

staticprivate

Definition at line 133 of file kis_transform_worker.cc.

{
    QRect r = rotateWithTf(180, dev, boundRect, progressUpdater, portion);
    dev->moveTo(dev->x() - 1, dev->y() -1);
    return QRect(- r.x() - r.width(), - r.top() - r.height(), r.width(), r.height());
}

References KisPaintDevice::moveTo(), rotateWithTf(), KisPaintDevice::x(), and KisPaintDevice::y().

rotateLeft90()

QRect KisTransformWorker::rotateLeft90 ( KisPaintDeviceSP dev, QRect boundRect, KoUpdaterPtr progressUpdater, int portion )

staticprivate

Definition at line 123 of file kis_transform_worker.cc.

{
    QRect r = rotateWithTf(270, dev, boundRect, progressUpdater, portion);
    dev->moveTo(dev->x(), dev->y() - 1);
    return QRect(r.top(), - r.x() - r.width(), r.height(), r.width());
}

References KisPaintDevice::moveTo(), rotateWithTf(), KisPaintDevice::x(), and KisPaintDevice::y().

rotateRight90()

QRect KisTransformWorker::rotateRight90 ( KisPaintDeviceSP dev, QRect boundRect, KoUpdaterPtr progressUpdater, int portion )

staticprivate

Definition at line 113 of file kis_transform_worker.cc.

{
    QRect r = rotateWithTf(90, dev, boundRect, progressUpdater, portion);
    dev->moveTo(dev->x() - 1, dev->y());
    return QRect(- r.top() - r.height(), r.x(), r.height(), r.width());
}

References KisPaintDevice::moveTo(), rotateWithTf(), KisPaintDevice::x(), and KisPaintDevice::y().

run()

bool KisTransformWorker::run

(

)

Definition at line 229 of file kis_transform_worker.cc.

{
    return runPartial(m_dev->exactBounds());
}

References KisPaintDevice::exactBounds(), m_dev, and runPartial().

runPartial()

bool KisTransformWorker::runPartial

(

const QRect &

processRect

)

We don't check for xtranslate and ytranslate to be integers here, because people expect the translation to be lossless, that is, not doing any resampling.

Theoretically, we could implement a separate option to allow translations with resampling in the transform tool, but I don't know how useful it would be. People who wo pixel art can set scale to something like 99.99% and it should do the trick.

See: https://bugs.kde.org/show_bug.cgi?id=445714

Pre-rotate the image to ensure the actual resampling is done for an angle -pi/4...pi/4. This is faster and produces better quality.

First X-pass, then Y-pass | a 0 0 | | 1 d 0 | m = | b 1 0 | x | 0 e 0 | (matrices are in Qt's notation) | c 0 1 | | 0 f 1 |

Purge the tiles which might be left after scaling down the image

Definition at line 234 of file kis_transform_worker.cc.

{
    /* Check for nonsense and let the user know, this helps debugging.
    Otherwise the program will crash at a later point, in a very obscure way, probably by division by zero */
    /* Note that because KisFilterWeightsBuffer uses KisFixedPoint, we need to check the fixed point as well
     * since it has different precision than qreal or double */
    KisFixedPoint m_xscale_fixedPoint = KisFixedPoint(m_xscale);
    KisFixedPoint m_yscale_fixedPoint = KisFixedPoint(m_yscale);
    Q_ASSERT_X(m_xscale != 0 && m_xscale_fixedPoint != 0, "KisTransformer::run() validation step", "xscale == 0");
    Q_ASSERT_X(m_yscale != 0 && m_yscale_fixedPoint != 0, "KisTransformer::run() validation step", "yscale == 0");
 
    // Fallback safety line in case Krita is compiled without ASSERTS
    if (m_xscale == 0 || m_yscale == 0 || m_xscale_fixedPoint == 0 || m_yscale_fixedPoint == 0) return false;
 
    m_boundRect = processRect;
 
    if (m_boundRect.isNull()) {
        if (!m_progressUpdater.isNull()) {
            m_progressUpdater->setProgress(100);
        }
        return true;
    }
 
    double xscale = m_xscale;
    double yscale = m_yscale;
    double rotation = m_rotation;
    qreal xtranslate = m_xtranslate;
    qreal ytranslate = m_ytranslate;
 
    // Apply shearX/Y separately. In Krita it is demanded separately
    // most of the times.
    if (m_xshear != 0 || m_yshear != 0) {
        int portion = 50;
 
        bool scalePresent = !(qFuzzyCompare(xscale, 1.0) && qFuzzyCompare(yscale, 1.0));
        bool xShearPresent = !qFuzzyCompare(m_xshear, 0.0);
        bool yShearPresent = !qFuzzyCompare(m_yshear, 0.0);
 
        if (scalePresent || (xShearPresent && yShearPresent)) {
            transformPass <KisHLineIteratorSP>(m_dev.data(), m_dev.data(), xscale, yscale *  m_xshear, 0, m_filter, portion);
            transformPass <KisVLineIteratorSP>(m_dev.data(), m_dev.data(), yscale, m_yshear, 0, m_filter, portion);
        } else if (xShearPresent) {
            transformPass <KisHLineIteratorSP>(m_dev.data(), m_dev.data(), xscale, m_xshear, 0, m_filter, portion);
        } else if (yShearPresent) {
            transformPass <KisVLineIteratorSP>(m_dev.data(), m_dev.data(), yscale, m_yshear, 0, m_filter, portion);
        }
 
        yscale = 1.;
        xscale = 1.;
    }
 
    if (rotation < 0.0) {
        rotation = -fmod(-rotation, 2 * M_PI) + 2 * M_PI;
    } else {
        rotation = fmod(rotation, 2 * M_PI);
    }
 
    int rotQuadrant = int(rotation / (M_PI / 2) + 0.5) & 3;
    rotation -= rotQuadrant * M_PI / 2;
 
 
    const bool simpleTransform =
        !m_forceSubPixelTranslation &&
        (qFuzzyCompare(rotation, 0.0)) &&
        (qFuzzyCompare(xscale, 1.0) ||
         qFuzzyCompare(xscale, -1.0)) &&
        (qFuzzyCompare(yscale, 1.0) ||
         qFuzzyCompare(yscale, -1.0));
 
 
    int progressTotalSteps = qMax(1, 2 * (!simpleTransform) + (rotQuadrant != 0));
    int progressPortion = 100 / progressTotalSteps;
 
    switch (rotQuadrant) {
    case 1:
        swapValues(&xscale, &yscale);
        m_boundRect = rotateRight90(m_dev, m_boundRect, m_progressUpdater, progressPortion);
        break;
    case 2:
        m_boundRect = rotate180(m_dev, m_boundRect, m_progressUpdater, progressPortion);
        break;
    case 3:
        swapValues(&xscale, &yscale);
        m_boundRect = rotateLeft90(m_dev, m_boundRect, m_progressUpdater, progressPortion);
        break;
    default:
        /* do nothing */
        break;
    }
 
    if (simpleTransform) {
 
        // Flipping horizontally
        if (qFuzzyCompare(xscale, -1.0)) {
            QRect bounds = m_dev->exactBounds();
            double center_x = bounds.topLeft().x() + bounds.width() / 2.0;
            xtranslate -= 2 * center_x;
            mirrorX(m_dev);
        }
 
        // Flipping vertically
        if (qFuzzyCompare(yscale, -1.0)) {
            QRect bounds = m_dev->exactBounds();
            double center_y = bounds.topLeft().y() + bounds.height() / 2.0;
            ytranslate -= 2 * center_y;
            mirrorY(m_dev);
        }
 
        // Simple translation
        const int intXTranslate = qRound(xtranslate);
        const int intYTranslate = qRound(ytranslate);
 
        m_boundRect.translate(intXTranslate, intYTranslate);
        m_dev->moveTo(m_dev->x() + intXTranslate, m_dev->y() + intYTranslate);
 
    } else {
        QTransform SC = QTransform::fromScale(xscale, yscale);
        QTransform R; R.rotateRadians(rotation);
        QTransform T = QTransform::fromTranslate(xtranslate, ytranslate);
        QTransform m = SC * R * T;
 
        qreal a = m.m11();
        qreal b = m.m21();
        qreal c = m.m31();
        qreal d = m.m12() / m.m11();
        qreal e = m.m22() - m.m21() * m.m12() / m.m11();
        qreal f = m.m32() - m.m31() * m.m12() / m.m11();
 
        // First Pass (X)
        transformPass <KisHLineIteratorSP>(m_dev.data(), m_dev.data(), a, b, c, m_filter, progressPortion);
 
        // Second Pass (Y)
        transformPass <KisVLineIteratorSP>(m_dev.data(), m_dev.data(), e, d, f, m_filter, progressPortion);
 
#if 0
        /************************************************************/
        qreal a = m.m11() - m.m21() * m.m12() / m.m22();
        qreal b = m.m21() / m.m22();
        qreal c = m.m31() - m.m21() * m.m32() / m.m22();
        qreal d = m.m12();
        qreal e = m.m22();
        qreal f = m.m32();
        // First Pass (X)
        transformPass <KisHLineIteratorSP>(m_dev.data(), m_dev.data(), a, b, c, m_filter, progressPortion);
        // Second Pass (Y)
        transformPass <KisVLineIteratorSP>(m_dev.data(), m_dev.data(), e, d, f, m_filter, progressPortion);
        /************************************************************/
#endif /* 0 */
 
#if 0
        /************************************************************/
        // Old three-pass implementation (for testing purposes)
        yshear = sin(rotation);
        xshear = -tan(rotation / 2);
        xtranslate -= int(xshear * ytranslate);
 
        transformPass <KisHLineIteratorSP>(m_dev.data(), m_dev.data(), xscale, yscale*xshear, 0, m_filter, 0);
        transformPass <KisVLineIteratorSP>(m_dev.data(), m_dev.data(), yscale, yshear, ytranslate, m_filter, 0);
        if (xshear != 0.0) {
            transformPass <KisHLineIteratorSP>(m_dev.data(), m_dev.data(), 1.0, xshear, xtranslate, m_filter, 0);
        } else {
            m_dev->move(m_dev->x() + xtranslate, m_dev->y());
            updateBounds <KisHLineIteratorSP>(m_boundRect, 1.0, 0, xtranslate);
        }
        /************************************************************/
#endif /* 0 */
 
    }
 
    if (!m_progressUpdater.isNull()) {
        m_progressUpdater->setProgress(100);
    }
 
    m_dev->purgeDefaultPixels();
 
    return true;
}

References bounds, KisSharedPtr< T >::data(), KisPaintDevice::exactBounds(), m_boundRect, m_dev, m_filter, m_forceSubPixelTranslation, M_PI, m_progressUpdater, m_rotation, m_xscale, m_xshear, m_xtranslate, m_yscale, m_yshear, m_ytranslate, mirrorX(), mirrorY(), KisPaintDevice::moveTo(), KisPaintDevice::purgeDefaultPixels(), qFuzzyCompare(), R, rotate180(), rotateLeft90(), rotateRight90(), swapValues(), updateBounds< KisHLineIteratorSP >(), KisPaintDevice::x(), and KisPaintDevice::y().

setForceSubPixelTranslation()

void KisTransformWorker::setForceSubPixelTranslation

(

bool

value

)

Definition at line 148 of file kis_transform_worker.cc.

{
    m_forceSubPixelTranslation = value;
}

References m_forceSubPixelTranslation, and value().

transform()

QTransform KisTransformWorker::transform

(

)

const

Returns a matrix of the transformation executed by the worker. Resulting transformation has the following form (in Qt's matrix notation (all the matrices are transposed)):

transform = SC * S * R * T

,where: SC - scale S - shear itself (shearX * shearY) R - rotation (rotation parameter) T - translation (xtranslate, ytranslate)

WARNING: due to some rounding problems in the worker the work it does not correspond to the matrix exactly! The result always differs 1-3 pixel. So be careful with it (or fix it)

Definition at line 59 of file kis_transform_worker.cc.

{
    QTransform SC = QTransform::fromScale(m_xscale, m_yscale);
    QTransform S; S.shear(0, m_yshear); S.shear(m_xshear, 0);
    QTransform R; R.rotateRadians(m_rotation);
    QTransform T = QTransform::fromTranslate(m_xtranslate, m_ytranslate);
 
    return SC * S * R * T;
}

References m_rotation, m_xscale, m_xshear, m_xtranslate, m_yscale, m_yshear, m_ytranslate, R, and S.

transformPass()

template<class T >

void KisTransformWorker::transformPass ( KisPaintDevice * src, KisPaintDevice * dst, double xscale, double shear, double dx, KisFilterStrategy * filterStrategy, int portion )

private

Definition at line 193 of file kis_transform_worker.cc.

{
    bool clampToEdge = shear == 0.0;
 
    qint32 srcStart, srcLen, firstLine, numLines;
    calcDimensions<T>(m_boundRect, srcStart, srcLen, firstLine, numLines);
 
    KisProgressUpdateHelper progressHelper(m_progressUpdater, portion, numLines);
    KisFilterWeightsBuffer buf(filterStrategy, qAbs(floatscale));
    KisFilterWeightsApplicator applicator(src, dst, floatscale, shear, dx, clampToEdge);
 
    KisFilterWeightsApplicator::LinePos dstBounds;
 
    for (int i = firstLine; i < firstLine + numLines; i++) {
        KisFilterWeightsApplicator::LinePos dstPos;
        KisFilterWeightsApplicator::LinePos srcPos(srcStart, srcLen);
 
        dstPos = applicator.processLine<T>(srcPos, i, &buf, filterStrategy->support(buf.weightsPositionScale().toFloat()));
        dstBounds.unite(dstPos);
 
        progressHelper.step();
    }
 
    updateBounds<T>(m_boundRect, dstBounds);
}

References m_boundRect, m_progressUpdater, KisFilterWeightsApplicator::processLine(), KisProgressUpdateHelper::step(), KisFilterStrategy::support(), and KisFilterWeightsApplicator::LinePos::unite().

transformPixelSelectionOutline()

void KisTransformWorker::transformPixelSelectionOutline

(

KisPixelSelectionSP

pixelSelection

)

const

Transforms the outline of the pixel selection (if it is valid)

Definition at line 69 of file kis_transform_worker.cc.

{
    if (pixelSelection->outlineCacheValid()) {
        QPainterPath outlineCache = pixelSelection->outlineCache();
        pixelSelection->setOutlineCache(transform().map(outlineCache));
    }
}

References KisPixelSelection::outlineCache, KisPixelSelection::outlineCacheValid, KisPixelSelection::setOutlineCache(), and transform().

Friends And Related Symbol Documentation

KisTransformWorkerTest

friend class KisTransformWorkerTest

friend

Definition at line 109 of file kis_transform_worker.h.

Member Data Documentation

m_boundRect

QRect KisTransformWorker::m_boundRect

private

Definition at line 134 of file kis_transform_worker.h.

m_dev

KisPaintDeviceSP KisTransformWorker::m_dev

private

Definition at line 127 of file kis_transform_worker.h.

m_filter

KisFilterStrategy* KisTransformWorker::m_filter

private

Definition at line 133 of file kis_transform_worker.h.

m_forceSubPixelTranslation

bool KisTransformWorker::m_forceSubPixelTranslation {false}

private

Definition at line 135 of file kis_transform_worker.h.

{false};

m_progressUpdater

KoUpdaterPtr KisTransformWorker::m_progressUpdater

private

Definition at line 132 of file kis_transform_worker.h.

m_rotation

double KisTransformWorker::m_rotation

private

Definition at line 129 of file kis_transform_worker.h.

m_xscale

double KisTransformWorker::m_xscale

private

Definition at line 128 of file kis_transform_worker.h.

m_xshear

double KisTransformWorker::m_xshear

private

Definition at line 129 of file kis_transform_worker.h.

m_xshearOrigin

double KisTransformWorker::m_xshearOrigin

private

Definition at line 130 of file kis_transform_worker.h.

m_xtranslate

qreal KisTransformWorker::m_xtranslate

private

Definition at line 131 of file kis_transform_worker.h.

m_yscale

double KisTransformWorker::m_yscale

private

Definition at line 128 of file kis_transform_worker.h.

m_yshear

double KisTransformWorker::m_yshear

private

Definition at line 129 of file kis_transform_worker.h.

m_yshearOrigin

double KisTransformWorker::m_yshearOrigin

private

Definition at line 130 of file kis_transform_worker.h.

m_ytranslate

qreal KisTransformWorker::m_ytranslate

private

Definition at line 131 of file kis_transform_worker.h.

---

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

• libs/image/kis_transform_worker.h
• libs/image/kis_transform_worker.cc