diff --git a/libs/brush/kis_qimage_pyramid.cpp b/libs/brush/kis_qimage_pyramid.cpp
index 6dcb2b40c5..5bdf8274ea 100644
--- a/libs/brush/kis_qimage_pyramid.cpp
+++ b/libs/brush/kis_qimage_pyramid.cpp
@@ -1,306 +1,302 @@
 /*
  *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_qimage_pyramid.h"
 
 #include <limits>
 #include <QPainter>
 #include <kis_debug.h>
 
 #define MIPMAP_SIZE_THRESHOLD 512
 #define MAX_MIPMAP_SCALE 8.0
 
 #define QPAINTER_WORKAROUND_BORDER 1
 
 
 KisQImagePyramid::KisQImagePyramid(const QImage &baseImage)
 {
     Q_ASSERT(!baseImage.isNull());
 
     m_originalSize = baseImage.size();
 
 
     qreal scale = MAX_MIPMAP_SCALE;
 
     while (scale > 1.0) {
         QSize scaledSize = m_originalSize * scale;
 
         if (scaledSize.width() <= MIPMAP_SIZE_THRESHOLD ||
                 scaledSize.height() <= MIPMAP_SIZE_THRESHOLD) {
 
             if (m_levels.isEmpty()) {
                 m_baseScale = scale;
             }
 
             appendPyramidLevel(baseImage.scaled(scaledSize,  Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
         }
 
         scale *= 0.5;
     }
 
     if (m_levels.isEmpty()) {
         m_baseScale = 1.0;
     }
     appendPyramidLevel(baseImage);
 
     scale = 0.5;
     while (true) {
         QSize scaledSize = m_originalSize * scale;
 
         if (scaledSize.width() == 0 ||
                 scaledSize.height() == 0) break;
 
         appendPyramidLevel(baseImage.scaled(scaledSize,  Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
 
         scale *= 0.5;
     }
 }
 
 KisQImagePyramid::~KisQImagePyramid()
 {
 }
 
 int KisQImagePyramid::findNearestLevel(qreal scale, qreal *baseScale) const
 {
     const qreal scale_epsilon = 1e-6;
 
     qreal levelScale = m_baseScale;
     int level = 0;
     int lastLevel = m_levels.size() - 1;
 
 
     while ((0.5 * levelScale > scale ||
             qAbs(0.5 * levelScale - scale) < scale_epsilon) &&
             level < lastLevel) {
 
         levelScale *= 0.5;
         level++;
     }
 
     *baseScale = levelScale;
     return level;
 }
 
 inline QRect roundRect(const QRectF &rc)
 {
     /**
      * This is an analog of toAlignedRect() with the only difference
      * that it ensures the rect position will never be below zero.
      *
      * Warning: be *very* careful with using bottom()/right() values
      *          of a pure QRect (we don't use it here for the dangers
      *          it can lead to).
      */
 
     QRectF rect(rc);
 
     KIS_ASSERT_RECOVER_NOOP(rect.x() > -1e-6);
     KIS_ASSERT_RECOVER_NOOP(rect.y() > -1e-6);
 
     if (rect.x() < 0.0) {
         rect.setLeft(0.0);
     }
 
     if (rect.y() < 0.0) {
         rect.setTop(0.0);
     }
 
     return rect.toAlignedRect();
 }
 
 QTransform baseBrushTransform(KisDabShape const& shape,
                               qreal subPixelX, qreal subPixelY,
                               const QRectF &baseBounds)
 {
     QTransform transform;
-    if (!qFuzzyCompare(shape.rotation(), 0)) {
-        QTransform rotationTransform;
-        rotationTransform.rotateRadians(shape.rotation());
+    transform.scale(shape.scaleX(), shape.scaleY());
 
-        QRectF rotatedBounds = rotationTransform.mapRect(baseBounds);
-        transform = rotationTransform *
-                    QTransform::fromTranslate(-rotatedBounds.x(), -rotatedBounds.y());
+    if (!qFuzzyCompare(shape.rotation(), 0)) {
+        transform = transform * QTransform().rotateRadians(shape.rotation());
+        QRectF rotatedBounds = transform.mapRect(baseBounds);
+        transform = transform * QTransform::fromTranslate(-rotatedBounds.x(), -rotatedBounds.y());
     }
 
-    return transform *
-           QTransform::fromScale(shape.scaleX(), shape.scaleY()) *
-           QTransform::fromTranslate(subPixelX, subPixelY);
+    return transform * QTransform::fromTranslate(subPixelX, subPixelY);
 }
 
 void KisQImagePyramid::calculateParams(KisDabShape const& shape,
                                        qreal subPixelX, qreal subPixelY,
                                        const QSize &originalSize,
                                        QTransform *outputTransform, QSize *outputSize)
 {
     calculateParams(shape,
                     subPixelX, subPixelY,
                     originalSize, 1.0, originalSize,
                     outputTransform, outputSize);
 }
 
 void KisQImagePyramid::calculateParams(KisDabShape shape,
                                        qreal subPixelX, qreal subPixelY,
                                        const QSize &originalSize,
                                        qreal baseScale, const QSize &baseSize,
                                        QTransform *outputTransform, QSize *outputSize)
 {
     Q_UNUSED(baseScale);
 
     QRectF originalBounds = QRectF(QPointF(), originalSize);
     QTransform originalTransform =
         baseBrushTransform(shape, subPixelX, subPixelY,
                            originalBounds);
 
     qreal realBaseScaleX = qreal(baseSize.width()) / originalSize.width();
     qreal realBaseScaleY = qreal(baseSize.height()) / originalSize.height();
     qreal scaleX = shape.scaleX() / realBaseScaleX;
     qreal scaleY = shape.scaleY() / realBaseScaleY;
     shape = KisDabShape(scaleX, scaleY/scaleX, shape.rotation());
 
     QRectF baseBounds = QRectF(QPointF(), baseSize);
 
     QTransform transform =
         baseBrushTransform(shape,
                            subPixelX, subPixelY,
                            baseBounds);
-
     QRect expectedDstRect = roundRect(originalTransform.mapRect(originalBounds));
 #if 0 // Only enable when debugging; users shouldn't see this warning
     {
         QRect testingRect = roundRect(transform.mapRect(baseBounds));
         if (testingRect != expectedDstRect) {
             warnKrita << "WARNING: expected and real dab rects do not coincide!";
             warnKrita << "         expected rect:" << expectedDstRect;
             warnKrita << "         real rect:    " << testingRect;
         }
     }
 #endif
     KIS_ASSERT_RECOVER_NOOP(expectedDstRect.x() >= 0);
     KIS_ASSERT_RECOVER_NOOP(expectedDstRect.y() >= 0);
 
     int width = expectedDstRect.x() + expectedDstRect.width();
     int height = expectedDstRect.y() + expectedDstRect.height();
 
     // we should not return invalid image, so adjust the image to be
     // at least 1 px in size.
     width = qMax(1, width);
     height = qMax(1, height);
 
     *outputTransform = transform;
     *outputSize = QSize(width, height);
 }
 
 QSize KisQImagePyramid::imageSize(const QSize &originalSize,
                                   KisDabShape const& shape,
                                   qreal subPixelX, qreal subPixelY)
 {
     QTransform transform;
     QSize dstSize;
 
     calculateParams(shape, subPixelX, subPixelY,
                     originalSize,
                     &transform, &dstSize);
 
     return dstSize;
 }
 
 QSizeF KisQImagePyramid::characteristicSize(const QSize &originalSize,
                                             KisDabShape const& shape)
 {
     QRectF originalRect(QPointF(), originalSize);
     QTransform transform = baseBrushTransform(shape,
                                               0.0, 0.0,
                                               originalRect);
 
     return transform.mapRect(originalRect).size();
 }
 
 void KisQImagePyramid::appendPyramidLevel(const QImage &image)
 {
     /**
      * QPainter has a bug: when doing a transformation it decides that
      * all the pixels outside of the image (source rect) are equal to
      * the border pixels (CLAMP in terms of openGL). This means that
      * there will be no smooth scaling on the border of the image when
      * it is rotated.  To workaround this bug we need to add one pixel
      * wide border to the image, so that it transforms smoothly.
      *
      * See a unittest in: KisBrushTest::testQPainterTransformationBorder
      */
     QSize levelSize = image.size();
     QImage tmp = image.convertToFormat(QImage::Format_ARGB32);
     tmp = tmp.copy(-QPAINTER_WORKAROUND_BORDER,
                    -QPAINTER_WORKAROUND_BORDER,
                    image.width() + 2 * QPAINTER_WORKAROUND_BORDER,
                    image.height() + 2 * QPAINTER_WORKAROUND_BORDER);
     m_levels.append(PyramidLevel(tmp, levelSize));
 }
 
 QImage KisQImagePyramid::createImage(KisDabShape const& shape,
                                      qreal subPixelX, qreal subPixelY) const
 {
     qreal baseScale = -1.0;
     int level = findNearestLevel(shape.scale(), &baseScale);
 
     const QImage &srcImage = m_levels[level].image;
 
     QTransform transform;
     QSize dstSize;
 
     calculateParams(shape, subPixelX, subPixelY,
                     m_originalSize, baseScale, m_levels[level].size,
                     &transform, &dstSize);
 
     if (transform.isIdentity() &&
             srcImage.format() == QImage::Format_ARGB32) {
 
         return srcImage.copy(QPAINTER_WORKAROUND_BORDER,
                              QPAINTER_WORKAROUND_BORDER,
                              srcImage.width() - 2 * QPAINTER_WORKAROUND_BORDER,
                              srcImage.height() - 2 * QPAINTER_WORKAROUND_BORDER);
     }
 
     QImage dstImage(dstSize, QImage::Format_ARGB32);
     dstImage.fill(0);
 
 
     /**
      * QPainter has one more bug: when a QTransform is TxTranslate, it
      * does wrong sampling (probably, Nearest Neighbour) even though
      * we tell it directly that we need SmoothPixmapTransform.
      *
      * So here is a workaround: we set a negligible scale to convince
      * Qt we use a non-only-translating transform.
      */
     while (transform.type() == QTransform::TxTranslate) {
         const qreal scale = transform.m11();
         const qreal fakeScale = scale - 10 * std::numeric_limits<qreal>::epsilon();
         transform *= QTransform::fromScale(fakeScale, fakeScale);
     }
 
     QPainter gc(&dstImage);
     gc.setTransform(
         QTransform::fromTranslate(-QPAINTER_WORKAROUND_BORDER,
                                   -QPAINTER_WORKAROUND_BORDER) * transform);
     gc.setRenderHints(QPainter::SmoothPixmapTransform);
     gc.drawImage(QPointF(), srcImage);
     gc.end();
 
     return dstImage;
 }
 
diff --git a/libs/brush/tests/kis_brush_test.cpp b/libs/brush/tests/kis_brush_test.cpp
index 9aedb451fa..3438d25c4e 100644
--- a/libs/brush/tests/kis_brush_test.cpp
+++ b/libs/brush/tests/kis_brush_test.cpp
@@ -1,345 +1,361 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt boud@valdyas.org
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_brush_test.h"
 
 #include <QTest>
 #include <QString>
 #include <QDir>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include "testutil.h"
 #include "../kis_gbr_brush.h"
 #include "kis_types.h"
 #include "kis_paint_device.h"
 #include "brushengine/kis_paint_information.h"
 #include <kis_fixed_paint_device.h>
 #include "kis_qimage_pyramid.h"
 
 void KisBrushTest::testMaskGenerationNoColor()
 {
     KisGbrBrush* brush = new KisGbrBrush(QString(FILES_DATA_DIR) + QDir::separator() + "brush.gbr");
     brush->load();
     Q_ASSERT(brush->valid());
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
 
     KisPaintInformation info(QPointF(100.0, 100.0), 0.5);
 
     // check masking an existing paint device
     KisFixedPaintDeviceSP fdev = new KisFixedPaintDevice(cs);
     fdev->setRect(QRect(0, 0, 100, 100));
     fdev->initialize();
     cs->setOpacity(fdev->data(), OPACITY_OPAQUE_U8, 100 * 100);
 
     QPoint errpoint;
     QImage result(QString(FILES_DATA_DIR) + QDir::separator() + "result_brush_1.png");
     QImage image = fdev->convertToQImage(0);
 
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("kis_brush_test_1.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
     brush->mask(fdev, KisDabShape(), info);
 
     result = QImage(QString(FILES_DATA_DIR) + QDir::separator() + "result_brush_2.png");
     image = fdev->convertToQImage(0);
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("kis_brush_test_2.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisBrushTest::testMaskGenerationSingleColor()
 {
     KisGbrBrush* brush = new KisGbrBrush(QString(FILES_DATA_DIR) + QDir::separator() + "brush.gbr");
     brush->load();
     Q_ASSERT(brush->valid());
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
 
     KisPaintInformation info(QPointF(100.0, 100.0), 0.5);
 
     // check masking an existing paint device
     KisFixedPaintDeviceSP fdev = new KisFixedPaintDevice(cs);
     fdev->setRect(QRect(0, 0, 100, 100));
     fdev->initialize();
     cs->setOpacity(fdev->data(), OPACITY_OPAQUE_U8, 100 * 100);
 
     // Check creating a mask dab with a single color
     fdev = new KisFixedPaintDevice(cs);
     brush->mask(fdev, KoColor(Qt::black, cs), KisDabShape(), info);
 
     QPoint errpoint;
     QImage result = QImage(QString(FILES_DATA_DIR) + QDir::separator() + "result_brush_3.png");
     QImage image = fdev->convertToQImage(0);
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("kis_brush_test_3.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisBrushTest::testMaskGenerationDevColor()
 {
     KisGbrBrush* brush = new KisGbrBrush(QString(FILES_DATA_DIR) + QDir::separator() + "brush.gbr");
     brush->load();
     Q_ASSERT(brush->valid());
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
 
     KisPaintInformation info(QPointF(100.0, 100.0), 0.5);
 
     // check masking an existing paint device
     KisFixedPaintDeviceSP fdev = new KisFixedPaintDevice(cs);
     fdev->setRect(QRect(0, 0, 100, 100));
     fdev->initialize();
     cs->setOpacity(fdev->data(), OPACITY_OPAQUE_U8, 100 * 100);
 
     // Check creating a mask dab with a color taken from a paint device
     KoColor red(Qt::red, cs);
     cs->setOpacity(red.data(), quint8(128), 1);
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->fill(0, 0, 100, 100, red.data());
 
     fdev = new KisFixedPaintDevice(cs);
     brush->mask(fdev, dev, KisDabShape(), info);
 
     QPoint errpoint;
     QImage result = QImage(QString(FILES_DATA_DIR) + QDir::separator() + "result_brush_4.png");
     QImage image = fdev->convertToQImage(0);
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("kis_brush_test_4.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisBrushTest::testMaskGenerationDefaultColor()
 {
     KisGbrBrush* brush = new KisGbrBrush(QString(FILES_DATA_DIR) + QDir::separator() + "brush.gbr");
     brush->load();
     Q_ASSERT(brush->valid());
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
 
     KisPaintInformation info(QPointF(100.0, 100.0), 0.5);
 
     // check masking an existing paint device
     KisFixedPaintDeviceSP fdev = new KisFixedPaintDevice(cs);
     fdev->setRect(QRect(0, 0, 100, 100));
     fdev->initialize();
     cs->setOpacity(fdev->data(), OPACITY_OPAQUE_U8, 100 * 100);
 
     // check creating a mask dab with a default color
     fdev = new KisFixedPaintDevice(cs);
     brush->mask(fdev, KisDabShape(), info);
 
     QPoint errpoint;
     QImage result = QImage(QString(FILES_DATA_DIR) + QDir::separator() + "result_brush_3.png");
     QImage image = fdev->convertToQImage(0);
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("kis_brush_test_5.png");
         QFAIL(QString("Failed to create identical image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
     delete brush;
 }
 
 
 void KisBrushTest::testImageGeneration()
 {
     KisGbrBrush* brush = new KisGbrBrush(QString(FILES_DATA_DIR) + QDir::separator() + "testing_brush_512_bars.gbr");
     bool res = brush->load();
     Q_UNUSED(res);
     Q_ASSERT(res);
     QVERIFY(!brush->brushTipImage().isNull());
     brush->prepareBrushPyramid();
     qsrand(1);
 
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintInformation info(QPointF(100.0, 100.0), 0.5);
     KisFixedPaintDeviceSP dab;
 
     for (int i = 0; i < 200; i++) {
         qreal scale = qreal(qrand()) / RAND_MAX * 2.0;
         qreal rotation = qreal(qrand()) / RAND_MAX * 2 * M_PI;
         qreal subPixelX = qreal(qrand()) / RAND_MAX * 0.5;
         QString testName =
             QString("brush_%1_sc_%2_rot_%3_sub_%4")
             .arg(i).arg(scale).arg(rotation).arg(subPixelX);
 
         dab = brush->paintDevice(cs, KisDabShape(scale, 1.0, rotation), info, subPixelX);
 
         /**
          * Compare first 10 images. Others are tested for asserts only
          */
         if (i < 10) {
             QImage result = dab->convertToQImage(0);
             TestUtil::checkQImage(result, "brush_masks", "", testName);
         }
     }
 }
 
 void KisBrushTest::benchmarkPyramidCreation()
 {
     KisGbrBrush* brush = new KisGbrBrush(QString(FILES_DATA_DIR) + QDir::separator() + "testing_brush_512_bars.gbr");
     brush->load();
     QVERIFY(!brush->brushTipImage().isNull());
 
     QBENCHMARK {
         brush->prepareBrushPyramid();
         brush->clearBrushPyramid();
     }
 }
 
 void KisBrushTest::benchmarkScaling()
 {
     KisGbrBrush* brush = new KisGbrBrush(QString(FILES_DATA_DIR) + QDir::separator() + "testing_brush_512_bars.gbr");
     brush->load();
     QVERIFY(!brush->brushTipImage().isNull());
     brush->prepareBrushPyramid();
     qsrand(1);
 
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintInformation info(QPointF(100.0, 100.0), 0.5);
     KisFixedPaintDeviceSP dab;
 
     QBENCHMARK {
         dab = brush->paintDevice(cs, KisDabShape(qreal(qrand()) / RAND_MAX * 2.0, 1.0, 0.0), info);
         //dab->convertToQImage(0).save(QString("dab_%1_new_smooth.png").arg(i++));
     }
 }
 
 void KisBrushTest::benchmarkRotation()
 {
     KisGbrBrush* brush = new KisGbrBrush(QString(FILES_DATA_DIR) + QDir::separator() + "testing_brush_512_bars.gbr");
     brush->load();
     QVERIFY(!brush->brushTipImage().isNull());
     brush->prepareBrushPyramid();
     qsrand(1);
 
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintInformation info(QPointF(100.0, 100.0), 0.5);
     KisFixedPaintDeviceSP dab;
 
     QBENCHMARK {
         dab = brush->paintDevice(cs, KisDabShape(1.0, 1.0, qreal(qrand()) / RAND_MAX * 2 * M_PI), info);
     }
 }
 
 void KisBrushTest::benchmarkMaskScaling()
 {
     KisGbrBrush* brush = new KisGbrBrush(QString(FILES_DATA_DIR) + QDir::separator() + "testing_brush_512_bars.gbr");
     brush->load();
     QVERIFY(!brush->brushTipImage().isNull());
     brush->prepareBrushPyramid();
     qsrand(1);
 
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintInformation info(QPointF(100.0, 100.0), 0.5);
     KisFixedPaintDeviceSP dab = new KisFixedPaintDevice(cs);
 
     QBENCHMARK {
         KoColor c(Qt::black, cs);
         qreal scale = qreal(qrand()) / RAND_MAX * 2.0;
         brush->mask(dab, c, KisDabShape(scale, 1.0, 0.0), info, 0.0, 0.0, 1.0);
     }
 }
 
 void KisBrushTest::testPyramidLevelRounding()
 {
     QSize imageSize(41, 41);
     QImage image(imageSize, QImage::Format_ARGB32);
     image.fill(0);
 
     KisQImagePyramid pyramid(image);
 
     qreal baseScale;
     int baseLevel;
 
     baseLevel = pyramid.findNearestLevel(1.0, &baseScale);
     QCOMPARE(baseScale, 1.0);
     QCOMPARE(baseLevel, 3);
 
     baseLevel = pyramid.findNearestLevel(2.0, &baseScale);
     QCOMPARE(baseScale, 2.0);
     QCOMPARE(baseLevel, 2);
 
     baseLevel = pyramid.findNearestLevel(4.0, &baseScale);
     QCOMPARE(baseScale, 4.0);
     QCOMPARE(baseLevel, 1);
 
     baseLevel = pyramid.findNearestLevel(0.5, &baseScale);
     QCOMPARE(baseScale, 0.5);
     QCOMPARE(baseLevel, 4);
 
     baseLevel = pyramid.findNearestLevel(0.25, &baseScale);
     QCOMPARE(baseScale, 0.25);
     QCOMPARE(baseLevel, 5);
 
     baseLevel = pyramid.findNearestLevel(0.25 + 1e-7, &baseScale);
     QCOMPARE(baseScale, 0.25);
     QCOMPARE(baseLevel, 5);
 }
 
+static QSize dabTransformHelper(KisDabShape const& shape)
+{
+    QSize const testSize(150, 150);
+    qreal const subPixelX = 0.0,
+                subPixelY = 0.0;
+    return KisQImagePyramid::imageSize(testSize, shape, subPixelX, subPixelY);
+}
+
+void KisBrushTest::testPyramidDabTransform()
+{
+    QCOMPARE(dabTransformHelper(KisDabShape(1.0, 1.0, 0.0)),      QSize(150, 150));
+    QCOMPARE(dabTransformHelper(KisDabShape(1.0, 0.5, 0.0)),      QSize(150,  75));
+    QCOMPARE(dabTransformHelper(KisDabShape(1.0, 1.0, M_PI / 4)), QSize(213, 213));
+    QCOMPARE(dabTransformHelper(KisDabShape(1.0, 0.5, M_PI / 4)), QSize(160, 160));
+}
+
 // see comment in KisQImagePyramid::appendPyramidLevel
 void KisBrushTest::testQPainterTransformationBorder()
 {
     QImage image1(10, 10, QImage::Format_ARGB32);
     QImage image2(12, 12, QImage::Format_ARGB32);
 
     image1.fill(0);
     image2.fill(0);
 
     {
         QPainter gc(&image1);
         gc.fillRect(QRect(0, 0, 10, 10), Qt::black);
     }
 
     {
         QPainter gc(&image2);
         gc.fillRect(QRect(1, 1, 10, 10), Qt::black);
     }
 
     image1.save("src1.png");
     image2.save("src2.png");
 
     {
         QImage canvas(100, 100, QImage::Format_ARGB32);
         canvas.fill(0);
         QPainter gc(&canvas);
         QTransform transform;
         transform.rotate(15);
         gc.setTransform(transform);
         gc.setRenderHints(QPainter::SmoothPixmapTransform);
         gc.drawImage(QPointF(50, 50), image1);
         gc.end();
         canvas.save("canvas1.png");
     }
     {
         QImage canvas(100, 100, QImage::Format_ARGB32);
         canvas.fill(0);
         QPainter gc(&canvas);
         QTransform transform;
         transform.rotate(15);
         gc.setTransform(transform);
         gc.setRenderHints(QPainter::SmoothPixmapTransform);
         gc.drawImage(QPointF(50, 50), image2);
         gc.end();
         canvas.save("canvas2.png");
     }
 }
 
 QTEST_MAIN(KisBrushTest)
diff --git a/libs/brush/tests/kis_brush_test.h b/libs/brush/tests/kis_brush_test.h
index 68c7465342..9d57d755df 100644
--- a/libs/brush/tests/kis_brush_test.h
+++ b/libs/brush/tests/kis_brush_test.h
@@ -1,48 +1,49 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt boud@valdyas.org
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_BRUSH_TEST_H
 #define KIS_BRUSH_TEST_H
 
 #include <QtTest>
 
 class KisBrushTest : public QObject
 {
     Q_OBJECT
 
     // XXX disabled until I figure out why they don't work from here, while the brushes do work from Krita
     void testMaskGenerationNoColor();
     void testMaskGenerationSingleColor();
     void testMaskGenerationDevColor();
     void testMaskGenerationDefaultColor();
 
 private Q_SLOTS:
 
     void testImageGeneration();
 
     void benchmarkPyramidCreation();
     void benchmarkScaling();
     void benchmarkRotation();
-
     void benchmarkMaskScaling();
+
     void testPyramidLevelRounding();
+    void testPyramidDabTransform();
 
     void testQPainterTransformationBorder();
 };
 
 #endif