KisOutlineGenerator Class Reference

#include <kis_outline_generator.h>

Public Member Functions
	KisOutlineGenerator (const KoColorSpace *cs, quint8 defaultOpacity)
QVector< QPolygon >	outline (const KisPaintDevice *buffer, qint32 xOffset, qint32 yOffset, qint32 width, qint32 height)
QVector< QPolygon >	outline (quint8 *buffer, qint32 xOffset, qint32 yOffset, qint32 width, qint32 height)
void	setSimpleOutline (bool simple)

Private Types
enum	EdgeType {   TopEdge = 1 , LeftEdge = 2 , BottomEdge = 3 , RightEdge = 0 ,   NoEdge = 4 }

Private Member Functions
void	appendCoordinate (QPolygon *path, int x, int y, EdgeType edge, EdgeType prevEdge)
template<class StorageStrategy >
bool	isOutlineEdge (StorageStrategy &storage, EdgeType edge, qint32 x, qint32 y, qint32 bufWidth, qint32 bufHeight)
EdgeType	nextEdge (EdgeType edge)
template<class StorageStrategy >
void	nextOutlineEdge (StorageStrategy &storage, EdgeType *edge, qint32 *row, qint32 *col, qint32 width, qint32 height)
template<class StorageStrategy >
QVector< QPolygon >	outlineImpl (typename StorageStrategy::StorageType buffer, qint32 xOffset, qint32 yOffset, qint32 width, qint32 height)

Private Attributes
KisRandomConstAccessorSP	m_accessor
const KoColorSpace *	m_cs
quint8	m_defaultOpacity
bool	m_simple

Detailed Description

Generates an 'outline' for a paint device. Used e.g. in for brushes and marching ants

Definition at line 26 of file kis_outline_generator.h.

Member Enumeration Documentation

EdgeType

enum KisOutlineGenerator::EdgeType

private

Enumerator
TopEdge
LeftEdge
BottomEdge
RightEdge
NoEdge

Definition at line 62 of file kis_outline_generator.h.

                  {
        TopEdge = 1, LeftEdge = 2, BottomEdge = 3, RightEdge = 0, NoEdge = 4
    };

Constructor & Destructor Documentation

KisOutlineGenerator()

KisOutlineGenerator::KisOutlineGenerator	(	const KoColorSpace *	cs,
		quint8	defaultOpacity )

Create an outline generator

Parameters

cs	colorspace for the buffer passed to the generator
defaultOpacity	opacity of pixels that shouldn't be included in the outline

Definition at line 84 of file kis_outline_generator.cpp.

    : m_cs(cs), m_defaultOpacity(defaultOpacity), m_simple(false)
{
}

Member Function Documentation

appendCoordinate()

void KisOutlineGenerator::appendCoordinate ( QPolygon * path, int x, int y, EdgeType edge, EdgeType prevEdge )

private

Definition at line 246 of file kis_outline_generator.cpp.

{
    Q_UNUSED(prevEdge);
 
    //const QPoint origPt(x, y);
 
    if (edge == TopEdge) {
        x++;
    } else if (edge == BottomEdge) {
        y++;
    } else if (edge == RightEdge) {
        x++;
        y++;
    }
 
    //qDebug() <<"add" << ppVar(origPt) << ppVar(edge) << ppVar(prevEdge) << "-->" << QPoint(x, y);
 
    *path << QPoint(x, y);
}

References BottomEdge, RightEdge, and TopEdge.

isOutlineEdge()

template<class StorageStrategy >

bool KisOutlineGenerator::isOutlineEdge ( StorageStrategy & storage, EdgeType edge, qint32 x, qint32 y, qint32 bufWidth, qint32 bufHeight )

private

Definition at line 176 of file kis_outline_generator.cpp.

{
    if (m_cs->opacityU8(storage.pickPixel(x, y)) == m_defaultOpacity)
        return false;
 
    switch (edge) {
    case LeftEdge:
        return x == 0 || m_cs->opacityU8(storage.pickPixel(x - 1, y)) == m_defaultOpacity;
    case TopEdge:
        return y == 0 || m_cs->opacityU8(storage.pickPixel(x, y - 1)) == m_defaultOpacity;
    case RightEdge:
        return x == bufWidth - 1 || m_cs->opacityU8(storage.pickPixel(x + 1, y)) == m_defaultOpacity;
    case BottomEdge:
        return y == bufHeight - 1 || m_cs->opacityU8(storage.pickPixel(x, y + 1)) == m_defaultOpacity;
    case NoEdge:
        return false;
    }
    return false;
}

References BottomEdge, LeftEdge, m_cs, m_defaultOpacity, NoEdge, KoColorSpace::opacityU8(), RightEdge, and TopEdge.

nextEdge()

EdgeType KisOutlineGenerator::nextEdge ( EdgeType edge )

inlineprivate

Definition at line 77 of file kis_outline_generator.h.

                                     {
        return edge == NoEdge ? edge : static_cast<EdgeType>((edge + 1) % 4);
    }

nextOutlineEdge()

template<class StorageStrategy >

void KisOutlineGenerator::nextOutlineEdge ( StorageStrategy & storage, EdgeType * edge, qint32 * row, qint32 * col, qint32 width, qint32 height )

private

Definition at line 211 of file kis_outline_generator.cpp.

{
    int original_row = *row;
    int original_col = *col;
 
    switch (*edge) {
    case RightEdge:
        TRY_PIXEL(-1, 0, RightEdge);
        TRY_PIXEL(-1, 1, BottomEdge);
        break;
 
    case TopEdge:
        TRY_PIXEL(0, -1, TopEdge);
        TRY_PIXEL(-1, -1, RightEdge);
        break;
 
    case LeftEdge:
        TRY_PIXEL(1, 0, LeftEdge);
        TRY_PIXEL(1, -1, TopEdge);
        break;
 
    case BottomEdge:
        TRY_PIXEL(0, 1, BottomEdge);
        TRY_PIXEL(1, 1, LeftEdge);
        break;
 
    default:
        break;
 
    }
 
    if (*row == original_row && *col == original_col)
        *edge = nextEdge(*edge);
}

References BottomEdge, LeftEdge, nextEdge(), RightEdge, TopEdge, and TRY_PIXEL.

outline() [1/2]

QVector< QPolygon > KisOutlineGenerator::outline	(	const KisPaintDevice *	buffer,
		qint32	xOffset,
		qint32	yOffset,
		qint32	width,
		qint32	height )

Definition at line 170 of file kis_outline_generator.cpp.

{
    return outlineImpl<PaintDeviceStorage>(buffer, xOffset, yOffset, width, height);
}

outline() [2/2]

QVector< QPolygon > KisOutlineGenerator::outline	(	quint8 *	buffer,
		qint32	xOffset,
		qint32	yOffset,
		qint32	width,
		qint32	height )

Generates the outline.

Parameters

buffer	buffer with the data for the outline
xOffset	offset that will be used for the x coordinate of the polygon points
yOffset	offset that will be used for the y coordinate of the polygon points
width	width of the buffer
height	height of the buffer

Returns

list of polygons around every non-transparent area

Definition at line 165 of file kis_outline_generator.cpp.

{
    return outlineImpl<LinearStorage>(buffer, xOffset, yOffset, width, height);
}

outlineImpl()

template<class StorageStrategy >

QVector< QPolygon > KisOutlineGenerator::outlineImpl ( typename StorageStrategy::StorageType buffer, qint32 xOffset, qint32 yOffset, qint32 width, qint32 height )

private

Definition at line 90 of file kis_outline_generator.cpp.

{
    QVector<QPolygon> paths;
 
    try {
        StorageStrategy storage(buffer, width, height, m_cs->pixelSize());
 
        for (qint32 y = 0; y < height; y++) {
            for (qint32 x = 0; x < width; x++) {
 
                if (m_cs->opacityU8(storage.pickPixel(x, y)) == m_defaultOpacity)
                    continue;
 
                const EdgeType initialEdge = TopEdge;
 
                EdgeType startEdge = initialEdge;
                while (startEdge != NoEdge &&
                       (*storage.pickMark(x, y) & (1 << startEdge) ||
                        !isOutlineEdge(storage, startEdge, x, y, width, height))) {
 
                    startEdge = nextEdge(startEdge);
                    if (startEdge == initialEdge)
                        startEdge = NoEdge;
                }
 
                if (startEdge != NoEdge) {
                    QPolygon path;
                    const bool clockwise = startEdge == BottomEdge;
 
                    qint32 row = y, col = x;
                    EdgeType currentEdge = startEdge;
                    EdgeType lastEdge = NoEdge;
 
                    if (currentEdge == BottomEdge) {
                        appendCoordinate(&path, col + xOffset, row + yOffset, currentEdge, lastEdge);
                        lastEdge = BottomEdge;
                    }
 
                    forever {
                        //qDebug() << "visit" << xOffset + col << yOffset + row << ppVar(currentEdge) << ppVar(lastEdge);
 
                        *storage.pickMark(col, row) |= 1 << currentEdge;
                        nextOutlineEdge(storage, &currentEdge, &row, &col, width, height);
 
                        //While following a straight line no points need to be added
                        if (lastEdge != currentEdge) {
                            appendCoordinate(&path, col + xOffset, row + yOffset, currentEdge, lastEdge);
                            lastEdge = currentEdge;
                        }
 
                        if (row == y && col == x && currentEdge == startEdge) {
                            if (startEdge != BottomEdge) {
                                // add last point of the polygon
                                appendCoordinate(&path, col + xOffset, row + yOffset, NoEdge, NoEdge);
                            }
                            break;
                        }
                    }
 
                    if(!m_simple || !clockwise) {
                        paths.push_back(path);
                    }
                }
            }
        }
    }
    catch(const std::bad_alloc&) {
        warnKrita << "KisOutlineGenerator::outline ran out of memory allocating " <<  width << "*" << height << "marks";
    }
 
    return paths;
}

References appendCoordinate(), BottomEdge, isOutlineEdge(), m_cs, m_defaultOpacity, m_simple, nextEdge(), nextOutlineEdge(), NoEdge, KoColorSpace::opacityU8(), KoColorSpace::pixelSize(), TopEdge, and warnKrita.

setSimpleOutline()

void KisOutlineGenerator::setSimpleOutline

(

bool

simple

)

Set the generator to produce simpile outline, skipping outline that are fully enclosed

Parameters

simple

set simple mode, if true enclosed outline will be skipped

Definition at line 266 of file kis_outline_generator.cpp.

{
    m_simple = simple;
}

References m_simple.

Member Data Documentation

m_accessor

KisRandomConstAccessorSP KisOutlineGenerator::m_accessor

private

Definition at line 89 of file kis_outline_generator.h.

m_cs

const KoColorSpace* KisOutlineGenerator::m_cs

private

Definition at line 85 of file kis_outline_generator.h.

m_defaultOpacity

quint8 KisOutlineGenerator::m_defaultOpacity

private

Definition at line 86 of file kis_outline_generator.h.

m_simple

bool KisOutlineGenerator::m_simple

private

Definition at line 87 of file kis_outline_generator.h.

---

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

• libs/image/kis_outline_generator.h
• libs/image/kis_outline_generator.cpp