EXRConverter::Private Struct Reference

Public Member Functions
bool	checkExtraLayersInfoConsistent (const QDomDocument &doc, std::set< std::string > exrLayerNames)
template<typename _T_ >
void	decodeData1 (Imf::InputFile &file, ExrPaintLayerInfo &info, KisPaintLayerSP layer, int width, int xstart, int ystart, int height, Imf::PixelType ptype)
template<typename _T_ >
void	decodeData4 (Imf::InputFile &file, ExrPaintLayerInfo &info, KisPaintLayerSP layer, int width, int xstart, int ystart, int height, Imf::PixelType ptype)
QString	fetchExtraLayersInfo (QList< ExrPaintLayerSaveInfo > &informationObjects)
QDomDocument	loadExtraLayersInfo (const Imf::Header &header)
void	makeLayerNamesUnique (QList< ExrPaintLayerSaveInfo > &informationObjects)
	Private ()
void	recBuildPaintLayerSaveInfo (QList< ExrPaintLayerSaveInfo > &informationObjects, const QString &name, KisGroupLayerSP parent)
void	reportLayersNotSaved (const QSet< KisNodeSP > &layersNotSaved)
template<class WrapperType >
void	unmultiplyAlpha (typename WrapperType::pixel_type *pixel)

Public Attributes
bool	alphaWasModified
KisDocument *	doc
QString	errorMessage
KisImageSP	image
bool	showNotifications

Detailed Description

Definition at line 126 of file exr_converter.cc.

Constructor & Destructor Documentation

Private()

EXRConverter::Private::Private ( )

inline

Definition at line 127 of file exr_converter.cc.

        : doc(0)
        , alphaWasModified(false)
        , showNotifications(false)
    {}

Member Function Documentation

checkExtraLayersInfoConsistent()

bool EXRConverter::Private::checkExtraLayersInfoConsistent	(	const QDomDocument &	doc,
		std::set< std::string >	exrLayerNames )

Definition at line 528 of file exr_converter.cc.

{
    std::set<std::string> extraInfoLayers;
 
    QDomElement root = doc.documentElement();
 
    KIS_ASSERT_RECOVER(!root.isNull() && root.hasChildNodes()) { return false; };
 
    QDomElement el = root.firstChildElement();
 
    while(!el.isNull()) {
        KIS_ASSERT_RECOVER(el.hasAttribute(EXR_NAME)) { return false; };
        QString layerName = el.attribute(EXR_NAME).toUtf8();
        if (layerName != QString(HDR_LAYER)) {
            extraInfoLayers.insert(el.attribute(EXR_NAME).toUtf8().constData());
        }
        el = el.nextSiblingElement();
    }
 
    bool result = (extraInfoLayers == exrLayerNames);
 
    if (!result) {
        dbgKrita << "WARNING: Krita EXR extra layers info is inconsistent!";
        dbgKrita << ppVar(extraInfoLayers.size()) << ppVar(exrLayerNames.size());
 
        std::set<std::string>::const_iterator it1 = extraInfoLayers.begin();
        std::set<std::string>::const_iterator it2 = exrLayerNames.begin();
 
        std::set<std::string>::const_iterator end1 = extraInfoLayers.end();
 
        for (; it1 != end1; ++it1, ++it2) {
            dbgKrita << it1->c_str() << it2->c_str();
        }
 
    }
 
    return result;
}

References dbgKrita, EXR_NAME, HDR_LAYER, KIS_ASSERT_RECOVER, and ppVar.

decodeData1()

template<typename _T_ >

void EXRConverter::Private::decodeData1	(	Imf::InputFile &	file,
		ExrPaintLayerInfo &	info,
		KisPaintLayerSP	layer,
		int	width,
		int	xstart,
		int	ystart,
		int	height,
		Imf::PixelType	ptype )

Definition at line 434 of file exr_converter.cc.

{
    typedef typename GrayPixelWrapper<_T_>::channel_type channel_type;
    typedef typename GrayPixelWrapper<_T_>::pixel_type pixel_type;
 
    KIS_ASSERT_RECOVER_RETURN(
                layer->paintDevice()->colorSpace()->colorModelId() == GrayAColorModelID);
 
    QVector<pixel_type> pixels(width * height);
 
    Q_ASSERT(info.channelMap.contains("Y"));
    dbgFile << "Gray -> " << info.channelMap["Y"];
 
    bool hasAlpha = info.channelMap.contains("A");
    dbgFile << "Has Alpha:" << hasAlpha;
 
 
    Imf::FrameBuffer frameBuffer;
    pixel_type* frameBufferData = (pixels.data()) - xstart - ystart * width;
    frameBuffer.insert(
        info.channelMap["Y"].toLatin1().constData(),
        Imf::Slice(ptype, (char *)&frameBufferData->gray, sizeof(pixel_type) * 1, sizeof(pixel_type) * width));
 
    if (hasAlpha) {
        frameBuffer.insert(info.channelMap["A"].toLatin1().constData(),
                Imf::Slice(ptype, (char *) &frameBufferData->alpha,
                           sizeof(pixel_type) * 1,
                           sizeof(pixel_type) * width));
    }
 
    file.setFrameBuffer(frameBuffer);
    file.readPixels(ystart, height + ystart - 1);
 
    pixel_type *srcPtr = pixels.data();
 
    QRect paintRegion(xstart, ystart, width, height);
    KisSequentialIterator it(layer->paintDevice(), paintRegion);
    while (it.nextPixel()) {
        if (hasAlpha) {
            unmultiplyAlpha<GrayPixelWrapper<_T_> >(srcPtr);
        }
 
        pixel_type* dstPtr = reinterpret_cast<pixel_type*>(it.rawData());
 
        dstPtr->gray = srcPtr->gray;
        dstPtr->alpha = hasAlpha ? srcPtr->alpha : channel_type(1.0);
 
        ++srcPtr;
    } ;
}

References ExrPaintLayerInfo::channelMap, KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), dbgFile, GrayAColorModelID, KIS_ASSERT_RECOVER_RETURN, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisPaintLayer::paintDevice, and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData().

decodeData4()

template<typename _T_ >

void EXRConverter::Private::decodeData4	(	Imf::InputFile &	file,
		ExrPaintLayerInfo &	info,
		KisPaintLayerSP	layer,
		int	width,
		int	xstart,
		int	ystart,
		int	height,
		Imf::PixelType	ptype )

Definition at line 378 of file exr_converter.cc.

{
    typedef Rgba<_T_> Rgba;
 
    QVector<Rgba> pixels(width * height);
 
    bool hasAlpha = info.channelMap.contains("A");
 
    Imf::FrameBuffer frameBuffer;
    Rgba* frameBufferData = (pixels.data()) - xstart - ystart * width;
    frameBuffer.insert(info.channelMap["R"].toLatin1().constData(),
            Imf::Slice(ptype, (char *) &frameBufferData->r,
                       sizeof(Rgba) * 1,
                       sizeof(Rgba) * width));
    frameBuffer.insert(info.channelMap["G"].toLatin1().constData(),
            Imf::Slice(ptype, (char *) &frameBufferData->g,
                       sizeof(Rgba) * 1,
                       sizeof(Rgba) * width));
    frameBuffer.insert(info.channelMap["B"].toLatin1().constData(),
            Imf::Slice(ptype, (char *) &frameBufferData->b,
                       sizeof(Rgba) * 1,
                       sizeof(Rgba) * width));
    if (hasAlpha) {
        frameBuffer.insert(info.channelMap["A"].toLatin1().constData(),
                Imf::Slice(ptype, (char *) &frameBufferData->a,
                           sizeof(Rgba) * 1,
                           sizeof(Rgba) * width));
    }
 
    file.setFrameBuffer(frameBuffer);
    file.readPixels(ystart, height + ystart - 1);
    Rgba *rgba = pixels.data();
 
    QRect paintRegion(xstart, ystart, width, height);
    KisSequentialIterator it(layer->paintDevice(), paintRegion);
    while (it.nextPixel()) {
        if (hasAlpha) {
            unmultiplyAlpha<RgbPixelWrapper<_T_> >(rgba);
        }
 
        typename KoRgbTraits<_T_>::Pixel* dst = reinterpret_cast<typename KoRgbTraits<_T_>::Pixel*>(it.rawData());
 
        dst->red = rgba->r;
        dst->green = rgba->g;
        dst->blue = rgba->b;
        if (hasAlpha) {
            dst->alpha = rgba->a;
        } else {
            dst->alpha = 1.0;
        }
 
        ++rgba;
    }
}

References Rgba< _T_ >::a, KoRgbTraits< _channels_type_ >::Pixel::alpha, Rgba< _T_ >::b, KoRgbTraits< _channels_type_ >::Pixel::blue, ExrPaintLayerInfo::channelMap, Rgba< _T_ >::g, KoRgbTraits< _channels_type_ >::Pixel::green, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisPaintLayer::paintDevice, Rgba< _T_ >::r, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KoRgbTraits< _channels_type_ >::Pixel::red.

fetchExtraLayersInfo()

QString EXRConverter::Private::fetchExtraLayersInfo

(

QList< ExrPaintLayerSaveInfo > &

informationObjects

)

Definition at line 1365 of file exr_converter.cc.

{
    KIS_ASSERT_RECOVER_NOOP(!informationObjects.isEmpty());
 
    if (informationObjects.size() == 1 && informationObjects[0].name == QString(HDR_LAYER) + ".") {
        return QString();
    }
 
    QDomDocument doc("krita-extra-layers-info");
    doc.appendChild(doc.createElement("root"));
    QDomElement rootElement = doc.documentElement();
 
    for (int i = 0; i < informationObjects.size(); i++) {
        ExrPaintLayerSaveInfo &info = informationObjects[i];
        quint32 unused;
        KisSaveXmlVisitor visitor(doc, rootElement, unused, QString(), false);
 
        // EXR data is saved without the offset, saving code uses normal iterators
        // that don't know about the layer offset, hence passing `false` for saving
        // the offsets
        QDomElement el = visitor.savePaintLayerAttributes(info.layer.data(), doc, false);
 
        // cut the ending '.'
        QString strippedName = info.name.left(info.name.size() - 1);
 
        el.setAttribute(EXR_NAME, strippedName);
 
        rootElement.appendChild(el);
    }
 
    return doc.toString();
}

References KisSharedPtr< T >::data(), EXR_NAME, HDR_LAYER, KIS_ASSERT_RECOVER_NOOP, ExrPaintLayerSaveInfo::layer, ExrPaintLayerSaveInfo::name, and KisSaveXmlVisitor::savePaintLayerAttributes().

loadExtraLayersInfo()

QDomDocument EXRConverter::Private::loadExtraLayersInfo

(

const Imf::Header &

header

)

Definition at line 513 of file exr_converter.cc.

{
    const Imf::StringAttribute *layersInfoAttribute =
            header.findTypedAttribute<Imf::StringAttribute>(EXR_KRITA_LAYERS);
 
    if (!layersInfoAttribute) return QDomDocument();
 
    QString layersInfoString = QString::fromUtf8(layersInfoAttribute->value().c_str());
 
    QDomDocument doc;
    doc.setContent(layersInfoString);
 
    return doc;
}

References EXR_KRITA_LAYERS.

makeLayerNamesUnique()

void EXRConverter::Private::makeLayerNamesUnique

(

QList< ExrPaintLayerSaveInfo > &

informationObjects

)

Definition at line 1212 of file exr_converter.cc.

{
    typedef QMultiMap<QString, QList<ExrPaintLayerSaveInfo>::iterator> NamesMap;
    NamesMap namesMap;
 
    {
        QList<ExrPaintLayerSaveInfo>::iterator it = informationObjects.begin();
        QList<ExrPaintLayerSaveInfo>::iterator end = informationObjects.end();
 
        for (; it != end; ++it) {
            namesMap.insert(it->name, it);
        }
    }
 
    Q_FOREACH (const QString &key, namesMap.keys()) {
        if (namesMap.count(key) > 1) {
            KIS_ASSERT_RECOVER(key.endsWith(".")) { continue; }
            QString strippedName = key.left(key.size() - 1); // trim the ending dot
            int nameCounter = 0;
 
            NamesMap::iterator it = namesMap.find(key);
            NamesMap::iterator end = namesMap.end();
 
            for (; it != end; ++it) {
                QString newName =
                        QString("%1_%2.")
                        .arg(strippedName)
                        .arg(nameCounter++);
 
                it.value()->name = newName;
 
                QList<QString>::iterator channelsIt = it.value()->channels.begin();
                QList<QString>::iterator channelsEnd = it.value()->channels.end();
 
                for  (; channelsIt != channelsEnd; ++channelsIt) {
                    channelsIt->replace(key, newName);
                }
            }
        }
    }
 
}

References KIS_ASSERT_RECOVER.

recBuildPaintLayerSaveInfo()

void EXRConverter::Private::recBuildPaintLayerSaveInfo	(	QList< ExrPaintLayerSaveInfo > &	informationObjects,
		const QString &	name,
		KisGroupLayerSP	parent )

The EXR can store paint and group layers only. The rest will go to /dev/null :(

Definition at line 1255 of file exr_converter.cc.

{
    QSet<KisNodeSP> layersNotSaved;
 
    for (uint i = 0; i < parent->childCount(); ++i) {
        KisNodeSP node = parent->at(i);
 
        if (KisPaintLayerSP paintLayer = dynamic_cast<KisPaintLayer*>(node.data())) {
            QMap<QString, QString> current2original;
 
            if (paintLayer->metaData()->containsEntry(KisMetaData::SchemaRegistry::instance()->create("http://krita.org/exrchannels/1.0/" , "exrchannels"), "channelsmap")) {
 
                const KisMetaData::Entry& entry = paintLayer->metaData()->getEntry(KisMetaData::SchemaRegistry::instance()->create("http://krita.org/exrchannels/1.0/" , "exrchannels"), "channelsmap");
                QList< KisMetaData::Value> values = entry.value().asArray();
 
                Q_FOREACH (const KisMetaData::Value& value, values) {
                    QMap<QString, KisMetaData::Value> map = value.asStructure();
                    if (map.contains("original") && map.contains("current")) {
                        current2original[map["current"].toString()] = map["original"].toString();
                    }
                }
 
            }
 
            ExrPaintLayerSaveInfo info;
            info.name = name + paintLayer->name() + '.';
            info.layer = paintLayer;
            info.layerDevice = wrapLayerDevice(paintLayer->paintDevice());
 
            if (info.name == QString(HDR_LAYER) + ".") {
                info.channels.push_back("R");
                info.channels.push_back("G");
                info.channels.push_back("B");
                info.channels.push_back("A");
            }
            else {
 
                if (info.layerDevice->colorSpace()->colorModelId() == RGBAColorModelID) {
                    info.channels.push_back(info.name + remap(current2original, "R"));
                    info.channels.push_back(info.name + remap(current2original, "G"));
                    info.channels.push_back(info.name + remap(current2original, "B"));
                    info.channels.push_back(info.name + remap(current2original, "A"));
                }
                else if (info.layerDevice->colorSpace()->colorModelId() == GrayAColorModelID) {
                    info.channels.push_back(info.name + remap(current2original, "Y"));
                    info.channels.push_back(info.name + remap(current2original, "A"));
                } else if (info.layerDevice->colorSpace()->colorModelId() == XYZAColorModelID) {
                    info.channels.push_back(info.name + remap(current2original, "X"));
                    info.channels.push_back(info.name + remap(current2original, "Y"));
                    info.channels.push_back(info.name + remap(current2original, "Z"));
                    info.channels.push_back(info.name + remap(current2original, "A"));
                }
            }
 
            if (info.layerDevice->colorSpace()->colorDepthId() == Float16BitsColorDepthID) {
                info.pixelType = Imf::HALF;
            }
            else if (info.layerDevice->colorSpace()->colorDepthId() == Float32BitsColorDepthID) {
                info.pixelType = Imf::FLOAT;
            }
            else {
                info.pixelType = Imf::NUM_PIXELTYPES;
            }
 
            if (info.pixelType < Imf::NUM_PIXELTYPES) {
                dbgFile << "Going to save layer" << info.name;
                informationObjects.push_back(info);
            }
            else {
                warnFile << "Will not save layer" << info.name;
                layersNotSaved << node;
            }
 
        }
        else if (KisGroupLayerSP groupLayer = dynamic_cast<KisGroupLayer*>(node.data())) {
            recBuildPaintLayerSaveInfo(informationObjects, name + groupLayer->name() + '.', groupLayer);
        }
        else {
            layersNotSaved.insert(node);
        }
    }
 
    if (!layersNotSaved.isEmpty()) {
        reportLayersNotSaved(layersNotSaved);
    }
}

References KisMetaData::Value::asArray(), ExrPaintLayerSaveInfo::channels, KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), KisMetaData::SchemaRegistry::create(), KisSharedPtr< T >::data(), dbgFile, Float16BitsColorDepthID, Float32BitsColorDepthID, GrayAColorModelID, HDR_LAYER, KisMetaData::SchemaRegistry::instance(), ExrPaintLayerSaveInfo::layer, ExrPaintLayerSaveInfo::layerDevice, ExrPaintLayerSaveInfo::name, ExrPaintLayerSaveInfo::pixelType, remap(), RGBAColorModelID, KisMetaData::Entry::value(), value(), warnFile, wrapLayerDevice(), and XYZAColorModelID.

reportLayersNotSaved()

void EXRConverter::Private::reportLayersNotSaved

(

const QSet< KisNodeSP > &

layersNotSaved

)

Definition at line 1346 of file exr_converter.cc.

{
    QString layersList;
    QTextStream textStream(&layersList);
    KisPortingUtils::setUtf8OnStream(textStream);
 
    Q_FOREACH (KisNodeSP node, layersNotSaved) {
        textStream << "<li>" << i18nc("@item:unsupported-node-message", "%1 (type: \"%2\")", node->name(), node->metaObject()->className()) << "</li>";
    }
 
    QString msg =
            i18nc("@info",
                  "<p>The following layers have a type that is not supported by EXR format:</p>"
                  "<r><ul>%1</ul></p>"
                  "<p><warning>these layers have <b>not</b> been saved to the final EXR file</warning></p>", layersList);
 
    errorMessage = msg;
}

References EXRConverter::errorMessage(), KisBaseNode::name(), and KisPortingUtils::setUtf8OnStream().

unmultiplyAlpha()

template<class WrapperType >

void EXRConverter::Private::unmultiplyAlpha

(

typename WrapperType::pixel_type *

pixel

)

Division by a tiny alpha may result in an overflow of half value. That is why we use safe iterative approach.

Definition at line 318 of file exr_converter.cc.

{
    typedef typename WrapperType::pixel_type pixel_type;
    typedef typename WrapperType::channel_type channel_type;
 
    WrapperType srcPixel(*pixel);
 
    if (!srcPixel.checkMultipliedColorsConsistent()) {
 
        channel_type newAlpha = srcPixel.alpha();
 
        pixel_type __dstPixelData;
        WrapperType dstPixel(__dstPixelData);
 
        while (1) {
            dstPixel.setUnmultiplied(srcPixel.pixel, newAlpha);
 
            if (dstPixel.checkUnmultipliedColorsConsistent(srcPixel.pixel)) {
                break;
            }
 
            newAlpha += alphaEpsilon<channel_type>();
            alphaWasModified = true;
        }
 
        *pixel = dstPixel.pixel;
 
 
    } else if (srcPixel.alpha() > 0.0) {
        srcPixel.setUnmultiplied(srcPixel.pixel, srcPixel.alpha());
    }
}

References alphaWasModified.

Member Data Documentation

alphaWasModified

bool EXRConverter::Private::alphaWasModified

Definition at line 136 of file exr_converter.cc.

doc

KisDocument* EXRConverter::Private::doc

Definition at line 134 of file exr_converter.cc.

errorMessage

QString EXRConverter::Private::errorMessage

Definition at line 139 of file exr_converter.cc.

image

KisImageSP EXRConverter::Private::image

Definition at line 133 of file exr_converter.cc.

showNotifications

bool EXRConverter::Private::showNotifications

Definition at line 137 of file exr_converter.cc.

---

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

• plugins/impex/exr/exr_converter.cc