diff --git a/libs/image/brushengine/kis_paintop.cc b/libs/image/brushengine/kis_paintop.cc
index ac28205c37..c896dbb605 100644
--- a/libs/image/brushengine/kis_paintop.cc
+++ b/libs/image/brushengine/kis_paintop.cc
@@ -1,211 +1,211 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Clarence Dang <dang@kde.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2004,2007,2010 Cyrille Berger <cberger@cberger.net>
  *
  *  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_paintop.h"
 
-#include <math.h>
+#include <QtMath>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoPointerEvent.h>
 
 #include "kis_painter.h"
 #include "kis_layer.h"
 
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_global.h"
 #include "kis_datamanager.h"
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paint_information.h>
 #include "kis_vec.h"
 #include "kis_perspective_math.h"
 #include "kis_fixed_paint_device.h"
 #include "kis_paintop_utils.h"
 
 
 #define BEZIER_FLATNESS_THRESHOLD 0.5
 #include <kis_distance_information.h>
 
 #include <qnumeric.h>
 
 struct Q_DECL_HIDDEN KisPaintOp::Private {
     Private(KisPaintOp *_q)
         : q(_q), dab(0),
           fanCornersEnabled(false),
           fanCornersStep(1.0) {}
 
     KisPaintOp *q;
 
     KisFixedPaintDeviceSP dab;
     KisPainter* painter;
 
     bool fanCornersEnabled;
     qreal fanCornersStep;
 };
 
 
 KisPaintOp::KisPaintOp(KisPainter * painter) : d(new Private(this))
 {
     d->painter = painter;
 }
 
 KisPaintOp::~KisPaintOp()
 {
     d->dab.clear();
     delete d;
 }
 
 KisFixedPaintDeviceSP KisPaintOp::cachedDab()
 {
     return cachedDab(d->painter->device()->colorSpace());
 }
 
 KisFixedPaintDeviceSP KisPaintOp::cachedDab(const KoColorSpace *cs)
 {
     if (!d->dab || *d->dab->colorSpace() != *cs) {
         d->dab = new KisFixedPaintDevice(cs);
     }
     return d->dab;
 }
 
 void KisPaintOp::setFanCornersInfo(bool fanCornersEnabled, qreal fanCornersStep)
 {
     d->fanCornersEnabled = fanCornersEnabled;
     d->fanCornersStep = fanCornersStep;
 }
 
 void KisPaintOp::splitCoordinate(qreal coordinate, qint32 *whole, qreal *fraction)
 {
-    const qint32 i = std::floor(coordinate);
+    const qint32 i = qFloor(coordinate);
     const qreal f = coordinate - i;
 
     *whole = i;
     *fraction = f;
 }
 
 std::pair<int, bool> KisPaintOp::doAsyncronousUpdate(QVector<KisRunnableStrokeJobData *> &jobs)
 {
     Q_UNUSED(jobs);
     return std::make_pair(40, false);
 }
 
 static void paintBezierCurve(KisPaintOp *paintOp,
                              const KisPaintInformation &pi1,
                              const KisVector2D &control1,
                              const KisVector2D &control2,
                              const KisPaintInformation &pi2,
                              KisDistanceInformation *currentDistance)
 {
     LineEquation line = LineEquation::Through(toKisVector2D(pi1.pos()), toKisVector2D(pi2.pos()));
     qreal d1 = line.absDistance(control1);
     qreal d2 = line.absDistance(control2);
 
     if ((d1 < BEZIER_FLATNESS_THRESHOLD && d2 < BEZIER_FLATNESS_THRESHOLD)
             || qIsNaN(d1) || qIsNaN(d2)) {
         paintOp->paintLine(pi1, pi2, currentDistance);
     } else {
         // Midpoint subdivision. See Foley & Van Dam Computer Graphics P.508
         KisVector2D l2 = (toKisVector2D(pi1.pos()) + control1) / 2;
         KisVector2D h = (control1 + control2) / 2;
         KisVector2D l3 = (l2 + h) / 2;
         KisVector2D r3 = (control2 + toKisVector2D(pi2.pos())) / 2;
         KisVector2D r2 = (h + r3) / 2;
         KisVector2D l4 = (l3 + r2) / 2;
 
         KisPaintInformation middlePI = KisPaintInformation::mix(toQPointF(l4), 0.5, pi1, pi2);
 
         paintBezierCurve(paintOp, pi1, l2, l3, middlePI, currentDistance);
         paintBezierCurve(paintOp, middlePI, r2, r3, pi2, currentDistance);
     }
 }
 
 void KisPaintOp::paintBezierCurve(const KisPaintInformation &pi1,
                                   const QPointF &control1,
                                   const QPointF &control2,
                                   const KisPaintInformation &pi2,
                                   KisDistanceInformation *currentDistance)
 {
     return ::paintBezierCurve(this, pi1, toKisVector2D(control1), toKisVector2D(control2), pi2, currentDistance);
 }
 
 
 void KisPaintOp::paintLine(const KisPaintInformation &pi1,
                            const KisPaintInformation &pi2,
                            KisDistanceInformation *currentDistance)
 {
     KisPaintOpUtils::paintLine(*this, pi1, pi2, currentDistance,
                                d->fanCornersEnabled,
                                d->fanCornersStep);
 }
 
 void KisPaintOp::paintAt(const KisPaintInformation& info, KisDistanceInformation *currentDistance)
 {
     Q_ASSERT(currentDistance);
 
     KisPaintInformation pi(info);
     pi.paintAt(*this, currentDistance);
 }
 
 void KisPaintOp::updateSpacing(const KisPaintInformation &info,
                                KisDistanceInformation &currentDistance) const
 {
     KisPaintInformation pi(info);
     KisSpacingInformation spacingInfo;
     {
         KisPaintInformation::DistanceInformationRegistrar r
             = pi.registerDistanceInformation(&currentDistance);
         spacingInfo = updateSpacingImpl(pi);
     }
 
     currentDistance.updateSpacing(spacingInfo);
 }
 
 void KisPaintOp::updateTiming(const KisPaintInformation &info,
                               KisDistanceInformation &currentDistance) const
 {
     KisPaintInformation pi(info);
     KisTimingInformation timingInfo;
     {
         KisPaintInformation::DistanceInformationRegistrar r
             = pi.registerDistanceInformation(&currentDistance);
         timingInfo = updateTimingImpl(pi);
     }
 
     currentDistance.updateTiming(timingInfo);
 }
 
 KisTimingInformation KisPaintOp::updateTimingImpl(const KisPaintInformation &info) const
 {
     Q_UNUSED(info);
     return KisTimingInformation();
 }
 
 KisPainter* KisPaintOp::painter() const
 {
     return d->painter;
 }
 
 KisPaintDeviceSP KisPaintOp::source() const
 {
     return d->painter->device();
 }
diff --git a/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp b/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
index 34a34b52d1..187aeddc6e 100644
--- a/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
+++ b/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
@@ -1,426 +1,406 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004-2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Clarence Dang <dang@kde.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@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_brushop.h"
 
 #include <QRect>
 
 #include <kis_image.h>
 #include <kis_vec.h>
 #include <kis_debug.h>
 
 #include <KoColorTransformation.h>
 #include <KoColor.h>
 
 #include <kis_brush.h>
 #include <kis_global.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 #include <kis_brush_based_paintop_settings.h>
 #include <kis_lod_transform.h>
 #include <kis_paintop_plugin_utils.h>
 #include "krita_utils.h"
 #include <QtConcurrent>
 #include "kis_algebra_2d.h"
 #include <KisDabRenderingExecutor.h>
 #include <KisDabCacheUtils.h>
 #include <KisRenderedDab.h>
 #include "KisBrushOpResources.h"
 
 #include <KisRunnableStrokeJobData.h>
 #include <KisRunnableStrokeJobsInterface.h>
 
 #include <QSharedPointer>
 #include <QThread>
 #include "kis_image_config.h"
 #include "kis_wrapped_rect.h"
 
 
 KisBrushOp::KisBrushOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
     : KisBrushBasedPaintOp(settings, painter)
     , m_opacityOption(node)
     , m_avgSpacing(50)
     , m_avgNumDabs(50)
     , m_avgUpdateTimePerDab(50)
     , m_idealNumRects(KisImageConfig(true).maxNumberOfThreads())
     , m_minUpdatePeriod(10)
     , m_maxUpdatePeriod(100)
 {
     Q_UNUSED(image);
     Q_ASSERT(settings);
 
     /**
      * We do our own threading here, so we need to forbid the brushes
      * to do threading internally
      */
     m_brush->setThreadingAllowed(false);
 
     m_airbrushOption.readOptionSetting(settings);
 
     m_opacityOption.readOptionSetting(settings);
     m_flowOption.readOptionSetting(settings);
     m_sizeOption.readOptionSetting(settings);
     m_ratioOption.readOptionSetting(settings);
     m_spacingOption.readOptionSetting(settings);
     m_rateOption.readOptionSetting(settings);
     m_softnessOption.readOptionSetting(settings);
     m_rotationOption.readOptionSetting(settings);
     m_scatterOption.readOptionSetting(settings);
     m_sharpnessOption.readOptionSetting(settings);
 
     m_opacityOption.resetAllSensors();
     m_flowOption.resetAllSensors();
     m_sizeOption.resetAllSensors();
     m_ratioOption.resetAllSensors();
     m_rateOption.resetAllSensors();
     m_softnessOption.resetAllSensors();
     m_sharpnessOption.resetAllSensors();
     m_rotationOption.resetAllSensors();
     m_scatterOption.resetAllSensors();
     m_sharpnessOption.resetAllSensors();
 
     m_rotationOption.applyFanCornersInfo(this);
 
     KisBrushSP baseBrush = m_brush;
     auto resourcesFactory =
         [baseBrush, settings, painter] () {
             KisDabCacheUtils::DabRenderingResources *resources =
                 new KisBrushOpResources(settings, painter);
             resources->brush = baseBrush->clone();
 
             return resources;
         };
 
 
     m_dabExecutor.reset(
         new KisDabRenderingExecutor(
                     painter->device()->compositionSourceColorSpace(),
                     resourcesFactory,
                     painter->runnableStrokeJobsInterface(),
                     &m_mirrorOption,
                     &m_precisionOption));
 }
 
 KisBrushOp::~KisBrushOp()
 {
 }
 
 KisSpacingInformation KisBrushOp::paintAt(const KisPaintInformation& info)
 {
     if (!painter()->device()) return KisSpacingInformation(1.0);
 
     KisBrushSP brush = m_brush;
     Q_ASSERT(brush);
     if (!brush)
         return KisSpacingInformation(1.0);
 
     if (!brush->canPaintFor(info))
         return KisSpacingInformation(1.0);
 
     qreal scale = m_sizeOption.apply(info);
     scale *= KisLodTransform::lodToScale(painter()->device());
     if (checkSizeTooSmall(scale)) return KisSpacingInformation();
 
     qreal rotation = m_rotationOption.apply(info);
     qreal ratio = m_ratioOption.apply(info);
 
     KisDabShape shape(scale, ratio, rotation);
     QPointF cursorPos =
         m_scatterOption.apply(info,
                               brush->maskWidth(shape, 0, 0, info),
                               brush->maskHeight(shape, 0, 0, info));
 
     m_opacityOption.setFlow(m_flowOption.apply(info));
 
     quint8 dabOpacity = OPACITY_OPAQUE_U8;
     quint8 dabFlow = OPACITY_OPAQUE_U8;
 
     m_opacityOption.apply(info, &dabOpacity, &dabFlow);
 
     KisDabCacheUtils::DabRequestInfo request(painter()->paintColor(),
                                              cursorPos,
                                              shape,
                                              info,
                                              m_softnessOption.apply(info));
 
     m_dabExecutor->addDab(request, qreal(dabOpacity) / 255.0, qreal(dabFlow) / 255.0);
 
 
     KisSpacingInformation spacingInfo =
         effectiveSpacing(scale, rotation, &m_airbrushOption, &m_spacingOption, info);
 
     // gather statistics about dabs
     m_avgSpacing(spacingInfo.scalarApprox());
 
     return spacingInfo;
 }
 
 struct KisBrushOp::UpdateSharedState
 {
     // rendering data
     KisPainter *painter = 0;
     QList<KisRenderedDab> dabsQueue;
 
     // speed metrics
     QVector<QPointF> dabPoints;
     QElapsedTimer dabRenderingTimer;
 
     // final report
     QVector<QRect> allDirtyRects;
 };
 
 void KisBrushOp::addMirroringJobs(Qt::Orientation direction,
                                   QVector<QRect> &rects,
                                   UpdateSharedStateSP state,
                                   QVector<KisRunnableStrokeJobData*> &jobs)
 {
     jobs.append(new KisRunnableStrokeJobData(0, KisStrokeJobData::SEQUENTIAL));
 
     for (KisRenderedDab &dab : state->dabsQueue) {
         jobs.append(
             new KisRunnableStrokeJobData(
                 [state, &dab, direction] () {
                     state->painter->mirrorDab(direction, &dab);
                 },
                 KisStrokeJobData::CONCURRENT));
     }
 
     jobs.append(new KisRunnableStrokeJobData(0, KisStrokeJobData::SEQUENTIAL));
 
     for (QRect &rc : rects) {
         state->painter->mirrorRect(direction, &rc);
 
         jobs.append(
             new KisRunnableStrokeJobData(
                 [rc, state] () {
                     state->painter->bltFixed(rc, state->dabsQueue);
                 },
                 KisStrokeJobData::CONCURRENT));
     }
 
     state->allDirtyRects.append(rects);
 }
 
 std::pair<int, bool> KisBrushOp::doAsyncronousUpdate(QVector<KisRunnableStrokeJobData*> &jobs)
 {
     bool someDabsAreStillInQueue = false;
     const bool hasPreparedDabsAtStart = m_dabExecutor->hasPreparedDabs();
 
     if (!m_updateSharedState && hasPreparedDabsAtStart) {
 
         m_updateSharedState = toQShared(new UpdateSharedState());
         UpdateSharedStateSP state = m_updateSharedState;
 
         state->painter = painter();
 
         {
             const qreal dabRenderingTime = m_dabExecutor->averageDabRenderingTime();
             const qreal totalRenderingTimePerDab = dabRenderingTime + m_avgUpdateTimePerDab.rollingMeanSafe();
 
             // we limit the number of fetched dabs to fit the maximum update period and not
             // make visual hiccups
             const int dabsLimit =
                 totalRenderingTimePerDab > 0 ?
                     qMax(10, int(m_maxUpdatePeriod  / totalRenderingTimePerDab * m_idealNumRects)) :
                     -1;
 
             state->dabsQueue = m_dabExecutor->takeReadyDabs(painter()->hasMirroring(), dabsLimit, &someDabsAreStillInQueue);
         }
 
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!state->dabsQueue.isEmpty(),
                                              std::make_pair(m_currentUpdatePeriod, false));
 
         const int diameter = m_dabExecutor->averageDabSize();
         const qreal spacing = m_avgSpacing.rollingMean();
 
         const int idealNumRects = m_idealNumRects;
 
         QVector<QRect> rects;
 
         // wrap the dabs if needed
         if (painter()->device()->defaultBounds()->wrapAroundMode()) {
             /**
              * In WA mode we do two things:
              *
              * 1) We ensure that the parallel threads do not access the same are on
              *    the image. For normal updates that is ensured by the code in KisImage
              *    and the scheduler. Here we should do that manually by adjusting 'rects'
              *    so that they would not intersect in the wrapped space.
              *
              * 2) We duplicate dabs, to ensure that all the pieces of dabs are painted
              *    inside the wrapped rect. No pieces are dabs are painted twice, because
              *    we paint only the parts intersecting the wrap rect.
              */
 
             const QRect wrapRect = painter()->device()->defaultBounds()->bounds();
 
             QList<KisRenderedDab> wrappedDabs;
 
             Q_FOREACH (const KisRenderedDab &dab, state->dabsQueue) {
                 const QVector<QPoint> normalizationOrigins =
                     KisWrappedRect::normalizationOriginsForRect(dab.realBounds(), wrapRect);
 
                 Q_FOREACH(const QPoint &pt, normalizationOrigins) {
                     KisRenderedDab newDab = dab;
 
                     newDab.offset = pt;
 
                     rects.append(newDab.realBounds() & wrapRect);
                     wrappedDabs.append(newDab);
                 }
             }
 
             state->dabsQueue = wrappedDabs;
 
         } else {
             // just get all rects
             Q_FOREACH (const KisRenderedDab &dab, state->dabsQueue) {
                 rects.append(dab.realBounds());
             }
         }
 
         // split/merge rects into non-overlapping areas
         rects = KisPaintOpUtils::splitDabsIntoRects(rects,
                                                     idealNumRects, diameter, spacing);
 
         state->allDirtyRects = rects;
 
         Q_FOREACH (const KisRenderedDab &dab, state->dabsQueue) {
             state->dabPoints.append(dab.realBounds().center());
         }
 
         state->dabRenderingTimer.start();
 
         Q_FOREACH (const QRect &rc, rects) {
             jobs.append(
                 new KisRunnableStrokeJobData(
                     [rc, state] () {
                         state->painter->bltFixed(rc, state->dabsQueue);
                     },
                     KisStrokeJobData::CONCURRENT));
         }
 
         /**
          * After the dab has been rendered once, we should mirror it either one
          * (h __or__ v) or three (h __and__ v) times. This sequence of 'if's achieves
          * the goal without any extra copying. Please note that it has __no__ 'else'
          * branches, which is done intentionally!
          */
         if (state->painter->hasHorizontalMirroring()) {
             addMirroringJobs(Qt::Horizontal, rects, state, jobs);
         }
 
         if (state->painter->hasVerticalMirroring()) {
             addMirroringJobs(Qt::Vertical, rects, state, jobs);
         }
 
         if (state->painter->hasHorizontalMirroring() && state->painter->hasVerticalMirroring()) {
             addMirroringJobs(Qt::Horizontal, rects, state, jobs);
         }
 
         jobs.append(
             new KisRunnableStrokeJobData(
                 [state, this, someDabsAreStillInQueue] () {
                     Q_FOREACH(const QRect &rc, state->allDirtyRects) {
                         state->painter->addDirtyRect(rc);
                     }
 
                     state->painter->setAverageOpacity(state->dabsQueue.last().averageOpacity);
 
                     const int updateRenderingTime = state->dabRenderingTimer.elapsed();
                     const qreal dabRenderingTime = m_dabExecutor->averageDabRenderingTime();
 
                     m_avgNumDabs(state->dabsQueue.size());
 
                     const qreal currentUpdateTimePerDab = qreal(updateRenderingTime) / state->dabsQueue.size();
                     m_avgUpdateTimePerDab(currentUpdateTimePerDab);
 
                     /**
                      * NOTE: using currentUpdateTimePerDab in the calculation for the next update time instead
                      *       of the average one makes rendering speed about 40% faster. It happens because the
                      *       adaptation period is shorter than if it used
                      */
                     const qreal totalRenderingTimePerDab = dabRenderingTime + currentUpdateTimePerDab;
 
                     const int approxDabRenderingTime =
                         qreal(totalRenderingTimePerDab) * m_avgNumDabs.rollingMean() / m_idealNumRects;
 
                     m_currentUpdatePeriod =
                         someDabsAreStillInQueue ? m_minUpdatePeriod :
                         qBound(m_minUpdatePeriod, int(1.5 * approxDabRenderingTime), m_maxUpdatePeriod);
 
 
                     { // debug chunk
 //                        ENTER_FUNCTION() << ppVar(state->allDirtyRects.size()) << ppVar(state->dabsQueue.size()) << ppVar(dabRenderingTime) << ppVar(updateRenderingTime);
 //                        ENTER_FUNCTION() << ppVar(m_currentUpdatePeriod) << ppVar(someDabsAreStillInQueue);
                     }
 
                     // release all the dab devices
                     state->dabsQueue.clear();
 
                     m_updateSharedState.clear();
                 },
                 KisStrokeJobData::SEQUENTIAL));
     } else if (m_updateSharedState && hasPreparedDabsAtStart) {
         someDabsAreStillInQueue = true;
     }
 
     return std::make_pair(m_currentUpdatePeriod, someDabsAreStillInQueue);
 }
 
 KisSpacingInformation KisBrushOp::updateSpacingImpl(const KisPaintInformation &info) const
 {
     const qreal scale = m_sizeOption.apply(info) * KisLodTransform::lodToScale(painter()->device());
     qreal rotation = m_rotationOption.apply(info);
     return effectiveSpacing(scale, rotation, &m_airbrushOption, &m_spacingOption, info);
 }
 
 KisTimingInformation KisBrushOp::updateTimingImpl(const KisPaintInformation &info) const
 {
     return KisPaintOpPluginUtils::effectiveTiming(&m_airbrushOption, &m_rateOption, info);
 }
 
 void KisBrushOp::paintLine(const KisPaintInformation& pi1, const KisPaintInformation& pi2, KisDistanceInformation *currentDistance)
 {
-    if (m_sharpnessOption.isChecked() && m_brush && (m_brush->width() == 1) && (m_brush->height() == 1)) {
-
-        if (!m_lineCacheDevice) {
-            m_lineCacheDevice = source()->createCompositionSourceDevice();
-        }
-        else {
-            m_lineCacheDevice->clear();
-        }
-
-        KisPainter p(m_lineCacheDevice);
-        p.setPaintColor(painter()->paintColor());
-        p.drawDDALine(pi1.pos(), pi2.pos());
-
-        QRect rc = m_lineCacheDevice->extent();
-        painter()->bitBlt(rc.x(), rc.y(), m_lineCacheDevice, rc.x(), rc.y(), rc.width(), rc.height());
-    //fixes Bug 338011
-    painter()->renderMirrorMask(rc, m_lineCacheDevice);
-    }
-    else {
-        KisPaintOp::paintLine(pi1, pi2, currentDistance);
-    }
+    KisPaintOp::paintLine(pi1, pi2, currentDistance);
 }
diff --git a/plugins/paintops/libpaintop/kis_dab_cache_base.cpp b/plugins/paintops/libpaintop/kis_dab_cache_base.cpp
index 9fb631abae..d3bcaa83f1 100644
--- a/plugins/paintops/libpaintop/kis_dab_cache_base.cpp
+++ b/plugins/paintops/libpaintop/kis_dab_cache_base.cpp
@@ -1,280 +1,280 @@
 /*
  *  Copyright (c) 2012 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_dab_cache_base.h"
 
 #include <KoColor.h>
 #include "kis_color_source.h"
 #include "kis_paint_device.h"
 #include "kis_brush.h"
 #include <kis_pressure_mirror_option.h>
 #include <kis_pressure_sharpness_option.h>
 #include <kis_texture_option.h>
 #include <kis_precision_option.h>
 #include <kis_fixed_paint_device.h>
 #include <brushengine/kis_paintop.h>
 
 #include <kundo2command.h>
 
 struct PrecisionValues {
     qreal angle;
     qreal sizeFrac;
     qreal subPixel;
     qreal softnessFactor;
 };
 
 const qreal eps = 1e-6;
 static const PrecisionValues precisionLevels[] = {
     {M_PI / 180, 0.05,   1, 0.01},
     {M_PI / 180, 0.01,   1, 0.01},
     {M_PI / 180,    0,   1, 0.01},
     {M_PI / 180,    0, 0.5, 0.01},
     {eps,         0, eps,  eps}
 };
 
 struct KisDabCacheBase::SavedDabParameters {
     KoColor color;
     qreal angle;
     int width;
     int height;
     qreal subPixelX;
     qreal subPixelY;
     qreal softnessFactor;
     int index;
     MirrorProperties mirrorProperties;
 
     bool compare(const SavedDabParameters &rhs, int precisionLevel) const {
         const PrecisionValues &prec = precisionLevels[precisionLevel];
 
         return color == rhs.color &&
                qAbs(angle - rhs.angle) <= prec.angle &&
                qAbs(width - rhs.width) <= (int)(prec.sizeFrac * width) &&
                qAbs(height - rhs.height) <= (int)(prec.sizeFrac * height) &&
                qAbs(subPixelX - rhs.subPixelX) <= prec.subPixel &&
                qAbs(subPixelY - rhs.subPixelY) <= prec.subPixel &&
                qAbs(softnessFactor - rhs.softnessFactor) <= prec.softnessFactor &&
                index == rhs.index &&
                mirrorProperties.horizontalMirror == rhs.mirrorProperties.horizontalMirror &&
                mirrorProperties.verticalMirror == rhs.mirrorProperties.verticalMirror;
     }
 };
 
 struct KisDabCacheBase::Private {
 
     Private()
         : mirrorOption(0),
           precisionOption(0),
           subPixelPrecisionDisabled(false)
     {}
 
     KisPressureMirrorOption *mirrorOption;
     KisPrecisionOption *precisionOption;
     bool subPixelPrecisionDisabled;
 
     SavedDabParameters lastSavedDabParameters;
 
     static qreal positiveFraction(qreal x);
 };
 
 
 
 KisDabCacheBase::KisDabCacheBase()
     : m_d(new Private())
 {
 }
 
 KisDabCacheBase::~KisDabCacheBase()
 {
     delete m_d;
 }
 
 void KisDabCacheBase::setMirrorPostprocessing(KisPressureMirrorOption *option)
 {
     m_d->mirrorOption = option;
 }
 
 void KisDabCacheBase::setPrecisionOption(KisPrecisionOption *option)
 {
     m_d->precisionOption = option;
 }
 
 void KisDabCacheBase::disableSubpixelPrecision()
 {
     m_d->subPixelPrecisionDisabled = true;
 }
 
 inline KisDabCacheBase::SavedDabParameters
 KisDabCacheBase::getDabParameters(KisBrushSP brush,
                               const KoColor& color,
                               KisDabShape const& shape,
                               const KisPaintInformation& info,
                               double subPixelX, double subPixelY,
                               qreal softnessFactor,
                               MirrorProperties mirrorProperties)
 {
     SavedDabParameters params;
 
     params.color = color;
     params.angle = shape.rotation();
     params.width = brush->maskWidth(shape, subPixelX, subPixelY, info);
     params.height = brush->maskHeight(shape, subPixelX, subPixelY, info);
     params.subPixelX = subPixelX;
     params.subPixelY = subPixelY;
     params.softnessFactor = softnessFactor;
     params.index = brush->brushIndex(info);
     params.mirrorProperties = mirrorProperties;
 
     return params;
 }
 
 bool KisDabCacheBase::needSeparateOriginal(KisTextureProperties *textureOption,
                                            KisPressureSharpnessOption *sharpnessOption) const
 {
     return (textureOption && textureOption->m_enabled) ||
            (sharpnessOption && sharpnessOption->isChecked());
 }
 
 struct KisDabCacheBase::DabPosition {
     DabPosition(const QRect &_rect,
                 const QPointF &_subPixel,
                 qreal _realAngle)
         : rect(_rect),
           subPixel(_subPixel),
           realAngle(_realAngle) {
     }
 
     QRect rect;
     QPointF subPixel;
     qreal realAngle;
 };
 
 qreal KisDabCacheBase::Private::positiveFraction(qreal x) {
     qint32 unused = 0;
     qreal fraction = 0.0;
     KisPaintOp::splitCoordinate(x, &unused, &fraction);
 
     return fraction;
 }
 
 inline
 KisDabCacheBase::DabPosition
 KisDabCacheBase::calculateDabRect(KisBrushSP brush,
                                   const QPointF &cursorPoint,
                                   KisDabShape shape,
                                   const KisPaintInformation& info,
                                   const MirrorProperties &mirrorProperties,
                                   KisPressureSharpnessOption *sharpnessOption)
 {
     qint32 x = 0, y = 0;
     qreal subPixelX = 0.0, subPixelY = 0.0;
 
     if (mirrorProperties.coordinateSystemFlipped) {
         shape = KisDabShape(shape.scale(), shape.ratio(), 2 * M_PI - shape.rotation());
     }
 
     QPointF hotSpot = brush->hotSpot(shape, info);
     QPointF pt = cursorPoint - hotSpot;
 
-    if (sharpnessOption) {
+    if (sharpnessOption && !(brush->width() == 1 && brush->height() ==1)) {
         sharpnessOption->apply(info, pt, x, y, subPixelX, subPixelY);
     }
     else {
         KisPaintOp::splitCoordinate(pt.x(), &x, &subPixelX);
         KisPaintOp::splitCoordinate(pt.y(), &y, &subPixelY);
     }
 
     if (m_d->subPixelPrecisionDisabled) {
         subPixelX = 0;
         subPixelY = 0;
     }
 
     if (qIsNaN(subPixelX)) {
         subPixelX = 0;
     }
 
     if (qIsNaN(subPixelY)) {
         subPixelY = 0;
     }
 
     int width = brush->maskWidth(shape, subPixelX, subPixelY, info);
     int height = brush->maskHeight(shape, subPixelX, subPixelY, info);
 
     if (mirrorProperties.horizontalMirror) {
         subPixelX = Private::positiveFraction(-(cursorPoint.x() + hotSpot.x()));
         width = brush->maskWidth(shape, subPixelX, subPixelY, info);
         x = qRound(cursorPoint.x() + subPixelX + hotSpot.x()) - width;
     }
 
     if (mirrorProperties.verticalMirror) {
         subPixelY = Private::positiveFraction(-(cursorPoint.y() + hotSpot.y()));
         height = brush->maskHeight(shape, subPixelX, subPixelY, info);
         y = qRound(cursorPoint.y() + subPixelY + hotSpot.y()) - height;
     }
 
     return DabPosition(QRect(x, y, width, height),
                        QPointF(subPixelX, subPixelY),
                        shape.rotation());
 }
 
 void KisDabCacheBase::fetchDabGenerationInfo(bool hasDabInCache,
                                              KisDabCacheUtils::DabRenderingResources *resources,
                                              const KisDabCacheUtils::DabRequestInfo &request,
                                              KisDabCacheUtils::DabGenerationInfo *di,
                                              bool *shouldUseCache)
 {
     di->info = request.info;
     di->softnessFactor = request.softnessFactor;
 
     if (m_d->mirrorOption) {
         di->mirrorProperties = m_d->mirrorOption->apply(request.info);
     }
 
     DabPosition position = calculateDabRect(resources->brush,
                                             request.cursorPoint,
                                             request.shape,
                                             request.info,
                                             di->mirrorProperties,
                                             resources->sharpnessOption.data());
     di->shape = KisDabShape(request.shape.scale(), request.shape.ratio(), position.realAngle);
     di->dstDabRect = position.rect;
     di->subPixel = position.subPixel;
 
     di->solidColorFill = !resources->colorSource || resources->colorSource->isUniformColor();
     di->paintColor = resources->colorSource && resources->colorSource->isUniformColor() ?
                 resources->colorSource->uniformColor() : request.color;
 
     SavedDabParameters newParams = getDabParameters(resources->brush,
                                                     di->paintColor,
                                                     di->shape,
                                                     di->info,
                                                     di->subPixel.x(),
                                                     di->subPixel.y(),
                                                     di->softnessFactor,
                                                     di->mirrorProperties);
 
     const int precisionLevel = m_d->precisionOption ? m_d->precisionOption->precisionLevel() - 1 : 3;
     *shouldUseCache = hasDabInCache && di->solidColorFill &&
             newParams.compare(m_d->lastSavedDabParameters, precisionLevel);
 
     if (!*shouldUseCache) {
         m_d->lastSavedDabParameters = newParams;
     }
 
     di->needsPostprocessing = needSeparateOriginal(resources->textureOption.data(), resources->sharpnessOption.data());
 }