KisPaintInformation Class Reference

#include <kis_paint_information.h>

Classes
class	DistanceInformationRegistrar
struct	Private

Public Member Functions
bool	canvasMirroredH () const
bool	canvasMirroredV () const
qreal	canvasRotation () const
int	currentDabSeqNo () const
	Number of dabs painted since the beginning of the stroke.
qreal	currentTime () const
	Number of ms since the beginning of the stroke.
qreal	drawingAngle (bool considerLockedAngle=false) const
qreal	drawingAngleSafe (const KisDistanceInformation &distance) const
	XXX !!! :-| Please add dox!
QPointF	drawingDirectionVector () const
qreal	drawingDistance () const
qreal	drawingSpeed () const
bool	isHoveringMode () const
	KisPaintInformation (const KisPaintInformation &rhs)
	KisPaintInformation (const QPointF &pos, qreal pressure, qreal xTilt, qreal yTilt, qreal rotation)
	KisPaintInformation (const QPointF &pos, qreal pressure, qreal xTilt, qreal yTilt, qreal rotation, qreal tangentialPressure, qreal perspective, qreal time, qreal speed)
	KisPaintInformation (const QPointF &pos=QPointF(), qreal pressure=PRESSURE_DEFAULT)
qreal	maxPressure () const
void	mixOtherOnlyPosition (qreal t, const KisPaintInformation &other)
void	mixOtherWithoutTime (qreal t, const KisPaintInformation &other)
void	operator= (const KisPaintInformation &rhs)
void	overrideDrawingAngle (qreal angle)
	XXX !!! :-| Please add dox!
template<class PaintOp >
void	paintAt (PaintOp &op, KisDistanceInformation *distanceInfo)
qreal	perspective () const
	reciprocal of distance on the perspective grid
KisPerStrokeRandomSourceSP	perStrokeRandomSource () const
const QPointF &	pos () const
qreal	pressure () const
	The pressure of the value (from 0.0 to 1.0)
KisRandomSourceSP	randomSource () const
DistanceInformationRegistrar	registerDistanceInformation (KisDistanceInformation *distance)
qreal	rotation () const
	rotation as given by the tablet event
void	setCanvasMirroredH (bool value)
void	setCanvasMirroredV (bool value)
void	setCanvasRotation (qreal rotation)
void	setCurrentTime (qreal time) const
void	setLevelOfDetail (int levelOfDetail)
void	setPerStrokeRandomSource (KisPerStrokeRandomSourceSP value)
void	setPos (const QPointF &p)
void	setPressure (qreal p)
	Set the pressure.
void	setRandomSource (KisRandomSourceSP value)
void	setTiltDirectionOffset (qreal angle)
qreal	tangentialPressure () const
	tangential pressure (i.e., rate for an airbrush device)
qreal	tiltDirectionOffset () const
qreal	totalStrokeLength () const
	The length of the stroke before painting the current dab.
void	toXML (QDomDocument &, QDomElement &) const
qreal	xTilt () const
	The tilt of the pen on the horizontal axis (from 0.0 to 1.0)
qreal	yTilt () const
	The tilt of the pen on the vertical axis (from 0.0 to 1.0)
	~KisPaintInformation ()

Static Public Member Functions
static KisPaintInformation	createHoveringModeInfo (const QPointF &pos, qreal pressure=PRESSURE_DEFAULT, qreal xTilt=0.0, qreal yTilt=0.0, qreal rotation=0.0, qreal tangentialPressure=0.0, qreal perspective=1.0, qreal speed=0.0, qreal canvasrotation=0.0, bool canvasMirroredH=false, bool canvasMirroredV=false, qreal tiltDirectionOffset=0.0)
static KisPaintInformation	fromXML (const QDomElement &)
static KisPaintInformation	mix (const QPointF &p, qreal t, const KisPaintInformation &p1, const KisPaintInformation &p2)
static KisPaintInformation	mix (qreal t, const KisPaintInformation &pi1, const KisPaintInformation &pi2)
static KisPaintInformation	mixOnlyPosition (qreal t, const KisPaintInformation &mixedPi, const KisPaintInformation &basePi)
	(1-t) * p1 + t * p2
static KisPaintInformation	mixWithoutTime (const QPointF &p, qreal t, const KisPaintInformation &p1, const KisPaintInformation &p2)
static KisPaintInformation	mixWithoutTime (qreal t, const KisPaintInformation &pi1, const KisPaintInformation &pi2)
static qreal	tiltDirection (const KisPaintInformation &info, bool normalize=true)
static qreal	tiltElevation (const KisPaintInformation &info, qreal maxTiltX=60.0, qreal maxTiltY=60.0, bool normalize=true)

Private Member Functions
void	mixOtherImpl (const QPointF &p, qreal t, const KisPaintInformation &other, bool posOnly, bool mixTime)

Static Private Member Functions
static KisPaintInformation	mixImpl (const QPointF &p, qreal t, const KisPaintInformation &p1, const KisPaintInformation &p2, bool posOnly, bool mixTime)

Private Attributes
Private *const	d

Detailed Description

KisPaintInformation contains information about the input event that causes the brush action to happen to the brush engine's paint methods.

XXX: we directly pass the KoPointerEvent x and y tilt to KisPaintInformation, and their range is -60 to +60!

Parameters

pos	the position of the paint event in subpixel accuracy
pressure	the pressure of the stylus
xTilt	the angle between the device (a pen, for example) and the perpendicular in the direction of the x axis. Positive values are towards the bottom of the tablet. The angle is within the range 0 to 1
yTilt	the angle between the device (a pen, for example) and the perpendicular in the direction of the y axis. Positive values are towards the bottom of the tablet. The angle is within the range 0 to .
movement	current position minus the last position of the call to paintAt
rotation
tangentialPressure
perspective

Definition at line 50 of file kis_paint_information.h.

Constructor & Destructor Documentation

KisPaintInformation() [1/4]

KisPaintInformation::KisPaintInformation	(	const QPointF &	pos,
		qreal	pressure,
		qreal	xTilt,
		qreal	yTilt,
		qreal	rotation,
		qreal	tangentialPressure,
		qreal	perspective,
		qreal	time,
		qreal	speed )

Create a new KisPaintInformation object.

Definition at line 174 of file kis_paint_information.cc.

    : d(new Private(pos,
                    pressure,
                    xTilt, yTilt,
                    rotation,
                    tangentialPressure,
                    perspective,
                    time,
                    speed,
                    false))
{
}

KisPaintInformation() [2/4]

KisPaintInformation::KisPaintInformation	(	const QPointF &	pos,
		qreal	pressure,
		qreal	xTilt,
		qreal	yTilt,
		qreal	rotation )

Definition at line 194 of file kis_paint_information.cc.

    : d(new Private(pos,
                    pressure,
                    xTilt, yTilt,
                    rotation,
                    0.0,
                    1.0,
                    0.0,
                    0.0,
                    false))
{
 
}

KisPaintInformation() [3/4]

KisPaintInformation::KisPaintInformation	(	const QPointF &	pos = QPointF(),
		qreal	pressure = PRESSURE_DEFAULT )

Definition at line 212 of file kis_paint_information.cc.

    : d(new Private(pos,
                    pressure,
                    0.0, 0.0,
                    0.0,
                    0.0,
                    1.0,
                    0.0,
                    0.0,
                    false))
{
}

KisPaintInformation() [4/4]

KisPaintInformation::KisPaintInformation

(

const KisPaintInformation &

rhs

)

Definition at line 226 of file kis_paint_information.cc.

    : d(new Private(*rhs.d))
{
}

~KisPaintInformation()

KisPaintInformation::~KisPaintInformation

(

)

Definition at line 236 of file kis_paint_information.cc.

{
    delete d;
}

References d.

Member Function Documentation

canvasMirroredH()

bool KisPaintInformation::canvasMirroredH

(

)

const

Whether the canvas is horizontally mirrored for the paint-operation.

Definition at line 285 of file kis_paint_information.cc.

{
    return d->canvasMirroredH;
}

References KisPaintInformation::Private::canvasMirroredH, and d.

canvasMirroredV()

bool KisPaintInformation::canvasMirroredV

(

)

const

Whether the canvas is vertically mirrored for the paint-operation.

Definition at line 295 of file kis_paint_information.cc.

{
    return d->canvasMirroredV;
}

References KisPaintInformation::Private::canvasMirroredV, and d.

canvasRotation()

qreal KisPaintInformation::canvasRotation

(

)

const

Returns the canvas rotation if that has been given to the kispaintinformation.

Definition at line 275 of file kis_paint_information.cc.

{
    return d->canvasRotation;
}

References KisPaintInformation::Private::canvasRotation, and d.

createHoveringModeInfo()

KisPaintInformation KisPaintInformation::createHoveringModeInfo ( const QPointF & pos, qreal pressure = PRESSURE_DEFAULT, qreal xTilt = 0.0, qreal yTilt = 0.0, qreal rotation = 0.0, qreal tangentialPressure = 0.0, qreal perspective = 1.0, qreal speed = 0.0, qreal canvasrotation = 0.0, bool canvasMirroredH = false, bool canvasMirroredV = false, qreal tiltDirectionOffset = 0.0 )

static

Create a fake info object with isHoveringMode() property set to true.

See also

isHoveringMode()

Definition at line 248 of file kis_paint_information.cc.

{
    KisPaintInformation info(pos,
                             pressure,
                             xTilt, yTilt,
                             rotation,
                             tangentialPressure,
                             perspective, 0, speed);
    info.d->isHoveringMode = true;
    info.d->canvasRotation = canvasrotation;
    info.d->canvasMirroredH = canvasMirroredH;
    info.d->canvasMirroredV = canvasMirroredV;
    info.d->tiltDirectionOffset = tiltDirectionOffset;
    return info;
}

References KisPaintInformation::Private::canvasMirroredH, canvasMirroredH(), KisPaintInformation::Private::canvasMirroredV, canvasMirroredV(), KisPaintInformation::Private::canvasRotation, d, KisPaintInformation::Private::isHoveringMode, perspective(), pos(), pressure(), rotation(), tangentialPressure(), KisPaintInformation::Private::tiltDirectionOffset, tiltDirectionOffset(), xTilt(), and yTilt().

currentDabSeqNo()

int KisPaintInformation::currentDabSeqNo

(

)

const

Number of dabs painted since the beginning of the stroke.

Definition at line 487 of file kis_paint_information.cc.

{
    if (!d->directionHistoryInfo) {
        warnKrita << "KisPaintInformation::currentDabSeqNo()" << "DirectionHistoryInfo object is not available";
        return 0;
    }
 
    return d->directionHistoryInfo->currentDabSeqNo;
}

References d, KisPaintInformation::Private::directionHistoryInfo, and warnKrita.

currentTime()

qreal KisPaintInformation::currentTime

(

)

const

Number of ms since the beginning of the stroke.

Definition at line 482 of file kis_paint_information.cc.

{
    return d->time;
}

References d, and KisPaintInformation::Private::time.

drawingAngle()

qreal KisPaintInformation::drawingAngle

(

bool

considerLockedAngle = false

)

const

Current brush direction computed from the cursor movement

WARNING: this method is available only inside paintAt() call, that is when the distance information is registered.

Definition at line 402 of file kis_paint_information.cc.

{
    if (d->drawingAngleOverride) return *d->drawingAngleOverride;
 
    if (!d->directionHistoryInfo) {
        warnKrita << "KisPaintInformation::drawingAngleSafe()" << "DirectionHistoryInfo object is not available";
        return 0.0;
    }
 
    if (considerLockedAngle &&
        d->directionHistoryInfo->lockedDrawingAngle) {
 
        return *d->directionHistoryInfo->lockedDrawingAngle;
    }
 
    // If the start and end positions are the same, we can't compute an angle. In that case, use the
    // provided default.
    return KisAlgebra2D::directionBetweenPoints(d->directionHistoryInfo->lastPosition,
                                                pos(),
                                                d->directionHistoryInfo->lastAngle);
}

References d, KisAlgebra2D::directionBetweenPoints(), KisPaintInformation::Private::directionHistoryInfo, KisPaintInformation::Private::drawingAngleOverride, pos(), and warnKrita.

drawingAngleSafe()

qreal KisPaintInformation::drawingAngleSafe

(

const KisDistanceInformation &

distance

)

const

XXX !!! :-| Please add dox!

Definition at line 384 of file kis_paint_information.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!d->directionHistoryInfo, 0.0);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(distance.hasLastDabInformation(), 0.0);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!d->drawingAngleOverride, 0.0);
 
    return KisAlgebra2D::directionBetweenPoints(distance.lastPosition(),
                                                pos(),
                                                distance.lastDrawingAngle());
 
}

References d, KisAlgebra2D::directionBetweenPoints(), KisPaintInformation::Private::directionHistoryInfo, distance(), KisPaintInformation::Private::drawingAngleOverride, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and pos().

drawingDirectionVector()

QPointF KisPaintInformation::drawingDirectionVector

(

)

const

Current brush direction vector computed from the cursor movement

WARNING: this method is available only inside paintAt() call, that is when the distance information is registered.

Definition at line 424 of file kis_paint_information.cc.

{
    const qreal angle = drawingAngle(false);
    return QPointF(cos(angle), sin(angle));
}

References drawingAngle().

drawingDistance()

qreal KisPaintInformation::drawingDistance

(

)

const

Current distance from the previous dab

WARNING: this method is available only inside paintAt() call, that is when the distance information is registered.

Definition at line 430 of file kis_paint_information.cc.

{
    if (!d->directionHistoryInfo) {
        warnKrita << "KisPaintInformation::drawingDistance()" << "DirectionHistoryInfo object is not available";
        return 1.0;
    }
 
    QVector2D diff(pos() - d->directionHistoryInfo->lastPosition);
    qreal length = diff.length();
 
    if (d->levelOfDetail) {
        length *= KisLodTransform::lodToInvScale(d->levelOfDetail);
    }
 
    return length;
}

References d, KisPaintInformation::Private::directionHistoryInfo, length(), KisPaintInformation::Private::levelOfDetail, KisLodTransformBase::lodToInvScale(), pos(), and warnKrita.

drawingSpeed()

qreal KisPaintInformation::drawingSpeed

(

)

const

Current brush speed computed from the cursor movement

WARNING: this method is available only inside paintAt() call, that is when the distance information is registered.

Definition at line 457 of file kis_paint_information.cc.

{
    return d->speed;
}

References d, and KisPaintInformation::Private::speed.

fromXML()

KisPaintInformation KisPaintInformation::fromXML ( const QDomElement & e )

static

Definition at line 332 of file kis_paint_information.cc.

{
    qreal pointX = qreal(KisDomUtils::toDouble(e.attribute("pointX", "0.0")));
    qreal pointY = qreal(KisDomUtils::toDouble(e.attribute("pointY", "0.0")));
    qreal pressure = qreal(KisDomUtils::toDouble(e.attribute("pressure", "0.0")));
    qreal rotation = qreal(KisDomUtils::toDouble(e.attribute("rotation", "0.0")));
    qreal tangentialPressure = qreal(KisDomUtils::toDouble(e.attribute("tangentialPressure", "0.0")));
    qreal perspective = qreal(KisDomUtils::toDouble(e.attribute("perspective", "0.0")));
    qreal xTilt = qreal(KisDomUtils::toDouble(e.attribute("xTilt", "0.0")));
    qreal yTilt = qreal(KisDomUtils::toDouble(e.attribute("yTilt", "0.0")));
    qreal time = KisDomUtils::toDouble(e.attribute("time", "0"));
    qreal speed = KisDomUtils::toDouble(e.attribute("speed", "0"));
 
    return KisPaintInformation(QPointF(pointX, pointY), pressure, xTilt, yTilt,
                               rotation, tangentialPressure, perspective, time, speed);
}

References KisPaintInformation(), perspective(), pressure(), rotation(), tangentialPressure(), KisDomUtils::toDouble(), xTilt(), and yTilt().

isHoveringMode()

bool KisPaintInformation::isHoveringMode

(

)

const

The paint information may be generated not only during real stroke when the actual painting is happening, but also when the cursor is hovering the canvas. In this mode some of the sensors work a bit differently. The most outstanding example is Fuzzy sensor, which returns unit value in this mode, otherwise it is too irritating for a user.

This value is true only for paint information objects created with createHoveringModeInfo() constructor.

See also

createHoveringModeInfo()

Definition at line 241 of file kis_paint_information.cc.

{
    return d->isHoveringMode;
}

References d, and KisPaintInformation::Private::isHoveringMode.

maxPressure()

qreal KisPaintInformation::maxPressure

(

)

const

Maximum pressure that has been known during the stroke

WARNING: this method is available only inside paintAt() call, that is when the distance information is registered.

Definition at line 447 of file kis_paint_information.cc.

{
    if (!d->directionHistoryInfo) {
        warnKrita << "KisPaintInformation::maxPressure()" << "DirectionHistoryInfo object is not available";
        return d->pressure;
    }
 
    return qMax(d->directionHistoryInfo->lastMaxPressure, d->pressure);
}

References d, KisPaintInformation::Private::directionHistoryInfo, KisPaintInformation::Private::pressure, and warnKrita.

mix() [1/2]

KisPaintInformation KisPaintInformation::mix ( const QPointF & p, qreal t, const KisPaintInformation & p1, const KisPaintInformation & p2 )

static

Definition at line 575 of file kis_paint_information.cc.

{
    return mixImpl(p, t, pi1, pi2, false, true);
}

References mixImpl(), and p.

mix() [2/2]

KisPaintInformation KisPaintInformation::mix ( qreal t, const KisPaintInformation & pi1, const KisPaintInformation & pi2 )

static

Definition at line 569 of file kis_paint_information.cc.

{
    QPointF pt = (1 - t) * pi1.pos() + t * pi2.pos();
    return mix(pt, t, pi1, pi2);
}

References mix(), and pos().

mixImpl()

KisPaintInformation KisPaintInformation::mixImpl ( const QPointF & p, qreal t, const KisPaintInformation & p1, const KisPaintInformation & p2, bool posOnly, bool mixTime )

staticprivate

Definition at line 603 of file kis_paint_information.cc.

{
    KisPaintInformation result(pi2);
    result.mixOtherImpl(p, t, pi1, posOnly, mixTime);
    return result;
}

References mixOtherImpl(), and p.

mixOnlyPosition()

KisPaintInformation KisPaintInformation::mixOnlyPosition ( qreal t, const KisPaintInformation & mixedPi, const KisPaintInformation & basePi )

static

(1-t) * p1 + t * p2

Definition at line 563 of file kis_paint_information.cc.

{
    QPointF pt = (1 - t) * mixedPi.pos() + t * basePi.pos();
    return mixImpl(pt, t, mixedPi, basePi, true, false);
}

References mixImpl(), and pos().

mixOtherImpl()

void KisPaintInformation::mixOtherImpl ( const QPointF & p, qreal t, const KisPaintInformation & other, bool posOnly, bool mixTime )

private

Definition at line 610 of file kis_paint_information.cc.

{
    if (posOnly) {
        this->d->pos = p;
        this->d->isHoveringMode = false;
        this->d->levelOfDetail = 0;
        return;
    }
    else {
        qreal pressure = (1 - t) * other.pressure() + t * this->pressure();
        qreal xTilt = (1 - t) * other.xTilt() + t * this->xTilt();
        qreal yTilt = (1 - t) * other.yTilt() + t * this->yTilt();
 
        qreal rotation = other.rotation();
 
        if (other.rotation() != this->rotation()) {
            qreal a1 = kisDegreesToRadians(other.rotation());
            qreal a2 = kisDegreesToRadians(this->rotation());
            qreal distance = shortestAngularDistance(a2, a1);
 
            rotation = kisRadiansToDegrees(incrementInDirection(a1, t * distance, a2));
        }
 
        qreal tangentialPressure = (1 - t) * other.tangentialPressure() + t * this->tangentialPressure();
        qreal perspective = (1 - t) * other.perspective() + t * this->perspective();
        qreal time = mixTime ? ((1 - t) * other.currentTime() + t * this->currentTime()) : this->currentTime();
        qreal speed = (1 - t) * other.drawingSpeed() + t * this->drawingSpeed();
 
        KIS_ASSERT_RECOVER_NOOP(other.isHoveringMode() == this->isHoveringMode());
        *(this->d) = Private(p, pressure, xTilt, yTilt, rotation, tangentialPressure, perspective, time, speed, other.isHoveringMode());
        this->d->canvasRotation = other.d->canvasRotation;
        this->d->canvasMirroredH = other.d->canvasMirroredH;
        this->d->canvasMirroredV = other.d->canvasMirroredV;
        this->d->randomSource = other.d->randomSource;
        this->d->perStrokeRandomSource = other.d->perStrokeRandomSource;
        // this->d->isHoveringMode = other.isHoveringMode();
        this->d->levelOfDetail = other.d->levelOfDetail;
        this->d->tiltDirectionOffset = other.d->tiltDirectionOffset;
    }
}

References KisPaintInformation::Private::canvasMirroredH, KisPaintInformation::Private::canvasMirroredV, KisPaintInformation::Private::canvasRotation, currentTime(), d, distance(), drawingSpeed(), incrementInDirection(), KisPaintInformation::Private::isHoveringMode, isHoveringMode(), KIS_ASSERT_RECOVER_NOOP, kisDegreesToRadians(), kisRadiansToDegrees(), KisPaintInformation::Private::levelOfDetail, p, perspective(), KisPaintInformation::Private::perStrokeRandomSource, KisPaintInformation::Private::pos, pressure(), KisPaintInformation::Private::randomSource, rotation(), shortestAngularDistance(), tangentialPressure(), KisPaintInformation::Private::tiltDirectionOffset, xTilt(), and yTilt().

mixOtherOnlyPosition()

void KisPaintInformation::mixOtherOnlyPosition	(	qreal	t,
		const KisPaintInformation &	other )

Definition at line 591 of file kis_paint_information.cc.

{
    QPointF pt = (1 - t) * other.pos() + t * this->pos();
    this->mixOtherImpl(pt, t, other, true, false);
}

References mixOtherImpl(), and pos().

mixOtherWithoutTime()

void KisPaintInformation::mixOtherWithoutTime	(	qreal	t,
		const KisPaintInformation &	other )

Definition at line 597 of file kis_paint_information.cc.

{
    QPointF pt = (1 - t) * other.pos() + t * this->pos();
    this->mixOtherImpl(pt, t, other, false, false);
}

References mixOtherImpl(), and pos().

mixWithoutTime() [1/2]

KisPaintInformation KisPaintInformation::mixWithoutTime ( const QPointF & p, qreal t, const KisPaintInformation & p1, const KisPaintInformation & p2 )

static

Definition at line 586 of file kis_paint_information.cc.

{
    return mixImpl(p, t, pi1, pi2, false, false);
}

References mixImpl(), and p.

mixWithoutTime() [2/2]

KisPaintInformation KisPaintInformation::mixWithoutTime ( qreal t, const KisPaintInformation & pi1, const KisPaintInformation & pi2 )

static

Definition at line 580 of file kis_paint_information.cc.

{
    QPointF pt = (1 - t) * pi1.pos() + t * pi2.pos();
    return mixWithoutTime(pt, t, pi1, pi2);
}

References mixWithoutTime(), and pos().

operator=()

void KisPaintInformation::operator=

(

const KisPaintInformation &

rhs

)

Definition at line 231 of file kis_paint_information.cc.

{
    *d = *rhs.d;
}

References d.

overrideDrawingAngle()

void KisPaintInformation::overrideDrawingAngle

(

qreal

angle

)

XXX !!! :-| Please add dox!

Definition at line 379 of file kis_paint_information.cc.

{
    d->drawingAngleOverride = angle;
}

References d, and KisPaintInformation::Private::drawingAngleOverride.

paintAt()

template<class PaintOp >

void KisPaintInformation::paintAt ( PaintOp & op, KisDistanceInformation * distanceInfo )

inline

Definition at line 100 of file kis_paint_information.h.

                                                                    {
        KisSpacingInformation spacingInfo;
        KisTimingInformation timingInfo;
        {
            DistanceInformationRegistrar r = registerDistanceInformation(distanceInfo);
            spacingInfo = op.paintAt(*this);
            timingInfo = op.updateTimingImpl(*this);
 
            // Initiate the process of locking the drawing angle. The locked value will
            // always be present in the internals, but it will be requested but the users
            // with a special parameter of drawingAngle() only.
            if (!this->isHoveringMode()) {
                distanceInfo->lockCurrentDrawingAngle(*this);
            }
        }
 
        distanceInfo->registerPaintedDab(*this, spacingInfo, timingInfo);
    }

References KisDistanceInformation::lockCurrentDrawingAngle(), and KisDistanceInformation::registerPaintedDab().

perspective()

qreal KisPaintInformation::perspective

(

)

const

reciprocal of distance on the perspective grid

Definition at line 477 of file kis_paint_information.cc.

{
    return d->perspective;
}

References d, and KisPaintInformation::Private::perspective.

perStrokeRandomSource()

KisPerStrokeRandomSourceSP KisPaintInformation::perStrokeRandomSource

(

)

const

Definition at line 523 of file kis_paint_information.cc.

{
    if (!d->perStrokeRandomSource) {
        qWarning() << "Accessing uninitialized per stroke random source!";
        d->perStrokeRandomSource = new KisPerStrokeRandomSource();
    }
 
    return d->perStrokeRandomSource;
}

References d, and KisPaintInformation::Private::perStrokeRandomSource.

pos()

const QPointF & KisPaintInformation::pos

(

)

const

Definition at line 349 of file kis_paint_information.cc.

{
    return d->pos;
}

References d, and KisPaintInformation::Private::pos.

pressure()

qreal KisPaintInformation::pressure

(

)

const

The pressure of the value (from 0.0 to 1.0)

Definition at line 359 of file kis_paint_information.cc.

{
    return d->pressure;
}

References d, and KisPaintInformation::Private::pressure.

randomSource()

KisRandomSourceSP KisPaintInformation::randomSource

(

)

const

Definition at line 507 of file kis_paint_information.cc.

{
    if (!d->randomSource) {
        qWarning() << "Accessing uninitialized random source!";
        qDebug().noquote() << kisBacktrace();
        d->randomSource = new KisRandomSource();
    }
 
    return d->randomSource;
}

References d, kisBacktrace(), and KisPaintInformation::Private::randomSource.

registerDistanceInformation()

KisPaintInformation::DistanceInformationRegistrar KisPaintInformation::registerDistanceInformation

(

KisDistanceInformation *

distance

)

Causes the specified distance information to be temporarily registered with this KisPaintInformation object, so that the KisPaintInformation can compute certain values that may be needed at painting time, such as the drawing direction. When the returned object is destroyed, the KisDistanceInformation will be unregistered. At most one KisDistanceInformation can be registered with a given KisPaintInformation at a time.

Definition at line 397 of file kis_paint_information.cc.

{
    return DistanceInformationRegistrar(this, distance);
}

References distance().

rotation()

qreal KisPaintInformation::rotation

(

)

const

rotation as given by the tablet event

Definition at line 467 of file kis_paint_information.cc.

{
    return d->rotation;
}

References d, and KisPaintInformation::Private::rotation.

setCanvasMirroredH()

void KisPaintInformation::setCanvasMirroredH

(

bool

value

)

Set whether the canvas is horizontally mirrored for the paint-operation.

Definition at line 290 of file kis_paint_information.cc.

{
    d->canvasMirroredH = value;
}

References KisPaintInformation::Private::canvasMirroredH, d, and value().

setCanvasMirroredV()

void KisPaintInformation::setCanvasMirroredV

(

bool

value

)

Set whether the canvas is vertically mirrored for the paint-operation.

Definition at line 300 of file kis_paint_information.cc.

{
    d->canvasMirroredV = value;
}

References KisPaintInformation::Private::canvasMirroredV, d, and value().

setCanvasRotation()

void KisPaintInformation::setCanvasRotation

(

qreal

rotation

)

Set the canvas rotation.

Definition at line 280 of file kis_paint_information.cc.

{
    d->canvasRotation = normalizeAngleDegrees(rotation);
}

References KisPaintInformation::Private::canvasRotation, d, normalizeAngleDegrees(), and rotation().

setCurrentTime()

void KisPaintInformation::setCurrentTime

(

qreal

time

)

const

Definition at line 462 of file kis_paint_information.cc.

                                                         {
 
    d->time =  time;
}

References d, and KisPaintInformation::Private::time.

setLevelOfDetail()

void KisPaintInformation::setLevelOfDetail

(

int

levelOfDetail

)

Definition at line 538 of file kis_paint_information.cc.

{
    d->levelOfDetail = levelOfDetail;
}

References d, and KisPaintInformation::Private::levelOfDetail.

setPerStrokeRandomSource()

void KisPaintInformation::setPerStrokeRandomSource

(

KisPerStrokeRandomSourceSP

value

)

Definition at line 533 of file kis_paint_information.cc.

{
    d->perStrokeRandomSource = value;
}

References d, KisPaintInformation::Private::perStrokeRandomSource, and value().

setPos()

void KisPaintInformation::setPos

(

const QPointF &

p

)

Definition at line 354 of file kis_paint_information.cc.

{
    d->pos = p;
}

References d, p, and KisPaintInformation::Private::pos.

setPressure()

void KisPaintInformation::setPressure

(

qreal

p

)

Set the pressure.

Definition at line 364 of file kis_paint_information.cc.

{
    d->pressure = p;
}

References d, p, and KisPaintInformation::Private::pressure.

setRandomSource()

void KisPaintInformation::setRandomSource

(

KisRandomSourceSP

value

)

Definition at line 518 of file kis_paint_information.cc.

{
    d->randomSource = value;
}

References d, KisPaintInformation::Private::randomSource, and value().

setTiltDirectionOffset()

void KisPaintInformation::setTiltDirectionOffset

(

qreal

angle

)

Set the tilt direction offset. Will be clamped to [0, 360) degrees.

Definition at line 310 of file kis_paint_information.cc.

{
    d->tiltDirectionOffset = normalizeAngleDegrees(value);
}

References d, normalizeAngleDegrees(), KisPaintInformation::Private::tiltDirectionOffset, and value().

tangentialPressure()

qreal KisPaintInformation::tangentialPressure

(

)

const

tangential pressure (i.e., rate for an airbrush device)

Definition at line 472 of file kis_paint_information.cc.

{
    return d->tangentialPressure;
}

References d, and KisPaintInformation::Private::tangentialPressure.

tiltDirection()

qreal KisPaintInformation::tiltDirection ( const KisPaintInformation & info, bool normalize = true )

static

When the stylus is in fully vertical position, stick it to a "neutral position", which is a 3 o'clock tilt of the stylus as defined in the Krita documentation.

The normal 0 deg position as returned from Qt is at 6 o'clock tilt of the stylus

Definition at line 651 of file kis_paint_information.cc.

{
    qreal xTilt = info.xTilt();
    qreal yTilt = info.yTilt();
 
    // radians -PI, PI
    qreal tiltDirection = 0.0;
 
    if (qFuzzyIsNull(xTilt) && qFuzzyIsNull(yTilt)) {
        tiltDirection = - KisAlgebra2D::signPZ(xTilt) * KisAlgebra2D::signPZ(yTilt) * M_PI_2;
    } else {
        tiltDirection = atan2(-xTilt, yTilt);
    }
 
    if (!qFuzzyIsNull(info.d->tiltDirectionOffset)) {
        tiltDirection += kisDegreesToRadians(info.d->tiltDirectionOffset);
        // ensure we stay in the -PI, PI range
        if (tiltDirection < -M_PI) {
            tiltDirection += 2 * M_PI;
        } else if (tiltDirection > M_PI) {
            tiltDirection -= 2 * M_PI;
        }
    }
 
    // if normalize is true map to 0.0..1.0
    return normalize ? (tiltDirection / (2 * M_PI) + 0.5) : tiltDirection;
}

References d, kisDegreesToRadians(), M_PI, qFuzzyIsNull(), KisAlgebra2D::signPZ(), tiltDirection(), KisPaintInformation::Private::tiltDirectionOffset, xTilt(), and yTilt().

tiltDirectionOffset()

qreal KisPaintInformation::tiltDirectionOffset

(

)

const

Constant offset added to the reported pen tilt direction. [0, 360) degrees.

Definition at line 305 of file kis_paint_information.cc.

{
    return d->tiltDirectionOffset;
}

References d, and KisPaintInformation::Private::tiltDirectionOffset.

tiltElevation()

qreal KisPaintInformation::tiltElevation ( const KisPaintInformation & info, qreal maxTiltX = 60.0, qreal maxTiltY = 60.0, bool normalize = true )

static

Definition at line 687 of file kis_paint_information.cc.

{
    qreal xTilt = qBound(qreal(-1.0), info.xTilt() / maxTiltX , qreal(1.0));
    qreal yTilt = qBound(qreal(-1.0), info.yTilt() / maxTiltY , qreal(1.0));
 
    qreal e;
    if (fabs(xTilt) > fabs(yTilt)) {
        e = sqrt(qreal(1.0) + yTilt * yTilt);
    } else {
        e = sqrt(qreal(1.0) + xTilt * xTilt);
    }
 
    qreal cosAlpha    = sqrt(xTilt * xTilt + yTilt * yTilt) / e;
    qreal tiltElevation = acos(cosAlpha); // in radians in [0, 0.5 * PI]
 
    // mapping to 0.0..1.0 if normalize is true
    return normalize ? (tiltElevation / (M_PI * qreal(0.5))) : tiltElevation;
}

References M_PI, tiltElevation(), xTilt(), and yTilt().

totalStrokeLength()

qreal KisPaintInformation::totalStrokeLength

(

)

const

The length of the stroke before painting the current dab.

Definition at line 497 of file kis_paint_information.cc.

{
    if (!d->directionHistoryInfo) {
        warnKrita << "KisPaintInformation::totalStrokeLength()" << "DirectionHistoryInfo object is not available";
        return 0;
    }
 
    return d->directionHistoryInfo->totalStrokeLength;
}

References d, KisPaintInformation::Private::directionHistoryInfo, and warnKrita.

toXML()

void KisPaintInformation::toXML	(	QDomDocument &	,
		QDomElement &	e ) const

Definition at line 315 of file kis_paint_information.cc.

{
    // hovering mode infos are not supposed to be saved
    KIS_ASSERT_RECOVER_NOOP(!d->isHoveringMode);
 
    e.setAttribute("pointX", QString::number(pos().x(), 'g', 15));
    e.setAttribute("pointY", QString::number(pos().y(), 'g', 15));
    e.setAttribute("pressure", QString::number(pressure(), 'g', 15));
    e.setAttribute("xTilt", QString::number(xTilt(), 'g', 15));
    e.setAttribute("yTilt", QString::number(yTilt(), 'g', 15));
    e.setAttribute("rotation", QString::number(rotation(), 'g', 15));
    e.setAttribute("tangentialPressure", QString::number(tangentialPressure(), 'g', 15));
    e.setAttribute("perspective", QString::number(perspective(), 'g', 15));
    e.setAttribute("time", QString::number(d->time, 'g', 15));
    e.setAttribute("speed", QString::number(d->speed, 'g', 15));
}

References d, KisPaintInformation::Private::isHoveringMode, KIS_ASSERT_RECOVER_NOOP, perspective(), pos(), pressure(), rotation(), KisPaintInformation::Private::speed, tangentialPressure(), KisPaintInformation::Private::time, xTilt(), and yTilt().

xTilt()

qreal KisPaintInformation::xTilt

(

)

const

The tilt of the pen on the horizontal axis (from 0.0 to 1.0)

Definition at line 369 of file kis_paint_information.cc.

{
    return d->xTilt;
}

References d, and KisPaintInformation::Private::xTilt.

yTilt()

qreal KisPaintInformation::yTilt

(

)

const

The tilt of the pen on the vertical axis (from 0.0 to 1.0)

Definition at line 374 of file kis_paint_information.cc.

{
    return d->yTilt;
}

References d, and KisPaintInformation::Private::yTilt.

Member Data Documentation

d

Private* const KisPaintInformation::d

private

Definition at line 326 of file kis_paint_information.h.

---

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

• libs/image/brushengine/kis_paint_information.h
• libs/image/brushengine/kis_paint_information.cc