diff --git a/plugins/tools/selectiontools/KisMagneticWorker.cc b/plugins/tools/selectiontools/KisMagneticWorker.cc
index 55db7ae32f..e0159aea10 100644
--- a/plugins/tools/selectiontools/KisMagneticWorker.cc
+++ b/plugins/tools/selectiontools/KisMagneticWorker.cc
@@ -1,279 +1,276 @@
 /*
  *  Copyright (c) 2019 Kuntal Majumder <hellozee@disroot.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "KisMagneticWorker.h"
 
 #include <kis_gaussian_kernel.h>
 #include <lazybrush/kis_lazy_fill_tools.h>
 #include <kis_algebra_2d.h>
 #include <kis_painter.h>
 
 #include <QtCore>
 #include <QPolygon>
 #include <QPainter>
 
 #include <boost/graph/astar_search.hpp>
 #include <krita_utils.h>
 
 #include "KisMagneticGraph.h"
 
 struct DistanceMap {
     typedef VertexDescriptor key_type;
     typedef double data_type;
     typedef std::pair<key_type, data_type> value_type;
 
     explicit DistanceMap(double const &dval)
         : m_default(dval)
     { }
 
     data_type &operator [] (key_type const &k)
     {
         if (m.find(k) == m.end())
             m[k] = m_default;
         return m[k];
     }
 
 private:
     std::map<key_type, data_type> m;
     data_type const               m_default;
 };
 
 struct PredecessorMap {
     PredecessorMap() = default;
 
     PredecessorMap(PredecessorMap const &that) = default;
 
     typedef VertexDescriptor key_type;
     typedef VertexDescriptor value_type;
     typedef boost::read_write_property_map_tag category;
 
     VertexDescriptor &operator [] (VertexDescriptor v)
     {
         return m_map[v];
     }
 
     std::map<VertexDescriptor, VertexDescriptor> m_map;
 };
 
 VertexDescriptor get(PredecessorMap const &m, VertexDescriptor v)
 {
     auto found = m.m_map.find(v);
     return found != m.m_map.end() ? found->second : v;
 }
 
 void put(PredecessorMap &m, VertexDescriptor key, VertexDescriptor value)
 {
     m.m_map[key] = value;
 }
 
 double EuclideanDistance(VertexDescriptor p1, VertexDescriptor p2)
 {
     return std::sqrt(std::pow(p1.y - p2.y, 2) + std::pow(p1.x - p2.x, 2));
 }
 
 class AStarHeuristic : public boost::astar_heuristic<KisMagneticGraph, double>
 {
 private:
     VertexDescriptor m_goal;
 
 public:
     explicit AStarHeuristic(VertexDescriptor goal) :
         m_goal(goal)
     { }
 
     double operator () (VertexDescriptor v)
     {
         return EuclideanDistance(v, m_goal);
     }
 };
 
 struct GoalFound { };
 
 class AStarGoalVisitor : public boost::default_astar_visitor
 {
 public:
     explicit AStarGoalVisitor(VertexDescriptor goal) : m_goal(goal){ }
 
     void examine_vertex(VertexDescriptor u, KisMagneticGraph const &g)
     {
         Q_UNUSED(g)
         if (u == m_goal) {
             throw GoalFound();
         }
     }
 
 private:
     VertexDescriptor m_goal;
 };
 
 struct WeightMap {
     typedef std::pair<VertexDescriptor, VertexDescriptor> key_type;
     typedef double data_type;
     typedef std::pair<key_type, data_type> value_type;
 
     WeightMap() = default;
 
     explicit WeightMap(const KisMagneticGraph &g) :
         m_graph(g)
     { }
 
     data_type &operator [] (key_type const &k)
     {
         if (m_map.find(k) == m_map.end()) {
             double edge_gradient = (m_graph.getIntensity(k.first) + m_graph.getIntensity(k.second)) / 2;
             m_map[k] = EuclideanDistance(k.first, k.second) + 255.0 - edge_gradient;
         }
         return m_map[k];
     }
 
 private:
     std::map<key_type, data_type> m_map;
     KisMagneticGraph              m_graph;
 };
 
-KisMagneticWorker::KisMagneticWorker(const KisPaintDeviceSP &dev)
+KisMagneticLazyTiles::KisMagneticLazyTiles(KisPaintDeviceSP dev)
 {
     m_dev = KisPainter::convertToAlphaAsGray(dev);
     QSize s = m_dev->exactBounds().size();
     m_tileSize    = KritaUtils::optimalPatchSize();
     m_tilesPerRow = std::ceil((double) s.width() / (double) m_tileSize.width());
     int tilesPerColumn = std::ceil((double) s.height() / (double) m_tileSize.height());
     m_dev->setDefaultBounds(dev->defaultBounds());
 
     for (int i = 0; i < tilesPerColumn; i++) {
         for (int j = 0; j < m_tilesPerRow; j++) {
             int width  = std::min(m_dev->exactBounds().width() - j * m_tileSize.width(), m_tileSize.width());
             int height = std::min(m_dev->exactBounds().height() - i * m_tileSize.height(), m_tileSize.height());
             QRect temp(j *m_tileSize.width(), i *m_tileSize.height(), width, height);
             m_tiles.push_back(temp);
         }
     }
 
     m_radiusRecord = QVector<qreal>(m_tiles.size(), -1);
 }
 
-void KisMagneticWorker::filterDevice(qreal radius, QRect &bounds)
+void KisMagneticLazyTiles::filter(qreal radius, QRect &rect)
 {
-    KisGaussianKernel::applyTightLoG(m_dev, bounds, radius, -1.0, QBitArray(), nullptr);
-    KisLazyFillTools::normalizeAlpha8Device(m_dev, bounds);
-}
-
-QPoint divide2DVal(QPoint p, QSize s)
-{
-    return QPoint(p.x() / s.width(), p.y() / s.height());
-}
-
-QVector<QPointF> KisMagneticWorker::computeEdge(int extraBounds, QPoint begin, QPoint end,
-     qreal radius)
-{
-    QRect rect;
-    KisAlgebra2D::accumulateBounds(QVector<QPoint> { begin, end }, &rect);
-    rect = kisGrowRect(rect, extraBounds);
+    auto divide = [](QPoint p, QSize s){
+        return QPoint(p.x() / s.width(), p.y() / s.height());
+    };
 
-    QPoint firstTile = divide2DVal(rect.topLeft(), m_tileSize);
-    QPoint lastTile  = divide2DVal(rect.bottomRight(), m_tileSize);
+    QPoint firstTile = divide(rect.topLeft(), m_tileSize);
+    QPoint lastTile  = divide(rect.bottomRight(), m_tileSize);
 
     for (int i = firstTile.y(); i <= lastTile.y(); i++) {
         for (int j = firstTile.x(); j <= lastTile.x(); j++) {
             int currentTile = i * m_tilesPerRow + j;
-            if (radius != m_radiusRecord[currentTile]) {
-                filterDevice(radius, m_tiles[currentTile]);
+            if (qFuzzyCompare(radius, m_radiusRecord[currentTile])) {
+                QRect bounds = m_tiles[currentTile];
+                KisGaussianKernel::applyTightLoG(m_dev, bounds, radius, -1.0, QBitArray(), nullptr);
+                KisLazyFillTools::normalizeAlpha8Device(m_dev, bounds);
                 m_radiusRecord[currentTile] = radius;
             }
         }
     }
+}
+
+KisMagneticWorker::KisMagneticWorker(const KisPaintDeviceSP &dev) :
+    m_lazyTileFilter(dev)
+{ }
+
+QVector<QPointF> KisMagneticWorker::computeEdge(int bounds, QPoint begin, QPoint end, qreal radius)
+{
+    QRect rect;
+    KisAlgebra2D::accumulateBounds(QVector<QPoint> { begin, end }, &rect);
+    rect = kisGrowRect(rect, bounds);
+
+    m_lazyTileFilter.filter(radius, rect);
+
     VertexDescriptor goal(end);
     VertexDescriptor start(begin);
 
-    KisMagneticGraph m_graph(m_dev, rect);
+    KisMagneticGraph m_graph(m_lazyTileFilter.device(), rect);
 
     // How many maps does it require?
     // Take a look here, if it doesn't make sense, https://www.boost.org/doc/libs/1_70_0/libs/graph/doc/astar_search.html
     PredecessorMap pmap;
     DistanceMap dmap(std::numeric_limits<double>::max());
     dmap[start] = 0;
     std::map<VertexDescriptor, double> rmap;
     std::map<VertexDescriptor, boost::default_color_type> cmap;
     std::map<VertexDescriptor, double> imap;
     WeightMap wmap(m_graph);
     AStarHeuristic heuristic(goal);
     QVector<QPointF> result;
 
     try {
         boost::astar_search_no_init(
             m_graph, start, heuristic,
             boost::visitor(AStarGoalVisitor(goal))
             .distance_map(boost::associative_property_map<DistanceMap>(dmap))
             .predecessor_map(boost::ref(pmap))
             .weight_map(boost::associative_property_map<WeightMap>(wmap))
             .vertex_index_map(boost::associative_property_map<std::map<VertexDescriptor, double> >(imap))
             .rank_map(boost::associative_property_map<std::map<VertexDescriptor, double> >(rmap))
             .color_map(boost::associative_property_map<std::map<VertexDescriptor, boost::default_color_type> >
                            (cmap))
             .distance_combine(std::plus<double>())
             .distance_compare(std::less<double>())
             );
     } catch (GoalFound const &) {
         for (VertexDescriptor u = goal; u != start; u = pmap[u]) {
             result.push_front(QPointF(u.x, u.y));
         }
     }
 
     result.push_front(QPoint(start.x, start.y));
 
     return result;
 } // KisMagneticWorker::computeEdge
 
 void KisMagneticWorker::saveTheImage(vQPointF points)
 {
-    QImage img = m_dev->convertToQImage(0, m_dev->exactBounds());
+    QImage img = m_lazyTileFilter.device()->convertToQImage(nullptr, m_lazyTileFilter.device()->exactBounds());
 
-    const QPointF offset = m_dev->exactBounds().topLeft();
+    const QPointF offset = m_lazyTileFilter.device()->exactBounds().topLeft();
     for (QPointF &pt : points) {
         pt -= offset;
     }
 
     img = img.convertToFormat(QImage::Format_ARGB32);
     QPainter gc(&img);
 
     QPainterPath path;
 
     for (int i = 0; i < points.size(); i++) {
         if (i == 0) {
             path.moveTo(points[i]);
         } else {
             path.lineTo(points[i]);
         }
     }
 
     gc.setPen(Qt::blue);
     gc.drawPath(path);
 
     gc.setPen(Qt::green);
     gc.drawEllipse(points[0], 3, 3);
     gc.setPen(Qt::red);
     gc.drawEllipse(points[points.count() - 1], 2, 2);
 
-    gc.setPen(Qt::red);
-    for (QRect &r: m_tiles) {
-        QString str = QString("%1x%2").arg(r.height()).arg(r.width());
-        gc.drawText(r, str);
-        gc.drawRect(r);
-    }
-
     img.save("result.png");
 } // KisMagneticWorker::saveTheImage
diff --git a/plugins/tools/selectiontools/KisMagneticWorker.h b/plugins/tools/selectiontools/KisMagneticWorker.h
index 7b9d6c0e79..d39bbf36be 100644
--- a/plugins/tools/selectiontools/KisMagneticWorker.h
+++ b/plugins/tools/selectiontools/KisMagneticWorker.h
@@ -1,45 +1,49 @@
 /*
  *  Copyright (c) 2019 Kuntal Majumder <hellozee@disroot.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 KISMAGNETICWORKER_H
 #define KISMAGNETICWORKER_H
 
 #include <kis_paint_device.h>
 #include <kritaselectiontools_export.h>
 
-class KRITASELECTIONTOOLS_EXPORT KisMagneticWorker {
+class KisMagneticLazyTiles{
+private:
+    QVector<QRect> m_tiles;
+    QVector<qreal> m_radiusRecord;
+    KisPaintDeviceSP m_dev;
+    QSize m_tileSize;
+    int m_tilesPerRow;
+
 public:
-    KisMagneticWorker()
-    {
-        // Do not use this, just for making the compiler happy
-    }
+    KisMagneticLazyTiles(KisPaintDeviceSP dev);
+    void filter(qreal radius, QRect &rect);
+    inline KisPaintDeviceSP device() { return m_dev; }
+};
 
+class KRITASELECTIONTOOLS_EXPORT KisMagneticWorker {
+public:
     KisMagneticWorker(const KisPaintDeviceSP &dev);
 
-    QVector<QPointF> computeEdge(int extraBounds, QPoint start, QPoint end, qreal radius);
+    QVector<QPointF> computeEdge(int bounds, QPoint start, QPoint end, qreal radius);
     void saveTheImage(vQPointF points);
 
 private:
-    void filterDevice(qreal radius, QRect &bounds);
-    KisPaintDeviceSP m_dev;
-    QVector<QRect> m_tiles;
-    QVector<qreal> m_radiusRecord;
-    QSize m_tileSize;
-    int m_tilesPerRow;
+    KisMagneticLazyTiles m_lazyTileFilter;
 };
 
 #endif // ifndef KISMAGNETICWORKER_H
diff --git a/plugins/tools/selectiontools/KisToolSelectMagnetic.cc b/plugins/tools/selectiontools/KisToolSelectMagnetic.cc
index cb5f2b8c60..4253535644 100644
--- a/plugins/tools/selectiontools/KisToolSelectMagnetic.cc
+++ b/plugins/tools/selectiontools/KisToolSelectMagnetic.cc
@@ -1,510 +1,504 @@
 /*
  *  Copyright (c) 2019 Kuntal Majumder <hellozee@disroot.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 "KisToolSelectMagnetic.h"
 
 #include <QApplication>
 #include <QPainter>
 #include <QWidget>
 #include <QPainterPath>
 #include <QLayout>
 #include <QVBoxLayout>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KoPointerEvent.h>
 #include <KoShapeController.h>
 #include <KoPathShape.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 #include <KoViewConverter.h>
 
 #include <kis_layer.h>
 #include <kis_selection_options.h>
 #include <kis_cursor.h>
 #include <kis_image.h>
 
 #include "kis_painter.h"
 #include <brushengine/kis_paintop_registry.h>
 #include "canvas/kis_canvas2.h"
 #include "kis_pixel_selection.h"
 #include "kis_selection_tool_helper.h"
 
 #include "kis_algebra_2d.h"
 
 #include "KisHandlePainterHelper.h"
 
 #include <kis_slider_spin_box.h>
 
 #define FEEDBACK_LINE_WIDTH 2
 
 KisToolSelectMagnetic::KisToolSelectMagnetic(KoCanvasBase *canvas)
     : KisToolSelect(canvas,
                     KisCursor::load("tool_magnetic_selection_cursor.png", 5, 5),
                     i18n("Magnetic Selection")),
-    m_continuedMode(false), m_complete(false), m_selected(false), m_finished(false), m_threshold(70),
+    m_continuedMode(false), m_complete(false), m_selected(false), m_finished(false), m_worker(image()->projection()), m_threshold(70),
     m_frequency(30), m_radius(3.0)
 { }
 
 void KisToolSelectMagnetic::keyPressEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Control) {
         m_continuedMode = true;
     }
 
     KisToolSelect::keyPressEvent(event);
 }
 
 void KisToolSelectMagnetic::keyReleaseEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Control ||
         !(event->modifiers() & Qt::ControlModifier))
     {
         m_continuedMode = false;
         if (mode() != PAINT_MODE && !m_points.isEmpty()) {
             finishSelectionAction();
         }
     }
 
     KisToolSelect::keyReleaseEvent(event);
 }
 
 vQPointF KisToolSelectMagnetic::computeEdgeWrapper(QPoint a, QPoint b)
 {
     return m_worker.computeEdge(m_frequency, a, b, m_radius);
 }
 
 // the cursor is still tracked even when no mousebutton is pressed
 void KisToolSelectMagnetic::mouseMoveEvent(KoPointerEvent *event)
 {
     m_lastCursorPos = convertToPixelCoord(event);
     KisToolSelect::mouseMoveEvent(event);
     updatePaintPath();
 } // KisToolSelectMagnetic::mouseMoveEvent
 
 // press primary mouse button
 void KisToolSelectMagnetic::beginPrimaryAction(KoPointerEvent *event)
 {
     setMode(KisTool::PAINT_MODE);
     QPointF temp(convertToPixelCoord(event));
 
     if(!image()->bounds().contains(temp.toPoint())){
         return;
     }
 
     if (m_complete) {
         checkIfAnchorIsSelected(temp);
         return;
     }
 
     if (m_points.count() != 0) {
         vQPointF edge = computeEdgeWrapper(m_anchorPoints.last(), temp.toPoint());
         m_points.append(edge);
         m_pointCollection.push_back(edge);
-        if (m_snapBound.contains(temp.toPoint())) {
+        if (m_snapBound.contains(temp)) {
             m_complete = true;
             return;
         }
     } else {
-        m_points.push_back(temp.toPoint());
-        m_snapBound = QRectF(temp.toPoint(), QSize(5, 5));
+        m_points.push_back(temp);
+        m_snapBound = QRectF(QPoint(0,0), QSize(5, 5));
+        m_snapBound.moveTo(temp);
     }
 
     m_lastAnchor = temp.toPoint();
     m_anchorPoints.push_back(m_lastAnchor);
     updateCanvasPixelRect(image()->bounds());
     m_complete = false;
 
     updatePaintPath();
 } // KisToolSelectMagnetic::beginPrimaryAction
 
 void KisToolSelectMagnetic::checkIfAnchorIsSelected(QPointF temp)
 {
     Q_FOREACH (const QPoint pt, m_anchorPoints) {
-        if (QRect(pt, QSize(5, 5)).contains(temp.toPoint())) {
+        QRect r = QRect(QPoint(0,0), QSize(5, 5));
+        r.moveCenter(pt);
+        if (r.contains(temp.toPoint())) {
             m_selected       = true;
             m_selectedAnchor = m_anchorPoints.lastIndexOf(pt);
             return;
         }
     }
 }
 
 void KisToolSelectMagnetic::beginPrimaryDoubleClickAction(KoPointerEvent *event)
 {
     if (m_complete) {
         QPointF temp = convertToPixelCoord(event);
         if(!image()->bounds().contains(temp.toPoint())){
             return;
         }
         int pointA = 0, pointB = 1;
         double dist = std::numeric_limits<double>::max();
         int total   = m_anchorPoints.count();
         for (int i = 0; i < total; i++) {
             double distToCompare =
                 kisDistance(m_anchorPoints[i], temp) + kisDistance(temp, m_anchorPoints[(i + 1) % total]);
             if (dist > distToCompare) {
                 pointA = i;
                 pointB = (i + 1) % total;
                 dist   = distToCompare;
             }
         }
 
         vQPointF path1 = computeEdgeWrapper(m_anchorPoints[pointA], temp.toPoint());
         vQPointF path2 = computeEdgeWrapper(temp.toPoint(), m_anchorPoints[pointB]);
 
         m_pointCollection[pointA] = path1;
         m_pointCollection.insert(pointB, path2);
         m_anchorPoints.insert(pointB, temp.toPoint());
 
         reEvaluatePoints();
     }
 }
 
 // drag while primary mouse button is pressed
 void KisToolSelectMagnetic::continuePrimaryAction(KoPointerEvent *event)
 {
     if (m_selected) {
         m_anchorPoints[m_selectedAnchor] = convertToPixelCoord(event).toPoint();
     }
     KisToolSelectBase::continuePrimaryAction(event);
 }
 
 // release primary mouse button
 void KisToolSelectMagnetic::endPrimaryAction(KoPointerEvent *event)
 {
     if (m_selected) {
         auto checkIfZero = [ = ](){
                                return m_selectedAnchor == 0 ? m_anchorPoints.count() - 1 : m_selectedAnchor - 1;
                            };
 
         QPoint currentAnchor  = m_anchorPoints[m_selectedAnchor];
         QPoint previousAnchor = m_anchorPoints[checkIfZero()];
         QPoint nextAnchor     = m_anchorPoints[(m_selectedAnchor + 1) % m_anchorPoints.count()];
 
         if (!image()->bounds().contains(m_anchorPoints[m_selectedAnchor])) {
             m_anchorPoints.remove(m_selectedAnchor);
             m_pointCollection[checkIfZero()] = computeEdgeWrapper(previousAnchor, nextAnchor);
             m_pointCollection.remove(m_selectedAnchor);
 
             if (m_selectedAnchor == 0)
-                m_snapBound = QRect(m_anchorPoints.first(), QSize(5, 5));
+                m_snapBound.moveCenter(m_anchorPoints.first());
         } else {
             m_pointCollection[checkIfZero()]    = computeEdgeWrapper(previousAnchor, currentAnchor);
             m_pointCollection[m_selectedAnchor] = computeEdgeWrapper(currentAnchor, nextAnchor);
         }
         reEvaluatePoints();
     }
     m_selected = false;
     KisToolSelectBase::endPrimaryAction(event);
 } // KisToolSelectMagnetic::endPrimaryAction
 
 void KisToolSelectMagnetic::reEvaluatePoints()
 {
     m_points.clear();
     Q_FOREACH (const vQPointF vec, m_pointCollection) {
         m_points.append(vec);
     }
 
     updatePaintPath();
 }
 
 void KisToolSelectMagnetic::finishSelectionAction()
 {
     KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->updateCanvas();
     setMode(KisTool::HOVER_MODE);
     m_complete = false;
     m_finished = true;
 
     // just for testing out
     // m_worker.saveTheImage(m_points);
 
     QRectF boundingViewRect =
         pixelToView(KisAlgebra2D::accumulateBounds(m_points));
 
     KisSelectionToolHelper helper(kisCanvas, kundo2_i18n("Magnetic Selection"));
 
     if (m_points.count() > 2 &&
         !helper.tryDeselectCurrentSelection(boundingViewRect, selectionAction()))
     {
         QApplication::setOverrideCursor(KisCursor::waitCursor());
 
         const SelectionMode mode =
             helper.tryOverrideSelectionMode(kisCanvas->viewManager()->selection(),
                                             selectionMode(),
                                             selectionAction());
         if (mode == PIXEL_SELECTION) {
             KisPixelSelectionSP tmpSel = KisPixelSelectionSP(new KisPixelSelection());
 
             KisPainter painter(tmpSel);
             painter.setPaintColor(KoColor(Qt::black, tmpSel->colorSpace()));
             painter.setAntiAliasPolygonFill(antiAliasSelection());
             painter.setFillStyle(KisPainter::FillStyleForegroundColor);
             painter.setStrokeStyle(KisPainter::StrokeStyleNone);
 
             painter.paintPolygon(m_points);
 
             QPainterPath cache;
             cache.addPolygon(m_points);
             cache.closeSubpath();
             tmpSel->setOutlineCache(cache);
 
             helper.selectPixelSelection(tmpSel, selectionAction());
         } else {
             KoPathShape *path = new KoPathShape();
             path->setShapeId(KoPathShapeId);
 
             QTransform resolutionMatrix;
             resolutionMatrix.scale(1 / currentImage()->xRes(), 1 / currentImage()->yRes());
             path->moveTo(resolutionMatrix.map(m_points[0]));
             for (int i = 1; i < m_points.count(); i++)
                 path->lineTo(resolutionMatrix.map(m_points[i]));
             path->close();
             path->normalize();
             helper.addSelectionShape(path, selectionAction());
         }
         QApplication::restoreOverrideCursor();
     }
 
     resetVariables();
 } // KisToolSelectMagnetic::finishSelectionAction
 
 void KisToolSelectMagnetic::resetVariables()
 {
     m_points.clear();
     m_anchorPoints.clear();
     m_pointCollection.clear();
     m_paintPath = QPainterPath();
 }
 
 void KisToolSelectMagnetic::updatePaintPath()
 {
     m_paintPath = QPainterPath();
     if (m_points.size() > 0) {
         m_paintPath.moveTo(pixelToView(m_points[0]));
     }
     for (int i = 1; i < m_points.count(); i++) {
         m_paintPath.lineTo(pixelToView(m_points[i]));
     }
 
     updateFeedback();
 
     if (m_continuedMode && mode() != PAINT_MODE) {
         updateContinuedMode();
     }
 
     updateCanvasPixelRect(image()->bounds());
 }
 
 void KisToolSelectMagnetic::paint(QPainter& gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
     updatePaintPath();
     if ((mode() == KisTool::PAINT_MODE || m_continuedMode) &&
         !m_points.isEmpty())
     {
         QPainterPath outline = m_paintPath;
         if (m_continuedMode && mode() != KisTool::PAINT_MODE) {
             outline.lineTo(pixelToView(m_lastCursorPos));
         }
         paintToolOutline(&gc, outline);
         drawAnchors(gc);
     }
 }
 
 void KisToolSelectMagnetic::drawAnchors(QPainter &gc)
 {
     Q_FOREACH (const QPoint pt, m_anchorPoints) {
         KisHandlePainterHelper helper(&gc, handleRadius());
-        if ((m_complete && QRect(pt, QSize(5, 5)).contains(m_lastCursorPos.toPoint())) ||
+        QRect r(QPoint(0,0), QSize(5,5));
+        r.moveCenter(pt);
+        if ((m_complete && r.contains(m_lastCursorPos.toPoint())) ||
             (m_snapBound.contains(m_lastCursorPos) && pt == m_anchorPoints.first()))
         {
             helper.setHandleStyle(KisHandleStyle::highlightedPrimaryHandles());
         } else {
             helper.setHandleStyle(KisHandleStyle::primarySelection());
         }
         helper.drawHandleRect(pixelToView(pt), 4, QPoint(0, 0));
     }
 }
 
 void KisToolSelectMagnetic::updateFeedback()
 {
     if (m_points.count() > 1) {
         qint32 lastPointIndex = m_points.count() - 1;
 
         QRectF updateRect = QRectF(m_points[lastPointIndex - 1], m_points[lastPointIndex]).normalized();
         updateRect = kisGrowRect(updateRect, FEEDBACK_LINE_WIDTH);
 
         updateCanvasPixelRect(updateRect);
     }
 }
 
 void KisToolSelectMagnetic::updateContinuedMode()
 {
     if (!m_points.isEmpty()) {
         qint32 lastPointIndex = m_points.count() - 1;
 
         QRectF updateRect = QRectF(m_points[lastPointIndex - 1], m_lastCursorPos).normalized();
         updateRect = kisGrowRect(updateRect, FEEDBACK_LINE_WIDTH);
 
         updateCanvasPixelRect(updateRect);
     }
 }
 
 void KisToolSelectMagnetic::activate(KoToolBase::ToolActivation activation, const QSet<KoShape *> &shapes)
 {
     m_worker      = KisMagneticWorker(image()->projection());
     m_configGroup = KSharedConfig::openConfig()->group(toolId());
     connect(action("undo_polygon_selection"), SIGNAL(triggered()), SLOT(undoPoints()), Qt::UniqueConnection);
     KisToolSelect::activate(activation, shapes);
 }
 
 void KisToolSelectMagnetic::deactivate()
 {
     KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->updateCanvas();
 
     m_continuedMode = false;
     m_complete      = true;
 
     disconnect(action("undo_polygon_selection"), nullptr, this, nullptr);
 
     KisTool::deactivate();
 }
 
 void KisToolSelectMagnetic::undoPoints()
 {
     if (m_complete) return;
 
     m_anchorPoints.pop_back();
-
-    if (m_anchorPoints.size() == 1) {
-        m_points.resize(1);
-    } else {
-        int last = m_points.count() - 1;
-        for (; last >= 0; last--) {
-            if (m_points[last] == m_anchorPoints.last()) {
-                break;
-            }
-        }
-        m_points.resize(last);
-    }
-    updatePaintPath();
+    m_pointCollection.pop_back();
+    reEvaluatePoints();
 }
 
 void KisToolSelectMagnetic::requestStrokeEnd()
 {
     if (m_finished || m_anchorPoints.count() < 2) return;
 
     finishSelectionAction();
     m_finished = false;
 }
 
 void KisToolSelectMagnetic::requestStrokeCancellation()
 {
     m_complete = false;
     m_points.clear();
     m_anchorPoints.clear();
     m_paintPath = QPainterPath();
     updatePaintPath();
 }
 
 QWidget * KisToolSelectMagnetic::createOptionWidget()
 {
     KisToolSelectBase::createOptionWidget();
     KisSelectionOptions *selectionWidget = selectionOptionWidget();
     QHBoxLayout *f1 = new QHBoxLayout();
     QLabel *lblRad  = new QLabel(i18n("Filter Radius: "), selectionWidget);
     f1->addWidget(lblRad);
 
     KisDoubleSliderSpinBox *radInput = new KisDoubleSliderSpinBox(selectionWidget);
     radInput->setObjectName("radius");
     radInput->setRange(2.5, 100.0, 2);
     radInput->setSingleStep(0.5);
     radInput->setToolTip("Radius of the filter for the detecting edges, might take some time to calculate");
     f1->addWidget(radInput);
     connect(radInput, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetRadius(qreal)));
 
     QHBoxLayout *f2      = new QHBoxLayout();
     QLabel *lblThreshold = new QLabel(i18n("Threshold: "), selectionWidget);
     f2->addWidget(lblThreshold);
 
     KisSliderSpinBox *threshInput = new KisSliderSpinBox(selectionWidget);
     threshInput->setObjectName("threshold");
     threshInput->setRange(1, 255);
     threshInput->setSingleStep(10);
     threshInput->setToolTip("Threshold for determining the minimum intensity of the edges");
     f2->addWidget(threshInput);
     connect(threshInput, SIGNAL(valueChanged(int)), this, SLOT(slotSetThreshold(int)));
 
     QHBoxLayout *f3     = new QHBoxLayout();
     QLabel *lblFrquency = new QLabel(i18n("Search Radius: "), selectionWidget);
     f3->addWidget(lblFrquency);
 
     KisSliderSpinBox *freqInput = new KisSliderSpinBox(selectionWidget);
     freqInput->setObjectName("frequency");
     freqInput->setRange(20, 200);
     freqInput->setSingleStep(10);
     freqInput->setToolTip("Extra area to be searched");
     freqInput->setSuffix(" px");
     f3->addWidget(freqInput);
     connect(freqInput, SIGNAL(valueChanged(int)), this, SLOT(slotSetFrequency(int)));
 
     QVBoxLayout *l = dynamic_cast<QVBoxLayout *>(selectionWidget->layout());
 
     l->insertLayout(1, f1);
     l->insertLayout(2, f2);
     l->insertLayout(3, f3);
 
     radInput->setValue(m_configGroup.readEntry("radius", 3.0));
     threshInput->setValue(m_configGroup.readEntry("threshold", 100));
     freqInput->setValue(m_configGroup.readEntry("frequency", 30));
     return selectionWidget;
 } // KisToolSelectMagnetic::createOptionWidget
 
 void KisToolSelectMagnetic::slotSetRadius(qreal r)
 {
     m_radius = r;
     m_configGroup.writeEntry("radius", r);
 }
 
 void KisToolSelectMagnetic::slotSetThreshold(int t)
 {
     m_threshold = t;
     m_configGroup.writeEntry("threshold", t);
 }
 
 void KisToolSelectMagnetic::slotSetFrequency(int f)
 {
     m_frequency = f;
     m_configGroup.writeEntry("frequency", f);
 }
 
 void KisToolSelectMagnetic::resetCursorStyle()
 {
     if (selectionAction() == SELECTION_ADD) {
         useCursor(KisCursor::load("tool_magnetic_selection_cursor_add.png", 6, 6));
     } else if (selectionAction() == SELECTION_SUBTRACT) {
         useCursor(KisCursor::load("tool_magnetic_selection_cursor_sub.png", 6, 6));
     } else {
         KisToolSelect::resetCursorStyle();
     }
 }