KisTIFFReaderTarget< T > Class Template Reference

#include <kis_tiff_reader.h>

Inheritance diagram for KisTIFFReaderTarget< T >:

Public Types
using	type = T

Public Member Functions
uint32_t	copyDataToChannels (quint32 x, quint32 y, quint32 dataWidth, QSharedPointer< KisBufferStreamBase > tiffstream) override
	KisTIFFReaderTarget (KisPaintDeviceSP device, const std::array< quint8, 5 > &poses, int32_t alphapos, uint16_t sourceDepth, uint16_t sample_format, uint16_t nbcolorssamples, uint16_t extrasamplescount, bool premultipliedAlpha, KoColorTransformation *transformProfile, QSharedPointer< KisTIFFPostProcessor > postprocessor, T alphaValue)
Public Member Functions inherited from KisTIFFReaderBase
virtual void	finalize ()
	KisTIFFReaderBase (KisPaintDeviceSP device, const std::array< quint8, 5 > &poses, int32_t alphapos, uint16_t sourceDepth, uint16_t sample_format, uint16_t nbcolorssamples, uint16_t extrasamplescount, bool premultipliedAlpha, KoColorTransformation *transformProfile, QSharedPointer< KisTIFFPostProcessor > postprocessor)
virtual	~KisTIFFReaderBase ()=default

Private Member Functions
template<typename U = T, typename std::enable_if<!std::numeric_limits< U >::is_integer, void >::type * = nullptr>
uint32_t	_copyDataToChannels (quint32 x, quint32 y, quint32 dataWidth, QSharedPointer< KisBufferStreamBase > tiffstream)
template<typename U = T, typename std::enable_if< std::numeric_limits< U >::is_integer, void >::type * = nullptr>
uint32_t	_copyDataToChannels (quint32 x, quint32 y, quint32 dataWidth, QSharedPointer< KisBufferStreamBase > tiffstream)

Private Attributes
T	m_alphaValue

Additional Inherited Members
Protected Member Functions inherited from KisTIFFReaderBase
qint32	alphaPos () const
bool	hasPremultipliedAlpha () const
quint16	nbColorsSamples () const
quint16	nbExtraSamples () const
KisPaintDeviceSP	paintDevice () const
const std::array< quint8, 5 > &	poses () const
const KisTIFFPostProcessor *	postProcessor () const
uint16_t	sampleFormat () const
quint16	sourceDepth () const
KoColorTransformation *	transform () const

Detailed Description

template<typename T>
class KisTIFFReaderTarget< T >

Definition at line 257 of file kis_tiff_reader.h.

Member Typedef Documentation

type

template<typename T >

using KisTIFFReaderTarget< T >::type = T

Definition at line 260 of file kis_tiff_reader.h.

Constructor & Destructor Documentation

KisTIFFReaderTarget()

template<typename T >

KisTIFFReaderTarget< T >::KisTIFFReaderTarget ( KisPaintDeviceSP device, const std::array< quint8, 5 > & poses, int32_t alphapos, uint16_t sourceDepth, uint16_t sample_format, uint16_t nbcolorssamples, uint16_t extrasamplescount, bool premultipliedAlpha, KoColorTransformation * transformProfile, QSharedPointer< KisTIFFPostProcessor > postprocessor, T alphaValue )

inline

Definition at line 262 of file kis_tiff_reader.h.

        : KisTIFFReaderBase(device,
                            poses,
                            alphapos,
                            sourceDepth,
                            sample_format,
                            nbcolorssamples,
                            extrasamplescount,
                            premultipliedAlpha,
                            transformProfile,
                            postprocessor)
        , m_alphaValue(alphaValue)
    {
    }

Member Function Documentation

_copyDataToChannels() [1/2]

template<typename T >

template<typename U = T, typename std::enable_if<!std::numeric_limits< U >::is_integer, void >::type * = nullptr>

uint32_t KisTIFFReaderTarget< T >::_copyDataToChannels ( quint32 x, quint32 y, quint32 dataWidth, QSharedPointer< KisBufferStreamBase > tiffstream )

inlineprivate

Definition at line 300 of file kis_tiff_reader.h.

    {
        KisHLineIteratorSP it = this->paintDevice()->createHLineIteratorNG(x, y, dataWidth);
        do {
            T *d = reinterpret_cast<T *>(it->rawData());
            quint8 i = 0;
            for (i = 0; i < this->nbColorsSamples(); i++) {
                // XXX: for half this should use the bit constructor (plus downcast to uint16_t) (same as in the rest accesses)
                const uint32_t v = tiffstream->nextValue();
                std::memcpy(&d[this->poses()[i]], &v, sizeof(T));
            }
            this->postProcessor()->postProcess(d);
            if (this->transform()) {
                this->transform()->transform(reinterpret_cast<quint8 *>(d), reinterpret_cast<quint8 *>(d), 1);
            }
            d[this->poses()[i]] = m_alphaValue;
            for (quint8 k = 0; k < this->nbExtraSamples(); k++) {
                if (k == this->alphaPos()) {
                    const uint32_t v = tiffstream->nextValue();
                    std::memcpy(&d[this->poses()[i]], &v, sizeof(T));
                } else {
                    (void)tiffstream->nextValue();
                }
            }
 
            if (this->hasPremultipliedAlpha()) {
                auto unmultipliedColorsConsistent = [this, i](T *d) { return !(std::abs(d[this->poses()[i]]) < std::numeric_limits<T>::epsilon()); };
 
                auto checkUnmultipliedColorsConsistent = [this, i](const T *d) {
                    const T alpha = std::abs(d[this->poses()[i]]);
 
                    if (alpha >= static_cast<T>(0.01)) {
                        return true;
                    } else {
                        for (size_t i = 0; i < this->nbColorsSamples(); i++) {
                            if (!qFuzzyCompare(T(d[i] * alpha), d[i])) {
                                return false;
                            }
                        }
                        return true;
                    }
                };
 
                if (!unmultipliedColorsConsistent(d)) {
                    while (true) {
                        T newAlpha = d[this->poses()[i]];
 
                        for (quint8 i = 0; i < this->nbColorsSamples(); i++) {
                            d[i] = std::lroundf(d[i] * newAlpha);
                        }
 
                        d[this->poses()[i]] = newAlpha;
 
                        if (checkUnmultipliedColorsConsistent(d)) {
                            break;
                        }
 
                        newAlpha += std::numeric_limits<T>::epsilon();
                    }
                } else {
                    const T alpha = d[this->poses()[i]];
                    for (quint8 i = 0; i < this->nbColorsSamples(); i++) {
                        d[i] = std::lroundf(d[i] * alpha);
                    }
                }
            }
        } while (it->nextPixel());
        return 1;
    }

References KisTIFFReaderBase::alphaPos(), KisPaintDevice::createHLineIteratorNG(), KisTIFFReaderBase::hasPremultipliedAlpha(), KisTIFFReaderTarget< T >::m_alphaValue, KisTIFFReaderBase::nbColorsSamples(), KisTIFFReaderBase::nbExtraSamples(), KisTIFFReaderBase::paintDevice(), KisTIFFReaderBase::poses(), KisTIFFPostProcessor::postProcess(), KisTIFFReaderBase::postProcessor(), qFuzzyCompare(), KisTIFFReaderBase::transform(), KoColorTransformation::transform(), v, and void().

_copyDataToChannels() [2/2]

template<typename T >

template<typename U = T, typename std::enable_if< std::numeric_limits< U >::is_integer, void >::type * = nullptr>

uint32_t KisTIFFReaderTarget< T >::_copyDataToChannels ( quint32 x, quint32 y, quint32 dataWidth, QSharedPointer< KisBufferStreamBase > tiffstream )

inlineprivate

Definition at line 376 of file kis_tiff_reader.h.

    {
        KisHLineIteratorSP it = this->paintDevice()->createHLineIteratorNG(x, y, dataWidth);
        const double coeff = std::numeric_limits<T>::max() / static_cast<double>(std::pow(2.0, this->sourceDepth()) - 1);
        const bool no_coeff = !std::is_same<T, uint8_t>::value && this->sourceDepth() == sizeof(T) * CHAR_BIT;
        //    dbgFile <<" depth expansion coefficient :" << coeff;
        do {
            T *d = reinterpret_cast<T *>(it->rawData());
            quint8 i;
            for (i = 0; i < this->nbColorsSamples(); i++) {
                if (sampleFormat() == SAMPLEFORMAT_INT) {
                    T value;
                    const typename std::make_signed<T>::type v =
                        static_cast<typename std::make_signed<T>::type>(
                            tiffstream->nextValue());
                    value = v + (std::numeric_limits<T>::max() / 2) + 1;
                    if (no_coeff) {
                        d[this->poses()[i]] = static_cast<T>(value);
                    } else {
                        d[this->poses()[i]] = static_cast<T>(value * coeff);
                    }
                } else {
                    if (no_coeff) {
                        d[this->poses()[i]] = static_cast<T>(tiffstream->nextValue());
                    } else {
                        d[this->poses()[i]] = static_cast<T>(tiffstream->nextValue() * coeff);
                    }
                }
            }
            this->postProcessor()->postProcess(d);
            if (this->transform()) {
                this->transform()->transform(reinterpret_cast<quint8 *>(d), reinterpret_cast<quint8 *>(d), 1);
            }
            d[this->poses()[i]] = m_alphaValue;
            for (quint8 k = 0; k < this->nbExtraSamples(); k++) {
                if (k == this->alphaPos()) {
                    if (sampleFormat() == SAMPLEFORMAT_INT) {
                        T value;
                        const typename std::make_signed<T>::type v =
                            static_cast<typename std::make_signed<T>::type>(
                                tiffstream->nextValue());
                        value = v + (std::numeric_limits<T>::max() / 2) + 1;
                        if (no_coeff) {
                            d[this->poses()[i]] = static_cast<T>(value);
                        } else {
                            d[this->poses()[i]] = static_cast<T>(value * coeff);
                        }
                    } else {
                        if (no_coeff) {
                            d[this->poses()[i]] = static_cast<T>(tiffstream->nextValue());
                        } else {
                            d[this->poses()[i]] = static_cast<T>(tiffstream->nextValue() * coeff);
                        }
                    }
                } else {
                    tiffstream->nextValue();
                }
            }
 
            if (hasPremultipliedAlpha()) {
                const T alpha = d[poses()[i]];
                const float factor = alpha == 0 ? 0 : static_cast<float>(std::numeric_limits<T>::max()) / alpha;
 
                for (quint8 i = 0; i < nbColorsSamples(); i++) {
                    d[i] = std::lroundf(d[i] * factor);
                }
            }
        } while (it->nextPixel());
        return 1;
    }

References KisTIFFReaderBase::alphaPos(), KisPaintDevice::createHLineIteratorNG(), KisTIFFReaderBase::hasPremultipliedAlpha(), KisTIFFReaderTarget< T >::m_alphaValue, KisTIFFReaderBase::nbColorsSamples(), KisTIFFReaderBase::nbExtraSamples(), KisTIFFReaderBase::paintDevice(), KisTIFFReaderBase::poses(), KisTIFFPostProcessor::postProcess(), KisTIFFReaderBase::postProcessor(), KisTIFFReaderBase::sampleFormat(), KisTIFFReaderBase::sourceDepth(), KisTIFFReaderBase::transform(), KoColorTransformation::transform(), v, and value().

copyDataToChannels()

template<typename T >

uint32_t KisTIFFReaderTarget< T >::copyDataToChannels ( quint32 x, quint32 y, quint32 dataWidth, QSharedPointer< KisBufferStreamBase > tiffstream )

inlineoverridevirtual

This function copy data from the tiff stream to the paint device starting at the given position.

Parameters

x	horizontal start position
y	vertical start position
dataWidth	width of the data to copy
tiffstream	source of data

Returns

the number of line which were copied

Implements KisTIFFReaderBase.

Definition at line 288 of file kis_tiff_reader.h.

    {
        return _copyDataToChannels(x, y, dataWidth, tiffstream);
    }

References KisTIFFReaderTarget< T >::_copyDataToChannels().

Member Data Documentation

m_alphaValue

template<typename T >

T KisTIFFReaderTarget< T >::m_alphaValue

private

Definition at line 451 of file kis_tiff_reader.h.

---

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

• plugins/impex/tiff/kis_tiff_reader.h