EXRConverter Class Reference

#include <exr_converter.h>

Inheritance diagram for EXRConverter:

Classes
struct	Private

Public Slots
virtual void	cancel ()

Public Member Functions
KisImportExportErrorCode	buildFile (const QString &filename, KisGroupLayerSP layer, bool flatten=false)
KisImportExportErrorCode	buildFile (const QString &filename, KisPaintLayerSP layer)
KisImportExportErrorCode	buildImage (const QString &filename)
QString	errorMessage () const
	EXRConverter (KisDocument *doc, bool showNotifications)
KisImageSP	image ()
	~EXRConverter () override

Private Member Functions
KisImportExportErrorCode	decode (const QString &filename)

Private Attributes
const QScopedPointer< Private >	d

Detailed Description

Definition at line 19 of file exr_converter.h.

Constructor & Destructor Documentation

EXRConverter()

EXRConverter::EXRConverter	(	KisDocument *	doc,
		bool	showNotifications )

Definition at line 159 of file exr_converter.cc.

    : d(new Private)
{
    d->doc = doc;
    d->showNotifications = showNotifications;
 
    // Set thread count for IlmImf library
    Imf::setGlobalThreadCount(QThread::idealThreadCount());
    dbgFile << "EXR Threadcount was set to: " << QThread::idealThreadCount();
}

References d, and dbgFile.

~EXRConverter()

EXRConverter::~EXRConverter ( )

override

Definition at line 170 of file exr_converter.cc.

{
}

Member Function Documentation

buildFile() [1/2]

KisImportExportErrorCode EXRConverter::buildFile	(	const QString &	filename,
		KisGroupLayerSP	layer,
		bool	flatten = false )

Definition at line 1398 of file exr_converter.cc.

{
    KIS_ASSERT_RECOVER_RETURN_VALUE(layer, ImportExportCodes::InternalError);
 
    KisImageSP image = layer->image();
    KIS_ASSERT_RECOVER_RETURN_VALUE(image, ImportExportCodes::InternalError);
 
    qint32 height = image->height();
    qint32 width = image->width();
    Imf::Header header(width, height);
 
    if (flatten) {
        KisPaintDeviceSP pd = new KisPaintDevice(*image->projection());
        KisPaintLayerSP l = new KisPaintLayer(image, "projection", OPACITY_OPAQUE_U8, pd);
        return buildFile(filename, l);
    }
    else {
        QList<ExrPaintLayerSaveInfo> informationObjects;
        d->recBuildPaintLayerSaveInfo(informationObjects, "", layer);
 
        if(informationObjects.isEmpty()) {
            return ImportExportCodes::FormatColorSpaceUnsupported;
        }
        d->makeLayerNamesUnique(informationObjects);
 
        QByteArray extraLayersInfo = d->fetchExtraLayersInfo(informationObjects).toUtf8();
        if (!extraLayersInfo.isNull()) {
            header.insert(EXR_KRITA_LAYERS, Imf::StringAttribute(extraLayersInfo.constData()));
        }
        dbgFile << informationObjects.size() << " layers to save";
        Q_FOREACH (const ExrPaintLayerSaveInfo& info, informationObjects) {
            if (info.pixelType < Imf::NUM_PIXELTYPES) {
                Q_FOREACH (const QString& channel, info.channels) {
                    dbgFile << channel << " " << info.pixelType;
                    header.channels().insert(channel.toUtf8().data(), Imf::Channel(info.pixelType));
                }
            }
        }
 
        // Open file for writing
        try {
            Imf::OutputFile file(filename.toUtf8(), header);
            encodeData(file, informationObjects, width, height);
            return ImportExportCodes::OK;
        } catch(std::exception &e) {
            dbgFile << "Exception while writing to exr file: " << e.what();
            if (!KisImportExportAdditionalChecks::isFileWritable(filename.toUtf8())) {
                return ImportExportCodes::NoAccessToWrite;
            }
            return ImportExportCodes::ErrorWhileWriting;
        }
 
    }
}

References buildFile(), ExrPaintLayerSaveInfo::channels, d, dbgFile, encodeData(), ImportExportCodes::ErrorWhileWriting, EXR_KRITA_LAYERS, ImportExportCodes::FormatColorSpaceUnsupported, KisImage::height(), KisBaseNode::image, image(), ImportExportCodes::InternalError, KisImportExportAdditionalChecks::isFileWritable(), KIS_ASSERT_RECOVER_RETURN_VALUE, ImportExportCodes::NoAccessToWrite, ImportExportCodes::OK, OPACITY_OPAQUE_U8, ExrPaintLayerSaveInfo::pixelType, KisImage::projection(), and KisImage::width().

buildFile() [2/2]

KisImportExportErrorCode EXRConverter::buildFile	(	const QString &	filename,
		KisPaintLayerSP	layer )

Definition at line 1131 of file exr_converter.cc.

{
    KIS_ASSERT_RECOVER_RETURN_VALUE(layer, ImportExportCodes::InternalError);
 
    KisImageSP image = layer->image();
    KIS_ASSERT_RECOVER_RETURN_VALUE(image, ImportExportCodes::InternalError);
 
 
    // Make the header
    qint32 height = image->height();
    qint32 width = image->width();
    Imf::Header header(width, height);
 
    ExrPaintLayerSaveInfo info;
    info.layer = layer;
    info.layerDevice = wrapLayerDevice(layer->paintDevice());
    Imf::PixelType pixelType = Imf::NUM_PIXELTYPES;
    if (info.layerDevice->colorSpace()->colorDepthId() == Float16BitsColorDepthID) {
        pixelType = Imf::HALF;
    }
    else if (info.layerDevice->colorSpace()->colorDepthId() == Float32BitsColorDepthID) {
        pixelType = Imf::FLOAT;
    }
 
    info.pixelType = pixelType;
 
    if (info.layerDevice->colorSpace()->colorModelId() == RGBAColorModelID) {
        header.channels().insert("R", Imf::Channel(pixelType));
        header.channels().insert("G", Imf::Channel(pixelType));
        header.channels().insert("B", Imf::Channel(pixelType));
        header.channels().insert("A", Imf::Channel(pixelType));
 
        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() == GrayAColorModelID) {
        header.channels().insert("Y", Imf::Channel(pixelType));
        header.channels().insert("A", Imf::Channel(pixelType));
 
        info.channels.push_back("Y");
        info.channels.push_back("A");
    } else if (info.layerDevice->colorSpace()->colorModelId() == XYZAColorModelID) {
        header.channels().insert("X", Imf::Channel(pixelType));
        header.channels().insert("Y", Imf::Channel(pixelType));
        header.channels().insert("Z", Imf::Channel(pixelType));
        header.channels().insert("A", Imf::Channel(pixelType));
 
        info.channels.push_back("X");
        info.channels.push_back("Y");
        info.channels.push_back("Z");
        info.channels.push_back("A");
    }
 
    // Open file for writing
    try {
        Imf::OutputFile file(filename.toUtf8(), header);
 
        QList<ExrPaintLayerSaveInfo> informationObjects;
        informationObjects.push_back(info);
        encodeData(file, informationObjects, width, height);
        return ImportExportCodes::OK;
 
    } catch(std::exception &e) {
        dbgFile << "Exception while writing to exr file: " << e.what();
        if (!KisImportExportAdditionalChecks::isFileWritable(filename)) {
            return ImportExportCodes::NoAccessToWrite;
        }
        return ImportExportCodes::ErrorWhileWriting;
    }
 
}

References ExrPaintLayerSaveInfo::channels, KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), dbgFile, encodeData(), ImportExportCodes::ErrorWhileWriting, Float16BitsColorDepthID, Float32BitsColorDepthID, GrayAColorModelID, KisImage::height(), KisBaseNode::image, image(), ImportExportCodes::InternalError, KisImportExportAdditionalChecks::isFileWritable(), KIS_ASSERT_RECOVER_RETURN_VALUE, ExrPaintLayerSaveInfo::layer, ExrPaintLayerSaveInfo::layerDevice, ImportExportCodes::NoAccessToWrite, ImportExportCodes::OK, KisPaintLayer::paintDevice, ExrPaintLayerSaveInfo::pixelType, RGBAColorModelID, KisImage::width(), wrapLayerDevice(), and XYZAColorModelID.

buildImage()

KisImportExportErrorCode EXRConverter::buildImage

(

const QString &

filename

)

Definition at line 954 of file exr_converter.cc.

{
    return decode(filename);
 
}

References decode().

cancel

void EXRConverter::cancel ( )

virtualslot

Definition at line 1453 of file exr_converter.cc.

{
    warnKrita << "WARNING: Cancelling of an EXR loading is not supported!";
}

References warnKrita.

decode()

KisImportExportErrorCode EXRConverter::decode ( const QString & filename )

private

EXR semi-transparent images are expected to be rendered on black to ensure correctness of the light model

NOTE: We cannot do that automatically, because the EXR may be imported into the image as a layer, in which case the default color will create major issues. See https://bugs.kde.org/show_bug.cgi?id=427720

Definition at line 567 of file exr_converter.cc.

{
    try {
        Imf::InputFile file(filename.toUtf8());
 
        Imath::Box2i dw = file.header().dataWindow();
        Imath::Box2i displayWindow = file.header().displayWindow();
 
        int width = dw.max.x - dw.min.x + 1;
        int height = dw.max.y - dw.min.y + 1;
        int dx = dw.min.x;
        int dy = dw.min.y;
 
        // Display the attributes of a file
        for (Imf::Header::ConstIterator it = file.header().begin();
             it != file.header().end(); ++it) {
            dbgFile << "Attribute: " << it.name() << " type: " << it.attribute().typeName();
        }
 
        // fetch Krita's extra layer info, which might have been stored previously
        QDomDocument extraLayersInfo = d->loadExtraLayersInfo(file.header());
 
        // Construct the list of LayerInfo
 
        QList<ExrPaintLayerInfo> informationObjects;
        QList<ExrGroupLayerInfo> groups;
 
        ImageType imageType = IT_UNKNOWN;
 
        const Imf::ChannelList &channels = file.header().channels();
        std::set<std::string> layerNames;
        channels.layers(layerNames);
 
        if (!extraLayersInfo.isNull() &&
                !d->checkExtraLayersInfoConsistent(extraLayersInfo, layerNames)) {
 
            // it is inconsistent anyway
            extraLayersInfo = QDomDocument();
        }
 
        // Check if there are A, R, G, B channels
 
        dbgFile << "Checking for ARGB channels, they can occur in single-layer _or_ multi-layer images:";
        ExrPaintLayerInfo info;
        bool topLevelRGBFound = false;
        info.name = HDR_LAYER;
 
        QStringList topLevelChannelNames = QStringList() << "A"
                                                         << "R"
                                                         << "G"
                                                         << "B"
                                                         << ".A"
                                                         << ".R"
                                                         << ".G"
                                                         << ".B"
                                                         << "A."
                                                         << "R."
                                                         << "G."
                                                         << "B."
                                                         << "A."
                                                         << "R."
                                                         << "G."
                                                         << "B."
                                                         << ".alpha"
                                                         << ".red"
                                                         << ".green"
                                                         << ".blue"
                                                         << "X"
                                                         << "Y"
                                                         << "Z"
                                                         << ".X"
                                                         << ".Y"
                                                         << ".Z"
                                                         << "X."
                                                         << "Y."
                                                         << "Z.";
 
        for (Imf::ChannelList::ConstIterator i = channels.begin(); i != channels.end(); ++i) {
            const Imf::Channel &channel = i.channel();
            dbgFile << "Channel name = " << i.name() << " type = " << channel.type;
 
            QString qname = i.name();
            if (topLevelChannelNames.contains(qname)) {
                topLevelRGBFound = true;
                dbgFile << "Found top-level channel" << qname;
                info.channelMap[qname] = qname;
                info.updateImageType(imfTypeToKisType(channel.type));
            }
            // Channel names that don't contain a "." or that contain a
            // "." only at the beginning or at the end are not considered
            // to be part of any layer.
            else if (!qname.contains('.')
                     || !qname.mid(1).contains('.')
                     || !qname.left(qname.size() - 1).contains('.')) {
                warnFile << "Found a top-level channel that is not part of the rendered image" << qname << ". Krita will not load this channel.";
            }
        }
        if (topLevelRGBFound) {
            dbgFile << "Toplevel layer" << info.name << ":Image type:" << imageType << "Layer type" << info.imageType;
            informationObjects.push_back(info);
            imageType = info.imageType;
        }
 
        dbgFile << "Extra layers:" << layerNames.size();
 
        for (std::set<std::string>::const_iterator i = layerNames.begin();i != layerNames.end(); ++i) {
 
            info = ExrPaintLayerInfo();
 
            dbgFile << "layer name = " << i->c_str();
            info.name = i->c_str();
            Imf::ChannelList::ConstIterator layerBegin, layerEnd;
            channels.channelsInLayer(*i, layerBegin, layerEnd);
            for (Imf::ChannelList::ConstIterator j = layerBegin;
                 j != layerEnd; ++j) {
                const Imf::Channel &channel = j.channel();
 
                info.updateImageType(imfTypeToKisType(channel.type));
 
                QString qname = j.name();
                QStringList list = qname.split('.');
                QString layersuffix = list.last();
 
                dbgFile << "\tchannel " << j.name() << "suffix" << layersuffix << " type = " << channel.type;
 
                // Nuke writes the channels for sublayers as .red instead of .R, so convert those.
                // See https://bugs.kde.org/show_bug.cgi?id=393771
                if (topLevelChannelNames.contains("." + layersuffix)) {
                    layersuffix = layersuffix.at(0).toUpper();
                }
                dbgFile << "\t\tsuffix" << layersuffix;
 
 
                if (list.size() > 1) {
                    info.name = list[list.size()-2];
                    info.parent = searchGroup(&groups, list, 0, list.size() - 3);
                }
 
                info.channelMap[layersuffix] = qname;
            }
 
            if (info.imageType != IT_UNKNOWN && info.imageType != IT_UNSUPPORTED) {
                informationObjects.push_back(info);
                if (imageType < info.imageType) {
                    imageType = info.imageType;
                }
            }
        }
 
        dbgFile << "File has" << informationObjects.size() << "layer(s)";
 
        // Set the colorspaces
        for (int i = 0; i < informationObjects.size(); ++i) {
            ExrPaintLayerInfo& info = informationObjects[i];
            QString modelId;
 
            if (info.channelMap.size() == 1) {
                modelId = GrayAColorModelID.id();
                QString key = info.channelMap.begin().key();
                if (key != "Y") {
                    info.remappedChannels.push_back(ExrPaintLayerInfo::Remap(key, "Y"));
                    QString channel =  info.channelMap.begin().value();
                    info.channelMap.clear();
                    info.channelMap["Y"] = channel;
                }
            }
            else if (info.channelMap.size() == 2) {
                modelId = GrayAColorModelID.id();
 
                QMap<QString,QString>::const_iterator it = info.channelMap.constBegin();
                QMap<QString,QString>::const_iterator end = info.channelMap.constEnd();
 
                QString failingChannelKey;
 
                for (; it != end; ++it) {
                    // BUG: 461975
                    if (it.key() != "A") {
                        failingChannelKey = it.key();
                        break;
                    }
                }
 
                info.remappedChannels.push_back(ExrPaintLayerInfo::Remap(failingChannelKey, "Y"));
 
                QString failingChannelValue = info.channelMap[failingChannelKey];
                info.channelMap.remove(failingChannelKey);
                info.channelMap["Y"] = failingChannelValue;
            }
            else if (info.channelMap.size() == 3 || info.channelMap.size() == 4) {
 
                if (info.channelMap.contains("R") && info.channelMap.contains("G") && info.channelMap.contains("B")) {
                    modelId = RGBAColorModelID.id();
                }
                else if (info.channelMap.contains("X") && info.channelMap.contains("Y") && info.channelMap.contains("Z")) {
                    modelId = XYZAColorModelID.id();
                    QMap<QString, QString> newChannelMap;
                    if (info.channelMap.contains("W")) {
                        newChannelMap["A"] = info.channelMap["W"];
                        info.remappedChannels.push_back(ExrPaintLayerInfo::Remap("W", "A"));
                        info.remappedChannels.push_back(ExrPaintLayerInfo::Remap("X", "X"));
                        info.remappedChannels.push_back(ExrPaintLayerInfo::Remap("Y", "Y"));
                        info.remappedChannels.push_back(ExrPaintLayerInfo::Remap("Z", "Z"));
                    } else if (info.channelMap.contains("A")) {
                        newChannelMap["A"] = info.channelMap["A"];
                    }
                    // The decode function expect R, G, B in the channel map
                    newChannelMap["R"] = info.channelMap["X"];
                    newChannelMap["G"] = info.channelMap["Y"];
                    newChannelMap["B"] = info.channelMap["Z"];
                    info.channelMap = newChannelMap;
                }
                else {
                    modelId = RGBAColorModelID.id();
                    QMap<QString, QString> newChannelMap;
                    QMap<QString, QString>::iterator it = info.channelMap.begin();
                    newChannelMap["R"] = it.value();
                    info.remappedChannels.push_back(ExrPaintLayerInfo::Remap(it.key(), "R"));
                    ++it;
                    newChannelMap["G"] = it.value();
                    info.remappedChannels.push_back(ExrPaintLayerInfo::Remap(it.key(), "G"));
                    ++it;
                    newChannelMap["B"] = it.value();
                    info.remappedChannels.push_back(ExrPaintLayerInfo::Remap(it.key(), "B"));
                    if (info.channelMap.size() == 4) {
                        ++it;
                        newChannelMap["A"] = it.value();
                        info.remappedChannels.push_back(ExrPaintLayerInfo::Remap(it.key(), "A"));
                    }
 
                    info.channelMap = newChannelMap;
                }
            }
            else {
                dbgFile << info.name << "has" << info.channelMap.size() << "channels, and we don't know what to do.";
            }
            if (!modelId.isEmpty()) {
                info.colorSpace = kisTypeToColorSpace(modelId, info.imageType);
            }
        }
 
        // Get colorspace
        dbgFile << "Image type = " << imageType;
        const KoColorSpace* colorSpace = kisTypeToColorSpace(RGBAColorModelID.id(), imageType);
 
        if (!colorSpace) return ImportExportCodes::FormatColorSpaceUnsupported;
        dbgFile << "Color space: " << colorSpace->name();
 
        // Set the colorspace on all groups
        for (int i = 0; i < groups.size(); ++i) {
            ExrGroupLayerInfo& info = groups[i];
            info.colorSpace = colorSpace;
        }
 
        // Create the image
        //  Make sure the created image is the same size as the displayWindow since
        //  the dataWindow can be cropped in some cases.
        int displayWidth = displayWindow.max.x - displayWindow.min.x + 1;
        int displayHeight = displayWindow.max.y - displayWindow.min.y + 1;
        d->image = new KisImage(d->doc->createUndoStore(), displayWidth, displayHeight, colorSpace, "");
 
        if (!d->image) {
            return ImportExportCodes::Failure;
        }
 
        //d->image->setDefaultProjectionColor(KoColor(Qt::black, colorSpace));
 
        // Create group layers
        for (int i = 0; i < groups.size(); ++i) {
            ExrGroupLayerInfo& info = groups[i];
            Q_ASSERT(info.parent == 0 || info.parent->groupLayer);
            KisGroupLayerSP groupLayerParent = (info.parent) ? info.parent->groupLayer : d->image->rootLayer();
            info.groupLayer = new KisGroupLayer(d->image, info.name, OPACITY_OPAQUE_U8);
            d->image->addNode(info.groupLayer, groupLayerParent);
        }
 
        // Load the layers
        for (int i = informationObjects.size() - 1; i >= 0; --i) {
            ExrPaintLayerInfo& info = informationObjects[i];
            if (info.colorSpace) {
                dbgFile << "Decoding " << info.name << " with " << info.channelMap.size() << " channels, and color space " << info.colorSpace->id();
                KisPaintLayerSP layer = new KisPaintLayer(d->image, info.name, OPACITY_OPAQUE_U8, info.colorSpace);
 
                if (!layer) {
                    return ImportExportCodes::Failure;
                }
 
                layer->setCompositeOpId(COMPOSITE_OVER);
 
                switch (info.channelMap.size()) {
                case 1:
                case 2:
                    // Decode the data
                    switch (info.imageType) {
                    case IT_FLOAT16:
                        d->decodeData1<half>(file, info, layer, width, dx, dy, height, Imf::HALF);
                        break;
                    case IT_FLOAT32:
                        d->decodeData1<float>(file, info, layer, width, dx, dy, height, Imf::FLOAT);
                        break;
                    case IT_UNKNOWN:
                    case IT_UNSUPPORTED:
                        qFatal("Impossible error");
                    }
                    break;
                case 3:
                case 4:
                    // Decode the data
                    switch (info.imageType) {
                    case IT_FLOAT16:
                        d->decodeData4<half>(file, info, layer, width, dx, dy, height, Imf::HALF);
                        break;
                    case IT_FLOAT32:
                        d->decodeData4<float>(file, info, layer, width, dx, dy, height, Imf::FLOAT);
                        break;
                    case IT_UNKNOWN:
                    case IT_UNSUPPORTED:
                        qFatal("Impossible error");
                    }
                    break;
                default:
                    qFatal("Invalid number of channels: %i", info.channelMap.size());
                }
                // Check if should set the channels
                if (!info.remappedChannels.isEmpty()) {
                    QList<KisMetaData::Value> values;
                    Q_FOREACH (const ExrPaintLayerInfo::Remap& remap, info.remappedChannels) {
                        QMap<QString, KisMetaData::Value> map;
                        map["original"] = KisMetaData::Value(remap.original);
                        map["current"] = KisMetaData::Value(remap.current);
                        values.append(map);
                    }
                    layer->metaData()->addEntry(KisMetaData::Entry(KisMetaData::SchemaRegistry::instance()->create("http://krita.org/exrchannels/1.0/" , "exrchannels"), "channelsmap", values));
                }
                // Add the layer
                KisGroupLayerSP groupLayerParent = (info.parent) ? info.parent->groupLayer : d->image->rootLayer();
                d->image->addNode(layer, groupLayerParent);
            } else {
                dbgFile << "No decoding " << info.name << " with " << info.channelMap.size() << " channels, and lack of a color space";
            }
        }
 
        // After reading the image, notify the user about changed alpha.
        if (d->alphaWasModified) {
            QString msg =
                    i18nc("@info",
                          "The image contains pixels with zero alpha channel and non-zero "
                          "color channels. Krita has modified those pixels to have "
                          "at least some alpha. The initial values will <i>not</i> "
                          "be reverted on saving the image back."
                          "<br/><br/>"
                          "This will hardly make any visual difference just keep it in mind.");
            if (d->showNotifications) {
                QMessageBox::information(qApp->activeWindow(), i18nc("@title:window", "EXR image has been modified"), msg);
            } else {
                warnKrita << "WARNING:" << msg;
            }
        }
 
        if (!extraLayersInfo.isNull()) {
            KisExrLayersSorter sorter(extraLayersInfo, d->image);
        }
 
        return ImportExportCodes::OK;
 
    } catch (std::exception &e) {
        dbgFile << "Error while reading from the exr file: " << e.what();
 
        if (!KisImportExportAdditionalChecks::doesFileExist(filename)) {
            return ImportExportCodes::FileNotExist;
        } else if(!KisImportExportAdditionalChecks::isFileReadable(filename)) {
            return ImportExportCodes::NoAccessToRead;
        } else {
            return ImportExportCodes::ErrorWhileReading;
        }
    }
 
    return ImportExportCodes::OK;
}

References KisMetaData::Store::addEntry(), ExrPaintLayerInfo::channelMap, ExrLayerInfoBase::colorSpace, COMPOSITE_OVER, d, dbgFile, KisImportExportAdditionalChecks::doesFileExist(), ImportExportCodes::ErrorWhileReading, ImportExportCodes::Failure, ImportExportCodes::FileNotExist, ImportExportCodes::FormatColorSpaceUnsupported, GrayAColorModelID, ExrGroupLayerInfo::groupLayer, HDR_LAYER, KoID::id(), KoColorSpace::id, ExrPaintLayerInfo::imageType, imfTypeToKisType(), KisMetaData::SchemaRegistry::instance(), KisImportExportAdditionalChecks::isFileReadable(), IT_FLOAT16, IT_FLOAT32, IT_UNKNOWN, IT_UNSUPPORTED, kisTypeToColorSpace(), KisLayer::metaData(), KoColorSpace::name, ExrLayerInfoBase::name, ImportExportCodes::NoAccessToRead, ImportExportCodes::OK, OPACITY_OPAQUE_U8, ExrLayerInfoBase::parent, remap(), ExrPaintLayerInfo::remappedChannels, RGBAColorModelID, searchGroup(), KisBaseNode::setCompositeOpId(), ExrPaintLayerInfo::updateImageType(), warnFile, warnKrita, and XYZAColorModelID.

errorMessage()

QString EXRConverter::errorMessage

(

)

const

Definition at line 966 of file exr_converter.cc.

{
    return d->errorMessage;
}

References d.

image()

KisImageSP EXRConverter::image

(

)

Retrieve the constructed image

Definition at line 961 of file exr_converter.cc.

{
    return d->image;
}

References d.

Member Data Documentation

d

const QScopedPointer<Private> EXRConverter::d

private

Definition at line 41 of file exr_converter.h.

---

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

• plugins/impex/exr/exr_converter.h
• plugins/impex/exr/exr_converter.cc