KisLsUtils Namespace Reference

Namespaces
namespace	Private

Classes
struct	LodWrapper

Functions
void	adjustRange (KisPixelSelectionSP selection, const QRect &applyRect, const int range)
void	applyContourCorrection (KisPixelSelectionSP selection, const QRect &applyRect, const quint8 *lookup_table, bool antiAliased, bool edgeHidden)
void	applyFinalSelection (const QString &projectionId, KisSelectionSP baseSelection, KisPaintDeviceSP srcDevice, KisMultipleProjection *dst, const QRect &, const QRect &dstRect, const psd_layer_effects_context *, const psd_layer_effects_shadow_base *config, KisResourcesInterfaceSP resourcesInterface, const KisLayerStyleFilterEnvironment *env)
void	applyGaussianWithTransaction (KisPixelSelectionSP selection, const QRect &applyRect, qreal radius)
void	applyNoise (KisPixelSelectionSP selection, const QRect &applyRect, int noise, const psd_layer_effects_context *context, KisLayerStyleFilterEnvironment *env)
bool	checkEffectEnabled (const psd_layer_effects_shadow_base *config, KisMultipleProjection *dst)
void	fillOverlayDevice (KisPaintDeviceSP fillDevice, const QRect &applyRect, const psd_layer_effects_overlay_base *config, KisResourcesInterfaceSP resourcesInterface, KisLayerStyleFilterEnvironment *env)
void	fillPattern (KisPaintDeviceSP fillDevice, const QRect &applyRect, KisLayerStyleFilterEnvironment *env, int scale, KoPatternSP pattern, int horizontalPhase, int verticalPhase, bool alignWithLayer)
void	findEdge (KisPixelSelectionSP selection, const QRect &applyRect, const bool edgeHidden)
QRect	growRectFromRadius (const QRect &rc, int radius)
QRect	growSelectionUniform (KisPixelSelectionSP selection, int growSize, const QRect &applyRect)
void	knockOutSelection (KisPixelSelectionSP selection, KisPixelSelectionSP knockOutSelection, const QRect &srcRect, const QRect &dstRect, const QRect &totalNeedRect, const bool knockOutInverted)
void	selectionFromAlphaChannel (KisPaintDeviceSP srcDevice, KisSelectionSP dstSelection, const QRect &srcRect)

Variables
static const int	FULL_PERCENT_RANGE = 100
const int	noiseNeedBorder = 8

Function Documentation

adjustRange()

void KisLsUtils::adjustRange	(	KisPixelSelectionSP	selection,
		const QRect &	applyRect,
		const int	range )

Definition at line 282 of file kis_ls_utils.cpp.

    {
        KIS_ASSERT_RECOVER_RETURN(range >= 1 && range <= 100);
 
        quint8 rangeTable[256];
        for(int i = 0; i < 256; i ++) {
            quint8 value = i * 100 / range;
            rangeTable[i] = qMin(value, quint8(255));
        }
 
        KisSequentialIterator dstIt(selection, applyRect);
 
        while (dstIt.nextPixel()) {
            quint8 *pixelPtr = dstIt.rawData();
            *pixelPtr = rangeTable[*pixelPtr];
        }
    }

References KIS_ASSERT_RECOVER_RETURN, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and value().

applyContourCorrection()

void KisLsUtils::applyContourCorrection	(	KisPixelSelectionSP	selection,
		const QRect &	applyRect,
		const quint8 *	lookup_table,
		bool	antiAliased,
		bool	edgeHidden )

Definition at line 300 of file kis_ls_utils.cpp.

    {
        quint8 contour[PSD_LOOKUP_TABLE_SIZE] = {
            0x00, 0x0b, 0x16, 0x21, 0x2c, 0x37, 0x42, 0x4d, 0x58, 0x63, 0x6e, 0x79, 0x84, 0x8f, 0x9a, 0xa5,
            0xb0, 0xbb, 0xc6, 0xd1, 0xdc, 0xf2, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 
        if (edgeHidden) {
            if (antiAliased) {
                for (int i = 0; i < PSD_LOOKUP_TABLE_SIZE; i++) {
                    contour[i] = contour[i] * lookup_table[i] >> 8;
                }
            } else {
                for (int i = 0; i < PSD_LOOKUP_TABLE_SIZE; i++) {
                    contour[i] = contour[i] * lookup_table[(int)((int)(i / 2.55) * 2.55 + 0.5)] >> 8;
                }
            }
        } else {
            if (antiAliased) {
                for (int i = 0; i < PSD_LOOKUP_TABLE_SIZE; i++) {
                    contour[i] = lookup_table[i];
                }
            } else {
                for (int i = 0; i < PSD_LOOKUP_TABLE_SIZE; i++) {
                    contour[i] = lookup_table[(int)((int)(i / 2.55) * 2.55 + 0.5)];
                }
            }
        }
 
        KisSequentialIterator dstIt(selection, applyRect);
        while (dstIt.nextPixel()) {
            quint8 *pixelPtr = dstIt.rawData();
            *pixelPtr = contour[*pixelPtr];
        }
    }

References KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), PSD_LOOKUP_TABLE_SIZE, and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData().

applyFinalSelection()

void KisLsUtils::applyFinalSelection	(	const QString &	projectionId,
		KisSelectionSP	baseSelection,
		KisPaintDeviceSP	srcDevice,
		KisMultipleProjection *	dst,
		const QRect &	,
		const QRect &	dstRect,
		const psd_layer_effects_context *	,
		const psd_layer_effects_shadow_base *	config,
		KisResourcesInterfaceSP	resourcesInterface,
		const KisLayerStyleFilterEnvironment *	env )

Definition at line 538 of file kis_ls_utils.cpp.

    {
        const KoColor effectColor(config->color(), srcDevice->colorSpace());
 
        const QRect effectRect(dstRect);
        const QString compositeOp = config->blendMode();
        const quint8 opacityU8 = quint8(qRound(255.0 / 100.0 * config->opacity()));
        KisPaintDeviceSP dstDevice = dst->getProjection(projectionId, compositeOp, opacityU8, QBitArray(), srcDevice);
 
        if (config->fillType() == psd_fill_solid_color) {
            KisFillPainter gc(dstDevice);
            gc.setCompositeOpId(COMPOSITE_COPY);
            gc.setSelection(baseSelection);
            gc.fillSelection(effectRect, effectColor);
            gc.end();
 
        } else if (config->fillType() == psd_fill_gradient) {
            if (!config->gradient(resourcesInterface)) {
                warnKrita << "KisLsUtils::applyFinalSelection: Gradient object is null! Skipping...";
                return;
            }
 
            QVector<KoColor> table(256);
            Private::getGradientTable(config->gradient(resourcesInterface).data(), &table, dstDevice->colorSpace());
 
            Private::applyGradient(dstDevice, baseSelection->pixelSelection(),
                                   effectRect, table,
                                   true, config->jitter(), env);
        }
 
        //dstDevice->convertToQImage(0, QRect(0,0,300,300)).save("6_device_shadow.png");
    }

References KisLsUtils::Private::applyGradient(), psd_layer_effects_shadow_base::blendMode(), psd_layer_effects_shadow_base::color(), KisPaintDevice::colorSpace(), COMPOSITE_COPY, KisPainter::end(), KisFillPainter::fillSelection(), psd_layer_effects_shadow_base::fillType(), KisLsUtils::Private::getGradientTable(), KisMultipleProjection::getProjection(), psd_layer_effects_shadow_base::gradient(), psd_layer_effects_shadow_base::jitter(), psd_layer_effects_shadow_base::opacity(), KisSelection::pixelSelection, psd_fill_gradient, psd_fill_solid_color, KisPainter::setCompositeOpId(), KisPainter::setSelection(), and warnKrita.

applyGaussianWithTransaction()

void KisLsUtils::applyGaussianWithTransaction	(	KisPixelSelectionSP	selection,
		const QRect &	applyRect,
		qreal	radius )

Definition at line 102 of file kis_ls_utils.cpp.

    {
        KisGaussianKernel::applyGaussian(selection, applyRect,
                                         radius, radius,
                                         QBitArray(), 0, true,
                                         BORDER_IGNORE);
    }

References KisGaussianKernel::applyGaussian(), and BORDER_IGNORE.

applyNoise()

void KisLsUtils::applyNoise	(	KisPixelSelectionSP	selection,
		const QRect &	applyRect,
		int	noise,
		const psd_layer_effects_context *	context,
		KisLayerStyleFilterEnvironment *	env )

Definition at line 235 of file kis_ls_utils.cpp.

    {
        Q_UNUSED(context);
 
        const QRect overlayRect = kisGrowRect(applyRect, noiseNeedBorder);
 
        KisPixelSelectionSP randomSelection = env->cachedRandomSelection(overlayRect);
 
 
        KisCachedSelection::Guard s1(*env->cachedSelection());
        KisPixelSelectionSP randomOverlay = s1.selection()->pixelSelection();
 
        KisSequentialConstIterator noiseIt(randomSelection, overlayRect);
        KisSequentialConstIterator srcIt(selection, overlayRect);
        KisRandomAccessorSP dstIt = randomOverlay->createRandomAccessorNG();
 
        while (noiseIt.nextPixel() && srcIt.nextPixel()) {
            int itX = noiseIt.x();
            int itY = noiseIt.y();
 
            int x = itX + (*noiseIt.rawDataConst() >> 4) - 8;
            int y = itY + (*noiseIt.rawDataConst() & 0x0F) - 8;
            x = (x + itX) >> 1;
            y = (y + itY) >> 1;
 
            dstIt->moveTo(x, y);
 
            quint8 dstAlpha = *dstIt->rawData();
            quint8 srcAlpha = *srcIt.rawDataConst();
 
            int value = qMin(255, dstAlpha + srcAlpha);
 
            *dstIt->rawData() = value;
        }
 
        KisPainter gc(selection);
        gc.setOpacityF(qreal(noise) / 100.0);
        gc.setCompositeOpId(COMPOSITE_COPY);
        gc.bitBlt(applyRect.topLeft(), randomOverlay, applyRect);
    }

References KisPainter::bitBlt(), KisLayerStyleFilterEnvironment::cachedRandomSelection, KisLayerStyleFilterEnvironment::cachedSelection(), COMPOSITE_COPY, KisPaintDevice::createRandomAccessorNG(), kisGrowRect(), KisRandomConstAccessorNG::moveTo(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), noiseNeedBorder, KisBaseAccessor::rawData(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst(), s1, KisPainter::setCompositeOpId(), KisPainter::setOpacityF(), value(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

checkEffectEnabled()

bool KisLsUtils::checkEffectEnabled	(	const psd_layer_effects_shadow_base *	config,
		KisMultipleProjection *	dst )

Definition at line 580 of file kis_ls_utils.cpp.

    {
        bool result = config->effectEnabled();
 
        if (!result) {
            dst->freeAllProjections();
        }
 
        return result;
    }

References psd_layer_effects_shadow_base::effectEnabled(), and KisMultipleProjection::freeAllProjections().

fillOverlayDevice()

void KisLsUtils::fillOverlayDevice	(	KisPaintDeviceSP	fillDevice,
		const QRect &	applyRect,
		const psd_layer_effects_overlay_base *	config,
		KisResourcesInterfaceSP	resourcesInterface,
		KisLayerStyleFilterEnvironment *	env )

Definition at line 405 of file kis_ls_utils.cpp.

    {
        if (config->fillType() == psd_fill_solid_color) {
            KoColor color(config->color(), fillDevice->colorSpace());
            fillDevice->setDefaultPixel(color);
 
        } else if (config->fillType() == psd_fill_pattern) {
            KoPatternSP pattern = config->pattern(resourcesInterface);
 
            KIS_SAFE_ASSERT_RECOVER_RETURN(pattern);
 
            if (pattern->hasAlpha()) {
                pattern = env->cachedFlattenedPattern(pattern);
            }
 
            fillPattern(fillDevice, applyRect, env,
                        config->scale(), pattern,
                        config->horizontalPhase(),
                        config->verticalPhase(),
                        config->alignWithLayer());
        } else if (config->fillType() == psd_fill_gradient) {
            const QRect boundsRect = config->alignWithLayer() ?
                env->layerBounds() : env->defaultBounds();
 
            QPoint center = boundsRect.center();
            center += QPoint(boundsRect.width() * config->gradientXOffset() / 100,
                             boundsRect.height() * config->gradientYOffset() / 100);
 
            int width = (boundsRect.width() * config->scale() + 100) / 200;
            int height = (boundsRect.height() * config->scale() + 100) / 200;
 
            /* copy paste from libpsd */
 
            int angle = config->angle();
            int corner_angle = (int)(atan((qreal)boundsRect.height() / boundsRect.width()) * 180 / M_PI + 0.5);
            int sign_x = 1;
            int sign_y = 1;
 
 
            if(angle < 0) {
                angle += 360;
            }
 
            if (angle >= 90 && angle < 180) {
                angle = 180 - angle;
                sign_x = -1;
            } else if (angle >= 180 && angle < 270) {
                angle = angle - 180;
                sign_x = -1;
                sign_y = -1;
            } else if (angle >= 270 && angle <= 360) {
                angle = 360 - angle;
                sign_y = -1;
            }
 
            int radius_x = 0;
            int radius_y = 0;
 
            if (angle <= corner_angle) {
                radius_x = width;
                radius_y = (int)(radius_x * tan(kisDegreesToRadians(qreal(angle))) + 0.5);
            } else {
                radius_y = height;
                radius_x = (int)(radius_y / tan(kisDegreesToRadians(qreal(angle))) + 0.5);
            }
 
            int radius_corner = (int)(std::sqrt((qreal)(radius_x * radius_x + radius_y * radius_y)) + 0.5);
 
            /* end of copy paste from libpsd */
 
            KisGradientPainter gc(fillDevice);
            gc.setGradient(config->gradient(resourcesInterface));
            QPointF gradStart;
            QPointF gradEnd;
            KisGradientPainter::enumGradientRepeat repeat =
                KisGradientPainter::GradientRepeatNone;
 
            QPoint rectangularOffset(sign_x * radius_x, -sign_y * radius_y);
 
 
            switch(config->style())
            {
            case psd_gradient_style_linear:
                gc.setGradientShape(KisGradientPainter::GradientShapeLinear);
                repeat = KisGradientPainter::GradientRepeatNone;
                gradStart = center - rectangularOffset;
                gradEnd = center + rectangularOffset;
                break;
 
            case psd_gradient_style_radial:
                gc.setGradientShape(KisGradientPainter::GradientShapeRadial);
                repeat = KisGradientPainter::GradientRepeatNone;
                gradStart = center;
                gradEnd = center + QPointF(radius_corner, 0);
                break;
 
            case psd_gradient_style_angle:
                gc.setGradientShape(KisGradientPainter::GradientShapeConical);
                repeat = KisGradientPainter::GradientRepeatNone;
                gradStart = center;
                gradEnd = center + rectangularOffset;
                break;
 
            case psd_gradient_style_reflected:
                gc.setGradientShape(KisGradientPainter::GradientShapeLinear);
                repeat = KisGradientPainter::GradientRepeatAlternate;
                gradStart = center - rectangularOffset;
                gradEnd = center;
                break;
 
            case psd_gradient_style_diamond:
                gc.setGradientShape(KisGradientPainter::GradientShapeBiLinear);
                repeat = KisGradientPainter::GradientRepeatNone;
                gradStart = center - rectangularOffset;
                gradEnd = center + rectangularOffset;
                break;
            default:
                qFatal("Gradient Overlay: unknown switch case!");
                break;
            }
 
            gc.paintGradient(gradStart, gradEnd,
                             repeat, 0.0,
                             config->reverse(),
                             applyRect,
                             config->dither());
        }
    }

References psd_layer_effects_overlay_base::alignWithLayer(), psd_layer_effects_shadow_base::angle(), KisLayerStyleFilterEnvironment::cachedFlattenedPattern, psd_layer_effects_shadow_base::color(), KisPaintDevice::colorSpace(), KisLayerStyleFilterEnvironment::defaultBounds(), psd_layer_effects_overlay_base::dither(), fillPattern(), psd_layer_effects_shadow_base::fillType(), psd_layer_effects_shadow_base::gradient(), KisGradientPainter::GradientRepeatAlternate, KisGradientPainter::GradientRepeatNone, KisGradientPainter::GradientShapeBiLinear, KisGradientPainter::GradientShapeConical, KisGradientPainter::GradientShapeLinear, KisGradientPainter::GradientShapeRadial, psd_layer_effects_overlay_base::gradientXOffset(), psd_layer_effects_overlay_base::gradientYOffset(), psd_layer_effects_overlay_base::horizontalPhase(), KIS_SAFE_ASSERT_RECOVER_RETURN, kisDegreesToRadians(), KisLayerStyleFilterEnvironment::layerBounds(), M_PI, KisGradientPainter::paintGradient(), psd_layer_effects_overlay_base::pattern(), psd_fill_gradient, psd_fill_pattern, psd_fill_solid_color, psd_gradient_style_angle, psd_gradient_style_diamond, psd_gradient_style_linear, psd_gradient_style_radial, psd_gradient_style_reflected, psd_layer_effects_overlay_base::reverse(), psd_layer_effects_overlay_base::scale(), KisPaintDevice::setDefaultPixel(), KisPainter::setGradient(), KisGradientPainter::setGradientShape(), psd_layer_effects_overlay_base::style(), and psd_layer_effects_overlay_base::verticalPhase().

fillPattern()

void KisLsUtils::fillPattern	(	KisPaintDeviceSP	fillDevice,
		const QRect &	applyRect,
		KisLayerStyleFilterEnvironment *	env,
		int	scale,
		KoPatternSP	pattern,
		int	horizontalPhase,
		int	verticalPhase,
		bool	alignWithLayer )

Definition at line 370 of file kis_ls_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN(pattern);
 
        QSize psize(pattern->width(), pattern->height());
 
        QPoint patternOffset(qreal(psize.width()) * horizontalPhase / 100,
                             qreal(psize.height()) * verticalPhase / 100);
 
        const QRect boundsRect = alignWithLayer ?
            env->layerBounds() : env->defaultBounds();
 
        patternOffset -= boundsRect.topLeft();
 
        patternOffset.rx() %= psize.width();
        patternOffset.ry() %= psize.height();
 
        QRect fillRect = applyRect | applyRect.translated(patternOffset);
 
        KisFillPainter gc(fillDevice);
        QTransform transform;
        transform.translate(-patternOffset.x(), -patternOffset.y());
        qreal scaleNorm = qreal(scale*0.01);
        transform.scale(scaleNorm, scaleNorm);
        gc.fillRectNoCompose(fillRect, pattern, transform);
        gc.end();
    }

References KisLayerStyleFilterEnvironment::defaultBounds(), KisPainter::end(), KisFillPainter::fillRectNoCompose(), KIS_SAFE_ASSERT_RECOVER_RETURN, and KisLayerStyleFilterEnvironment::layerBounds().

findEdge()

void KisLsUtils::findEdge	(	KisPixelSelectionSP	selection,
		const QRect &	applyRect,
		const bool	edgeHidden )

Definition at line 74 of file kis_ls_utils.cpp.

    {
        KisSequentialIterator dstIt(selection, applyRect);
 
        if (edgeHidden) {
            while(dstIt.nextPixel()) {
                quint8 *pixelPtr = dstIt.rawData();
 
                *pixelPtr =
                    (*pixelPtr < 24) ?
                    *pixelPtr * 10 : 0xFF;
 
            }
        } else {
            while(dstIt.nextPixel()) {
                quint8 *pixelPtr = dstIt.rawData();
                *pixelPtr = 0xFF;
 
            }
        }
    }

References KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData().

growRectFromRadius()

QRect KisLsUtils::growRectFromRadius	(	const QRect &	rc,
		int	radius )

Definition at line 96 of file kis_ls_utils.cpp.

    {
        int halfSize = KisGaussianKernel::kernelSizeFromRadius(radius) / 2;
        return rc.adjusted(-halfSize, -halfSize, halfSize, halfSize);
    }

References KisGaussianKernel::kernelSizeFromRadius().

growSelectionUniform()

QRect KisLsUtils::growSelectionUniform	(	KisPixelSelectionSP	selection,
		int	growSize,
		const QRect &	applyRect )

Definition at line 37 of file kis_ls_utils.cpp.

    {
        QRect changeRect = applyRect;
 
        if (growSize > 0) {
            KisGrowSelectionFilter filter(growSize, growSize);
            changeRect = filter.changeRect(applyRect, selection->defaultBounds());
            filter.process(selection, applyRect);
        } else if (growSize < 0) {
            KisShrinkSelectionFilter filter(qAbs(growSize), qAbs(growSize), false);
            changeRect = filter.changeRect(applyRect, selection->defaultBounds());
            filter.process(selection, applyRect);
        }
 
        return changeRect;
    }

References KisGrowSelectionFilter::changeRect(), KisShrinkSelectionFilter::changeRect(), KisPaintDevice::defaultBounds(), KisGrowSelectionFilter::process(), and KisShrinkSelectionFilter::process().

knockOutSelection()

void KisLsUtils::knockOutSelection	(	KisPixelSelectionSP	selection,
		KisPixelSelectionSP	knockOutSelection,
		const QRect &	srcRect,
		const QRect &	dstRect,
		const QRect &	totalNeedRect,
		const bool	knockOutInverted )

Definition at line 353 of file kis_ls_utils.cpp.

    {
        KIS_ASSERT_RECOVER_RETURN(knockOutSelection);
 
        QRect knockOutRect = !knockOutInverted ? srcRect : totalNeedRect;
        knockOutRect &= dstRect;
 
        KisPainter gc(selection);
        gc.setCompositeOpId(COMPOSITE_ERASE);
        gc.bitBlt(knockOutRect.topLeft(), knockOutSelection, knockOutRect);
    }

References KisPainter::bitBlt(), COMPOSITE_ERASE, KIS_ASSERT_RECOVER_RETURN, knockOutSelection(), and KisPainter::setCompositeOpId().

selectionFromAlphaChannel()

KRITAIMAGE_EXPORT void KisLsUtils::selectionFromAlphaChannel	(	KisPaintDeviceSP	srcDevice,
		KisSelectionSP	dstSelection,
		const QRect &	srcRect )

Definition at line 54 of file kis_ls_utils.cpp.

    {
        const KoColorSpace *cs = srcDevice->colorSpace();
 
 
        KisPixelSelectionSP selection = dstSelection->pixelSelection();
 
        KisSequentialConstIterator srcIt(srcDevice, srcRect);
        KisSequentialIterator dstIt(selection, srcRect);
 
        while (srcIt.nextPixel() && dstIt.nextPixel()) {
            quint8 *dstPtr = dstIt.rawData();
            const quint8* srcPtr = srcIt.rawDataConst();
            *dstPtr = cs->opacityU8(srcPtr);
        }
 
    }

References KisPaintDevice::colorSpace(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KoColorSpace::opacityU8(), KisSelection::pixelSelection, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawDataConst().

Variable Documentation

FULL_PERCENT_RANGE

const int KisLsUtils::FULL_PERCENT_RANGE = 100

static

Definition at line 40 of file kis_ls_utils.h.

noiseNeedBorder

const int KisLsUtils::noiseNeedBorder = 8

Definition at line 233 of file kis_ls_utils.cpp.