KisFixedPaintDevice Class Reference

#include <kis_fixed_paint_device.h>

Inheritance diagram for KisFixedPaintDevice:

Public Member Functions
int	allocatedPixels () const
QRect	bounds () const
void	clear (const QRect &rc)
const KoColorSpace *	colorSpace () const
const quint8 *	constData () const
virtual void	convertFromQImage (const QImage &image, const QString &srcProfileName)
void	convertTo (const KoColorSpace *dstColorSpace=0, KoColorConversionTransformation::Intent renderingIntent=KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags=KoColorConversionTransformation::internalConversionFlags())
virtual QImage	convertToQImage (const KoColorProfile *dstProfile, KoColorConversionTransformation::Intent renderingIntent=KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags=KoColorConversionTransformation::internalConversionFlags()) const
virtual QImage	convertToQImage (const KoColorProfile *dstProfile, qint32 x, qint32 y, qint32 w, qint32 h, KoColorConversionTransformation::Intent renderingIntent=KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags=KoColorConversionTransformation::internalConversionFlags()) const
quint8 *	data ()
quint8 *	data () const
void	fill (const QRect &rc, const KoColor &color)
void	fill (qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *fillPixel)
bool	initialize (quint8 defaultValue=0)
	KisFixedPaintDevice (const KisFixedPaintDevice &rhs)
	KisFixedPaintDevice (const KoColorSpace *colorSpace, KisOptimizedByteArray::MemoryAllocatorSP allocator=KisOptimizedByteArray::MemoryAllocatorSP())
void	lazyGrowBufferWithoutInitialization ()
void	mirror (bool horizontal, bool vertical)
KisFixedPaintDevice &	operator= (const KisFixedPaintDevice &rhs)
quint32	pixelSize () const
void	readBytes (quint8 *dstData, qint32 x, qint32 y, qint32 w, qint32 h) const
void	reallocateBufferWithoutInitialization ()
void	setColorSpace (const KoColorSpace *cs)
void	setProfile (const KoColorProfile *profile)
void	setRect (const QRect &rc)
virtual	~KisFixedPaintDevice ()
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Private Attributes
QRect	m_bounds
const KoColorSpace *	m_colorSpace
KisOptimizedByteArray	m_data

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

Detailed Description

A fixed paint device is a simple paint device that consists of an array of bytes and a rectangle. It cannot grow, it cannot shrink, all you can do is fill the paint device with the right bytes and use it as an argument to KisPainter or use the bytes as an argument to KoColorSpace functions.

Definition at line 27 of file kis_fixed_paint_device.h.

Constructor & Destructor Documentation

KisFixedPaintDevice() [1/2]

KisFixedPaintDevice::KisFixedPaintDevice	(	const KoColorSpace *	colorSpace,
		KisOptimizedByteArray::MemoryAllocatorSP	allocator = KisOptimizedByteArray::MemoryAllocatorSP() )

Definition at line 14 of file kis_fixed_paint_device.cpp.

        : m_colorSpace(colorSpace),
          m_data(allocator)
{
}

~KisFixedPaintDevice()

KisFixedPaintDevice::~KisFixedPaintDevice ( )

virtual

Definition at line 20 of file kis_fixed_paint_device.cpp.

{
}

KisFixedPaintDevice() [2/2]

KisFixedPaintDevice::KisFixedPaintDevice

(

const KisFixedPaintDevice &

rhs

)

Deep copy the fixed paint device, including the data.

Definition at line 24 of file kis_fixed_paint_device.cpp.

        : KisShared()
{
    m_bounds = rhs.m_bounds;
    m_colorSpace = rhs.m_colorSpace;
    m_data = rhs.m_data;
}

References m_bounds, m_colorSpace, and m_data.

Member Function Documentation

allocatedPixels()

int KisFixedPaintDevice::allocatedPixels

(

)

const

Returns

the amount of allocated pixels (you can fake the size with setRect/bounds) It is useful to know the accumulated memory size in pixels (not in bytes) for optimizations to avoid re-allocation.

Definition at line 65 of file kis_fixed_paint_device.cpp.

{
    return m_data.size() / m_colorSpace->pixelSize();
}

References m_colorSpace, m_data, KoColorSpace::pixelSize(), and KisOptimizedByteArray::size().

bounds()

QRect KisFixedPaintDevice::bounds

(

)

const

Returns

the rect that the data represents

Definition at line 59 of file kis_fixed_paint_device.cpp.

{
    return m_bounds;
}

References m_bounds.

clear()

void KisFixedPaintDevice::clear

(

const QRect &

rc

)

Clear the given rectangle to transparent black.

XXX: this will not (yet) expand the paint device to contain the specified rect but if the paintdevice has not been initialized, it will be.

Definition at line 227 of file kis_fixed_paint_device.cpp.

{
    KoColor c(Qt::black, m_colorSpace);
    quint8* black = new quint8[pixelSize()];
    memcpy(black, c.data(), m_colorSpace->pixelSize());
    m_colorSpace->setOpacity(black, OPACITY_TRANSPARENT_U8, 1);
    fill(rc.x(), rc.y(), rc.width(), rc.height(), black);
    delete[] black;
}

References KoColor::data(), fill(), m_colorSpace, OPACITY_TRANSPARENT_U8, pixelSize(), KoColorSpace::pixelSize(), and KoColorSpace::setOpacity().

colorSpace()

const KoColorSpace * KisFixedPaintDevice::colorSpace ( ) const

inline

Definition at line 79 of file kis_fixed_paint_device.h.

                                           {
        return m_colorSpace;
    }

constData()

const quint8 * KisFixedPaintDevice::constData

(

)

const

Definition at line 106 of file kis_fixed_paint_device.cpp.

{
    return (const quint8*) m_data.constData();
}

References KisOptimizedByteArray::constData(), and m_data.

convertFromQImage()

void KisFixedPaintDevice::convertFromQImage ( const QImage & image, const QString & srcProfileName )

virtual

Fill this paint device with the data from image

Parameters

image	the image
srcProfileName	name of the RGB profile to interpret the image as. 0 is interpreted as sRGB

Definition at line 154 of file kis_fixed_paint_device.cpp.

{
    QImage image = _image;
 
    if (image.format() != QImage::Format_ARGB32) {
        image.convertTo(QImage::Format_ARGB32);
    }
    setRect(image.rect());
    lazyGrowBufferWithoutInitialization();
 
    // Don't convert if not no profile is given and both paint dev and qimage are rgba.
    if (srcProfileName.isEmpty() && colorSpace()->id() == "RGBA") {
        memcpy(data(), image.constBits(), image.sizeInBytes());
    } else {
        KoColorSpaceRegistry::instance()
            ->colorSpace( RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), srcProfileName)
            ->convertPixelsTo(image.constBits(), data(), colorSpace(), image.width() * image.height(),
                              KoColorConversionTransformation::internalRenderingIntent(),
                              KoColorConversionTransformation::internalConversionFlags());
    }
}

References colorSpace(), KoColorSpaceRegistry::colorSpace(), KoColorSpace::convertPixelsTo(), data(), KoID::id(), KoColorSpaceRegistry::instance(), Integer8BitsColorDepthID, KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), lazyGrowBufferWithoutInitialization(), RGBAColorModelID, and setRect().

convertTo()

void KisFixedPaintDevice::convertTo	(	const KoColorSpace *	dstColorSpace = 0,
		KoColorConversionTransformation::Intent	renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
		KoColorConversionTransformation::ConversionFlags	conversionFlags = KoColorConversionTransformation::internalConversionFlags() )

Converts the paint device to a different colorspace

Definition at line 116 of file kis_fixed_paint_device.cpp.

{
    if (*m_colorSpace == *dstColorSpace) {
        return;
    }
    quint32 size = m_bounds.width() * m_bounds.height();
    KisOptimizedByteArray dstData(m_data.customMemoryAllocator());
 
    // make sure that we are not initializing the destination pixels!
    dstData.resize(size * dstColorSpace->pixelSize());
 
    m_colorSpace->convertPixelsTo(constData(), (quint8*)dstData.data(),
                                  dstColorSpace,
                                  size,
                                  renderingIntent,
                                  conversionFlags);
 
    m_colorSpace = dstColorSpace;
    m_data = dstData;
}

References constData(), KoColorSpace::convertPixelsTo(), KisOptimizedByteArray::customMemoryAllocator(), KisOptimizedByteArray::data(), m_bounds, m_colorSpace, m_data, KoColorSpace::pixelSize(), and KisOptimizedByteArray::resize().

convertToQImage() [1/2]

QImage KisFixedPaintDevice::convertToQImage ( const KoColorProfile * dstProfile, KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags() ) const

virtual

Create an RGBA QImage from a rectangle in the paint device. The rectangle is defined by the parent image's bounds.

Parameters

dstProfile	RGB profile to use in conversion. May be 0, in which case it's up to the color strategy to choose a profile (most like sRGB).
renderingIntent	The rendering intent of conversion.
conversionFlags	The conversion flags.

Definition at line 176 of file kis_fixed_paint_device.cpp.

{
    qint32 x1;
    qint32 y1;
    qint32 w;
    qint32 h;
 
    x1 = m_bounds.x();
    y1 = m_bounds.y();
    w = m_bounds.width();
    h = m_bounds.height();
 
    return convertToQImage(dstProfile, x1, y1, w, h, intent, conversionFlags);
}

References convertToQImage(), and m_bounds.

convertToQImage() [2/2]

QImage KisFixedPaintDevice::convertToQImage ( const KoColorProfile * dstProfile, qint32 x, qint32 y, qint32 w, qint32 h, KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags() ) const

virtual

Create an RGBA QImage from a rectangle in the paint device.

Parameters

dstProfile	RGB profile to use in conversion. May be 0, in which case it's up to the color strategy to choose a profile (most like sRGB).
x	Left coordinate of the rectangle
y	Top coordinate of the rectangle
w	Width of the rectangle in pixels
h	Height of the rectangle in pixels
renderingIntent	Rendering intent
conversionFlags	Conversion flags

Definition at line 191 of file kis_fixed_paint_device.cpp.

{
    Q_ASSERT( m_bounds.contains(QRect(x1,y1,w,h)) );
 
    if (w < 0)
        return QImage();
 
    if (h < 0)
        return QImage();
 
    if (QRect(x1, y1, w, h) == m_bounds) {
        return colorSpace()->convertToQImage(constData(), w, h, dstProfile,
                                             intent, conversionFlags);
    } else {
        try {
            // XXX: fill the image row by row!
            const int pSize = pixelSize();
            const int deviceWidth = m_bounds.width();
            quint8* newData = new quint8[w * h * pSize];
            const quint8* srcPtr = constData() + x1 * pSize + y1 * deviceWidth * pSize;
            quint8* dstPtr = newData;
            // copy the right area out of the paint device into data
            for (int row = 0; row < h; row++) {
                memcpy(dstPtr, srcPtr, w * pSize);
                srcPtr += deviceWidth * pSize;
                dstPtr += w * pSize;
            }
            QImage image = colorSpace()->convertToQImage(newData, w, h, dstProfile, intent, conversionFlags);
            return image;
        }
        catch(const std::bad_alloc&) {
            return QImage();
        }
    }
}

References colorSpace(), constData(), KoColorSpace::convertToQImage(), m_bounds, and pixelSize().

data() [1/2]

quint8 * KisFixedPaintDevice::data

(

)

Returns

a pointer to the beginning of the data associated with this fixed paint device.

Definition at line 101 of file kis_fixed_paint_device.cpp.

{
    return (quint8*) m_data.data();
}

References KisOptimizedByteArray::data(), and m_data.

data() [2/2]

quint8 * KisFixedPaintDevice::data

(

)

const

Definition at line 111 of file kis_fixed_paint_device.cpp.

{
    return const_cast<quint8*>(m_data.constData());
}

References KisOptimizedByteArray::constData(), and m_data.

fill() [1/2]

void KisFixedPaintDevice::fill	(	const QRect &	rc,
		const KoColor &	color )

Definition at line 237 of file kis_fixed_paint_device.cpp.

{
    KoColor realColor(color);
    realColor.convertTo(colorSpace());
    fill(rc.x(), rc.y(), rc.width(), rc.height(), realColor.data());
}

References colorSpace(), KoColor::convertTo(), KoColor::data(), and fill().

fill() [2/2]

void KisFixedPaintDevice::fill	(	qint32	x,
		qint32	y,
		qint32	w,
		qint32	h,
		const quint8 *	fillPixel )

Fill the given rectangle with the given pixel. This does not take the selection into account.

XXX: this will not (yet) expand the paint device to contain the specified rect but if the paintdevice has not been initialized, it will be.

Definition at line 244 of file kis_fixed_paint_device.cpp.

{
    if (m_data.isEmpty() || m_bounds.isEmpty()) {
        setRect(QRect(x, y, w, h));
        reallocateBufferWithoutInitialization();
    }
 
    QRect rc(x, y, w, h);
    if (!m_bounds.contains(rc)) {
        rc = m_bounds;
    }
 
    quint8 pixelSize = m_colorSpace->pixelSize();
    quint8* dabPointer = data();
 
    if (rc.contains(m_bounds)) {
        for (int i = 0; i < w * h ; ++i) {
            memcpy(dabPointer, fillPixel, pixelSize);
            dabPointer += pixelSize;
        }
 
    } else {
        int deviceWidth = bounds().width();
        quint8* rowPointer = dabPointer + ((y - bounds().y()) * deviceWidth + (x - bounds().x())) * pixelSize;
        for (int row = 0; row < h; row++) {
            for (int col = 0; col < w; col++) {
                memcpy(rowPointer + col * pixelSize , fillPixel, pixelSize);
            }
            rowPointer += deviceWidth * pixelSize;
        }
    }
}

References bounds(), data(), KisOptimizedByteArray::isEmpty(), m_bounds, m_colorSpace, m_data, pixelSize(), KoColorSpace::pixelSize(), reallocateBufferWithoutInitialization(), and setRect().

initialize()

bool KisFixedPaintDevice::initialize

(

quint8

defaultValue = 0

)

initializes the paint device.

Parameters

defaultValue

the default byte with which all pixels will be filled.

Returns

false if the allocation failed.

Definition at line 76 of file kis_fixed_paint_device.cpp.

{
    m_data.fill(defaultValue, m_bounds.height() * m_bounds.width() * pixelSize());
 
    return true;
}

References KisOptimizedByteArray::fill(), m_bounds, m_data, and pixelSize().

lazyGrowBufferWithoutInitialization()

void KisFixedPaintDevice::lazyGrowBufferWithoutInitialization

(

)

If the size of the internal buffer is smaller than the one needed to accommodate bounds(), resize the buffer. Otherwise, do nothing. The allocated data is neither copying or initialized!

Definition at line 92 of file kis_fixed_paint_device.cpp.

{
    const int referenceSize = m_bounds.height() * m_bounds.width() * pixelSize();
 
    if (m_data.size() < referenceSize) {
        m_data.resize(referenceSize);
    }
}

References m_bounds, m_data, pixelSize(), KisOptimizedByteArray::resize(), and KisOptimizedByteArray::size().

mirror()

void KisFixedPaintDevice::mirror	(	bool	horizontal,
		bool	vertical )

Mirrors the device.

Definition at line 305 of file kis_fixed_paint_device.cpp.

{
    if (!horizontal && !vertical){
        return;
    }
 
    int pixelSize = m_colorSpace->pixelSize();
    int w = m_bounds.width();
    int h = m_bounds.height();
 
    if (horizontal){
        int rowSize = pixelSize * w;
 
        quint8 * dabPointer = data();
        quint8 * row = new quint8[ rowSize ];
        quint8 * mirror = 0;
 
        for (int y = 0; y < h ; y++){
            // TODO: implement better flipping of the data
 
            memcpy(row, dabPointer, rowSize);
            mirror = row;
            mirror += (w-1) * pixelSize;
            for (int x = 0; x < w; x++){
                memcpy(dabPointer,mirror,pixelSize);
                dabPointer += pixelSize;
                mirror -= pixelSize;
            }
        }
 
        delete [] row;
    }
 
    if (vertical){
        int rowsToMove = h / 2;
        int rowSize = pixelSize * w;
 
        quint8 * startRow = data();
        quint8 * endRow = data() + (h-1) * w * pixelSize;
        quint8 * row = new quint8[ rowSize ];
 
        for (int y = 0; y < rowsToMove; y++){
            memcpy(row, startRow, rowSize);
            memcpy(startRow, endRow, rowSize);
            memcpy(endRow, row, rowSize);
 
            startRow += rowSize;
            endRow -= rowSize;
        }
 
        delete [] row;
    }
 
}

References data(), m_bounds, m_colorSpace, mirror(), pixelSize(), and KoColorSpace::pixelSize().

operator=()

KisFixedPaintDevice & KisFixedPaintDevice::operator=

(

const KisFixedPaintDevice &

rhs

)

Deep copy the fixed paint device, including the data.

Definition at line 32 of file kis_fixed_paint_device.cpp.

{
    m_bounds = rhs.m_bounds;
    m_colorSpace = rhs.m_colorSpace;
 
 
    const int referenceSize = m_bounds.height() * m_bounds.width() * pixelSize();
 
    if (m_data.size() >= referenceSize) {
        memcpy(m_data.data(), rhs.m_data.constData(), referenceSize);
    } else {
        m_data = rhs.m_data;
    }
 
    return *this;
}

References KisOptimizedByteArray::constData(), KisOptimizedByteArray::data(), m_bounds, m_colorSpace, m_data, pixelSize(), and KisOptimizedByteArray::size().

pixelSize()

quint32 KisFixedPaintDevice::pixelSize

(

)

const

Returns

the pixelSize associated with this fixed paint device.

Definition at line 71 of file kis_fixed_paint_device.cpp.

{
    return m_colorSpace->pixelSize();
}

References m_colorSpace, and KoColorSpace::pixelSize().

readBytes()

void KisFixedPaintDevice::readBytes	(	quint8 *	dstData,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h ) const

Read the bytes representing the rectangle described by x, y, w, h into data. If data is not big enough, Krita will gladly overwrite the rest of your precious memory.

Since this is a copy, you need to make sure you have enough memory.

The reading is done only if the rectangular area x,y,w,h is inside the bounds of the device and the device is not empty

Definition at line 278 of file kis_fixed_paint_device.cpp.

{
    if (m_data.isEmpty() || m_bounds.isEmpty()) {
        return;
    }
 
    QRect rc(x, y, w, h);
    if (!m_bounds.contains(rc)){
        return;
    }
 
    const int pixelSize = m_colorSpace->pixelSize();
    const quint8* dabPointer = constData();
 
    if (rc == m_bounds) {
        memcpy(dstData, dabPointer, pixelSize * w * h);
    } else {
        int deviceWidth = m_bounds.width();
        const quint8* rowPointer = dabPointer + ((y - bounds().y()) * deviceWidth + (x - bounds().x())) * pixelSize;
        for (int row = 0; row < h; row++) {
            memcpy(dstData, rowPointer, w * pixelSize);
            rowPointer += deviceWidth * pixelSize;
            dstData += w * pixelSize;
        }
    }
}

References bounds(), constData(), KisOptimizedByteArray::isEmpty(), m_bounds, m_colorSpace, m_data, pixelSize(), and KoColorSpace::pixelSize().

reallocateBufferWithoutInitialization()

void KisFixedPaintDevice::reallocateBufferWithoutInitialization

(

)

Changed the size of the internal buffer to accommodate the exact number of bytes needed to store area bounds(). The allocated data is not initialized!

Definition at line 83 of file kis_fixed_paint_device.cpp.

{
    const int referenceSize = m_bounds.height() * m_bounds.width() * pixelSize();
 
    if (referenceSize != m_data.size()) {
        m_data.resize(m_bounds.height() * m_bounds.width() * pixelSize());
    }
}

References m_bounds, m_data, pixelSize(), KisOptimizedByteArray::resize(), and KisOptimizedByteArray::size().

setColorSpace()

void KisFixedPaintDevice::setColorSpace

(

const KoColorSpace *

cs

)

setColorSpace reassigns the color space of the paint device without converting or reallocating the buffer. One needs to update the buffer manually after that.

Definition at line 54 of file kis_fixed_paint_device.cpp.

{
    m_colorSpace = cs;
}

References m_colorSpace.

setProfile()

void KisFixedPaintDevice::setProfile

(

const KoColorProfile *

profile

)

Set color profile for the device without converting actual pixel data

Definition at line 139 of file kis_fixed_paint_device.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(profile);
 
    const KoColorSpace *dstColorSpace =
        KoColorSpaceRegistry::instance()->colorSpace(
                colorSpace()->colorModelId().id(),
                colorSpace()->colorDepthId().id(),
                profile);
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(dstColorSpace);
 
    m_colorSpace = dstColorSpace;
}

References colorSpace(), KoColorSpaceRegistry::colorSpace(), KoColorSpaceRegistry::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN, and m_colorSpace.

setRect()

void KisFixedPaintDevice::setRect

(

const QRect &

rc

)

setRect sets the rect of the fixed paint device to rect. This will not create the associated data area.

Parameters

rc	the bounds in pixels. The x,y of the rect represent the origin of the fixed paint device.

Definition at line 49 of file kis_fixed_paint_device.cpp.

{
    m_bounds = rc;
}

References m_bounds.

Member Data Documentation

m_bounds

QRect KisFixedPaintDevice::m_bounds

private

Definition at line 204 of file kis_fixed_paint_device.h.

m_colorSpace

const KoColorSpace* KisFixedPaintDevice::m_colorSpace

private

Definition at line 203 of file kis_fixed_paint_device.h.

m_data

KisOptimizedByteArray KisFixedPaintDevice::m_data

private

Definition at line 205 of file kis_fixed_paint_device.h.

---

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

• libs/image/kis_fixed_paint_device.h
• libs/image/kis_fixed_paint_device.cpp