HatchingBrush Class Reference

#include <hatching_brush.h>

Public Member Functions
void	hatch (KisPaintDeviceSP dev, qreal x, qreal y, double width, double height, double givenAngle, const KoColor &color, qreal additionalScale)
	HatchingBrush (KisHatchingPaintOpSettingsSP settings)
	HatchingBrush (KoColor inkColor)
	~HatchingBrush ()

Private Member Functions
void	init ()
void	iterateLines (bool forward, int lineindex, bool oneline)
void	iterateVerticalLines (bool forward, int lineindex, bool oneline)
double	separationAsFunctionOfParameter (double parameter, double separation, int numintervals)

Private Attributes
double	angle {0.0}
double	baseLineIntercept {0}
double	cursorLineIntercept {0}
double	dx {0}
double	dy {0}
double	height_ {0.0}
double	hotIntercept {0}
int	m_counter {0}
KoColor	m_inkColor
KisPainter	m_painter
int	m_radius {0}
KisHatchingPaintOpSettingsSP	m_settings
double	origin_x {0.0}
double	origin_y {0.0}
double	scanIntercept {0}
double	separation {0.0}
double	slope {0}
int	thickness {0}
double	verticalHotX {0.0}
double	verticalScanX {0.0}
double	width_ {0.0}

Detailed Description

Definition at line 20 of file hatching_brush.h.

Constructor & Destructor Documentation

HatchingBrush() [1/2]

HatchingBrush::HatchingBrush

(

KisHatchingPaintOpSettingsSP

settings

)

Definition at line 25 of file hatching_brush.cpp.

  : m_settings(settings)
  , separation(m_settings->separation)
  , origin_x(m_settings->origin_x)
  , origin_y(m_settings->origin_y)
{
}

~HatchingBrush()

HatchingBrush::~HatchingBrush

(

)

Definition at line 34 of file hatching_brush.cpp.

{
}

HatchingBrush() [2/2]

HatchingBrush::HatchingBrush

(

KoColor

inkColor

)

Member Function Documentation

hatch()

void HatchingBrush::hatch	(	KisPaintDeviceSP	dev,
		qreal	x,
		qreal	y,
		double	width,
		double	height,
		double	givenAngle,
		const KoColor &	color,
		qreal	additionalScale )

Performs a single hatching pass according to specifications

Definition at line 42 of file hatching_brush.cpp.

{
    m_painter.begin(dev);
    m_painter.setFillStyle(KisPainter::FillStyleForegroundColor);
    m_painter.setPaintColor(color);
    m_painter.setBackgroundColor(color);
 
    angle = givenAngle;
    double tempthickness = m_settings->thickness * m_settings->thicknesssensorvalue;
    thickness = qMax(1, qRound(additionalScale * tempthickness));
    separation = additionalScale *
        (m_settings->enabledcurveseparation ?
         separationAsFunctionOfParameter(m_settings->separationsensorvalue, m_settings->separation, m_settings->separationintervals) :
         m_settings->separation);
 
    height_ = height;
    width_ = width;
 
    m_painter.setMaskImageSize(width_, height_);
 
    /*  dx and dy are the separation between lines in the x and y axis
    dx = separation / sin(angle*M_PI/180);     csc = 1/sin(angle)  */
    dy = fabs(separation / cos(angle * M_PI / 180)); // sec = 1/cos(angle)
    // I took the absolute value to avoid confusions with negative numbers
 
    if (!m_settings->subpixelprecision)
        modf(dy, &dy);
 
    // Exception for vertical lines, for which a tangent does not exist
    if ((angle == 90) || (angle == -90)) {
        verticalHotX = fmod((origin_x - x), separation);
 
        iterateVerticalLines(true, 1, false);    // Forward
        iterateVerticalLines(true, 0, true);     // In Between both
        iterateVerticalLines(false, 1, false);   // Backward
    }
    else {
        // Turn Angle + Point into Slope + Intercept
        slope = tan(angle * M_PI / 180);                // Angle into slope
        baseLineIntercept = origin_y - slope * origin_x; // Slope and Point of the Base Line into Intercept
        cursorLineIntercept = y - slope * x;
        hotIntercept = fmod((baseLineIntercept - cursorLineIntercept), dy);  // This hotIntercept belongs to a line that intersects with the hatching area
 
        iterateLines(true, 1, false);    // Forward
        iterateLines(true, 0, true);     // In Between both
        iterateLines(false, 1, false);   // Backward
        // I tried to make this cleaner but there's too many possibilities to be
        // worth the micromanagement to optimize
    }
}

References angle, baseLineIntercept, KisPainter::begin(), cursorLineIntercept, dy, KisHatchingPaintOpSettings::enabledcurveseparation, KisPainter::FillStyleForegroundColor, height_, hotIntercept, iterateLines(), iterateVerticalLines(), m_painter, M_PI, m_settings, origin_x, origin_y, separation, KisHatchingPaintOpSettings::separation, separationAsFunctionOfParameter(), KisHatchingPaintOpSettings::separationintervals, KisHatchingPaintOpSettings::separationsensorvalue, KisPainter::setBackgroundColor(), KisPainter::setFillStyle(), KisPainter::setMaskImageSize(), KisPainter::setPaintColor(), slope, KisHatchingPaintOpSettings::subpixelprecision, thickness, KisHatchingPaintOpSettings::thickness, KisHatchingPaintOpSettings::thicknesssensorvalue, verticalHotX, and width_.

init()

void HatchingBrush::init ( )

private

Definition at line 38 of file hatching_brush.cpp.

{
}

iterateLines()

void HatchingBrush::iterateLines ( bool forward, int lineindex, bool oneline )

private

Function that begins exploring the field from hotIntercept and moves in the direction of dy (forward==true) or -dy (forward==false) to draw all the lines it finds to KisPaintDeviceSP 'dev'

Definition at line 93 of file hatching_brush.cpp.

{
    //---Preparations before the loop---
 
    double xdraw[2] = {0, 0};
    double ydraw[2] = {0, 0};
    //points A and B of the segments to trace
    QPointF A, B;
    int append_index = 0;
    bool remaininginnerlines = true;
 
    while (remaininginnerlines) {
 
        //---------START INTERSECTION POINT VERIFICATION--------
 
        append_index = 0;
        remaininginnerlines = false; // We assume there's no more lines unless proven contrary
        if (forward)
            scanIntercept = hotIntercept + dy * lineindex; // scanIntercept will represent the Intercept of the current line
        else
            scanIntercept = hotIntercept - dy * lineindex;  // scanIntercept will represent the Intercept of the current line
 
        lineindex++; // We are descending vertically out of convenience, see blog entry at pentalis.org/kritablog
 
        /*
        Explanation: only 2 out of the 4 segments can include limit values
        to verify intersections, otherwise we could encounter a situation where
        our new lines intersect with all 4 segments and is still considered an
        inner line (for example, a line that goes from corner to corner), thus
        triggering an error. The idea is of the algorithm is that only 2 intersections
        at most are considered at a time. Graphically this is indistinguishable, it's
        just there to avoid making unnecessary control structures (like additional "ifs").
        */
 
        if ((scanIntercept >= 0) && (scanIntercept <= height_)) {
            xdraw[append_index] = 0;
            ydraw[append_index] = scanIntercept;       //intersection at left
            remaininginnerlines = true;
            append_index++;
        }
 
        if ((slope * width_ + scanIntercept <= height_) && (slope * width_ + scanIntercept >= 0)) {
            xdraw[append_index] = width_;
            ydraw[append_index] = scanIntercept + slope * width_; //intersection at right
            remaininginnerlines = true;
            append_index++;
        }
 
        if ((-scanIntercept / slope > 0) && (-scanIntercept / slope < width_)) {
            xdraw[append_index] = -scanIntercept / slope;
            ydraw[append_index] = 0;       //intersection at top
            remaininginnerlines = true;
            append_index++;
        }
 
        if (((height_ - scanIntercept) / slope > 0) && ((height_ - scanIntercept) / slope < width_)) {
            xdraw[append_index] = (height_ - scanIntercept) / slope;
            ydraw[append_index] = height_;       //intersection at bottom
            remaininginnerlines = true;
            append_index++;
        }
        //--------END INTERSECTION POINT VERIFICATION---------
 
        if (!remaininginnerlines)
            break;
 
        if (!m_settings->subpixelprecision) {
            myround(&xdraw[0]);
            myround(&xdraw[1]);
            myround(&ydraw[0]);
            myround(&ydraw[1]);
        }
 
        A.setX(xdraw[0]);
        A.setY(ydraw[0]);
 
        // If 2 lines intersect with the dab square
        if (append_index == 2) {
            B.setX(xdraw[1]);
            B.setY(ydraw[1]);
 
            if (m_settings->antialias)
                m_painter.drawThickLine(A, B, thickness, thickness);
            else
                m_painter.drawLine(A, B, thickness, false);    //testing no subpixel;
 
            if (oneline)
                break;
        }
        else {
            continue;
            /*Drawing points at the vertices causes inconsistent results due to
            floating point calculations not being quite in sync with algebra,
            therefore if I have only 1 intersection (= corner = this case),
            don't draw*/
        }
    }
}

References A, KisHatchingPaintOpSettings::antialias, B, KisPainter::drawLine(), KisPainter::drawThickLine(), dy, height_, hotIntercept, m_painter, m_settings, myround(), scanIntercept, slope, KisHatchingPaintOpSettings::subpixelprecision, thickness, and width_.

iterateVerticalLines()

void HatchingBrush::iterateVerticalLines ( bool forward, int lineindex, bool oneline )

private

Function that begins exploring the field from verticalHotX and moves in the direction of separation (forward==true) or -separation (forward==false) to draw all the lines it finds to KisPaintDeviceSP 'dev'. This function should only be called when (angle == 90) or (angle == -90)

Definition at line 192 of file hatching_brush.cpp.

{
    //---Preparations before the loop---
 
    double xdraw = 0;
    double ydraw[2] = {0, height_};
    //points A and B of the segments to trace
    QPointF A, B;
    bool remaininginnerlines = true;
 
    while (remaininginnerlines) {
 
        //---------START INTERSECTION POINT VERIFICATION--------
        remaininginnerlines = false;     // We assume there's no more lines unless proven contrary
        if (forward)
            verticalScanX = verticalHotX + separation * lineindex;
        else
            verticalScanX = verticalHotX - separation * lineindex;
 
        lineindex++;
 
        /*Read the explanation in HatchingBrush::iterateLines for more information*/
 
        if ((verticalScanX >= 0) && (verticalScanX <= width_)) {
            xdraw = verticalScanX;
            remaininginnerlines = true;
        }
        //--------END INTERSECTION POINT VERIFICATION---------
 
        if (!remaininginnerlines)
            break;
 
        if (!m_settings->subpixelprecision) {
            myround(&xdraw);
            myround(&ydraw[1]);
        }
 
        A.setX(xdraw);
        A.setY(ydraw[0]);
        B.setX(xdraw);
        B.setY(ydraw[1]);
 
        if (m_settings->antialias)
            m_painter.drawThickLine(A, B, thickness, thickness);
        else
            m_painter.drawLine(A, B, thickness, false);    //testing no subpixel;
 
        if (oneline)
            break;
        else
            continue;
    }
}

References A, KisHatchingPaintOpSettings::antialias, B, KisPainter::drawLine(), KisPainter::drawThickLine(), height_, m_painter, m_settings, myround(), separation, KisHatchingPaintOpSettings::subpixelprecision, thickness, verticalHotX, verticalScanX, and width_.

separationAsFunctionOfParameter()

double HatchingBrush::separationAsFunctionOfParameter ( double parameter, double separation, int numintervals )

private

Simple function that returns a new distance equal to a multiple or divisor of separation depending on the magnitude of 'parameter' and the number of intervals of its magnitude. The multiples and divisors used are all powers of 2 to prevent desynchronization of the lines during drawing.

Definition at line 246 of file hatching_brush.cpp.

{
    if ((numintervals < 2) || (numintervals > 7)) {
        dbgKrita << "Fix your function" << numintervals << "<> 2-7" ;
        return separation;
    }
 
    double sizeinterval = 1 / double(numintervals);
    double lowerlimit = 0;
    double upperlimit = 0;
    double factor = 0;
 
    int basefactor = numintervals / 2;
    // Make the base separation factor tend to greater instead of lesser numbers when numintervals is even
    if ((numintervals % 2) == 0)
        basefactor--;
 
    for (quint8 currentinterval = 0; currentinterval < numintervals; currentinterval++) {
        lowerlimit = upperlimit;
        upperlimit += sizeinterval;
        if (currentinterval == (numintervals - 1))
            upperlimit = 1;
        if ((parameter >= lowerlimit) && (parameter <= upperlimit)) {
            factor = pow(2.0, (basefactor - currentinterval));
            //dbgKrita << factor;
            return (separation * factor);
        }
    }
 
    dbgKrita << "Fix your function" << parameter << ">" << upperlimit ;
    return separation;
}

References dbgKrita, and separation.

Member Data Documentation

angle

double HatchingBrush::angle {0.0}

private

Angle in degrees of all the lines in a single hatching pass

Definition at line 46 of file hatching_brush.h.

{0.0};

baseLineIntercept

double HatchingBrush::baseLineIntercept {0}

private

Intercept of the base line

Definition at line 64 of file hatching_brush.h.

{0};

cursorLineIntercept

double HatchingBrush::cursorLineIntercept {0}

private

Intercept of the line that extends from the mouse cursor position, calculated from the point (x, y) of the cursor and 'slope'

Definition at line 96 of file hatching_brush.h.

{0};

dx

double HatchingBrush::dx {0}

private

Unused variable, distance separating non-vertical lines in the X axis

Definition at line 88 of file hatching_brush.h.

{0};

dy

double HatchingBrush::dy {0}

private

Distance separating non-vertical lines in the Y axis

Definition at line 91 of file hatching_brush.h.

{0};

height_

double HatchingBrush::height_ {0.0}

private

Height of the imaginary square to be hatched, the "hatching area"

Definition at line 52 of file hatching_brush.h.

{0.0};

hotIntercept

double HatchingBrush::hotIntercept {0}

private

Intercept of the first line found to pass or be neighbour of a line that passes through the hatching area, this line is used as a base to start iterating with HatchingBrush::iterateLines()

Definition at line 70 of file hatching_brush.h.

{0};

m_counter

int HatchingBrush::m_counter {0}

private

Definition at line 37 of file hatching_brush.h.

{0};

m_inkColor

KoColor HatchingBrush::m_inkColor

private

Definition at line 36 of file hatching_brush.h.

m_painter

KisPainter HatchingBrush::m_painter

private

Definition at line 40 of file hatching_brush.h.

m_radius

int HatchingBrush::m_radius {0}

private

Definition at line 38 of file hatching_brush.h.

{0};

m_settings

KisHatchingPaintOpSettingsSP HatchingBrush::m_settings

private

Definition at line 39 of file hatching_brush.h.

origin_x

double HatchingBrush::origin_x {0.0}

private

X coordinate of the point that determines the base line

Definition at line 58 of file hatching_brush.h.

{0.0};

origin_y

double HatchingBrush::origin_y {0.0}

private

Y coordinate of the point that determines the base line

Definition at line 61 of file hatching_brush.h.

{0.0};

scanIntercept

double HatchingBrush::scanIntercept {0}

private

Intercept of each line as it is scanned, this value changes constantly

Definition at line 73 of file hatching_brush.h.

{0};

separation

double HatchingBrush::separation {0.0}

private

Distance separating one line from the other, in pixels

Definition at line 49 of file hatching_brush.h.

{0.0};

slope

double HatchingBrush::slope {0}

private

Angle of the lines expressed algebraically, as in slope*x + intercept = y

Definition at line 85 of file hatching_brush.h.

{0};

thickness

int HatchingBrush::thickness {0}

private

Thickness in pixels of each hatch line

Definition at line 43 of file hatching_brush.h.

{0};

verticalHotX

double HatchingBrush::verticalHotX {0.0}

private

X position of the first vertical line found to pass or be neighbour of a line that passes through the hatching area, this line is used as a base to start iterating with HatchingBrush::iterateVerticalLines()

Definition at line 79 of file hatching_brush.h.

{0.0};

verticalScanX

double HatchingBrush::verticalScanX {0.0}

private

X position of the vertical lines as they are scanned, this value changes constantly

Definition at line 82 of file hatching_brush.h.

{0.0};

width_

double HatchingBrush::width_ {0.0}

private

Width of the imaginary square to be hatched, the "hatching area"

Definition at line 55 of file hatching_brush.h.

{0.0};

---

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

• plugins/paintops/hatching/hatching_brush.h
• plugins/paintops/hatching/hatching_brush.cpp