TwoPointAssistant Class Reference

#include <TwoPointAssistant.h>

Inheritance diagram for TwoPointAssistant:

Public Types
enum	TwoPointHandle {   FirstHandle , SecondHandle , VerticalHandle , LocalFirstHandle ,   LocalSecondHandle }

Public Member Functions
void	adjustLine (QPointF &point, QPointF &strokeBegin) override
QPointF	adjustPosition (const QPointF &point, const QPointF &strokeBegin, const bool snapToAny, qreal moveThresholdPt) override
bool	canBeLocal () const override
	canBeLocal
KisPaintingAssistantSP	clone (QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap) const override
void	endStroke () override
QPointF	getDefaultEditorPosition () const override
double	gridDensity ()
bool	isAssistantComplete () const override
bool	loadCustomXml (QXmlStreamReader *xml) override
QTransform	localTransform (QPointF vp_a, QPointF vp_b, QPointF pt_c, qreal *size)
int	numHandles () const override
void	saveCustomXml (QXmlStreamWriter *xml) override
void	setGridDensity (double density)
void	setUseVertical (bool value)
	TwoPointAssistant ()
bool	useVertical ()
Public Member Functions inherited from KisPaintingAssistant
void	addHandle (KisPaintingAssistantHandleSP handle, HandleType type)
bool	areTwoPointsClose (const QPointF &pointOne, const QPointF &pointTwo)
QColor	assistantCustomColor ()
KisPaintingAssistantHandleSP	bottomLeft ()
const KisPaintingAssistantHandleSP	bottomLeft () const
KisPaintingAssistantHandleSP	bottomMiddle ()
const KisPaintingAssistantHandleSP	bottomMiddle () const
KisPaintingAssistantHandleSP	bottomRight ()
const KisPaintingAssistantHandleSP	bottomRight () const
KisPaintingAssistantHandleSP	closestCornerHandleFromPoint (QPointF point)
void	copySharedData (KisPaintingAssistantSP assistant)
void	drawError (QPainter &painter, const QPainterPath &path, const KoColorDisplayRendererInterface *displayRenderInterface)
void	drawPath (QPainter &painter, const QPainterPath &path, const KoColorDisplayRendererInterface *displayRenderInterface, bool drawActive=true)
void	drawPreview (QPainter &painter, const QPainterPath &path, const KoColorDisplayRendererInterface *displayRenderInterface)
void	drawX (QPainter &painter, const QPointF &pt, const KoColorDisplayRendererInterface *displayRenderInterface)
QPointF	editorWidgetOffset ()
QColor	effectiveAssistantColor () const
void	findPerspectiveAssistantHandleLocation ()
virtual QPointF	getEditorPosition () const
QList< KisPaintingAssistantHandleSP >	handles ()
const QList< KisPaintingAssistantHandleSP > &	handles () const
const QString &	id () const
bool	isDuplicating ()
	isDuplicating
bool	isLocal () const
	isLocal
bool	isLocked ()
	isLocked
bool	isSnappingActive () const
	KisPaintingAssistant (const QString &id, const QString &name)
KisPaintingAssistantHandleSP	leftMiddle ()
const KisPaintingAssistantHandleSP	leftMiddle () const
void	loadXml (KoStore *store, QMap< int, KisPaintingAssistantHandleSP > &handleMap, QString path)
const QString &	name () const
KisPaintingAssistantHandleSP	oppHandleOne ()
void	replaceHandle (KisPaintingAssistantHandleSP _handle, KisPaintingAssistantHandleSP _with)
KisPaintingAssistantHandleSP	rightMiddle ()
const KisPaintingAssistantHandleSP	rightMiddle () const
QByteArray	saveXml (QMap< KisPaintingAssistantHandleSP, int > &handleMap)
void	saveXmlList (QDomDocument &doc, QDomElement &assistantsElement, int count)
virtual void	setAdjustedBrushPosition (const QPointF position)
void	setAssistantCustomColor (QColor color)
void	setAssistantGlobalColorCache (const QColor &color)
void	setDecorationThickness (int thickness)
void	setDuplicating (bool value)
	setDuplicating
void	setEditorWidgetOffset (QPointF offset)
virtual void	setFollowBrushPosition (bool follow)
void	setLocal (bool value)
	setLocal
void	setLocked (bool value)
	setLocked
void	setSnappingActive (bool set)
void	setUseCustomColor (bool useCustomColor)
QList< KisPaintingAssistantHandleSP >	sideHandles ()
const QList< KisPaintingAssistantHandleSP > &	sideHandles () const
KisPaintingAssistantHandleSP	topLeft ()
const KisPaintingAssistantHandleSP	topLeft () const
KisPaintingAssistantHandleSP	topMiddle ()
const KisPaintingAssistantHandleSP	topMiddle () const
KisPaintingAssistantHandleSP	topRight ()
const KisPaintingAssistantHandleSP	topRight () const
virtual void	transform (const QTransform &transform)
void	uncache ()
bool	useCustomColor ()
QPointF	viewportConstrainedEditorPosition (const KisCoordinatesConverter *converter, const QSize editorSize)
virtual	~KisPaintingAssistant ()

Protected Member Functions
void	drawAssistant (QPainter &gc, const QRectF &updateRect, const KisCoordinatesConverter *converter, const KoColorDisplayRendererInterface *displayRenderInterface, bool cached=true, KisCanvas2 *canvas=nullptr, bool assistantVisible=true, bool previewVisible=true) override
void	drawCache (QPainter &gc, const KisCoordinatesConverter *converter, const KoColorDisplayRendererInterface *displayRenderInterface, bool assistantVisible=true) override
	performance layer where the graphics can be drawn from a cache instead of generated every render update
KisPaintingAssistantHandleSP	firstLocalHandle () const override
	firstLocalHandle Note: this doesn't guarantee it will be the topleft corner! For that, use getLocalRect().topLeft() The only purpose of those functions to exist is to be able to put getLocalRect() function in the KisPaintingAssistant instead of reimplementing it in every specific assistant.
KisPaintingAssistantHandleSP	secondLocalHandle () const override
	secondLocalHandle Note: this doesn't guarantee it will be the bottomRight corner! For that, use getLocalRect().bottomRight() (and remember that for QRect bottomRight() works differently than for QRectF, so don't convert to QRect before accessing the corner)
Protected Member Functions inherited from KisPaintingAssistant
virtual QRect	boundingRect () const
QPointF	effectiveBrushPosition (const KisCoordinatesConverter *converter, KisCanvas2 *canvas) const
	Query the effective brush position to be used for preview lines. This is intended to be used for painting the dynamic preview lines for assistants that feature them. Affected by setAdjustedBrushPosition() and setFollowBrushPosition().
QRectF	getLocalRect () const
	getLocalRect The function deals with local handles not being topLeft and bottomRight gracefully and returns a correct rectangle. Thanks to that the user can place handles in a "wrong" order or move them around but the local rectangle will still be correct.
void	initHandles (QList< KisPaintingAssistantHandleSP > _handles)
	KisPaintingAssistant (const KisPaintingAssistant &rhs, QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap)
QPointF	pixelToView (const QPoint pixelCoords) const

Private Member Functions
QPointF	project (const QPointF &pt, const QPointF &strokeBegin, const bool snapToAny, qreal moveThreshold)
	TwoPointAssistant (const TwoPointAssistant &rhs, QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap)

Private Attributes
KisCanvas2 *	m_canvas {nullptr}
double	m_gridDensity {1.0}
int	m_lastUsedPoint {-1}
QLineF	m_snapLine
bool	m_useVertical {true}

Additional Inherited Members
Static Public Member Functions inherited from KisPaintingAssistant
static QList< KisPaintingAssistantSP >	cloneAssistantList (const QList< KisPaintingAssistantSP > &list)
static double	norm2 (const QPointF &p)
Protected Attributes inherited from KisPaintingAssistant
QList< KisPaintingAssistantHandleSP >	m_handles
bool	m_hasBeenInsideLocalRect {false}

Detailed Description

Definition at line 17 of file TwoPointAssistant.h.

Member Enumeration Documentation

TwoPointHandle

enum TwoPointAssistant::TwoPointHandle

Enumerator
FirstHandle
SecondHandle
VerticalHandle
LocalFirstHandle
LocalSecondHandle

Definition at line 21 of file TwoPointAssistant.h.

                        {
        FirstHandle,
        SecondHandle,
        VerticalHandle,
        LocalFirstHandle,
        LocalSecondHandle
    };

Constructor & Destructor Documentation

TwoPointAssistant() [1/2]

TwoPointAssistant::TwoPointAssistant

(

)

Definition at line 27 of file TwoPointAssistant.cc.

    : KisPaintingAssistant("two point", i18n("Two point assistant"))
{
}

TwoPointAssistant() [2/2]

TwoPointAssistant::TwoPointAssistant ( const TwoPointAssistant & rhs, QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > & handleMap )

explicitprivate

Definition at line 32 of file TwoPointAssistant.cc.

    : KisPaintingAssistant(rhs, handleMap)
    , m_canvas(rhs.m_canvas)
    , m_snapLine(rhs.m_snapLine)
    , m_gridDensity(rhs.m_gridDensity)
    , m_useVertical(rhs.m_useVertical)
    , m_lastUsedPoint(rhs.m_lastUsedPoint)
{
}

Member Function Documentation

adjustLine()

void TwoPointAssistant::adjustLine ( QPointF & point, QPointF & strokeBegin )

overridevirtual

Implements KisPaintingAssistant.

Definition at line 146 of file TwoPointAssistant.cc.

{
    QPointF p = project(point, strokeBegin, true, 0.0);
    point = p;
}

References p, and project().

adjustPosition()

QPointF TwoPointAssistant::adjustPosition ( const QPointF & point, const QPointF & strokeBegin, const bool snapToAny, qreal moveThresholdPt )

overridevirtual

Adjust the position given in parameter.

Parameters

point	the coordinates in point in the document reference
strokeBegin	the coordinates of the beginning of the stroke
snapToAny	because now assistants can be composited out of multiple inside assistants. snapToAny true means that you can use any of the inside assistant, while it being false means you should use the last used one. The logic determining when it happens (first stroke etc.) is in the decoration, so those two options are enough.
moveThresholdPt	the threshold for the "move" of the cursor measured in pt (usually equals to 2px in screen coordinates converted to pt)

Implements KisPaintingAssistant.

Definition at line 141 of file TwoPointAssistant.cc.

{
    return project(pt, strokeBegin, snapToAny, moveThresholdPt);
}

References project().

canBeLocal()

bool TwoPointAssistant::canBeLocal ( ) const

overridevirtual

canBeLocal

Returns

if the assistant can be potentially a "local assistant" (limited to rectangular area) or not

Reimplemented from KisPaintingAssistant.

Definition at line 484 of file TwoPointAssistant.cc.

{
    return true;
}

clone()

KisPaintingAssistantSP TwoPointAssistant::clone ( QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > & handleMap ) const

overridevirtual

Implements KisPaintingAssistant.

Definition at line 42 of file TwoPointAssistant.cc.

{
    return KisPaintingAssistantSP(new TwoPointAssistant(*this, handleMap));
}

References TwoPointAssistant().

drawAssistant()

void TwoPointAssistant::drawAssistant ( QPainter & gc, const QRectF & updateRect, const KisCoordinatesConverter * converter, const KoColorDisplayRendererInterface * displayRenderInterface, bool cached = true, KisCanvas2 * canvas = nullptr, bool assistantVisible = true, bool previewVisible = true )

overrideprotectedvirtual

Reimplemented from KisPaintingAssistant.

Definition at line 152 of file TwoPointAssistant.cc.

{
    Q_UNUSED(updateRect);
    Q_UNUSED(cached);
    gc.save();
    gc.resetTransform();
 
    const QColor canvasAssistantColor = displayRenderInterface->convertColorToDisplayColorSpace(KoColor(effectiveAssistantColor(), KoColorSpaceRegistry::instance()->rgb8()));
 
    const QTransform initialTransform = converter->documentToWidgetTransform();
    bool isEditing = false;
    bool showLocal = isLocal() && handles().size() == 5;
 
    if (canvas) {
        isEditing = canvas->paintingAssistantsDecoration()->isEditingAssistants();
    }
 
    if (isEditing) {
        Q_FOREACH (const QPointF* handle, handles()) {
            QPointF h = initialTransform.map(*handle);
            QRectF ellipse = QRectF(QPointF(h.x() -15, h.y() -15), QSizeF(30, 30));
 
            QPainterPath pathCenter;
            pathCenter.addEllipse(ellipse);
            drawPath(gc, pathCenter, displayRenderInterface, isSnappingActive());
 
            // Draw circle to represent center of vision
            if (handles().length() == 3 && handle == handles()[2]) {
                const QLineF horizon = QLineF(*handles()[0],*handles()[1]);
                QLineF normal = horizon.normalVector();
                normal.translate(*handles()[2]-normal.p1());
                QPointF cov = horizon.center();
                normal.intersects(horizon,&cov);
                const QPointF center = initialTransform.map(cov);
                QRectF center_ellipse = QRectF(QPointF(center.x() -15, center.y() -15), QSizeF(30, 30));
                QPainterPath pathCenter;
                pathCenter.addEllipse(center_ellipse);
                drawPath(gc, pathCenter, displayRenderInterface, isSnappingActive());
            }
        }
 
        if (handles().size() <= 2) {
            QPainterPath path;
            int tempDensity = m_gridDensity * 10; // the vanishing point density seems visibly more dense, hence let's make it less dense
            QRect viewport = gc.viewport();
 
            for (int i = 0; i < handles().size(); i++) {
                const QPointF p = initialTransform.map(*handles()[i]);
                for (int currentAngle=0; currentAngle <= 180; currentAngle = currentAngle + tempDensity) {
 
                    // determine the correct angle based on the iteration
                    float xPos = cos(currentAngle * M_PI / 180);
                    float yPos = sin(currentAngle * M_PI / 180);
                    float length = 100;
                    QPointF unit = QPointF(length*xPos, length*yPos);
 
                    // find point
                    QLineF snapLine = QLineF(p, p + unit);
                    if (KisAlgebra2D::intersectLineRect(snapLine, viewport, false)) {
                        // make a line from VP center to edge of canvas with that angle
 
                        path.moveTo(snapLine.p1());
                        path.lineTo(snapLine.p2());
                    }
 
                    QLineF snapLine2 = QLineF(p, p - unit);
                    if (KisAlgebra2D::intersectLineRect(snapLine2, viewport, false)) {
                        // make a line from VP center to edge of canvas with that angle
 
                        path.moveTo(snapLine2.p1());
                        path.lineTo(snapLine2.p2());
                    }
 
 
                }
 
                drawPreview(gc, path, displayRenderInterface);//and we draw the preview.
 
            }
        }
 
    }
 
    if (handles().size() >= 2) {
        QPointF mousePos = effectiveBrushPosition(converter, canvas);
        const QPointF p1 = *handles()[0];
        const QPointF p2 = *handles()[1];
        const QRect viewport= gc.viewport();
 
        const QPolygonF localPoly = (isLocal() && handles().size() == 5) ? initialTransform.map(QPolygonF(getLocalRect())) : QPolygonF();
        const QPolygonF viewportAndLocalPoly = !localPoly.isEmpty() ? QPolygonF(QRectF(viewport)).intersected(localPoly) : QRectF(viewport);
 
 
        QPainterPath path;
        QPainterPath previewPath; // part of the preview, instead of the assistant itself
 
        // draw the horizon
        if (assistantVisible == true || isEditing == true) {
            QLineF horizonLine = initialTransform.map(QLineF(p1,p2));
            KisAlgebra2D::cropLineToConvexPolygon(horizonLine, viewportAndLocalPoly, true, true);
            path.moveTo(horizonLine.p1());
            path.lineTo(horizonLine.p2());
        }
 
        // draw the VP-->mousePos lines
        if (isEditing == false && previewVisible == true && isSnappingActive() == true) {
            // draw the line vp <-> mouse even outside of the local rectangle
            // but only if the mouse pos is inside the rectangle
            QLineF snapMouse1 = QLineF(initialTransform.map(p1), mousePos);
            QLineF snapMouse2 = QLineF(initialTransform.map(p2), mousePos);
            KisAlgebra2D::cropLineToConvexPolygon(snapMouse1, viewportAndLocalPoly, false, true);
            KisAlgebra2D::cropLineToConvexPolygon(snapMouse2, viewportAndLocalPoly, false, true);
            previewPath.moveTo(snapMouse1.p1());
            previewPath.lineTo(snapMouse1.p2());
            previewPath.moveTo(snapMouse2.p1());
            previewPath.lineTo(snapMouse2.p2());
        }
 
        // draw the side handle bars
        if (isEditing == true && !sideHandles().isEmpty()) {
            path.moveTo(initialTransform.map(p1));
            path.lineTo(initialTransform.map(*sideHandles()[0]));
            path.lineTo(initialTransform.map(*sideHandles()[1]));
            path.moveTo(initialTransform.map(p2));
            path.lineTo(initialTransform.map(*sideHandles()[2]));
            path.lineTo(initialTransform.map(*sideHandles()[3]));
            path.moveTo(initialTransform.map(p1));
            path.lineTo(initialTransform.map(*sideHandles()[4]));
            path.lineTo(initialTransform.map(*sideHandles()[5]));
            path.moveTo(initialTransform.map(p2));
            path.lineTo(initialTransform.map(*sideHandles()[6]));
            path.lineTo(initialTransform.map(*sideHandles()[7]));
        }
 
        // draw the local rectangle
        if (showLocal && assistantVisible) {
            QPointF p1 = *handles()[(int)LocalFirstHandle];
            QPointF p3 = *handles()[(int)LocalSecondHandle];
            QPointF p2 = QPointF(p1.x(), p3.y());
            QPointF p4 = QPointF(p3.x(), p1.y());
 
            path.moveTo(initialTransform.map(p1));
 
            path.lineTo(initialTransform.map(p2));
            path.lineTo(initialTransform.map(p3));
            path.lineTo(initialTransform.map(p4));
            path.lineTo(initialTransform.map(p1));
        }
 
 
        drawPreview(gc,previewPath, displayRenderInterface);
        drawPath(gc, path, displayRenderInterface, isSnappingActive());
 
        if (handles().size() >= 3 && isSnappingActive()) {
            path = QPainterPath(); // clear
            const QPointF p3 = *handles()[2];
 
            qreal size = 0;
            const QTransform t = localTransform(p1,p2,p3,&size);
            const QTransform inv = t.inverted();
            const QPointF vp_a = t.map(p1);
            const QPointF vp_b = t.map(p2);
 
            if ((vp_a.x() < 0 && vp_b.x() > 0) ||
                (vp_a.x() > 0 && vp_b.x() < 0)) {
                if (m_useVertical) {
                    // Draw vertical line, but only if the center is between both VPs
                    QLineF vertical = initialTransform.map(inv.map(QLineF::fromPolar(1,90)));
                    if (!isEditing) vertical.translate(mousePos - vertical.p1());
                    KisAlgebra2D::cropLineToConvexPolygon(vertical, viewportAndLocalPoly, true, true);
                    if (previewVisible) {
                        path.moveTo(vertical.p1());
                        path.lineTo(vertical.p2());
                    }
 
                    if (assistantVisible) {
                        // Display a notch to represent the center of vision
                        path.moveTo(initialTransform.map(inv.map(QPointF(0,vp_a.y()-10))));
                        path.lineTo(initialTransform.map(inv.map(QPointF(0,vp_a.y()+10))));
                    }
                    drawPreview(gc,path, displayRenderInterface);
                    path = QPainterPath(); // clear
                }
            }
 
            const QPointF upper = QPointF(0,vp_a.y() + size);
            const QPointF lower = QPointF(0,vp_a.y() - size);
 
            // Set up the fading effect for the grid lines
            // Needed so the grid density doesn't look distracting
            QColor color = canvasAssistantColor;
            QGradient fade = QLinearGradient(initialTransform.map(inv.map(upper)),
                                             initialTransform.map(inv.map(lower)));
            color.setAlphaF(0);
            fade.setColorAt(0.4, canvasAssistantColor);
            fade.setColorAt(0.5, color);
            fade.setColorAt(0.6, canvasAssistantColor);
            const QPen pen = gc.pen();
            const QBrush new_brush = QBrush(fade);
            int width = 1;
            const QPen new_pen = QPen(new_brush, width, pen.style());
            gc.setPen(new_pen);
 
            const QList<QPointF> station_points = {upper, lower};
            const QList<QPointF> vanishing_points = {vp_a, vp_b};
 
            // Draw grid lines above and below the horizon
            Q_FOREACH (const QPointF sp, station_points) {
 
                // Draw grid lines towards each vanishing point
                Q_FOREACH (const QPointF vp, vanishing_points) {
 
                    // Interval between each grid line, uses grid density specified by user
                    const qreal initial_angle = QLineF(sp, vp).angle();
                    const qreal interval = size*m_gridDensity / cos((initial_angle - 90) * M_PI/180);
                    const QPointF translation = QPointF(interval, 0);
 
                    // Draw grid lines originating from both the left and right of the central vertical line
                    Q_FOREACH (const int dir, QList<int>({-1, 1})) {
 
                        // Limit at 300 grid lines per direction, reasonable even for m_gridDensity=0.1;
                        for (int i = 0; i <= 300; i++) {
                            const QLineF gridline = QLineF(sp + translation * i * dir, vp);
 
                            // Don't bother drawing lines that are nearly parallel to horizon
                            const qreal angle = gridline.angle();
                            if (angle < 0.25 || angle > 359.75 || (angle < 180.25 && angle > 179.75)) {
                                break;
                            }
 
                            QLineF drawn_gridline = initialTransform.map(inv.map(gridline));
                            KisAlgebra2D::cropLineToConvexPolygon(drawn_gridline, viewportAndLocalPoly, true, false);
 
                            if (assistantVisible || isEditing == true) {
                                path.moveTo(drawn_gridline.p2());
                                path.lineTo(drawn_gridline.p1());
                            }
                        }
                    }
                }
            }
            gc.drawPath(path);
        }
    }
 
    gc.restore();
    //KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
}

References KoColorDisplayRendererInterface::convertColorToDisplayColorSpace(), KisAlgebra2D::cropLineToConvexPolygon(), KisCoordinatesConverter::documentToWidgetTransform(), KisPaintingAssistant::drawPath(), KisPaintingAssistant::drawPreview(), KisPaintingAssistant::effectiveAssistantColor(), KisPaintingAssistant::effectiveBrushPosition(), KisPaintingAssistant::getLocalRect(), KisPaintingAssistant::handles(), KoColorSpaceRegistry::instance(), KisAlgebra2D::intersectLineRect(), KisPaintingAssistantsDecoration::isEditingAssistants(), KisPaintingAssistant::isLocal(), KisPaintingAssistant::isSnappingActive(), length(), LocalFirstHandle, LocalSecondHandle, localTransform(), m_gridDensity, M_PI, m_useVertical, p, p1, p2, p3, KisCanvas2::paintingAssistantsDecoration(), and KisPaintingAssistant::sideHandles().

drawCache()

void TwoPointAssistant::drawCache ( QPainter & gc, const KisCoordinatesConverter * converter, const KoColorDisplayRendererInterface * displayRenderInterface, bool assistantVisible = true )

overrideprotectedvirtual

performance layer where the graphics can be drawn from a cache instead of generated every render update

Implements KisPaintingAssistant.

Definition at line 401 of file TwoPointAssistant.cc.

{
    Q_UNUSED(gc);
    Q_UNUSED(converter);
    Q_UNUSED(assistantVisible);
    Q_UNUSED(displayRenderInterface);
    if (!m_canvas || !isAssistantComplete()) {
        return;
    }
 
    if (assistantVisible == false ||   m_canvas->paintingAssistantsDecoration()->isEditingAssistants()) {
        return;
    }
}

References isAssistantComplete(), KisPaintingAssistantsDecoration::isEditingAssistants(), m_canvas, and KisCanvas2::paintingAssistantsDecoration().

endStroke()

void TwoPointAssistant::endStroke ( )

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 134 of file TwoPointAssistant.cc.

{
    m_snapLine = QLineF();
    m_lastUsedPoint = -1;
    KisPaintingAssistant::endStroke();
}

References KisPaintingAssistant::endStroke(), m_lastUsedPoint, and m_snapLine.

firstLocalHandle()

KisPaintingAssistantHandleSP TwoPointAssistant::firstLocalHandle ( ) const

overrideprotectedvirtual

firstLocalHandle Note: this doesn't guarantee it will be the topleft corner! For that, use getLocalRect().topLeft() The only purpose of those functions to exist is to be able to put getLocalRect() function in the KisPaintingAssistant instead of reimplementing it in every specific assistant.

Returns

the first handle of the rectangle of the limited area

Reimplemented from KisPaintingAssistant.

Definition at line 416 of file TwoPointAssistant.cc.

{
    if (handles().size() > LocalFirstHandle) {
        return handles().at(LocalFirstHandle);
    } else {
        return nullptr;
    }
}

References KisPaintingAssistant::handles(), and LocalFirstHandle.

getDefaultEditorPosition()

QPointF TwoPointAssistant::getDefaultEditorPosition ( ) const

overridevirtual

Implements KisPaintingAssistant.

Definition at line 434 of file TwoPointAssistant.cc.

{
    int centerOfVisionHandle = 2;
    if (handles().size() > centerOfVisionHandle) {
        return *handles().at(centerOfVisionHandle);
    } else if (handles().size() > 0) {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(false, *handles().at(0));
        return *handles().at(0);
    } else {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(false, QPointF(0, 0));
        return QPointF(0, 0);
    }
}

References KisPaintingAssistant::handles(), and KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE.

gridDensity()

double TwoPointAssistant::gridDensity

(

)

Definition at line 463 of file TwoPointAssistant.cc.

{
    return m_gridDensity;
}

References m_gridDensity.

isAssistantComplete()

bool TwoPointAssistant::isAssistantComplete ( ) const

overridevirtual

determines if the assistant has enough handles to be considered created new assistants get in a "creation" phase where they are currently being made on the canvas it will return false if we are in the middle of creating the assistant.

Reimplemented from KisPaintingAssistant.

Definition at line 479 of file TwoPointAssistant.cc.

{
    return handles().size() >= numHandles();
}

References KisPaintingAssistant::handles(), and numHandles().

loadCustomXml()

bool TwoPointAssistant::loadCustomXml ( QXmlStreamReader * xml )

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 503 of file TwoPointAssistant.cc.

{
    if (xml && xml->name() == "gridDensity") {
        this->setGridDensity((float)KisDomUtils::toDouble(xml->attributes().value("value").toString()));
    }
    if (xml && xml->name() == "useVertical") {
        this->setUseVertical((bool)KisDomUtils::toInt(xml->attributes().value("value").toString()));
    }
    if (xml && xml->name() == "isLocal") {
        this->setLocal((bool)KisDomUtils::toInt(xml->attributes().value("value").toString()));
    }
    return true;
}

References setGridDensity(), KisPaintingAssistant::setLocal(), setUseVertical(), KisDomUtils::toDouble(), and KisDomUtils::toInt().

localTransform()

QTransform TwoPointAssistant::localTransform	(	QPointF	vp_a,
		QPointF	vp_b,
		QPointF	pt_c,
		qreal *	size )

Definition at line 468 of file TwoPointAssistant.cc.

{
    QTransform t = QTransform();
    t.rotate(QLineF(vp_a, vp_b).angle());
    t.translate(-pt_c.x(),-pt_c.y());
    const QLineF horizon = QLineF(t.map(vp_a), QPointF(t.map(vp_b).x(),t.map(vp_a).y()));
    *size = sqrt(pow(horizon.length()/2.0,2) - pow(abs(horizon.center().x()),2));
 
    return t;
}

numHandles()

int TwoPointAssistant::numHandles ( ) const

inlineoverridevirtual

Implements KisPaintingAssistant.

Definition at line 37 of file TwoPointAssistant.h.

{ return isLocal() ? 5 : 3; }

References KisPaintingAssistant::isLocal().

project()

QPointF TwoPointAssistant::project ( const QPointF & pt, const QPointF & strokeBegin, const bool snapToAny, qreal moveThreshold )

private

Definition at line 47 of file TwoPointAssistant.cc.

{
    Q_ASSERT(isAssistantComplete());
 
    QPointF best_pt = point;
    double best_dist = DBL_MAX;
    QList<int> possibleHandles;
 
    // must be above or equal to 0;
    // if useVertical, then last used point must be below 3, because 2 means vertical
    //     and it's the last possible point here (sanity check)
    // if !useVertical, then it must be below 2, because 2 means vertical
    bool isLastUsedPointCorrectNow = m_lastUsedPoint >= 0 && (m_useVertical ? m_lastUsedPoint < 3 : m_lastUsedPoint < 2);
 
    if (isLocal() && handles().size() == 5) {
        // here we can just return since we don't want to do anything
        // so we're returning a NaN
        // but only if we don't have a point/axes it was already using
 
        QRectF rect = getLocalRect();
        bool insideLocalRect = rect.contains(point);
        if (!insideLocalRect && (!isLastUsedPointCorrectNow || !m_hasBeenInsideLocalRect)) {
            return QPointF(qQNaN(), qQNaN());
        } else if (insideLocalRect) {
            m_hasBeenInsideLocalRect = true;
        }
    }
 
    if (!isLastUsedPointCorrectNow && KisAlgebra2D::norm(point - strokeBegin) < moveThreshold) {
        return strokeBegin;
    }
 
    if (!snapToAny && isLastUsedPointCorrectNow) {
        possibleHandles = QList<int>({m_lastUsedPoint});
    } else {
        if (m_useVertical) {
            possibleHandles = QList<int>({0, 1, 2});
        } else {
            possibleHandles = QList<int>({0, 1});
        }
    }
 
    Q_FOREACH (int vpIndex, possibleHandles) {
        QPointF vp = *handles()[vpIndex];
        double dist = 0;
        QPointF pt = QPointF();
        QLineF snapLine = QLineF();
 
        // TODO: Would be a good idea to generalize this whole routine
        // in KisAlgebra2d, as it's all lifted from the vanishing
        // point assistant and parallel ruler assistant, and by
        // extension the perspective assistant...
        qreal dx = point.x() - strokeBegin.x();
        qreal dy = point.y() - strokeBegin.y();
 
        if (vp != *handles()[2]) {
            snapLine = QLineF(vp, strokeBegin);
        } else {
            QLineF vertical = QLineF(*handles()[0],*handles()[1]).normalVector();
            snapLine = QLineF(vertical.p1(), vertical.p2());
            QPointF translation = (vertical.p1()-strokeBegin)*-1.0;
            snapLine = snapLine.translated(translation);
        }
 
        dx = snapLine.dx();
        dy = snapLine.dy();
 
        const qreal dx2 = dx * dx;
        const qreal dy2 = dy * dy;
        const qreal invsqrlen = 1.0 / (dx2 + dy2);
 
        pt = QPointF(dx2 * point.x() + dy2 * snapLine.x1() + dx * dy * (point.y() - snapLine.y1()),
                     dx2 * snapLine.y1() + dy2 * point.y() + dx * dy * (point.x() - snapLine.x1()));
 
        pt *= invsqrlen;
        dist = qAbs(pt.x() - point.x()) + qAbs(pt.y() - point.y());
 
        if (dist < best_dist) {
            best_pt = pt;
            best_dist = dist;
            m_lastUsedPoint = vpIndex;
        }
    }
 
    return best_pt;
}

References KisPaintingAssistant::getLocalRect(), KisPaintingAssistant::handles(), isAssistantComplete(), KisPaintingAssistant::isLocal(), KisPaintingAssistant::m_hasBeenInsideLocalRect, m_lastUsedPoint, m_useVertical, and KisAlgebra2D::norm().

saveCustomXml()

void TwoPointAssistant::saveCustomXml ( QXmlStreamWriter * xml )

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 489 of file TwoPointAssistant.cc.

{
    xml->writeStartElement("gridDensity");
    xml->writeAttribute("value", KisDomUtils::toString( this->gridDensity()));
    xml->writeEndElement();
    xml->writeStartElement("useVertical");
    xml->writeAttribute("value", KisDomUtils::toString( (int)this->useVertical()));
    xml->writeEndElement();
    xml->writeStartElement("isLocal");
    xml->writeAttribute("value", KisDomUtils::toString( (int)this->isLocal()));
    xml->writeEndElement();
 
}

References gridDensity(), KisPaintingAssistant::isLocal(), KisDomUtils::toString(), and useVertical().

secondLocalHandle()

KisPaintingAssistantHandleSP TwoPointAssistant::secondLocalHandle ( ) const

overrideprotectedvirtual

secondLocalHandle Note: this doesn't guarantee it will be the bottomRight corner! For that, use getLocalRect().bottomRight() (and remember that for QRect bottomRight() works differently than for QRectF, so don't convert to QRect before accessing the corner)

Returns

Reimplemented from KisPaintingAssistant.

Definition at line 425 of file TwoPointAssistant.cc.

{
    if (handles().size() > LocalSecondHandle) {
        return handles().at(LocalSecondHandle);
    } else {
        return nullptr;
    }
}

References KisPaintingAssistant::handles(), and LocalSecondHandle.

setGridDensity()

void TwoPointAssistant::setGridDensity

(

double

density

)

Definition at line 448 of file TwoPointAssistant.cc.

{
    m_gridDensity = density;
}

References m_gridDensity.

setUseVertical()

void TwoPointAssistant::setUseVertical

(

bool

value

)

Definition at line 458 of file TwoPointAssistant.cc.

{
    m_useVertical = value;
}

References m_useVertical, and value().

useVertical()

bool TwoPointAssistant::useVertical

(

)

Definition at line 453 of file TwoPointAssistant.cc.

{
    return m_useVertical;
}

References m_useVertical.

Member Data Documentation

m_canvas

KisCanvas2* TwoPointAssistant::m_canvas {nullptr}

private

Definition at line 76 of file TwoPointAssistant.h.

{nullptr};

m_gridDensity

double TwoPointAssistant::m_gridDensity {1.0}

private

Definition at line 79 of file TwoPointAssistant.h.

{1.0};

m_lastUsedPoint

int TwoPointAssistant::m_lastUsedPoint {-1}

private

Definition at line 82 of file TwoPointAssistant.h.

{-1}; // last used vanishing point

m_snapLine

QLineF TwoPointAssistant::m_snapLine

private

Definition at line 78 of file TwoPointAssistant.h.

m_useVertical

bool TwoPointAssistant::m_useVertical {true}

private

Definition at line 80 of file TwoPointAssistant.h.

{true};

---

The documentation for this class was generated from the following files:

• plugins/assistants/Assistants/TwoPointAssistant.h
• plugins/assistants/Assistants/TwoPointAssistant.cc