diff --git a/plugins/tools/tool_transform2/tool_transform_args.cc b/plugins/tools/tool_transform2/tool_transform_args.cc
index ce49669134..a013d3a4c4 100644
--- a/plugins/tools/tool_transform2/tool_transform_args.cc
+++ b/plugins/tools/tool_transform2/tool_transform_args.cc
@@ -1,510 +1,492 @@
 /*
  *  tool_transform_args.h - part of Krita
  *
  *  Copyright (c) 2010 Marc Pegon <pe.marc@free.fr>
  *
  *  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 "tool_transform_args.h"
 
 #include <QDomElement>
 
 #include <ksharedconfig.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 #include "kis_liquify_transform_worker.h"
 #include "kis_dom_utils.h"
 
 
 ToolTransformArgs::ToolTransformArgs()
-    : m_mode(FREE_TRANSFORM)
-    , m_defaultPoints(true)
-    , m_origPoints {QVector<QPointF>()}
-    , m_transfPoints {QVector<QPointF>()}
-    , m_warpType(KisWarpTransformWorker::RIGID_TRANSFORM)
-    , m_alpha(1.0)
-    , m_transformedCenter(QPointF(0, 0))
-    , m_originalCenter(QPointF(0, 0))
-    , m_rotationCenterOffset(QPointF(0, 0))
-    , m_aX(0)
-    , m_aY(0)
-    , m_aZ(0)
-    , m_scaleX(1.0)
-    , m_scaleY(1.0)
-    , m_shearX(0.0)
-    , m_shearY(0.0)
-    , m_liquifyProperties(new KisLiquifyProperties())
-    , m_pixelPrecision(8)
-    , m_previewPixelPrecision(16)
+    : m_liquifyProperties(new KisLiquifyProperties())
 {
     KConfigGroup configGroup =  KSharedConfig::openConfig()->group("KisToolTransform");
     QString savedFilterId = configGroup.readEntry("filterId", "Bicubic");
     setFilterId(savedFilterId);
     m_transformAroundRotationCenter = configGroup.readEntry("transformAroundRotationCenter", "0").toInt();
 }
 
 void ToolTransformArgs::setFilterId(const QString &id) {
     m_filter = KisFilterStrategyRegistry::instance()->value(id);
 
     if (m_filter) {
         KConfigGroup configGroup =  KSharedConfig::openConfig()->group("KisToolTransform");
         configGroup.writeEntry("filterId", id);
     }
 }
 
 void ToolTransformArgs::setTransformAroundRotationCenter(bool value)
 {
     m_transformAroundRotationCenter = value;
 
     KConfigGroup configGroup =  KSharedConfig::openConfig()->group("KisToolTransform");
     configGroup.writeEntry("transformAroundRotationCenter", int(value));
 }
 
 void ToolTransformArgs::init(const ToolTransformArgs& args)
 {
     m_mode = args.mode();
     m_transformedCenter = args.transformedCenter();
     m_originalCenter = args.originalCenter();
     m_rotationCenterOffset = args.rotationCenterOffset();
     m_transformAroundRotationCenter = args.transformAroundRotationCenter();
     m_cameraPos = args.m_cameraPos;
     m_aX = args.aX();
     m_aY = args.aY();
     m_aZ = args.aZ();
     m_scaleX = args.scaleX();
     m_scaleY = args.scaleY();
     m_shearX = args.shearX();
     m_shearY = args.shearY();
     m_origPoints = args.origPoints(); //it's a copy
     m_transfPoints = args.transfPoints();
     m_warpType = args.warpType();
     m_alpha = args.alpha();
     m_defaultPoints = args.defaultPoints();
     m_keepAspectRatio = args.keepAspectRatio();
     m_filter = args.m_filter;
     m_flattenedPerspectiveTransform = args.m_flattenedPerspectiveTransform;
     m_editTransformPoints = args.m_editTransformPoints;
     m_pixelPrecision = args.pixelPrecision();
     m_previewPixelPrecision = args.previewPixelPrecision();
 
     if (args.m_liquifyWorker) {
         m_liquifyWorker.reset(new KisLiquifyTransformWorker(*args.m_liquifyWorker.data()));
     }
 
     m_continuedTransformation.reset(args.m_continuedTransformation ? new ToolTransformArgs(*args.m_continuedTransformation) : 0);
 }
 
 void ToolTransformArgs::clear()
 {
     m_origPoints.clear();
     m_transfPoints.clear();
 }
 
 ToolTransformArgs::ToolTransformArgs(const ToolTransformArgs& args)
     : m_liquifyProperties(new KisLiquifyProperties(*args.m_liquifyProperties.data()))
 {
     init(args);
 }
 
 KisToolChangesTrackerData *ToolTransformArgs::clone() const
 {
     return new ToolTransformArgs(*this);
 }
 
 ToolTransformArgs& ToolTransformArgs::operator=(const ToolTransformArgs& args)
 {
     clear();
 
     m_liquifyProperties.reset(new KisLiquifyProperties(*args.m_liquifyProperties.data()));
     init(args);
 
     return *this;
 }
 
 bool ToolTransformArgs::operator==(const ToolTransformArgs& other) const
 {
     return
         m_mode == other.m_mode &&
         m_defaultPoints == other.m_defaultPoints &&
         m_origPoints == other.m_origPoints &&
         m_transfPoints == other.m_transfPoints &&
         m_warpType == other.m_warpType &&
         m_alpha == other.m_alpha &&
         m_transformedCenter == other.m_transformedCenter &&
         m_originalCenter == other.m_originalCenter &&
         m_rotationCenterOffset == other.m_rotationCenterOffset &&
         m_transformAroundRotationCenter == other.m_transformAroundRotationCenter &&
         m_aX == other.m_aX &&
         m_aY == other.m_aY &&
         m_aZ == other.m_aZ &&
         m_cameraPos == other.m_cameraPos &&
         m_scaleX == other.m_scaleX &&
         m_scaleY == other.m_scaleY &&
         m_shearX == other.m_shearX &&
         m_shearY == other.m_shearY &&
         m_keepAspectRatio == other.m_keepAspectRatio &&
         m_flattenedPerspectiveTransform == other.m_flattenedPerspectiveTransform &&
         m_editTransformPoints == other.m_editTransformPoints &&
         (m_liquifyProperties == other.m_liquifyProperties ||
          *m_liquifyProperties == *other.m_liquifyProperties) &&
 
         // pointer types
 
         ((m_filter && other.m_filter &&
           m_filter->id() == other.m_filter->id())
          || m_filter == other.m_filter) &&
 
         ((m_liquifyWorker && other.m_liquifyWorker &&
           *m_liquifyWorker == *other.m_liquifyWorker)
          || m_liquifyWorker == other.m_liquifyWorker) &&
             m_pixelPrecision == other.m_pixelPrecision &&
             m_previewPixelPrecision == other.m_previewPixelPrecision;
 }
 
 bool ToolTransformArgs::isSameMode(const ToolTransformArgs& other) const
 {
     if (m_mode != other.m_mode) return false;
 
     bool result = true;
 
     if (m_mode == FREE_TRANSFORM) {
         result &= m_transformedCenter == other.m_transformedCenter;
         result &= m_originalCenter == other.m_originalCenter;
         result &= m_scaleX == other.m_scaleX;
         result &= m_scaleY == other.m_scaleY;
         result &= m_shearX == other.m_shearX;
         result &= m_shearY == other.m_shearY;
         result &= m_aX == other.m_aX;
         result &= m_aY == other.m_aY;
         result &= m_aZ == other.m_aZ;
 
     } else if (m_mode == PERSPECTIVE_4POINT) {
         result &= m_transformedCenter == other.m_transformedCenter;
         result &= m_originalCenter == other.m_originalCenter;
         result &= m_scaleX == other.m_scaleX;
         result &= m_scaleY == other.m_scaleY;
         result &= m_shearX == other.m_shearX;
         result &= m_shearY == other.m_shearY;
         result &= m_flattenedPerspectiveTransform == other.m_flattenedPerspectiveTransform;
 
     } else if(m_mode == WARP || m_mode == CAGE) {
         result &= m_origPoints == other.m_origPoints;
         result &= m_transfPoints == other.m_transfPoints;
 
     } else if (m_mode == LIQUIFY) {
         result &= m_liquifyProperties &&
             (m_liquifyProperties == other.m_liquifyProperties ||
              *m_liquifyProperties == *other.m_liquifyProperties);
 
         result &=
             (m_liquifyWorker && other.m_liquifyWorker &&
              *m_liquifyWorker == *other.m_liquifyWorker)
             || m_liquifyWorker == other.m_liquifyWorker;
 
     } else {
         KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "unknown transform mode");
     }
 
     return result;
 }
 
 ToolTransformArgs::ToolTransformArgs(TransformMode mode,
                                      QPointF transformedCenter,
                                      QPointF originalCenter,
                                      QPointF rotationCenterOffset,
                                      bool transformAroundRotationCenter,
                                      double aX, double aY, double aZ,
                                      double scaleX, double scaleY,
                                      double shearX, double shearY,
                                      KisWarpTransformWorker::WarpType warpType,
                                      double alpha,
                                      bool defaultPoints,
                                      const QString &filterId,
                                      int pixelPrecision, int previewPixelPrecision)
     : m_mode(mode)
     , m_defaultPoints(defaultPoints)
     , m_origPoints {QVector<QPointF>()}
     , m_transfPoints {QVector<QPointF>()}
     , m_warpType(warpType)
     , m_alpha(alpha)
     , m_transformedCenter(transformedCenter)
     , m_originalCenter(originalCenter)
     , m_rotationCenterOffset(rotationCenterOffset)
     , m_transformAroundRotationCenter(transformAroundRotationCenter)
     , m_aX(aX)
     , m_aY(aY)
     , m_aZ(aZ)
     , m_scaleX(scaleX)
     , m_scaleY(scaleY)
     , m_shearX(shearX)
     , m_shearY(shearY)
     , m_liquifyProperties(new KisLiquifyProperties())
     , m_pixelPrecision(pixelPrecision)
     , m_previewPixelPrecision(previewPixelPrecision)
 {
     setFilterId(filterId);
 }
 
 
 ToolTransformArgs::~ToolTransformArgs()
 {
     clear();
 }
 
 void ToolTransformArgs::translate(const QPointF &offset)
 {
     if (m_mode == FREE_TRANSFORM || m_mode == PERSPECTIVE_4POINT) {
         m_originalCenter += offset;
         m_rotationCenterOffset += offset;
         m_transformedCenter += offset;
     } else if(m_mode == WARP || m_mode == CAGE) {
         for (auto &pt : m_origPoints) {
             pt += offset;
         }
 
         for (auto &pt : m_transfPoints) {
             pt += offset;
         }
     } else if (m_mode == LIQUIFY) {
         KIS_ASSERT_RECOVER_RETURN(m_liquifyWorker);
         m_liquifyWorker->translate(offset);
     } else {
         KIS_ASSERT_RECOVER_NOOP(0 && "unknown transform mode");
     }
 }
 
 bool ToolTransformArgs::isIdentity() const
 {
     if (m_mode == FREE_TRANSFORM) {
         return (m_transformedCenter == m_originalCenter && m_scaleX == 1
                 && m_scaleY == 1 && m_shearX == 0 && m_shearY == 0
                 && m_aX == 0 && m_aY == 0 && m_aZ == 0);
     } else if (m_mode == PERSPECTIVE_4POINT) {
             return (m_transformedCenter == m_originalCenter && m_scaleX == 1
                     && m_scaleY == 1 && m_shearX == 0 && m_shearY == 0
                     && m_flattenedPerspectiveTransform.isIdentity());
     } else if(m_mode == WARP || m_mode == CAGE) {
         for (int i = 0; i < m_origPoints.size(); ++i)
             if (m_origPoints[i] != m_transfPoints[i])
                 return false;
 
         return true;
     } else if (m_mode == LIQUIFY) {
         // Not implemented!
         return false;
     } else {
         KIS_ASSERT_RECOVER_NOOP(0 && "unknown transform mode");
         return true;
     }
 }
 
 void ToolTransformArgs::initLiquifyTransformMode(const QRect &srcRect)
 {
     m_liquifyWorker.reset(new KisLiquifyTransformWorker(srcRect, 0, 8));
     m_liquifyProperties->loadAndResetMode();
 }
 
 void ToolTransformArgs::saveLiquifyTransformMode() const
 {
     m_liquifyProperties->saveMode();
 }
 
 void ToolTransformArgs::toXML(QDomElement *e) const
 {
     e->setAttribute("mode", (int) m_mode);
 
     QDomDocument doc = e->ownerDocument();
 
     if (m_mode == FREE_TRANSFORM || m_mode == PERSPECTIVE_4POINT) {
 
         QDomElement freeEl = doc.createElement("free_transform");
         e->appendChild(freeEl);
 
         KisDomUtils::saveValue(&freeEl, "transformedCenter", m_transformedCenter);
         KisDomUtils::saveValue(&freeEl, "originalCenter", m_originalCenter);
         KisDomUtils::saveValue(&freeEl, "rotationCenterOffset", m_rotationCenterOffset);
         KisDomUtils::saveValue(&freeEl, "transformAroundRotationCenter", m_transformAroundRotationCenter);
 
         KisDomUtils::saveValue(&freeEl, "aX", m_aX);
         KisDomUtils::saveValue(&freeEl, "aY", m_aY);
         KisDomUtils::saveValue(&freeEl, "aZ", m_aZ);
 
         KisDomUtils::saveValue(&freeEl, "cameraPos", m_cameraPos);
 
         KisDomUtils::saveValue(&freeEl, "scaleX", m_scaleX);
         KisDomUtils::saveValue(&freeEl, "scaleY", m_scaleY);
 
         KisDomUtils::saveValue(&freeEl, "shearX", m_shearX);
         KisDomUtils::saveValue(&freeEl, "shearY", m_shearY);
 
         KisDomUtils::saveValue(&freeEl, "keepAspectRatio", m_keepAspectRatio);
         KisDomUtils::saveValue(&freeEl, "flattenedPerspectiveTransform", m_flattenedPerspectiveTransform);
 
         KisDomUtils::saveValue(&freeEl, "filterId", m_filter->id());
 
     } else if (m_mode == WARP || m_mode == CAGE) {
         QDomElement warpEl = doc.createElement("warp_transform");
         e->appendChild(warpEl);
 
         KisDomUtils::saveValue(&warpEl, "defaultPoints", m_defaultPoints);
         KisDomUtils::saveValue(&warpEl, "originalPoints", m_origPoints);
         KisDomUtils::saveValue(&warpEl, "transformedPoints", m_transfPoints);
 
         KisDomUtils::saveValue(&warpEl, "warpType", (int)m_warpType); // limited!
         KisDomUtils::saveValue(&warpEl, "alpha", m_alpha);
 
         if(m_mode == CAGE){
             KisDomUtils::saveValue(&warpEl,"pixelPrecision",m_pixelPrecision);
             KisDomUtils::saveValue(&warpEl,"previewPixelPrecision",m_previewPixelPrecision);
         }
 
     } else if (m_mode == LIQUIFY) {
         QDomElement liqEl = doc.createElement("liquify_transform");
         e->appendChild(liqEl);
 
         m_liquifyProperties->toXML(&liqEl);
         m_liquifyWorker->toXML(&liqEl);
     } else {
         KIS_ASSERT_RECOVER_RETURN(0 && "Unknown transform mode");
     }
 
     // m_editTransformPoints should not be saved since it is reset explicitly
 }
 
 ToolTransformArgs ToolTransformArgs::fromXML(const QDomElement &e)
 {
     ToolTransformArgs args;
 
     int newMode = e.attribute("mode", "0").toInt();
     if (newMode < 0 || newMode >= N_MODES) return ToolTransformArgs();
 
     args.m_mode = (TransformMode) newMode;
 
     // reset explicitly
     args.m_editTransformPoints = false;
 
     bool result = false;
 
     if (args.m_mode == FREE_TRANSFORM || args.m_mode == PERSPECTIVE_4POINT) {
 
         QDomElement freeEl;
 
         QString filterId;
 
         result =
             KisDomUtils::findOnlyElement(e, "free_transform", &freeEl) &&
 
             KisDomUtils::loadValue(freeEl, "transformedCenter", &args.m_transformedCenter) &&
             KisDomUtils::loadValue(freeEl, "originalCenter", &args.m_originalCenter) &&
             KisDomUtils::loadValue(freeEl, "rotationCenterOffset", &args.m_rotationCenterOffset) &&
 
             KisDomUtils::loadValue(freeEl, "aX", &args.m_aX) &&
             KisDomUtils::loadValue(freeEl, "aY", &args.m_aY) &&
             KisDomUtils::loadValue(freeEl, "aZ", &args.m_aZ) &&
 
             KisDomUtils::loadValue(freeEl, "cameraPos", &args.m_cameraPos) &&
 
             KisDomUtils::loadValue(freeEl, "scaleX", &args.m_scaleX) &&
             KisDomUtils::loadValue(freeEl, "scaleY", &args.m_scaleY) &&
 
             KisDomUtils::loadValue(freeEl, "shearX", &args.m_shearX) &&
             KisDomUtils::loadValue(freeEl, "shearY", &args.m_shearY) &&
 
             KisDomUtils::loadValue(freeEl, "keepAspectRatio", &args.m_keepAspectRatio) &&
             KisDomUtils::loadValue(freeEl, "flattenedPerspectiveTransform", &args.m_flattenedPerspectiveTransform) &&
             KisDomUtils::loadValue(freeEl, "filterId", &filterId);
 
         // transformAroundRotationCenter is a new parameter introduced in Krita 4.0,
         // so it might be not present in older transform masks
         if (!KisDomUtils::loadValue(freeEl, "transformAroundRotationCenter", &args.m_transformAroundRotationCenter)) {
             args.m_transformAroundRotationCenter = false;
         }
 
         if (result) {
             args.m_filter = KisFilterStrategyRegistry::instance()->value(filterId);
             result = (bool) args.m_filter;
         }
 
     } else if (args.m_mode == WARP || args.m_mode == CAGE) {
         QDomElement warpEl;
 
         int warpType = 0;
 
         result =
             KisDomUtils::findOnlyElement(e, "warp_transform", &warpEl) &&
 
             KisDomUtils::loadValue(warpEl, "defaultPoints", &args.m_defaultPoints) &&
 
             KisDomUtils::loadValue(warpEl, "originalPoints", &args.m_origPoints) &&
             KisDomUtils::loadValue(warpEl, "transformedPoints", &args.m_transfPoints) &&
 
             KisDomUtils::loadValue(warpEl, "warpType", &warpType) &&
             KisDomUtils::loadValue(warpEl, "alpha", &args.m_alpha);
 
         if(args.m_mode == CAGE){
             // Pixel precision is a parameter introduced in Krita 4.2, so we should
             // expect it not being present in older files. In case it is not found,
             // just use the defalt value initialized by c-tor (that is, do nothing).
 
             (void) KisDomUtils::loadValue(warpEl, "pixelPrecision", &args.m_pixelPrecision);
             (void) KisDomUtils::loadValue(warpEl, "previewPixelPrecision", &args.m_previewPixelPrecision);
         }
 
         if (result && warpType >= 0 && warpType < KisWarpTransformWorker::N_MODES) {
             args.m_warpType = (KisWarpTransformWorker::WarpType_) warpType;
         } else {
             result = false;
         }
 
     } else if (args.m_mode == LIQUIFY) {
         QDomElement liquifyEl;
 
         result =
             KisDomUtils::findOnlyElement(e, "liquify_transform", &liquifyEl);
 
         *args.m_liquifyProperties = KisLiquifyProperties::fromXML(e);
         args.m_liquifyWorker.reset(KisLiquifyTransformWorker::fromXML(e));
     } else {
         KIS_ASSERT_RECOVER_NOOP(0 && "Unknown transform mode");
     }
 
     KIS_SAFE_ASSERT_RECOVER(result) {
         args = ToolTransformArgs();
     }
 
     return args;
 }
 
 void ToolTransformArgs::saveContinuedState()
 {
     m_continuedTransformation.reset();
     m_continuedTransformation.reset(new ToolTransformArgs(*this));
 }
 
 void ToolTransformArgs::restoreContinuedState()
 {
     QScopedPointer<ToolTransformArgs> tempTransformation(
         new ToolTransformArgs(*m_continuedTransformation));
 
     *this = *tempTransformation;
     m_continuedTransformation.swap(tempTransformation);
 }
 
 const ToolTransformArgs* ToolTransformArgs::continuedTransform() const
 {
     return m_continuedTransformation.data();
 }
diff --git a/plugins/tools/tool_transform2/tool_transform_args.h b/plugins/tools/tool_transform2/tool_transform_args.h
index 9cb1589950..abc6f060b3 100644
--- a/plugins/tools/tool_transform2/tool_transform_args.h
+++ b/plugins/tools/tool_transform2/tool_transform_args.h
@@ -1,356 +1,356 @@
 /*
  *  tool_transform_args.h - part of Krita
  *
  *  Copyright (c) 2010 Marc Pegon <pe.marc@free.fr>
  *
  *  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 TOOL_TRANSFORM_ARGS_H_
 #define TOOL_TRANSFORM_ARGS_H_
 
 #include <QPointF>
 #include <QVector3D>
 #include <kis_warptransform_worker.h>
 #include <kis_filter_strategy.h>
 #include "kis_liquify_properties.h"
 #include "kritatooltransform_export.h"
 #include "kis_global.h"
 #include "KisToolChangesTrackerData.h"
 
 #include <QScopedPointer>
 class KisLiquifyTransformWorker;
 class QDomElement;
 
 /**
  * Class used to store the parameters of a transformation.
  * Some parameters are specific to free transform mode, and
  * others to warp mode : maybe add a union to save a little more
  * memory.
  */
 
 class KRITATOOLTRANSFORM_EXPORT ToolTransformArgs : public KisToolChangesTrackerData
 {
 public:
     enum TransformMode {FREE_TRANSFORM = 0,
                         WARP,
                         CAGE,
                         LIQUIFY,
                         PERSPECTIVE_4POINT,
                         N_MODES};
 
     /**
      * Initializes the parameters for an identity transformation,
      * with mode set to free transform.
      */
     ToolTransformArgs();
 
     /**
      * The object return will be a copy of args.
      */
     ToolTransformArgs(const ToolTransformArgs& args);
 
     KisToolChangesTrackerData *clone() const;
 
     /**
      * If mode is warp, original and transformed vector points will be of size 0.
      * Use setPoints method to set those vectors.
      */
     ToolTransformArgs(TransformMode mode,
                       QPointF transformedCenter,
                       QPointF originalCenter,
                       QPointF rotationCenterOffset, bool transformAroundRotationCenter,
                       double aX, double aY, double aZ,
                       double scaleX, double scaleY,
                       double shearX, double shearY,
                       KisWarpTransformWorker::WarpType warpType,
                       double alpha,
                       bool defaultPoints,
                       const QString &filterId,
                       int pixelPrecision, int previewPixelPrecision);
     ~ToolTransformArgs();
     ToolTransformArgs& operator=(const ToolTransformArgs& args);
 
     bool operator==(const ToolTransformArgs& other) const;
     bool isSameMode(const ToolTransformArgs& other) const;
 
     inline TransformMode mode() const {
         return m_mode;
     }
     inline void setMode(TransformMode mode) {
         m_mode = mode;
     }
 
     inline int pixelPrecision() const {
         return m_pixelPrecision;
     }
 
     inline void setPixelPrecision(int precision) {
         m_pixelPrecision = precision;
     }
 
     inline int previewPixelPrecision() const {
         return m_previewPixelPrecision;
     }
 
     inline void setPreviewPixelPrecision(int precision) {
         m_previewPixelPrecision = precision;
     }
 
     //warp-related
     inline int numPoints() const {
         KIS_ASSERT_RECOVER_NOOP(m_origPoints.size() == m_transfPoints.size());
         return m_origPoints.size();
     }
     inline QPointF &origPoint(int i) {
         return m_origPoints[i];
     }
     inline QPointF &transfPoint(int i) {
         return m_transfPoints[i];
     }
     inline const QVector<QPointF> &origPoints() const {
         return m_origPoints;
     }
     inline const QVector<QPointF> &transfPoints() const {
         return m_transfPoints;
     }
 
     inline QVector<QPointF> &refOriginalPoints() {
         return m_origPoints;
     }
     inline QVector<QPointF> &refTransformedPoints() {
         return m_transfPoints;
     }
 
     inline KisWarpTransformWorker::WarpType warpType() const {
         return m_warpType;
     }
     inline double alpha() const {
         return m_alpha;
     }
     inline bool defaultPoints() const {
         return m_defaultPoints;
     }
     inline void setPoints(QVector<QPointF> origPoints, QVector<QPointF> transfPoints) {
         m_origPoints = QVector<QPointF>(origPoints);
         m_transfPoints = QVector<QPointF>(transfPoints);
     }
     inline void setWarpType(KisWarpTransformWorker::WarpType warpType) {
         m_warpType = warpType;
     }
     inline void setWarpCalculation(KisWarpTransformWorker::WarpCalculation warpCalc) {
         m_warpCalculation = warpCalc;
     }
     inline KisWarpTransformWorker::WarpCalculation warpCalculation() {
         return m_warpCalculation;
     }
 
     inline void setAlpha(double alpha) {
         m_alpha = alpha;
     }
     inline void setDefaultPoints(bool defaultPoints) {
         m_defaultPoints = defaultPoints;
     }
 
     //"free transform"-related
     inline QPointF transformedCenter() const {
         return m_transformedCenter;
     }
     inline QPointF originalCenter() const {
         return m_originalCenter;
     }
     inline QPointF rotationCenterOffset() const {
         return m_rotationCenterOffset;
     }
     inline bool transformAroundRotationCenter() const {
         return m_transformAroundRotationCenter;
     }
     inline double aX() const {
         return m_aX;
     }
     inline double aY() const {
         return m_aY;
     }
     inline double aZ() const {
         return m_aZ;
     }
     inline QVector3D cameraPos() const {
         return m_cameraPos;
     }
     inline double scaleX() const {
         return m_scaleX;
     }
     inline double scaleY() const {
         return m_scaleY;
     }
     inline bool keepAspectRatio() const {
         return m_keepAspectRatio;
     }
     inline double shearX() const {
         return m_shearX;
     }
     inline double shearY() const {
         return m_shearY;
     }
 
     inline void setTransformedCenter(QPointF transformedCenter) {
         m_transformedCenter = transformedCenter;
     }
     inline void setOriginalCenter(QPointF originalCenter) {
         m_originalCenter = originalCenter;
     }
     inline void setRotationCenterOffset(QPointF rotationCenterOffset) {
         m_rotationCenterOffset = rotationCenterOffset;
     }
     void setTransformAroundRotationCenter(bool value);
     inline void setAX(double aX) {
         KIS_ASSERT_RECOVER_NOOP(aX == normalizeAngle(aX));
         m_aX = aX;
     }
     inline void setAY(double aY) {
         KIS_ASSERT_RECOVER_NOOP(aY == normalizeAngle(aY));
         m_aY = aY;
     }
     inline void setAZ(double aZ) {
         KIS_ASSERT_RECOVER_NOOP(aZ == normalizeAngle(aZ));
         m_aZ = aZ;
     }
     inline void setCameraPos(const QVector3D &pos) {
         m_cameraPos = pos;
     }
     inline void setScaleX(double scaleX) {
         m_scaleX = scaleX;
     }
     inline void setScaleY(double scaleY) {
         m_scaleY = scaleY;
     }
     inline void setKeepAspectRatio(bool value) {
         m_keepAspectRatio = value;
     }
     inline void setShearX(double shearX) {
         m_shearX = shearX;
     }
     inline void setShearY(double shearY) {
         m_shearY = shearY;
     }
 
     inline QString filterId() const {
         return m_filter->id();
     }
 
     void setFilterId(const QString &id);
 
     inline KisFilterStrategy* filter() const {
         return m_filter;
     }
 
     bool isIdentity() const;
 
     inline QTransform flattenedPerspectiveTransform() const {
         return m_flattenedPerspectiveTransform;
     }
 
     inline void setFlattenedPerspectiveTransform(const QTransform &value) {
         m_flattenedPerspectiveTransform = value;
     }
 
     bool isEditingTransformPoints() const {
         return m_editTransformPoints;
     }
 
     void setEditingTransformPoints(bool value) {
         m_editTransformPoints = value;
     }
 
     const KisLiquifyProperties* liquifyProperties() const {
         return m_liquifyProperties.data();
     }
 
     KisLiquifyProperties* liquifyProperties() {
         return m_liquifyProperties.data();
     }
 
     void initLiquifyTransformMode(const QRect &srcRect);
     void saveLiquifyTransformMode() const;
 
     KisLiquifyTransformWorker* liquifyWorker() const {
         return m_liquifyWorker.data();
     }
 
     void toXML(QDomElement *e) const;
     static ToolTransformArgs fromXML(const QDomElement &e);
 
     void translate(const QPointF &offset);
 
     void saveContinuedState();
     void restoreContinuedState();
     const ToolTransformArgs* continuedTransform() const;
 
 private:
     void clear();
     void init(const ToolTransformArgs& args);
-    TransformMode m_mode;
+    TransformMode m_mode {ToolTransformArgs::TransformMode::FREE_TRANSFORM};
 
     // warp-related arguments
     // these are basically the arguments taken by the warp transform worker
-    bool m_defaultPoints; // true : the original points are set to make a grid
+    bool m_defaultPoints {true}; // true : the original points are set to make a grid
                           // which density is given by numPoints()
     QVector<QPointF> m_origPoints;
     QVector<QPointF> m_transfPoints;
-    KisWarpTransformWorker::WarpType m_warpType;
-    KisWarpTransformWorker::WarpCalculation m_warpCalculation; // DRAW or GRID
-    double m_alpha;
+    KisWarpTransformWorker::WarpType m_warpType {KisWarpTransformWorker::WarpType_::RIGID_TRANSFORM};
+    KisWarpTransformWorker::WarpCalculation m_warpCalculation {KisWarpTransformWorker::WarpCalculation::DRAW}; // DRAW or GRID
+    double m_alpha {1.0};
 
     //'free transform'-related
     // basically the arguments taken by the transform worker
     QPointF m_transformedCenter;
     QPointF m_originalCenter;
     QPointF m_rotationCenterOffset; // the position of the rotation center relative to
                                     // the original top left corner of the selection
                                     // before any transformation
-    bool m_transformAroundRotationCenter; // In freehand mode makes the scaling and other transformations
+    bool m_transformAroundRotationCenter {false}; // In freehand mode makes the scaling and other transformations
                                           // be anchored to the rotation center point.
 
-    double m_aX;
-    double m_aY;
-    double m_aZ;
+    double m_aX {0};
+    double m_aY {0};
+    double m_aZ {0};
     QVector3D m_cameraPos {QVector3D(0,0,1024)};
-    double m_scaleX;
-    double m_scaleY;
-    double m_shearX;
-    double m_shearY;
+    double m_scaleX {1.0};
+    double m_scaleY {1.0};
+    double m_shearX {0.0};
+    double m_shearY {0.0};
     bool m_keepAspectRatio {false};
 
     // perspective trasform related
     QTransform m_flattenedPerspectiveTransform;
 
-    KisFilterStrategy *m_filter;
+    KisFilterStrategy *m_filter {0};
     bool m_editTransformPoints {false};
     QSharedPointer<KisLiquifyProperties> m_liquifyProperties;
     QScopedPointer<KisLiquifyTransformWorker> m_liquifyWorker;
 
     /**
      * When we continue a transformation, m_continuedTransformation
      * stores the initial step of our transform. All cancel and revert
      * operations should revert to it.
      */
     QScopedPointer<ToolTransformArgs> m_continuedTransformation;
 
     //PixelPrecision should always be in powers of 2
-    int m_pixelPrecision;
-    int m_previewPixelPrecision;
+    int m_pixelPrecision {8};
+    int m_previewPixelPrecision {16};
 };
 
 #endif // TOOL_TRANSFORM_ARGS_H_