CurvilinearPerspectiveAssistant Class Reference

#include <CurvilinearPerspectiveAssistant.h>

Inheritance diagram for CurvilinearPerspectiveAssistant:

Public Member Functions
void	adjustLine (QPointF &point, QPointF &strokeBegin) override
QPointF	adjustPosition (const QPointF &point, const QPointF &strokeBegin, const bool snapToAny, qreal moveThresholdPt) override
KisPaintingAssistantSP	clone (QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap) const override
	CurvilinearPerspectiveAssistant ()
QPointF	getDefaultEditorPosition () const override
bool	isAssistantComplete () const override
int	numHandles () const override
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
virtual bool	canBeLocal () const
	canBeLocal
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
virtual void	endStroke ()
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
virtual bool	loadCustomXml (QXmlStreamReader *xml)
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
virtual void	saveCustomXml (QXmlStreamWriter *xml)
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=0, 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
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().
virtual KisPaintingAssistantHandleSP	firstLocalHandle () const
	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.
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
virtual KisPaintingAssistantHandleSP	secondLocalHandle () const
	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)

Private Member Functions
	CurvilinearPerspectiveAssistant (const CurvilinearPerspectiveAssistant &rhs, QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap)
QLineF	identifyCircle (const QPointF thirdPoint)

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 18 of file CurvilinearPerspectiveAssistant.h.

Constructor & Destructor Documentation

CurvilinearPerspectiveAssistant() [1/2]

CurvilinearPerspectiveAssistant::CurvilinearPerspectiveAssistant

(

)

Definition at line 28 of file CurvilinearPerspectiveAssistant.cc.

    : KisPaintingAssistant("curvilinear-perspective", i18n("Curvilinear Perspective assistant"))
{
}

CurvilinearPerspectiveAssistant() [2/2]

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

explicitprivate

Definition at line 33 of file CurvilinearPerspectiveAssistant.cc.

    : KisPaintingAssistant(rhs, handleMap)
{
}

Member Function Documentation

adjustLine()

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

overridevirtual

Implements KisPaintingAssistant.

Definition at line 43 of file CurvilinearPerspectiveAssistant.cc.

{
    point = QPointF();
    strokeBegin = QPointF();
}

adjustPosition()

QPointF CurvilinearPerspectiveAssistant::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 226 of file CurvilinearPerspectiveAssistant.cc.

{
    // Get the center and radius for the given point
    QLineF initialCircle = identifyCircle(strokeBegin);
 
    // Set the new point onto the circle.
    QLineF magnetizedCircle(initialCircle.p1(), pt);
    magnetizedCircle.setLength(initialCircle.length());
 
    return magnetizedCircle.p2();
 
}

References identifyCircle().

clone()

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

overridevirtual

Implements KisPaintingAssistant.

Definition at line 38 of file CurvilinearPerspectiveAssistant.cc.

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

References CurvilinearPerspectiveAssistant().

drawAssistant()

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

overrideprotectedvirtual

Reimplemented from KisPaintingAssistant.

Definition at line 49 of file CurvilinearPerspectiveAssistant.cc.

{
    Q_UNUSED(cached);
    Q_UNUSED(updateRect);
 
    gc.save();
    gc.resetTransform();
 
    const QColor canvasAssistantColor = displayRenderInterface->convertColorToDisplayColorSpace(KoColor(effectiveAssistantColor(), KoColorSpaceRegistry::instance()->rgb8()));
    
    if (isSnappingActive()) {
 
        QTransform initialTransform = converter->documentToWidgetTransform();
        QPainterPath baseGuidePath;
        QPainterPath mouseGuidePath;
 
        gc.setTransform(initialTransform);
 
        /*
         * Curvilinear perspective is created by circular arcs that intersect 2 vanishing points.
         * As such, the center of the circle and the radius of the circle need to be determined.
         * 
         * Create guidelines by selecting incremental multipliers for the assistant size between [-1, 1),
         * and calculating the center location and radius of the circle to include the point 
         * at the location specified by the multiplier (the "arbitrary point").
         * 
         * Formulas: 
         * Radius^2 = HalfHandleDist^2 + CenterDist^2 (b.c. The circle must include both vanishing points.)
         * Radius^2 = (CenterDist + Multiplier * HalfHandleDist)^2 (b.c. The circle must include the arbitrary point)
         * 
         * Solve for CenterDist and Radius:
         * CenterDist = HalfHandleDist * (1 - Multiplier * Multiplier) / ( 2 * Multiplier)
         * Radius     = HalfHandleDist * (1 + Multiplier * Multiplier) / ( 2 * Multiplier)
         * 
         */
        
        QPointF p1 = *handles()[0];
        QPointF p2 = *handles()[1];
 
        double deltaX = p2.x() - p1.x();
        double deltaY = p2.y() - p1.y();
 
        // Copied from Two-Point Perspective's fading effect for approaching vanishing points.
        // Set up the fading effect for the grid lines
        // Needed so the grid density doesn't look distracting
        QColor color = canvasAssistantColor;
        QGradient fade = QLinearGradient(
            QPointF(p1.x() - deltaY, p1.y() + deltaX), 
            QPointF(p1.x() + deltaY, p1.y() - deltaX));
        
        color.setAlphaF(0.0);
        fade.setColorAt(0.42, canvasAssistantColor);
        fade.setColorAt(0.5, color);
        fade.setColorAt(0.58, canvasAssistantColor);
        const QPen pen = gc.pen();
        const QBrush new_brush = QBrush(fade);
        int width = 0;
        const QPen new_pen = QPen(new_brush, width, pen.style());
        gc.setPen(new_pen);
 
        double handleDistance = KisAlgebra2D::norm(QPointF(deltaX, deltaY));
        double halfHandleDist = handleDistance / 2.0;
 
        double avgX = deltaX / 2.0 + p1.x();
        double avgY = deltaY / 2.0 + p1.y();
 
        // Rotate 90 degrees by formula: (-y, x)
        // Then normalize vector.
        double dirX = -deltaY / handleDistance;
        double dirY = deltaX / handleDistance;
 
        int resolution = halfHandleDist / 3;
 
        if(assistantVisible) {
            
            for(int i = -resolution; i < resolution; i++) {
                // If i = 0, the circle would be infinitely far away with an infinite radius (aka a line)
                if(i == 0) {
                    baseGuidePath.moveTo(QPointF(p1.x() - deltaX*2, p1.y() - deltaY*2));
                    baseGuidePath.lineTo(QPointF(p2.x() + deltaX*2, p2.y() + deltaY*2));
                    continue;
                }
                // Map loop iterator to multiplier. This line gives the depth-like effect.
                double mult = 1.0 / i;
                // Use formula to calculate CenterDist
                double centerDist = halfHandleDist * (1 - pow2(mult)) / (2*mult);
 
                // Use the distance to the center (from the average point) to calculate the center location.
                double circleCenterX = centerDist * dirX + avgX;
                double circleCenterY = centerDist * dirY + avgY;
                // Use formula to calculate Radius
                double radius = halfHandleDist * (1 + pow2(mult)) / (2*mult);
 
                baseGuidePath.addEllipse(QPointF(circleCenterX, circleCenterY), radius, radius);
 
            }
            gc.drawPath(baseGuidePath);//drawPath(gc, baseGuidePath);
        }
        
        if(previewVisible) {
            // Draw guideline for the mouse, based on mouse position.
            QPointF mousePos = effectiveBrushPosition(converter, canvas);
            // Get location on the screen of handles.
            QPointF screenP1 = initialTransform.map(*handles()[0]);
            QPointF screenP2 = initialTransform.map(*handles()[1]);
            // Don't draw if mouse is too close to vanishing points (will flicker if not)
            // Use distance squared to avoid expensive sqrt.
            if(
                kisSquareDistance(mousePos, screenP2) > 9 &&
                kisSquareDistance(mousePos, screenP1) > 9
            ) {
                QLineF circle = identifyCircle(initialTransform.inverted().map(mousePos));
                double radius = circle.length();
                mouseGuidePath.addEllipse(circle.p1(), radius, radius);
            }
 
            gc.drawPath(mouseGuidePath);//drawPath(gc, mouseGuidePath);
        }
 
    }
    gc.restore();
 
    //KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
}

References KoColorDisplayRendererInterface::convertColorToDisplayColorSpace(), KisCoordinatesConverter::documentToWidgetTransform(), KisPaintingAssistant::effectiveAssistantColor(), KisPaintingAssistant::effectiveBrushPosition(), KisPaintingAssistant::handles(), identifyCircle(), KoColorSpaceRegistry::instance(), KisPaintingAssistant::isSnappingActive(), kisSquareDistance(), KisAlgebra2D::norm(), p1, p2, and pow2().

drawCache()

void CurvilinearPerspectiveAssistant::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 175 of file CurvilinearPerspectiveAssistant.cc.

{
    Q_UNUSED(gc);
    Q_UNUSED(converter);
    Q_UNUSED(assistantVisible);
    Q_UNUSED(displayRenderInterface);
}

getDefaultEditorPosition()

QPointF CurvilinearPerspectiveAssistant::getDefaultEditorPosition ( ) const

overridevirtual

Implements KisPaintingAssistant.

Definition at line 239 of file CurvilinearPerspectiveAssistant.cc.

{
    return (*handles()[0] + *handles()[1]) * 0.5;
}

References KisPaintingAssistant::handles().

identifyCircle()

QLineF CurvilinearPerspectiveAssistant::identifyCircle ( const QPointF thirdPoint )

private

Definition at line 183 of file CurvilinearPerspectiveAssistant.cc.

                                                                               {
    /*
    * Calculate center location and radius for an arbitrary point (usually the mouse location).
    * Given Formulas:
    * Radius^2 = HalfHandleDist^2 + CenterDist^2
    * avgX + CenterDist * dirX = CenterX
    * avgY + CenterDist * dirY = CenterY
    * 
    * For ease of use, let BetaX = MouseX - AvgX, BetaY = MouseY - AvgY
    * Calculated Formula for CenterDist:
    * CenterDist = (BetaX^2 + BetaY^2 - HalfHandleDist^2) / (2 * DirY * BetaX + 2 * DirY * BetaY)
    * 
    * Returns line from center to the arbitrary point.
    * 
    */
    QPointF p1 = *handles()[0];
    QPointF p2 = *handles()[1];
 
    double deltaX = p2.x() - p1.x();
    double deltaY = p2.y() - p1.y();
 
    double handleDistance = KisAlgebra2D::norm(QPointF(deltaX, deltaY));
    double halfHandleDist = handleDistance / 2.0;
 
    double avgX = deltaX / 2.0 + p1.x();
    double avgY = deltaY / 2.0 + p1.y();
 
    double dirX = -deltaY / handleDistance;
    double dirY = deltaX / handleDistance;
 
    double betaX = thirdPoint.x() - avgX;
    double betaY = thirdPoint.y() - avgY;
 
    double centerDist = 
        (pow2(betaX) + pow2(betaY) - pow2(halfHandleDist)) 
        / 
        (2 * dirX * betaX + 2 * dirY * betaY);
    
    double circleCenterX = centerDist*dirX + avgX;
    double circleCenterY = centerDist*dirY + avgY;
    return QLineF(QPointF(circleCenterX, circleCenterY), thirdPoint);
}

References KisPaintingAssistant::handles(), KisAlgebra2D::norm(), p1, p2, and pow2().

isAssistantComplete()

bool CurvilinearPerspectiveAssistant::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 244 of file CurvilinearPerspectiveAssistant.cc.

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

References KisPaintingAssistant::handles().

numHandles()

int CurvilinearPerspectiveAssistant::numHandles ( ) const

inlineoverridevirtual

Implements KisPaintingAssistant.

Definition at line 28 of file CurvilinearPerspectiveAssistant.h.

{ return 2; }

---

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

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