VanishingPointAssistant Class Reference

#include <VanishingPointAssistant.h>

Inheritance diagram for VanishingPointAssistant:

Public Types
enum	VanishingPointAssistantHandle { VanishingPointHandle , LocalFirstHandle , LocalSecondHandle }

Public Member Functions
void	adjustLine (QPointF &point, QPointF &strokeBegin) override
QPointF	adjustPosition (const QPointF &point, const QPointF &strokeBegin, bool snapToAny, qreal moveThresholdPt) override
bool	canBeLocal () const override
	canBeLocal
KisPaintingAssistantSP	clone (QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap) const override
QPointF	getDefaultEditorPosition () const override
bool	isAssistantComplete () const override
bool	loadCustomXml (QXmlStreamReader *xml) override
int	numHandles () const override
float	referenceLineDensity ()
void	saveCustomXml (QXmlStreamWriter *xml) override
void	setReferenceLineDensity (float value)
	VanishingPointAssistant ()
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)
void	drawPath (QPainter &painter, const QPainterPath &path, bool drawActive=true)
void	drawPreview (QPainter &painter, const QPainterPath &path)
void	drawX (QPainter &painter, const QPointF &pt)
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
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, bool cached=true, KisCanvas2 *canvas=nullptr, bool assistantVisible=true, bool previewVisible=true) override
void	drawCache (QPainter &gc, const KisCoordinatesConverter *converter, 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, qreal moveThresholdPt)
	VanishingPointAssistant (const VanishingPointAssistant &rhs, QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap)

Private Attributes
KisCanvas2 *	m_canvas {nullptr}
float	m_referenceLineDensity {15.0}

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 31 of file VanishingPointAssistant.h.

Member Enumeration Documentation

VanishingPointAssistantHandle

enum VanishingPointAssistant::VanishingPointAssistantHandle

Enumerator
VanishingPointHandle
LocalFirstHandle
LocalSecondHandle

Definition at line 36 of file VanishingPointAssistant.h.

                                       {
        VanishingPointHandle,
        LocalFirstHandle,
        LocalSecondHandle
    };

Constructor & Destructor Documentation

VanishingPointAssistant() [1/2]

VanishingPointAssistant::VanishingPointAssistant

(

)

Definition at line 26 of file VanishingPointAssistant.cc.

    : KisPaintingAssistant("vanishing point", i18n("Vanishing Point assistant"))
{
}

VanishingPointAssistant() [2/2]

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

explicitprivate

Definition at line 31 of file VanishingPointAssistant.cc.

    : KisPaintingAssistant(rhs, handleMap)
    , m_canvas(rhs.m_canvas)
    , m_referenceLineDensity(rhs.m_referenceLineDensity)
{
}

Member Function Documentation

adjustLine()

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

overridevirtual

Implements KisPaintingAssistant.

Definition at line 78 of file VanishingPointAssistant.cc.

{
    point = project(point, strokeBegin, 0.0);
}

References project().

adjustPosition()

QPointF VanishingPointAssistant::adjustPosition ( const QPointF & point, const QPointF & strokeBegin, 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 73 of file VanishingPointAssistant.cc.

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

References project().

canBeLocal()

bool VanishingPointAssistant::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 298 of file VanishingPointAssistant.cc.

{
    return true;
}

clone()

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

overridevirtual

Implements KisPaintingAssistant.

Definition at line 38 of file VanishingPointAssistant.cc.

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

References VanishingPointAssistant().

drawAssistant()

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

overrideprotectedvirtual

Reimplemented from KisPaintingAssistant.

Definition at line 83 of file VanishingPointAssistant.cc.

{
    // HACK ALERT: side handles aren't saved in old krita versions
    // we need to just add a default position for now if we are loading a vanishing point
    if (sideHandles().isEmpty()) {
        QPointF vpPoint = *handles()[0]; // main vanishing point
        addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(-70,0)), HandleType::SIDE);
        addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(-140,0)), HandleType::SIDE);
        addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(70,0)), HandleType::SIDE);
        addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(140,0)), HandleType::SIDE);
    }
 
    gc.save();
    gc.resetTransform();
 
    QRect viewport= gc.viewport();
 
    QPolygonF viewportAndLocalPoly = (isLocal() && isAssistantComplete()) ?
                QPolygonF(QRectF(viewport)).intersected(converter->documentToWidgetTransform().map(QPolygonF(QRectF(getLocalRect())))) : QPolygonF(QRectF(viewport));
 
    // draw controls when we are not editing
    if (canvas && canvas->paintingAssistantsDecoration()->isEditingAssistants() == false && isAssistantComplete()) {
 
        if (isSnappingActive() && previewVisible == true) {
            //don't draw if invalid.
 
            QTransform initialTransform = converter->documentToWidgetTransform();
            QPointF startPoint = initialTransform.map(*handles()[0]);
            QPointF mousePos = effectiveBrushPosition(converter, canvas);
 
            QLineF snapLine= QLineF(startPoint, mousePos);
 
            KisAlgebra2D::cropLineToConvexPolygon(snapLine, viewportAndLocalPoly, false, true);
 
            QPainterPath path;
 
            path.moveTo(snapLine.p2());
            path.lineTo(snapLine.p1());
 
            drawPreview(gc, path);//and we draw the preview.
 
        }
    }
 
 
 
 
    // editor specific controls display
    if (canvas && canvas->paintingAssistantsDecoration()->isEditingAssistants()) {
 
        // draws a circle around the vanishing point node while editing
        QTransform initialTransform = converter->documentToWidgetTransform();
        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]);
 
 
        QRectF ellipse = QRectF(QPointF(p0.x() -15, p0.y() -15), QSizeF(30, 30));
 
        QPainterPath pathCenter;
        pathCenter.addEllipse(ellipse);
        drawPath(gc, pathCenter, isSnappingActive());
 
        QColor paintingColor = effectiveAssistantColor();
 
 
        // draw the lines connecting the different nodes
        QPen penStyle(paintingColor, 2.0, Qt::SolidLine);
 
        if (!isSnappingActive()) {
            QColor snappingColor = paintingColor;
            snappingColor.setAlpha(snappingColor.alpha() * 0.2);
 
            penStyle.setColor(snappingColor);
        }
 
        gc.save();
        gc.setPen(penStyle);
        gc.drawLine(p0, p1);
        gc.drawLine(p0, p3);
        gc.drawLine(p1, p2);
        gc.drawLine(p3, p4);
        gc.restore();
    }
 
    QTransform initialTransform = converter->documentToWidgetTransform();
 
    // draw the local rectangle
    if (assistantVisible && isLocal() && isAssistantComplete()) {
        // limited area rectangle
        QPainterPath path;
        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));
        drawPath(gc, path, isSnappingActive());//and we draw the rectangle
    }
 
 
    // draw references guide for vanishing points at specified density
    if (assistantVisible && this->isSnappingActive() ) {
 
        // cycle through degrees from 0 to 180. We are doing an infinite line, so we don't need to go 360
        QPointF p0 = initialTransform.map(*handles()[0]); // main vanishing point
 
        for (int currentAngle=0; currentAngle <= 180; currentAngle = currentAngle + m_referenceLineDensity ) {
 
            // determine the correct angle based on the iteration
            float xPos = cos(currentAngle * M_PI / 180);
            float yPos = sin(currentAngle * M_PI / 180);
            QPointF unitAngle;
            unitAngle.setX(p0.x() + xPos);
            unitAngle.setY(p0.y() + yPos);
 
            // find point
            QLineF snapLine= QLineF(p0, unitAngle);
            KisAlgebra2D::intersectLineConvexPolygon(snapLine, viewportAndLocalPoly, true, true);
 
            // make a line from VP center to edge of canvas with that angle
            QPainterPath path;
            path.moveTo(snapLine.p1());
            path.lineTo(snapLine.p2());
            drawPreview(gc, path);//and we draw the preview.
        }
    }
 
 
    gc.restore();
 
    KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
}

References KisPaintingAssistant::addHandle(), KisAlgebra2D::cropLineToConvexPolygon(), KisCoordinatesConverter::documentToWidgetTransform(), KisPaintingAssistant::drawAssistant(), KisPaintingAssistant::drawPath(), KisPaintingAssistant::drawPreview(), KisPaintingAssistant::effectiveAssistantColor(), KisPaintingAssistant::effectiveBrushPosition(), KisPaintingAssistant::getLocalRect(), KisPaintingAssistant::handles(), KisAlgebra2D::intersectLineConvexPolygon(), isAssistantComplete(), KisPaintingAssistantsDecoration::isEditingAssistants(), KisPaintingAssistant::isLocal(), KisPaintingAssistant::isSnappingActive(), LocalFirstHandle, LocalSecondHandle, M_PI, m_referenceLineDensity, p0, p1, p2, p3, KisCanvas2::paintingAssistantsDecoration(), SIDE, and KisPaintingAssistant::sideHandles().

drawCache()

void VanishingPointAssistant::drawCache ( QPainter & gc, const KisCoordinatesConverter * converter, 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 224 of file VanishingPointAssistant.cc.

{
    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());
}

References KisCoordinatesConverter::documentToWidgetTransform(), KisPaintingAssistant::drawPath(), KisPaintingAssistant::handles(), isAssistantComplete(), KisPaintingAssistantsDecoration::isEditingAssistants(), KisPaintingAssistant::isSnappingActive(), m_canvas, p0, and KisCanvas2::paintingAssistantsDecoration().

firstLocalHandle()

KisPaintingAssistantHandleSP VanishingPointAssistant::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 249 of file VanishingPointAssistant.cc.

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

References KisPaintingAssistant::handles(), and LocalFirstHandle.

getDefaultEditorPosition()

QPointF VanishingPointAssistant::getDefaultEditorPosition ( ) const

overridevirtual

Implements KisPaintingAssistant.

Definition at line 267 of file VanishingPointAssistant.cc.

{
    int pointHandle = 0;
    if (handles().size() > pointHandle) {
        return *handles().at(pointHandle);
    } 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.

isAssistantComplete()

bool VanishingPointAssistant::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 293 of file VanishingPointAssistant.cc.

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

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

loadCustomXml()

bool VanishingPointAssistant::loadCustomXml ( QXmlStreamReader * xml )

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 313 of file VanishingPointAssistant.cc.

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

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

numHandles()

int VanishingPointAssistant::numHandles ( ) const

inlineoverridevirtual

Implements KisPaintingAssistant.

Definition at line 46 of file VanishingPointAssistant.h.

{ return isLocal() ? 3 : 1; }

References KisPaintingAssistant::isLocal().

project()

QPointF VanishingPointAssistant::project ( const QPointF & pt, const QPointF & strokeBegin, qreal moveThresholdPt )

private

Definition at line 43 of file VanishingPointAssistant.cc.

{
    //Q_ASSERT(handles().size() == 1 || handles().size() == 5);
 
    if (isLocal() && isAssistantComplete()) {
        if (getLocalRect().contains(pt)) {
            m_hasBeenInsideLocalRect = true;
        } else if (!m_hasBeenInsideLocalRect) { // isn't inside and wasn't inside before
            return QPointF(qQNaN(), qQNaN());
        }
    }
 
    //dbgKrita<<strokeBegin<< ", " <<*handles()[0];
    QLineF snapLine = QLineF(*handles()[0], strokeBegin);
 
 
    qreal dx = snapLine.dx();
    qreal 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;
}

References KisPaintingAssistant::getLocalRect(), KisPaintingAssistant::handles(), isAssistantComplete(), KisPaintingAssistant::isLocal(), and KisPaintingAssistant::m_hasBeenInsideLocalRect.

referenceLineDensity()

float VanishingPointAssistant::referenceLineDensity

(

)

Definition at line 288 of file VanishingPointAssistant.cc.

{
    return m_referenceLineDensity;
}

References m_referenceLineDensity.

saveCustomXml()

void VanishingPointAssistant::saveCustomXml ( QXmlStreamWriter * xml )

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 303 of file VanishingPointAssistant.cc.

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

References KisPaintingAssistant::isLocal(), referenceLineDensity(), and KisDomUtils::toString().

secondLocalHandle()

KisPaintingAssistantHandleSP VanishingPointAssistant::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 258 of file VanishingPointAssistant.cc.

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

References KisPaintingAssistant::handles(), and LocalSecondHandle.

setReferenceLineDensity()

void VanishingPointAssistant::setReferenceLineDensity

(

float

value

)

Definition at line 278 of file VanishingPointAssistant.cc.

{
    // cannot have less than 1 degree value
    if (value < 1.0) {
        value = 1.0;
    }
 
    m_referenceLineDensity = value;
}

References m_referenceLineDensity, and value().

Member Data Documentation

m_canvas

KisCanvas2* VanishingPointAssistant::m_canvas {nullptr}

private

Definition at line 70 of file VanishingPointAssistant.h.

{nullptr};

m_referenceLineDensity

float VanishingPointAssistant::m_referenceLineDensity {15.0}

private

Definition at line 72 of file VanishingPointAssistant.h.

{15.0};

---

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

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