KisShrinkSelectionFilter Class Reference

#include <kis_selection_filters.h>

Inheritance diagram for KisShrinkSelectionFilter:

Public Member Functions
QRect	changeRect (const QRect &rect, KisDefaultBoundsBaseSP defaultBounds) override
	KisShrinkSelectionFilter (qint32 xRadius, qint32 yRadius, bool edgeLock)
KUndo2MagicString	name () override
void	process (KisPixelSelectionSP pixelSelection, const QRect &rect) override
Public Member Functions inherited from KisSelectionFilter
virtual	~KisSelectionFilter ()

Private Attributes
qint32	m_edgeLock
qint32	m_xRadius
qint32	m_yRadius

Additional Inherited Members
Protected Member Functions inherited from KisSelectionFilter
void	computeBorder (qint32 *circ, qint32 xradius, qint32 yradius)
void	computeTransition (quint8 *transition, quint8 **buf, qint32 width)
void	rotatePointers (quint8 **p, quint32 n)

Detailed Description

Definition at line 107 of file kis_selection_filters.h.

Constructor & Destructor Documentation

KisShrinkSelectionFilter()

KisShrinkSelectionFilter::KisShrinkSelectionFilter	(	qint32	xRadius,
		qint32	yRadius,
		bool	edgeLock )

Definition at line 670 of file kis_selection_filters.cpp.

    : m_xRadius(xRadius)
    , m_yRadius(yRadius)
    , m_edgeLock(edgeLock)
{
}

Member Function Documentation

changeRect()

QRect KisShrinkSelectionFilter::changeRect ( const QRect & rect, KisDefaultBoundsBaseSP defaultBounds )

overridevirtual

Reimplemented from KisSelectionFilter.

Definition at line 682 of file kis_selection_filters.cpp.

{
    return m_edgeLock ? defaultBounds->imageBorderRect() : rect;
}

References KisDefaultBoundsBase::imageBorderRect(), and m_edgeLock.

name()

KUndo2MagicString KisShrinkSelectionFilter::name ( )

overridevirtual

Reimplemented from KisSelectionFilter.

Definition at line 677 of file kis_selection_filters.cpp.

{
    return kundo2_i18n("Shrink Selection");
}

References kundo2_i18n().

process()

void KisShrinkSelectionFilter::process ( KisPixelSelectionSP pixelSelection, const QRect & rect )

overridevirtual

Implements KisSelectionFilter.

Definition at line 687 of file kis_selection_filters.cpp.

{
    if (m_xRadius <= 0 || m_yRadius <= 0) return;
 
    /*
        pretty much the same as fatten_region only different
        blame all bugs in this function on jaycox@gimp.org
    */
    /* If edge_lock is true  we assume that pixels outside the region
        we are passed are identical to the edge pixels.
        If edge_lock is false, we assume that pixels outside the region are 0
    */
    quint8  **buf;  // caches the region's pixels
    quint8  **max;  // caches the smallest values for each column
    qint32    last_max, last_index;
 
    max = new quint8* [rect.width() + 2 * m_xRadius];
    buf = new quint8* [m_yRadius + 1];
    for (qint32 i = 0; i < m_yRadius + 1; i++) {
        buf[i] = new quint8[rect.width()];
    }
 
    qint32 buffer_size = (rect.width() + 2 * m_xRadius + 1) * (m_yRadius + 1);
    quint8* buffer = new quint8[buffer_size];
 
    if (m_edgeLock)
        memset(buffer, 255, buffer_size);
    else
        memset(buffer, 0, buffer_size);
 
    for (qint32 i = 0; i < rect.width() + 2 * m_xRadius; i++) {
        if (i < m_xRadius)
            if (m_edgeLock)
                max[i] = buffer;
            else
                max[i] = &buffer[(m_yRadius + 1) * (rect.width() + m_xRadius)];
        else if (i < rect.width() + m_xRadius)
            max[i] = &buffer[(m_yRadius + 1) * (i - m_xRadius)];
        else if (m_edgeLock)
            max[i] = &buffer[(m_yRadius + 1) * (rect.width() + m_xRadius - 1)];
        else
            max[i] = &buffer[(m_yRadius + 1) * (rect.width() + m_xRadius)];
    }
    if (!m_edgeLock)
        for (qint32 j = 0 ; j < m_xRadius + 1; j++) max[0][j] = 0;
 
    // offset the max pointer by m_xRadius so the range of the array is [-m_xRadius] to [region->w + m_xRadius]
    max += m_xRadius;
 
    quint8* out = new quint8[rect.width()]; // holds the new scan line we are computing
 
    qint32* circ = new qint32[2 * m_xRadius + 1]; // holds the y coords of the filter's mask
 
    computeBorder(circ, m_xRadius, m_yRadius);
 
    // offset the circ pointer by m_xRadius so the range of the array is [-m_xRadius] to [m_xRadius]
    circ += m_xRadius;
 
    for (qint32 i = 0; i < m_yRadius && i < rect.height(); i++) // load top of image
        pixelSelection->readBytes(buf[i + 1], rect.x(), rect.y() + i, rect.width(), 1);
 
    if (m_edgeLock)
        memcpy(buf[0], buf[1], rect.width());
    else
        memset(buf[0], 0, rect.width());
 
 
    for (qint32 x = 0; x < rect.width(); x++) { // set up max for top of image
        max[x][0] = buf[0][x];
        for (qint32 j = 1; j < m_yRadius + 1; j++)
            max[x][j] = MIN(buf[j][x], max[x][j-1]);
    }
 
    for (qint32 y = 0; y < rect.height(); y++) {
        rotatePointers(buf, m_yRadius + 1);
        if (y < rect.height() - m_yRadius)
            pixelSelection->readBytes(buf[m_yRadius], rect.x(), rect.y() + y + m_yRadius, rect.width(), 1);
        else if (m_edgeLock)
            memcpy(buf[m_yRadius], buf[m_yRadius - 1], rect.width());
        else
            memset(buf[m_yRadius], 0, rect.width());
 
        for (qint32 x = 0 ; x < rect.width(); x++) { // update max array
            for (qint32 i = m_yRadius; i > 0; i--) {
                max[x][i] = MIN(MIN(max[x][i - 1], buf[i - 1][x]), buf[i][x]);
            }
            max[x][0] = buf[0][x];
        }
        last_max =  max[0][circ[-1]];
        last_index = 0;
 
        for (qint32 x = 0 ; x < rect.width(); x++) { // render scan line
            last_index--;
            if (last_index >= 0) {
                if (last_max == 0)
                    out[x] = 0;
                else {
                    last_max = 255;
                    for (qint32 i = m_xRadius; i >= 0; i--)
                        if (last_max > max[x + i][circ[i]]) {
                            last_max = max[x + i][circ[i]];
                            last_index = i;
                        }
                    out[x] = last_max;
                }
            } else {
                last_index = m_xRadius;
                last_max = max[x + m_xRadius][circ[m_xRadius]];
                for (qint32 i = m_xRadius - 1; i >= -m_xRadius; i--)
                    if (last_max > max[x + i][circ[i]]) {
                        last_max = max[x + i][circ[i]];
                        last_index = i;
                    }
                out[x] = last_max;
            }
        }
        pixelSelection->writeBytes(out, rect.x(), rect.y() + y, rect.width(), 1);
    }
 
    // undo the offsets to the pointers so we can free the malloced memory
    circ -= m_xRadius;
    max -= m_xRadius;
 
    delete[] circ;
    delete[] buffer;
    delete[] max;
    for (qint32 i = 0; i < m_yRadius + 1; i++)
        delete[] buf[i];
    delete[] buf;
    delete[] out;
}

References KisSelectionFilter::computeBorder(), m_edgeLock, m_xRadius, m_yRadius, MIN, KisPaintDevice::readBytes(), KisSelectionFilter::rotatePointers(), and KisPaintDevice::writeBytes().

Member Data Documentation

m_edgeLock

qint32 KisShrinkSelectionFilter::m_edgeLock

private

Definition at line 121 of file kis_selection_filters.h.

m_xRadius

qint32 KisShrinkSelectionFilter::m_xRadius

private

Definition at line 119 of file kis_selection_filters.h.

m_yRadius

qint32 KisShrinkSelectionFilter::m_yRadius

private

Definition at line 120 of file kis_selection_filters.h.

---

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

• libs/image/kis_selection_filters.h
• libs/image/kis_selection_filters.cpp