diff --git a/plugins/tools/selectiontools/kis_tool_select_guided.cpp b/plugins/tools/selectiontools/kis_tool_select_guided.cpp
index dd764123b5..bd23b602a4 100644
--- a/plugins/tools/selectiontools/kis_tool_select_guided.cpp
+++ b/plugins/tools/selectiontools/kis_tool_select_guided.cpp
@@ -1,151 +1,146 @@
 #include "kis_tool_select_guided.h"
 
 #include "QApplication"
 #include "QPainterPath"
 
 #include <klocalizedstring.h>
 #include <KoColor.h>
 #include <KisViewManager.h>
 #include "kis_canvas2.h"
 #include "kis_cursor.h"
 #include "kis_painter.h"
 #include "kis_paintop_preset.h"
 
 #include "kundo2magicstring.h"
 #include "kundo2stack.h"
 #include "commands_new/kis_transaction_based_command.h"
 #include "kis_transaction.h"
 
 #include "kis_processing_applicator.h"
 #include "kis_datamanager.h"
 
 #include "KoColorSpaceRegistry.h"
 
 #include "kis_tool_select_guided_options_widget.h"
 #include "libs/image/kis_paint_device_debug_utils.h"
 
 #include "kis_paint_layer.h"
 #include "kis_algebra_2d.h"
 #include <QApplication>
 #include <QPainter>
-#include <QWidget>
 #include <QPainterPath>
 #include <QLayout>
 #include <QVBoxLayout>
 #include <QBitArray>
 
 #include <kis_selection_options.h>
 
 #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_tool_select_guided_options_widget.h"
 
 #include "kis_algebra_2d.h"
 
 #include "KisHandlePainterHelper.h"
 
 #include <kis_slider_spin_box.h>
 
 #include <KoColorSpace.h>
 #include <KoChannelInfo.h>
 #include <KoColor.h>
 #include <kis_painter.h>
 #include <kis_paint_device.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 
 #include <kis_slider_spin_box.h>
 
 
 KisToolSelectGuided::KisToolSelectGuided(KoCanvasBase *canvas)
     : KisToolSelect(canvas,
                     KisCursor::crossCursor(),
                     i18n("Guided Selection")),
     m_finished(false), m_filterRadius(3), m_epsilon(70)
 { }
 
-struct KisToolSelectGuided::Private {
-    KisToolSelectGuidedOptionsWidget *optionsWidget = nullptr;
-};
-
 /*void KisToolSelectGuided::GuidedSelectGenerate()
 {
 	KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->updateCanvas();
     setMode(KisTool::HOVER_MODE);
     
     if (mode == PIXEL_SELECTION){
 		KisPaintDeviceSP image = KisPaintDeviceSP(new KisPaintDevice(currentImage()->projection()));
 		
 		image.ConvertTo(KoColorSpaceRegistry::instance()->rgb32());
 		
 		KisLodTransformScalar t(image);
 		const qreal BoxBlurAmount = t.scale(m_filterEpsilon ? m_filterEpsilon.toDouble() : 1.0);
 		QRect applyRect(QPoint(0, 0), image.width(),image.height());
 		const QRect boxNeedRect = this->neededRect(applyRect, config, originalimage->defaultBounds()->currentLevelOfDetail());
 
 		KisSequentialConstIterator it(imageDev, QRect(0, 0, image.width(), image.height()));
 
         for (int y = 0; y < image.height(); y++) {
             for (int x = 0; x < image.width(); x++) {
                 it.nextPixel();
                 const quint8* pixel = it.rawDataConst();
                 for (int chan = 0; chan < 4; ++chan) {
                     image &img = image[chan];
                     *(img.scanLine(y) + x) = cs->scaleToU8(pixel, chan);
                 }
             }
 		}		
 	}
 }
 
 QRect KisToolSelectGuided::neededRect(const QRect & rect, int lod) const
 {
     KisLodTransformScalar t(lod);
 
     const int halfSize = m_filterRadius ? KisGaussianKernel::kernelSizeFromRadius(t.scale(m_filterRadius.toFloat())) / 2 : 5;
 
     return rect.adjusted( -halfSize * 2, -halfSize * 2, halfSize * 2, halfSize * 2);
 }
 
 QRect KisToolSelectGuided::changedRect(const QRect & rect, int lod) const
 {
     KisLodTransformScalar t(lod);
 
     const int halfSize = m_filterRadius ? KisGaussianKernel::kernelSizeFromRadius(t.scale(m_filterRadius.toFloat())) / 2 : 5;
 
     return rect.adjusted( -halfSize, -halfSize, halfSize, halfSize);
 }*/
 
 void KisToolSelectGuided::paint(QPainter& gc, const KoViewConverter &converter)
 {
 }
 
 QWidget * KisToolSelectGuided::createOptionWidget()
 {
     KisCanvas2 * kiscanvas = dynamic_cast<KisCanvas2*>(canvas());
 
     m_d->optionsWidget = new KisToolSelectGuidedOptionsWidget(kiscanvas->viewManager()->canvasResourceProvider(), 0);
     m_d->optionsWidget->setObjectName(toolId() + "option widget");
 
     return m_d->optionsWidget;
 }
diff --git a/plugins/tools/selectiontools/kis_tool_select_guided.h b/plugins/tools/selectiontools/kis_tool_select_guided.h
index cd7d924920..5b2eb5275a 100644
--- a/plugins/tools/selectiontools/kis_tool_select_guided.h
+++ b/plugins/tools/selectiontools/kis_tool_select_guided.h
@@ -1,82 +1,86 @@
 #ifndef KIS_TOOL_SELECT_GUIDED_H_
 #define KIS_TOOL_SELECT_GUIDED_H_
 
 #include <QPoint>
 #include <QPainterPath>
 #include <QScopedPointer>
+#include <QWidget>
+#include "kis_tool_select_guided_options_widget.h"
 
 #include "kis_tool_paint.h"
 #include "KisSelectionToolFactoryBase.h"
 #include "KisToolPaintFactoryBase.h"
 
 #include <kis_signal_compressor.h>
 #include <flake/kis_node_shape.h>
 #include <kis_icon.h>
 #include <QKeySequence>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <KoIcon.h>
 
 #include <kis_tool_select_base.h>
 #include "selection_tools.h"
 #include "kis_selection_tool_config_widget_helper.h"
 
 #include <QMenu>
 
 class KActionCollection;
 class QPainterPath;
 class KoCanvasBase;
+class KisSpacingInfomation;
 
 class KisToolSelectGuided : public KisToolSelect
 {
     Q_OBJECT
 
 public:
     KisToolSelectGuided(KoCanvasBase * canvas);
     ~KisToolSelectGuided() override = default;
 
     void paint(QPainter& gc, const KoViewConverter &converter) override;
 
     QWidget * createOptionWidget() override;
 public Q_SLOTS:
-    int getKernelRadius(void);
-    qreal getEpsilon(void);
-    bool getSelectActive(void);
 
 protected:
 
 private:
     //const QRect& applyRect;
     //const QRect& neededRect;
     struct Private;
+    const QScopedPointer<Private> m_d;
     bool m_finished;
     int m_filterRadius;
     qreal m_epsilon;
     bool activate_selection_painting;
-    const QScopedPointer<Private> m_d;
+};
+
+struct KisToolSelectGuided::Private {
+    KisToolSelectGuidedOptionsWidget *optionsWidget = nullptr;
 };
 
 class KisToolSelectGuidedFactory : public KisSelectionToolFactoryBase
 {
 public:
     KisToolSelectGuidedFactory()
         : KisSelectionToolFactoryBase("KisToolSelectGuided")
     {
         setToolTip(i18n("Guided Selection Tool"));
         setSection(TOOL_TYPE_SELECTION);
         setIconName(koIconNameCStr("tool_guided_selection"));
         setPriority(9);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
     }
 
     ~KisToolSelectGuidedFactory() override { }
 
     KoToolBase * createTool(KoCanvasBase *canvas) override
     {
         return new KisToolSelectGuided(canvas);
     }
 };
 
 
 #endif // KIS_TOOL_SELECT_GUIDED_H