KisBorderSelectionFilter Class Reference

#include <kis_selection_filters.h>

Inheritance diagram for KisBorderSelectionFilter:

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

Private Attributes
bool	m_antialiasing
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 60 of file kis_selection_filters.h.

Constructor & Destructor Documentation

KisBorderSelectionFilter()

KisBorderSelectionFilter::KisBorderSelectionFilter	(	qint32	xRadius,
		qint32	yRadius,
		bool	fade )

Definition at line 246 of file kis_selection_filters.cpp.

  : m_xRadius(xRadius),
    m_yRadius(yRadius),
    m_antialiasing(antialiasing)
{
}

Member Function Documentation

changeRect()

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

overridevirtual

Reimplemented from KisSelectionFilter.

Definition at line 258 of file kis_selection_filters.cpp.

{
    Q_UNUSED(defaultBounds);
 
    return rect.adjusted(-m_xRadius, -m_yRadius, m_xRadius, m_yRadius);
}

References m_xRadius, and m_yRadius.

name()

KUndo2MagicString KisBorderSelectionFilter::name ( )

overridevirtual

Reimplemented from KisSelectionFilter.

Definition at line 253 of file kis_selection_filters.cpp.

{
    return kundo2_i18n("Border Selection");
}

References kundo2_i18n().

process()

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

overridevirtual

Implements KisSelectionFilter.

Definition at line 265 of file kis_selection_filters.cpp.

{
    if (m_xRadius <= 0 || m_yRadius <= 0) return;
 
    quint8  *buf[3];
    quint8 **density;
    quint8 **transition;
 
    if (m_xRadius == 1 && m_yRadius == 1) {
        // optimize this case specifically
        quint8* source[3];
 
        for (qint32 i = 0; i < 3; i++)
            source[i] = new quint8[rect.width()];
 
        quint8* transition = new quint8[rect.width()];
 
        pixelSelection->readBytes(source[0], rect.x(), rect.y(), rect.width(), 1);
        memcpy(source[1], source[0], rect.width());
        if (rect.height() > 1)
            pixelSelection->readBytes(source[2], rect.x(), rect.y() + 1, rect.width(), 1);
        else
            memcpy(source[2], source[1], rect.width());
 
        computeTransition(transition, source, rect.width());
        pixelSelection->writeBytes(transition, rect.x(), rect.y(), rect.width(), 1);
 
        for (qint32 y = 1; y < rect.height(); y++) {
            rotatePointers(source, 3);
            if (y + 1 < rect.height())
                pixelSelection->readBytes(source[2], rect.x(), rect.y() + y + 1, rect.width(), 1);
            else
                memcpy(source[2], source[1], rect.width());
            computeTransition(transition, source, rect.width());
            pixelSelection->writeBytes(transition, rect.x(), rect.y() + y, rect.width(), 1);
        }
 
        for (qint32 i = 0; i < 3; i++)
            delete[] source[i];
        delete[] transition;
        return;
    }
 
    qint32* max = new qint32[rect.width() + 2 * m_xRadius];
    for (qint32 i = 0; i < (rect.width() + 2 * m_xRadius); i++)
        max[i] = m_yRadius + 2;
    max += m_xRadius;
 
    for (qint32 i = 0; i < 3; i++)
        buf[i] = new quint8[rect.width()];
 
    transition = new quint8*[m_yRadius + 1];
    for (qint32 i = 0; i < m_yRadius + 1; i++) {
        transition[i] = new quint8[rect.width() + 2 * m_xRadius];
        memset(transition[i], 0, rect.width() + 2 * m_xRadius);
        transition[i] += m_xRadius;
    }
    quint8* out = new quint8[rect.width()];
    density = new quint8*[2 * m_xRadius + 1];
    density += m_xRadius;
 
    for (qint32 x = 0; x < (m_xRadius + 1); x++) { // allocate density[][]
        density[ x]  = new quint8[2 * m_yRadius + 1];
        density[ x] += m_yRadius;
        density[-x]  = density[x];
    }
 
    // compute density[][]
    if (m_antialiasing) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(m_xRadius == m_yRadius && "anisotropic fading is not implemented");
        const qreal maxRadius = 0.5 * (m_xRadius + m_yRadius);
        const qreal minRadius = maxRadius - 1.0;
 
        for (qint32 x = 0; x < (m_xRadius + 1); x++) {
            double dist;
            quint8 a;
 
            for (qint32 y = 0; y < (m_yRadius + 1); y++) {
 
                dist = sqrt(pow2(x) + pow2(y));
 
                if (dist > maxRadius) {
                    a = 0;
                } else if (dist > minRadius) {
                    a = qRound((1.0 - dist + minRadius) * 255.0);
                } else {
                    a = 255;
                }
 
                density[ x][ y] = a;
                density[ x][-y] = a;
                density[-x][ y] = a;
                density[-x][-y] = a;
            }
        }
 
    } else {
        for (qint32 x = 0; x < (m_xRadius + 1); x++) {
            double tmpx, tmpy, dist;
            quint8 a;
 
            tmpx = x > 0.0 ? x - 0.5 : 0.0;
 
            for (qint32 y = 0; y < (m_yRadius + 1); y++) {
                tmpy = y > 0.0 ? y - 0.5 : 0.0;
 
                dist = (pow2(tmpy) / pow2(m_yRadius) +
                        pow2(tmpx) / pow2(m_xRadius));
 
                a = dist <= 1.0 ? 255 : 0;
 
                density[ x][ y] = a;
                density[ x][-y] = a;
                density[-x][ y] = a;
                density[-x][-y] = a;
            }
        }
    }
 
    pixelSelection->readBytes(buf[0], rect.x(), rect.y(), rect.width(), 1);
    memcpy(buf[1], buf[0], rect.width());
    if (rect.height() > 1)
        pixelSelection->readBytes(buf[2], rect.x(), rect.y() + 1, rect.width(), 1);
    else
        memcpy(buf[2], buf[1], rect.width());
    computeTransition(transition[1], buf, rect.width());
 
    for (qint32 y = 1; y < m_yRadius && y + 1 < rect.height(); y++) { // set up top of image
        rotatePointers(buf, 3);
        pixelSelection->readBytes(buf[2], rect.x(), rect.y() + y + 1, rect.width(), 1);
        computeTransition(transition[y + 1], buf, rect.width());
    }
    for (qint32 x = 0; x < rect.width(); x++) { // set up max[] for top of image
        max[x] = -(m_yRadius + 7);
        for (qint32 j = 1; j < m_yRadius + 1; j++)
            if (transition[j][x]) {
                max[x] = j;
                break;
            }
    }
    for (qint32 y = 0; y < rect.height(); y++) { // main calculation loop
        rotatePointers(buf, 3);
        rotatePointers(transition, m_yRadius + 1);
        if (y < rect.height() - (m_yRadius + 1)) {
            pixelSelection->readBytes(buf[2], rect.x(), rect.y() + y + m_yRadius + 1, rect.width(), 1);
            computeTransition(transition[m_yRadius], buf, rect.width());
        } else
            memcpy(transition[m_yRadius], transition[m_yRadius - 1], rect.width());
 
        for (qint32 x = 0; x < rect.width(); x++) { // update max array
            if (max[x] < 1) {
                if (max[x] <= -m_yRadius) {
                    if (transition[m_yRadius][x])
                        max[x] = m_yRadius;
                    else
                        max[x]--;
                } else if (transition[-max[x]][x])
                    max[x] = -max[x];
                else if (transition[-max[x] + 1][x])
                    max[x] = -max[x] + 1;
                else
                    max[x]--;
            } else
                max[x]--;
            if (max[x] < -m_yRadius - 1)
                max[x] = -m_yRadius - 1;
        }
        quint8 last_max =  max[0][density[-1]];
        qint32 last_index = 1;
        for (qint32 x = 0 ; x < rect.width(); x++) { // render scan line
            last_index--;
            if (last_index >= 0) {
                last_max = 0;
                for (qint32 i = m_xRadius; i >= 0; i--)
                    if (max[x + i] <= m_yRadius && max[x + i] >= -m_yRadius && density[i][max[x+i]] > last_max) {
                        last_max = density[i][max[x + i]];
                        last_index = i;
                    }
                out[x] = last_max;
            } else {
                last_max = 0;
                for (qint32 i = m_xRadius; i >= -m_xRadius; i--)
                    if (max[x + i] <= m_yRadius && max[x + i] >= -m_yRadius && density[i][max[x + i]] > last_max) {
                        last_max = density[i][max[x + i]];
                        last_index = i;
                    }
                out[x] = last_max;
            }
            if (last_max == 0) {
                qint32 i;
                for (i = x + 1; i < rect.width(); i++) {
                    if (max[i] >= -m_yRadius)
                        break;
                }
                if (i - x > m_xRadius) {
                    for (; x < i - m_xRadius; x++)
                        out[x] = 0;
                    x--;
                }
                last_index = m_xRadius;
            }
        }
        pixelSelection->writeBytes(out, rect.x(), rect.y() + y, rect.width(), 1);
    }
    delete [] out;
 
    for (qint32 i = 0; i < 3; i++)
        delete[] buf[i];
 
    max -= m_xRadius;
    delete[] max;
 
    for (qint32 i = 0; i < m_yRadius + 1; i++) {
        transition[i] -= m_xRadius;
        delete transition[i];
    }
    delete[] transition;
 
    for (qint32 i = 0; i < m_xRadius + 1 ; i++) {
        density[i] -= m_yRadius;
        delete density[i];
    }
    density -= m_xRadius;
    delete[] density;
}

References KisSelectionFilter::computeTransition(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_antialiasing, m_xRadius, m_yRadius, pow2(), KisPaintDevice::readBytes(), KisSelectionFilter::rotatePointers(), source(), and KisPaintDevice::writeBytes().

Member Data Documentation

m_antialiasing

bool KisBorderSelectionFilter::m_antialiasing

private

Definition at line 74 of file kis_selection_filters.h.

m_xRadius

qint32 KisBorderSelectionFilter::m_xRadius

private

Definition at line 72 of file kis_selection_filters.h.

m_yRadius

qint32 KisBorderSelectionFilter::m_yRadius

private

Definition at line 73 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