diff --git a/plugins/tools/selectiontools/KisToolSelectGuided.cc b/plugins/tools/selectiontools/KisToolSelectGuided.cc
index 7521caf6cf..c024a1a9a0 100644
--- a/plugins/tools/selectiontools/KisToolSelectGuided.cc
+++ b/plugins/tools/selectiontools/KisToolSelectGuided.cc
@@ -1,100 +1,152 @@
 #include "KisToolSelectGuided.h"
 
 #include <QApplication>
 #include <QPainter>
 #include <QWidget>
 #include <QPainterPath>
 #include <QLayout>
 #include <QVBoxLayout>
 #include <QBitArray>
 
 #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>
 
 #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>
 
 KisToolSelectGuided::KisToolSelectGuided(KoCanvasBase *canvas)
-    : KisToolSelect(canvas),
-    m_started(false), m_finished(false),m_worker(image()->projection()), m_epsilon(70),m_filterRadius(3.0)
+    : KisToolSelect(canvas,
+                    i18n("Guidedc Selection")),
+    m_started(false), m_finished(false),m_worker(image()->projection()), m_epsilon(70),m_filterRadius(3)
 
 { }
 
 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_filterRadius ? m_filterRadius.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
+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
+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);
 }
+
+QWidget * KisToolSelectGuided::createOptionWidget()
+{
+    KisToolSelectBase::createOptionWidget();
+    KisSelectionOptions *selectionWidget = selectionOptionWidget();
+    QHBoxLayout *f1 = new QHBoxLayout();
+    QLabel *filterRadiusLabel = new QLabel(i18n("Filter Radius: "), selectionWidget);
+    f1->addWidget(filterRadiusLabel);
+
+    KisSliderSpinBox *filterRadiusInput = new KisSliderSpinBox(selectionWidget);
+    filterRadiusInput->setObjectName("radius");
+    filterRadiusInput->setRange(2.5, 100.0, 2);
+    filterRadiusInput->setSingleStep(0.5);
+    filterRadiusInput->setToolTip("Radius of the filter for the detecting edges, might take some time to calculate");
+    f1->addWidget(filterRadiusInput);
+    connect(filterRadiusInput, SIGNAL(valueChanged(int)), this, SLOT(slotSetFilterRadius(int)));
+
+    QHBoxLayout *f1        = new QHBoxLayout();
+    QLabel *thresholdLabel = new QLabel(i18n("Threshold: "), selectionWidget);
+    f1->addWidget(thresholdLabel);
+
+    KisDoubleSliderSpinBox *epsilonInput = new KisDoubleSliderSpinBox(selectionWidget);
+    thresholdInput->setObjectName("epsilon");
+    thresholdInput->setRange(1, 255);
+    thresholdInput->setSingleStep(10);
+    thresholdInput->setToolTip("Variable to adjust guided selection end results");
+    f2->addWidget(thresholdInput);
+    connect(filterRadiusInput, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetFilterRadius(qreal)));
+
+    QVBoxLayout *l = dynamic_cast<QVBoxLayout *>(selectionWidget->layout());
+
+    l->insertLayout(1, f1);
+    l->insertLayout(2, f2);
+
+    filterRadiusInput->setValue(m_configGroup.readEntry("filterradius", 3.0));
+    epsilonInput->setValue(m_configGroup.readEntry("epsilon", 100));
+
+    return selectionWidget;
+} // KisToolSelectGuided::createOptionWidget
+
+void KisToolSelectGuided::slotSetFilterRadius(qreal r)
+{
+    m_filterRadius = r;
+    m_configGroup.writeEntry("filterradius", r);
+}
+
+void KisToolSelectGuided::slotSetEpsilon(int e)
+{
+    m_epsilon = e;
+    m_configGroup.writeEntry("epsilon", e);
+}
diff --git a/plugins/tools/selectiontools/KisToolSelectGuided.h b/plugins/tools/selectiontools/KisToolSelectGuided.h
index c6e9f5ae9f..636e75a682 100644
--- a/plugins/tools/selectiontools/KisToolSelectGuided.h
+++ b/plugins/tools/selectiontools/KisToolSelectGuided.h
@@ -1,49 +1,61 @@
 #ifndef KIS_TOOL_SELECT_GUIDED_H_
 #define KIS_TOOL_SELECT_GUIDED_H_
 
 #include <QPoint>
 #include "KisSelectionToolFactoryBase.h"
 #include <kis_tool_select_base.h>
 #include <kis_signal_compressor.h>
 #include <kis_icon.h>
 
 class QPainterPath;
 
 class KisToolSelectGuided : public KisToolSelect
 {
     Q_OBJECT
     
 public:
+    KisToolSelectGuided(KoCanvasBase *canvas);
+    ~KisToolSelectGuided() override = default;
+    QWidget * createOptionWidget() override;
 public Q_SLOTS:
+    void slotSetFilterRadius(int);
+    void slotSetEpsilon(qreal);
 protected:
     using KisToolSelectBase::m_widgetHelper;
 private:
+    int m_filterRadius;
+    qreal m_epsilon;
 };
 
 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);
+    }
 
     QList<QAction *> createActionsImpl() override
     {
         KisActionRegistry *actionRegistry = KisActionRegistry::instance();
         QList<QAction *> actions = KisSelectionToolFactoryBase::createActionsImpl();
 
         actions << actionRegistry->makeQAction("undo_guided_selection");
 
         return actions;
     }
 };
 
 #endif // __selecttoolguided_h__