diff --git a/libs/ui/kis_painting_assistants_decoration.cpp b/libs/ui/kis_painting_assistants_decoration.cpp
index 2857c466bd..d83ce60afe 100644
--- a/libs/ui/kis_painting_assistants_decoration.cpp
+++ b/libs/ui/kis_painting_assistants_decoration.cpp
@@ -1,417 +1,432 @@
 /*
  *  Copyright (c) 2009 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_painting_assistants_decoration.h"
 
 #include <cfloat>
 
 #include <QList>
 #include <QPointF>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <ktoggleaction.h>
 #include "kis_debug.h"
 #include "KisDocument.h"
 #include "kis_canvas2.h"
 #include "kis_icon_utils.h"
 #include "KisViewManager.h"
 
 #include <QPainter>
 
 struct KisPaintingAssistantsDecoration::Private {
     Private()
         : assistantVisible(false)
         , outlineVisible(false)
         , snapOnlyOneAssistant(true)
         , firstAssistant(0)
         , aFirstStroke(false)
     {}
 
     bool assistantVisible;
     bool outlineVisible;
     bool snapOnlyOneAssistant;
     KisPaintingAssistantSP firstAssistant;
     bool aFirstStroke;
     QColor m_assistantsColor;
     bool m_isEditingAssistants = false;
     bool m_useCache = false;
     bool m_outlineVisible = false;
     int m_handleSize = 14; // size of editor handles on assistants
 
     // move, visibility, delete icons for each assistant. These only display while the assistant tool is active
     // these icons will be covered by the kis_paintint_assistant_decoration with things like the perspective assistant
     QPixmap m_iconDelete = KisIconUtils::loadIcon("dialog-cancel").pixmap(16, 16);
     QPixmap m_iconSnapOn = KisIconUtils::loadIcon("visible").pixmap(16, 16);
     QPixmap m_iconSnapOff = KisIconUtils::loadIcon("novisible").pixmap(16, 16);
     QPixmap m_iconMove = KisIconUtils::loadIcon("transform-move").pixmap(32, 32);
 
     KisCanvas2 * m_canvas = 0;
 };
 
 KisPaintingAssistantsDecoration::KisPaintingAssistantsDecoration(QPointer<KisView> parent) :
     KisCanvasDecoration("paintingAssistantsDecoration", parent),
     d(new Private)
 {
     setAssistantVisible(true);
     setOutlineVisible(true);
     d->snapOnlyOneAssistant = true; //turn on by default.
 }
 
 KisPaintingAssistantsDecoration::~KisPaintingAssistantsDecoration()
 {
     delete d;
 }
 
 void KisPaintingAssistantsDecoration::addAssistant(KisPaintingAssistantSP assistant)
 {
     QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
     if (assistants.contains(assistant)) return;
 
     assistants.append(assistant);
 
     view()->document()->setAssistants(assistants);
     setVisible(!assistants.isEmpty());
     emit assistantChanged();
 }
 
 void KisPaintingAssistantsDecoration::removeAssistant(KisPaintingAssistantSP assistant)
 {
     QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
     KIS_ASSERT_RECOVER_NOOP(assistants.contains(assistant));
 
     if (assistants.removeAll(assistant)) {
         view()->document()->setAssistants(assistants);
         setVisible(!assistants.isEmpty());
         emit assistantChanged();
     }
 }
 
 void KisPaintingAssistantsDecoration::removeAll()
 {
     QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
     assistants.clear();
     view()->document()->setAssistants(assistants);
     setVisible(!assistants.isEmpty());
 
     emit assistantChanged();
 }
 
 QPointF KisPaintingAssistantsDecoration::adjustPosition(const QPointF& point, const QPointF& strokeBegin)
 {
 
     if (assistants().empty()) {
         return point;
     }
 
     if (assistants().count() == 1) {
         if(assistants().first()->isSnappingActive() == true){
             QPointF newpoint = assistants().first()->adjustPosition(point, strokeBegin);
             // check for NaN
             if (newpoint.x() != newpoint.x()) return point;
             return newpoint;
         }
     }
     QPointF best = point;
     double distance = DBL_MAX;
     //the following tries to find the closest point to stroke-begin. It checks all assistants for the closest point//
     if(!d->snapOnlyOneAssistant){
         Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
             if(assistant->isSnappingActive() == true){//this checks if the assistant in question has it's snapping boolean turned on//
                 QPointF pt = assistant->adjustPosition(point, strokeBegin);
                 if (pt.x() != pt.x()) continue;
                 double dist = qAbs(pt.x() - point.x()) + qAbs(pt.y() - point.y());
                 if (dist < distance) {
                     best = pt;
                     distance = dist;
                 }
             }
         }
     } else if (d->aFirstStroke==false) {
         Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
             if(assistant->isSnappingActive() == true){//this checks if the assistant in question has it's snapping boolean turned on//
                 QPointF pt = assistant->adjustPosition(point, strokeBegin);
                 if (pt.x() != pt.x()) continue;
                 double dist = qAbs(pt.x() - point.x()) + qAbs(pt.y() - point.y());
                 if (dist < distance) {
                     best = pt;
                     distance = dist;
                     d->firstAssistant = assistant;
                 }
             }
         }
     } else if(d->firstAssistant) {
         //make sure there's a first assistant to begin with.//
         best = d->firstAssistant->adjustPosition(point, strokeBegin);
     } else {
         d->aFirstStroke=false;
     }
     //this is here to be compatible with the movement in the perspective tool.
     qreal dx = point.x() - strokeBegin.x(), dy = point.y() - strokeBegin.y();
     if (dx * dx + dy * dy >= 4.0) {
         // allow some movement before snapping
         d->aFirstStroke=true;
     }
     return best;
 }
 
 void KisPaintingAssistantsDecoration::endStroke()
 {
     d->aFirstStroke = false;
 
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
         assistant->endStroke();
     }
 }
 
 void KisPaintingAssistantsDecoration::drawDecoration(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter *converter,KisCanvas2* canvas)
 {
     if (!canvas) {
         dbgFile<<"canvas does not exist in painting assistant decoration, you may have passed arguments incorrectly:"<<canvas;
     } else {
         d->m_canvas = canvas;
     }
 
     if (d->m_isEditingAssistants) {
         d->m_outlineVisible = false;
 
         // TODO: the uncache method takes care of this state. can probably remove this as well as
         // references in the drawAssistant function
         d->m_useCache = true;
     }
     else {
         d->m_outlineVisible = outlineVisibility();
     }
 
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
         assistant->setAssistantColor(assistantsColor());
         assistant->drawAssistant(gc, updateRect, converter, d->m_useCache, canvas, assistantVisibility(), d->m_outlineVisible);
 
         if (isEditingAssistants()) {
             drawHandles(assistant, gc, converter);
         }
     }
 
     // draw editor controls on top of all assistant lines (why this code is last)
     if (isEditingAssistants()) {
         Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
             drawEditorWidget(assistant, gc, converter);
         }
      }
 }
 
 void KisPaintingAssistantsDecoration::drawHandles(KisPaintingAssistantSP assistant, QPainter& gc, const KisCoordinatesConverter *converter)
 {
         QTransform initialTransform = converter->documentToWidgetTransform();
 
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->handles()) {
 
             QPointF transformedHandle = initialTransform.map(*handle);
             QRectF ellipse(transformedHandle -  QPointF(handleSize() * 0.5, handleSize() * 0.5), QSizeF(handleSize(), handleSize()));
 
             QPainterPath path;
             path.addEllipse(ellipse);
 
             gc.save();
             gc.setPen(Qt::NoPen);
             gc.setBrush(assistantsColor());
             gc.drawPath(path);
             gc.restore();
         }
+
+         // some assistants have side handles like the vanishing point assistant
+         Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->sideHandles()) {
+             QPointF transformedHandle = initialTransform.map(*handle);
+             QRectF ellipse(transformedHandle -  QPointF(handleSize() * 0.5, handleSize() * 0.5), QSizeF(handleSize(), handleSize()));
+
+             QPainterPath path;
+             path.addEllipse(ellipse);
+
+             gc.save();
+             gc.setPen(Qt::NoPen);
+             gc.setBrush(assistantsColor());
+             gc.drawPath(path);
+             gc.restore();
+         }
 }
 
 int KisPaintingAssistantsDecoration::handleSize()
 {
     return  d->m_handleSize;
 }
 
 void KisPaintingAssistantsDecoration::setHandleSize(int handleSize)
 {
     d->m_handleSize = handleSize;
 }
 
 QList<KisPaintingAssistantHandleSP> KisPaintingAssistantsDecoration::handles()
 {
     QList<KisPaintingAssistantHandleSP> hs;
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->handles()) {
             if (!hs.contains(handle)) {
                 hs.push_back(handle);
             }
         }
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->sideHandles()) {
             if (!hs.contains(handle)) {
                 hs.push_back(handle);
             }
         }
     }
     return hs;
 }
 
 QList<KisPaintingAssistantSP> KisPaintingAssistantsDecoration::assistants()
 {
     QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
     return assistants;
 }
 
 void KisPaintingAssistantsDecoration::setAssistantVisible(bool set)
 {
     d->assistantVisible=set;
 }
 
 void KisPaintingAssistantsDecoration::setOutlineVisible(bool set)
 {
     d->outlineVisible=set;
 }
 
 void KisPaintingAssistantsDecoration::setOnlyOneAssistantSnap(bool assistant)
 {
     d->snapOnlyOneAssistant = assistant;
 }
 
 bool KisPaintingAssistantsDecoration::assistantVisibility()
 {
     return d->assistantVisible;
 }
 bool KisPaintingAssistantsDecoration::outlineVisibility()
 {
     return d->outlineVisible;
 }
 void KisPaintingAssistantsDecoration::uncache()
 {
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
         assistant->uncache();
     }
 }
 void KisPaintingAssistantsDecoration::toggleAssistantVisible()
 {
     setAssistantVisible(!assistantVisibility());
     uncache();
 }
 
 void KisPaintingAssistantsDecoration::toggleOutlineVisible()
 {
     setOutlineVisible(!outlineVisibility());
 }
 
 QColor KisPaintingAssistantsDecoration::assistantsColor() {
     return d->m_assistantsColor;
 }
 
 void KisPaintingAssistantsDecoration::setAssistantsColor(QColor color)
 {
     d->m_assistantsColor = color;
     uncache();
 }
 
 void KisPaintingAssistantsDecoration::activateAssistantsEditor()
 {
     setVisible(true); // this turns on the decorations in general. we leave it on at this point
     d->m_isEditingAssistants = true;
     d->m_useCache = false; // force the assistants to update with cleared cache
 }
 
 void KisPaintingAssistantsDecoration::deactivateAssistantsEditor()
 {
     if (!d->m_canvas) {
         return;
     }
 
     d->m_isEditingAssistants = false; // some elements are hidden when we aren't editing
     uncache(); // updates visuals when not editing
 }
 
 bool KisPaintingAssistantsDecoration::isEditingAssistants()
 {
     return d->m_isEditingAssistants;
 }
 
 QPointF KisPaintingAssistantsDecoration::snapToGuide(KoPointerEvent *e, const QPointF &offset, bool useModifiers)
 {
     if (!d->m_canvas->currentImage())
         return e->point;
 
     KoSnapGuide *snapGuide = d->m_canvas->snapGuide();
     QPointF pos = snapGuide->snap(e->point, offset, useModifiers ? e->modifiers() : Qt::NoModifier);
 
     return pos;
 }
 
 QPointF KisPaintingAssistantsDecoration::snapToGuide(const QPointF& pt, const QPointF &offset)
 {
     if (!d->m_canvas)
         return pt;
 
     KoSnapGuide *snapGuide = d->m_canvas->snapGuide();
     QPointF pos = snapGuide->snap(pt, offset, Qt::NoModifier);
 
     return pos;
 }
 
 /*
  * functions only used interally in this class
  * we potentially could make some of these inline to speed up performance
 */
 
 void KisPaintingAssistantsDecoration::drawEditorWidget(KisPaintingAssistantSP assistant, QPainter& gc, const KisCoordinatesConverter *converter)
 {
     QTransform initialTransform = converter->documentToWidgetTransform();
     int m_assistantHelperYOffset = 10;
 
 
     // We are going to put all of the assistant actions below the bounds of the assistant
     // so they are out of the way
     // assistant->buttonPosition() gets the center X/Y position point
     QPointF actionsPosition = initialTransform.map(assistant->buttonPosition());
 
     QPointF iconDeletePosition(actionsPosition + QPointF(78, m_assistantHelperYOffset + 7));
     QPointF iconSnapPosition(actionsPosition + QPointF(54, m_assistantHelperYOffset + 7));
     QPointF iconMovePosition(actionsPosition + QPointF(15, m_assistantHelperYOffset ));
 
 
     // Background container for helpers
     QBrush backgroundColor = d->m_canvas->viewManager()->mainWindow()->palette().window();
     QPointF actionsBGRectangle(actionsPosition + QPointF(25, m_assistantHelperYOffset));
 
     gc.setRenderHint(QPainter::Antialiasing);
 
     QPainterPath bgPath;
     bgPath.addRoundedRect(QRectF(actionsBGRectangle.x(), actionsBGRectangle.y(), 80, 30), 6, 6);
     QPen stroke(QColor(60, 60, 60, 80), 2);
     gc.setPen(stroke);
     gc.fillPath(bgPath, backgroundColor);
     gc.drawPath(bgPath);
 
 
     QPainterPath movePath;  // render circle behind by move helper
     gc.setPen(stroke);
     movePath.addEllipse(iconMovePosition.x()-5, iconMovePosition.y()-5, 40, 40);// background behind icon
     gc.fillPath(movePath, backgroundColor);
     gc.drawPath(movePath);
 
     // Preview/Snap Tool helper
     gc.drawPixmap(iconDeletePosition, d->m_iconDelete);
     if (assistant->isSnappingActive() == true) {
         gc.drawPixmap(iconSnapPosition, d->m_iconSnapOn);
     }
     else {
         gc.drawPixmap(iconSnapPosition, d->m_iconSnapOff);
     }
 
     // Move Assistant Tool helper
     gc.drawPixmap(iconMovePosition, d->m_iconMove);
 }
diff --git a/plugins/assistants/Assistants/VanishingPointAssistant.cc b/plugins/assistants/Assistants/VanishingPointAssistant.cc
index 8ab7716f15..da1ef7fa7a 100644
--- a/plugins/assistants/Assistants/VanishingPointAssistant.cc
+++ b/plugins/assistants/Assistants/VanishingPointAssistant.cc
@@ -1,228 +1,225 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  *
  *  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 "VanishingPointAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 
 #include <math.h>
 
 VanishingPointAssistant::VanishingPointAssistant()
     : KisPaintingAssistant("vanishing point", i18n("Vanishing Point assistant"))
 {
 }
 
 QPointF VanishingPointAssistant::project(const QPointF& pt, const QPointF& strokeBegin)
 {
     //Q_ASSERT(handles().size() == 1 || handles().size() == 5);
     //code nicked from the perspective ruler.
     qreal dx = pt.x() - strokeBegin.x();
     qreal dy = pt.y() - strokeBegin.y();
 
     if (dx * dx + dy * dy < 4.0) {
         // allow some movement before snapping
         return strokeBegin;
     }
 
     //dbgKrita<<strokeBegin<< ", " <<*handles()[0];
     QLineF snapLine = QLineF(*handles()[0], strokeBegin);
     
     
     dx = snapLine.dx();
     dy = snapLine.dy();
 
     const qreal dx2 = dx * dx;
     const qreal dy2 = dy * dy;
     const qreal invsqrlen = 1.0 / (dx2 + dy2);
 
     QPointF r(dx2 * pt.x() + dy2 * snapLine.x1() + dx * dy * (pt.y() - snapLine.y1()),
               dx2 * snapLine.y1() + dy2 * pt.y() + dx * dy * (pt.x() - snapLine.x1()));
 
     r *= invsqrlen;
     return r;
 }
 
 QPointF VanishingPointAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 }
 
 void VanishingPointAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
     QPointF delta(0,0);
     QPointF mousePos(0,0);
     QPointF endPoint(0,0);//this is the final point that the line is being extended to, we seek it just outside the view port//
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
         m_canvas = canvas;
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in ruler, you may have passed arguments incorrectly:"<<canvas;
     }
     
 
 
      // draw controls when we are not editing
      if (canvas->paintingAssistantsDecoration()->isEditingAssistants() == false && isAssistantComplete()) {
 
          if (isSnappingActive() && previewVisible == true) {
              //don't draw if invalid.
              QTransform initialTransform = converter->documentToWidgetTransform();
              QPointF startPoint = initialTransform.map(*handles()[0]);
 
              QLineF snapLine= QLineF(startPoint, mousePos);
              QRect viewport= gc.viewport();
 
              KisAlgebra2D::intersectLineRect(snapLine, viewport);
 
              QRect bounds= QRect(snapLine.p1().toPoint(), snapLine.p2().toPoint());
 
              QPainterPath path;
 
              if (bounds.contains(startPoint.toPoint())){
                  path.moveTo(startPoint);
                  path.lineTo(snapLine.p1());
              }
              else
              {
                  path.moveTo(snapLine.p1());
                  path.lineTo(snapLine.p2());
              }
 
              drawPreview(gc, path);//and we draw the preview.
          }
      }
 
 
 
 
     // editor specific controls display
     if (canvas->paintingAssistantsDecoration()->isEditingAssistants()) {
 
         // draws a circle around the vanishing point node while editing
         QTransform initialTransform = converter->documentToWidgetTransform();
-        QPointF startPoint2 = initialTransform.map(*handles()[0]);
+        QPointF p0 = initialTransform.map(*handles()[0]); // main vanishing point
+        QPointF p1 = initialTransform.map(*sideHandles()[0]);
+        QPointF p2 = initialTransform.map(*sideHandles()[1]);
+        QPointF p3 = initialTransform.map(*sideHandles()[2]);
+        QPointF p4 = initialTransform.map(*sideHandles()[3]);
 
-        QPainterPath pathCenter;
 
-        QRectF ellipse = QRectF(QPointF(startPoint2.x() -15, startPoint2.y() -15), QSizeF(30, 30));;
+        QRectF ellipse = QRectF(QPointF(p0.x() -15, p0.y() -15), QSizeF(30, 30));
+
+        QPainterPath pathCenter;
         pathCenter.addEllipse(ellipse);
         drawPath(gc, pathCenter, isSnappingActive());
 
-
-
         // draw the lines connecting the different nodes
-        QPointF p0 = initialTransform.map(*handles()[0]);
-        QPointF p1 = initialTransform.map(*sideHandles()[0]);
-        QPointF p2 = initialTransform.map(*sideHandles()[1]);
-        QPointF p3 = initialTransform.map(*sideHandles()[2]);
-        QPointF p4 = initialTransform.map(*sideHandles()[3]);
-
         QPen penStyle(m_canvas->paintingAssistantsDecoration()->assistantsColor(), 2.0, Qt::SolidLine);
         gc.save();
         gc.setPen(penStyle);
         gc.drawLine(p0, p1);
         gc.drawLine(p0, p3);
         gc.drawLine(p1, p2);
         gc.drawLine(p3, p4);
         gc.restore();
     }
 
 
     gc.restore();
 
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 
 
 }
 
 void VanishingPointAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (!m_canvas || !isAssistantComplete()) {
         return;
     }
 
     if (assistantVisible == false ||   m_canvas->paintingAssistantsDecoration()->isEditingAssistants()) {
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
     QPointF p0 = initialTransform.map(*handles()[0]);
 
     // draws an "X"
     QPainterPath path;
     path.moveTo(QPointF(p0.x() - 10.0, p0.y() - 10.0));
     path.lineTo(QPointF(p0.x() + 10.0, p0.y() + 10.0));
 
     path.moveTo(QPointF(p0.x() - 10.0, p0.y() + 10.0));
     path.lineTo(QPointF(p0.x() + 10.0, p0.y() - 10.0));
 
 
     drawPath(gc, path, isSnappingActive());
 }
 
 QPointF VanishingPointAssistant::buttonPosition() const
 {
     return (*handles()[0]);
 }
 
 bool VanishingPointAssistant::isAssistantComplete() const
 {
     return handles().size() > 0; // only need one point to be ready
 }
 
 
 VanishingPointAssistantFactory::VanishingPointAssistantFactory()
 {
 }
 
 VanishingPointAssistantFactory::~VanishingPointAssistantFactory()
 {
 }
 
 QString VanishingPointAssistantFactory::id() const
 {
     return "vanishing point";
 }
 
 QString VanishingPointAssistantFactory::name() const
 {
     return i18n("Vanishing Point");
 }
 
 KisPaintingAssistant* VanishingPointAssistantFactory::createPaintingAssistant() const
 {
     return new VanishingPointAssistant;
 }