MaskedImage Class Reference

Inheritance diagram for MaskedImage:

Public Member Functions
int	channelCount (void) const
void	clearMask (void)
bool	containsMasked (int x, int y, int S)
KisSharedPtr< MaskedImage >	copy (void)
int	countMasked (void)
void	DebugDump (const QString &name)
void	downsample2x (void)
quint8 *	getImagePixel (int x, int y)
QVector< float >	getImagePixels (int x, int y) const
quint8	getImagePixelU8 (int x, int y, int chan) const
void	initialize (KisPaintDeviceSP _imageDev, KisPaintDeviceSP _maskDev, QRect _maskRect)
bool	isMasked (int x, int y)
	MaskedImage (KisPaintDeviceSP _imageDev, KisPaintDeviceSP _maskDev, QRect _maskRect)
void	mixColors (std::vector< quint8 * > pixels, std::vector< float > w, float wsum, quint8 *dst)
void	setImagePixels (int x, int y, QVector< float > &value)
void	setMask (int x, int y, quint8 v)
QRect	size ()
void	toPaintDevice (KisPaintDeviceSP imageDev, QRect rect, KisSelectionSP selection)
void	upscale (int newW, int newH)
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Public Attributes
std::function< float(const MaskedImage &, int, int, const MaskedImage &, int, int)	distance )

Private Member Functions
void	cacheImage (KisPaintDeviceSP imageDev, QRect rect)
void	cacheMask (KisPaintDeviceSP maskDev, QRect rect)
	MaskedImage ()

Private Attributes
const KoColorSpace *	cs {nullptr}
const KoColorSpace *	csMask {nullptr}
ImageData	imageData
QRect	imageSize
ImageData	maskData
int	nChannels {0}

Friends
template<typename T >
float	distance_impl (const MaskedImage &my, int x, int y, const MaskedImage &other, int xo, int yo)

Additional Inherited Members
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Detailed Description

Definition at line 199 of file kis_inpaint.cpp.

Constructor & Destructor Documentation

MaskedImage() [1/2]

MaskedImage::MaskedImage ( )

inlineprivate

Definition at line 237 of file kis_inpaint.cpp.

{}

MaskedImage() [2/2]

MaskedImage::MaskedImage ( KisPaintDeviceSP _imageDev, KisPaintDeviceSP _maskDev, QRect _maskRect )

inline

Definition at line 292 of file kis_inpaint.cpp.

    {
        initialize(_imageDev, _maskDev, _maskRect);
    }

References initialize().

Member Function Documentation

cacheImage()

void MaskedImage::cacheImage ( KisPaintDeviceSP imageDev, QRect rect )

inlineprivate

Definition at line 215 of file kis_inpaint.cpp.

    {
        cs = imageDev->colorSpace();
        nChannels = cs->channelCount();
        imageData.Init(imageDev, rect);
        imageSize = rect;
    }

References KoColorSpace::channelCount(), KisPaintDevice::colorSpace(), cs, imageData, imageSize, ImageData::Init(), and nChannels.

cacheMask()

void MaskedImage::cacheMask ( KisPaintDeviceSP maskDev, QRect rect )

inlineprivate

Definition at line 224 of file kis_inpaint.cpp.

    {
        Q_ASSERT(maskDev->colorSpace()->pixelSize() == 1);
        csMask = maskDev->colorSpace();
        maskData.Init(maskDev, rect);
 
        //hard threshold for the initial mask
        //may be optional. needs testing
        std::for_each(maskData.data(), maskData.data() + maskData.num_bytes(), [](quint8 & v) {
            v = (v > MASK_CLEAR) ? MASK_SET : MASK_CLEAR;
        });
    }

References KisPaintDevice::colorSpace(), csMask, ImageView::data(), ImageData::Init(), maskData, ImageView::num_bytes(), KoColorSpace::pixelSize(), and v.

channelCount()

int MaskedImage::channelCount ( void ) const

inline

Definition at line 472 of file kis_inpaint.cpp.

    {
        return cs->channelCount();
    }

References KoColorSpace::channelCount(), and cs.

clearMask()

void MaskedImage::clearMask ( void )

inline

Definition at line 262 of file kis_inpaint.cpp.

    {
        std::fill(maskData.data(), maskData.data() + maskData.num_bytes(), MASK_CLEAR);
    }

References ImageView::data(), MASK_CLEAR, maskData, and ImageView::num_bytes().

containsMasked()

bool MaskedImage::containsMasked ( int x, int y, int S )

inline

Definition at line 403 of file kis_inpaint.cpp.

    {
        for (int dy = -S; dy <= S; ++dy) {
            int ys = y + dy;
            if (ys < 0 || ys >= imageSize.height())
                continue;
 
            for (int dx = -S; dx <= S; ++dx) {
                int xs = x + dx;
                if (xs < 0 || xs >= imageSize.width())
                    continue;
                if (isMasked(xs, ys))
                    return true;
            }
        }
        return false;
    }

References imageSize, isMasked(), and S.

copy()

KisSharedPtr< MaskedImage > MaskedImage::copy ( void )

inline

Definition at line 376 of file kis_inpaint.cpp.

    {
        KisSharedPtr<MaskedImage> clone = new MaskedImage();
        clone->imageSize = this->imageSize;
        clone->nChannels = this->nChannels;
        clone->maskData = this->maskData;
        clone->imageData = this->imageData;
        clone->cs = this->cs;
        clone->csMask = this->csMask;
        clone->distance = this->distance;
        return clone;
    }

References cs, csMask, distance, imageData, imageSize, maskData, MaskedImage(), and nChannels.

countMasked()

int MaskedImage::countMasked ( void )

inline

Definition at line 389 of file kis_inpaint.cpp.

    {
        int count = std::count_if(maskData.data(), maskData.data() + maskData.num_elements(), [](quint8 v) {
            return v > MASK_CLEAR;
        });
        return count;
    }

References ImageView::data(), maskData, ImageView::num_elements(), and v.

DebugDump()

void MaskedImage::DebugDump ( const QString & name )

inline

Definition at line 256 of file kis_inpaint.cpp.

    {
        imageData.DebugDump(name + "_img");
        maskData.DebugDump(name + "_mask");
    }

References ImageView::DebugDump(), imageData, and maskData.

downsample2x()

void MaskedImage::downsample2x ( void )

inline

Definition at line 297 of file kis_inpaint.cpp.

    {
        int H = imageSize.height();
        int W = imageSize.width();
        int newW = W / 2, newH = H / 2;
 
        KisPaintDeviceSP imageDev = new KisPaintDevice(cs);
        KisPaintDeviceSP maskDev = new KisPaintDevice(csMask);
        imageDev->writeBytes(imageData.data(), 0, 0, W, H);
        maskDev->writeBytes(maskData.data(), 0, 0, W, H);
 
        ImageData newImage(newW, newH, cs->pixelSize());
        ImageData newMask(newW, newH, 1);
 
        KoDummyUpdaterHolder updaterHolder;
        KisTransformWorker worker(imageDev, 1. / 2., 1. / 2., 0.0, 0.0, 0.0, 0.0, 0.0,
                                  updaterHolder.updater(), KisFilterStrategyRegistry::instance()->value("Bicubic"));
        worker.run();
 
        KisTransformWorker workerMask(maskDev, 1. / 2., 1. / 2., 0.0, 0.0, 0.0, 0.0, 0.0,
                                      updaterHolder.updater(), KisFilterStrategyRegistry::instance()->value("Bicubic"));
        workerMask.run();
 
        imageDev->readBytes(newImage.data(), 0, 0, newW, newH);
        maskDev->readBytes(newMask.data(), 0, 0, newW, newH);
        imageData = std::move(newImage);
        maskData = std::move(newMask);
 
        for (int i = 0; i < imageData.num_elements(); ++i) {
            quint8* maskPix = maskData.data() + i * maskData.pixel_size();
            if (*maskPix == MASK_SET) {
                for (int k = 0; k < imageData.pixel_size(); k++)
                    *(imageData.data() + i * imageData.pixel_size() + k) = 0;
            } else {
                *maskPix = MASK_CLEAR;
            }
        }
        imageSize = QRect(0, 0, newW, newH);
    }

References cs, csMask, ImageView::data(), imageData, imageSize, KisFilterStrategyRegistry::instance(), MASK_CLEAR, MASK_SET, maskData, ImageView::num_elements(), ImageView::pixel_size(), KoColorSpace::pixelSize(), KisPaintDevice::readBytes(), KisTransformWorker::run(), KoDummyUpdaterHolder::updater(), KoGenericRegistry< T >::value(), and KisPaintDevice::writeBytes().

getImagePixel()

quint8 * MaskedImage::getImagePixel ( int x, int y )

inline

Definition at line 433 of file kis_inpaint.cpp.

    {
        return imageData(x, y);
    }

References imageData.

getImagePixels()

QVector< float > MaskedImage::getImagePixels ( int x, int y ) const

inline

Definition at line 426 of file kis_inpaint.cpp.

    {
        QVector<float> v(cs->channelCount());
        cs->normalisedChannelsValue(imageData(x, y), v);
        return v;
    }

References KoColorSpace::channelCount(), cs, imageData, KoColorSpace::normalisedChannelsValue(), and v.

getImagePixelU8()

quint8 MaskedImage::getImagePixelU8 ( int x, int y, int chan ) const

inline

Definition at line 421 of file kis_inpaint.cpp.

    {
        return cs->scaleToU8(imageData(x, y), chan);
    }

References cs, imageData, and KoColorSpace::scaleToU8().

initialize()

void MaskedImage::initialize ( KisPaintDeviceSP _imageDev, KisPaintDeviceSP _maskDev, QRect _maskRect )

inline

Definition at line 267 of file kis_inpaint.cpp.

    {
        cacheImage(_imageDev, _maskRect);
        cacheMask(_maskDev, _maskRect);
 
        //distance function is the only that needs to know the type
        //For performance reasons we can't use functions provided by color space
        KoID colorDepthId =  _imageDev->colorSpace()->colorDepthId();
 
        //Use RGB traits to assign actual pixel data types.
        distance = &distance_impl<KoRgbU8Traits::channels_type>;
 
        if( colorDepthId == Integer16BitsColorDepthID )
            distance = &distance_impl<KoRgbU16Traits::channels_type>;
#ifdef HAVE_OPENEXR
        if( colorDepthId == Float16BitsColorDepthID )
            distance = &distance_impl<KoRgbF16Traits::channels_type>;
#endif
        if( colorDepthId == Float32BitsColorDepthID )
            distance = &distance_impl<KoRgbF32Traits::channels_type>;
 
        if( colorDepthId == Float64BitsColorDepthID )
            distance = &distance_impl<KoRgbF64Traits::channels_type>;
    }

References cacheImage(), cacheMask(), KoColorSpace::colorDepthId(), KisPaintDevice::colorSpace(), distance, Float16BitsColorDepthID, Float32BitsColorDepthID, Float64BitsColorDepthID, and Integer16BitsColorDepthID.

isMasked()

bool MaskedImage::isMasked ( int x, int y )

inline

Definition at line 397 of file kis_inpaint.cpp.

    {
        return (*maskData(x, y) > MASK_CLEAR);
    }

References MASK_CLEAR, and maskData.

mixColors()

void MaskedImage::mixColors ( std::vector< quint8 * > pixels, std::vector< float > w, float wsum, quint8 * dst )

inline

Definition at line 443 of file kis_inpaint.cpp.

    {
        const KoMixColorsOp* mixOp = cs->mixColorsOp();
 
        size_t n = w.size();
        assert(pixels.size() == n);
        std::vector< qint16 > weights;
        weights.clear();
 
        float dif = 0;
 
        float scale = 255 / (wsum + 0.001);
 
        for (auto& v : w) {
            //compensated summation to increase accuracy
            float v1 = v * scale + dif;
            float v2 = std::round(v1);
            dif = v1 - v2;
            weights.push_back(v2);
        }
 
        mixOp->mixColors(pixels.data(), weights.data(), n, dst);
    }

References cs, KoMixColorsOp::mixColors(), KoColorSpace::mixColorsOp, and v.

setImagePixels()

void MaskedImage::setImagePixels ( int x, int y, QVector< float > & value )

inline

Definition at line 438 of file kis_inpaint.cpp.

    {
        cs->fromNormalisedChannelsValue(imageData(x, y), value);
    }

References cs, KoColorSpace::fromNormalisedChannelsValue(), imageData, and value().

setMask()

void MaskedImage::setMask ( int x, int y, quint8 v )

inline

Definition at line 467 of file kis_inpaint.cpp.

    {
        *(maskData(x, y)) = v;
    }

References maskData, and v.

size()

QRect MaskedImage::size ( )

inline

Definition at line 371 of file kis_inpaint.cpp.

    {
        return imageSize;
    }

References imageSize.

toPaintDevice()

void MaskedImage::toPaintDevice ( KisPaintDeviceSP imageDev, QRect rect, KisSelectionSP selection )

inline

Definition at line 242 of file kis_inpaint.cpp.

    {
        if (!selection) {
            imageData.saveToDevice(imageDev, rect);
        } else {
            KisPaintDeviceSP dev = new KisPaintDevice(imageDev->colorSpace());
            dev->setDefaultBounds(imageDev->defaultBounds());
 
            imageData.saveToDevice(dev, rect);
 
            KisPainter::copyAreaOptimized(rect.topLeft(), dev, imageDev, rect, selection);
        }
    }

References KisPaintDevice::colorSpace(), KisPainter::copyAreaOptimized(), KisPaintDevice::defaultBounds(), imageData, ImageView::saveToDevice(), and KisPaintDevice::setDefaultBounds().

upscale()

void MaskedImage::upscale ( int newW, int newH )

inline

Definition at line 337 of file kis_inpaint.cpp.

    {
        int H = imageSize.height();
        int W = imageSize.width();
 
        ImageData newImage(newW, newH, cs->pixelSize());
        ImageData newMask(newW, newH, 1);
 
        QVector<float> colors(nChannels, 0.f);
        QVector<float> v(nChannels, 0.f);
 
        for (int y = 0; y < newH; ++y) {
            for (int x = 0; x < newW; ++x) {
 
                // original pixel
                int xs = (x * W) / newW;
                int ys = (y * H) / newH;
 
                // copy to new image
                if (!isMasked(xs, ys)) {
                    std::copy(imageData(xs, ys), imageData(xs, ys) + imageData.pixel_size(), newImage(x, y));
                    *newMask(x, y) = MASK_CLEAR;
                } else {
                    std::fill(newImage(x, y), newImage(x, y) + newImage.pixel_size(), 0);
                    *newMask(x, y) = MASK_SET;
                }
            }
        }
 
        imageData = std::move(newImage);
        maskData = std::move(newMask);
        imageSize = QRect(0, 0, newW, newH);
    }

References cs, imageData, imageSize, isMasked(), MASK_CLEAR, MASK_SET, maskData, nChannels, ImageView::pixel_size(), KoColorSpace::pixelSize(), and v.

Friends And Related Symbol Documentation

distance_impl

template<typename T >

float distance_impl ( const MaskedImage & my, int x, int y, const MaskedImage & other, int xo, int yo )

friend

Definition at line 481 of file kis_inpaint.cpp.

{
    float dsq = 0;
    quint32 nchannels = my.channelCount();
    T *v1 = reinterpret_cast<T*>(my.imageData(x, y));
    T *v2 = reinterpret_cast<T*>(other.imageData(xo, yo));
 
    for (quint32 chan = 0; chan < nchannels; chan++) {
        //It's very important not to lose precision in the next line
        float v = ((float)(*(v1 + chan)) - (float)(*(v2 + chan)));
        dsq += v * v;
    }
 
    // in HDR color spaces the value of the channel may become bigger than the unitValue
    return qMin((float)(nchannels * MAX_DIST), dsq / (pow2((float)KoColorSpaceMathsTraits<T>::unitValue) / MAX_DIST ));
}

Member Data Documentation

cs

const KoColorSpace* MaskedImage::cs {nullptr}

private

Definition at line 208 of file kis_inpaint.cpp.

{nullptr};

csMask

const KoColorSpace* MaskedImage::csMask {nullptr}

private

Definition at line 209 of file kis_inpaint.cpp.

{nullptr};

distance

std::function< float(const MaskedImage&, int, int, const MaskedImage& , int , int ) MaskedImage::distance)

Definition at line 240 of file kis_inpaint.cpp.

imageData

ImageData MaskedImage::imageData

private

Definition at line 212 of file kis_inpaint.cpp.

imageSize

QRect MaskedImage::imageSize

private

Definition at line 205 of file kis_inpaint.cpp.

maskData

ImageData MaskedImage::maskData

private

Definition at line 211 of file kis_inpaint.cpp.

nChannels

int MaskedImage::nChannels {0}

private

Definition at line 206 of file kis_inpaint.cpp.

{0};

---

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

• plugins/tools/tool_smart_patch/kis_inpaint.cpp