KisRawImport Class Reference

#include <kis_raw_import.h>

Inheritance diagram for KisRawImport:

Public Member Functions
KisImportExportErrorCode	convert (KisDocument *document, QIODevice *io, KisPropertiesConfigurationSP configuration=0) override
	KisRawImport (QObject *parent, const QVariantList &)
	~KisRawImport () override
Public Member Functions inherited from KisImportExportFilter
virtual KisConfigWidget *	createConfigurationWidget (QWidget *parent, const QByteArray &from="", const QByteArray &to="") const
	createConfigurationWidget creates a widget that can be used to define the settings for a given import/export filter
virtual KisPropertiesConfigurationSP	defaultConfiguration (const QByteArray &from="", const QByteArray &to="") const
	defaultConfiguration defines the default settings for the given import export filter
virtual QMap< QString, KisExportCheckBase * >	exportChecks ()
	generate and return the list of capabilities of this export filter. The list
virtual bool	exportSupportsGuides () const
	exportSupportsGuides Because guides are in the document and not the image, checking for guides cannot be made an exportCheck.
KisPropertiesConfigurationSP	lastSavedConfiguration (const QByteArray &from="", const QByteArray &to="") const
	lastSavedConfiguration return the last saved configuration for this filter
	Private ()
void	setBatchMode (bool batchmode)
void	setFilename (const QString &filename)
void	setImportUserFeedBackInterface (KisImportUserFeedbackInterface *interface)
void	setMimeType (const QString &mime)
void	setRealFilename (const QString &filename)
void	setUpdater (QPointer< KoUpdater > updater)
virtual bool	supportsIO () const
	Override and return false for the filters that use a library that cannot handle file handles, only file names.
QPointer< KoUpdater >	updater ()
virtual QString	verify (const QString &fileName) const
	Verify whether the given file is correct and readable.
	~KisImportExportFilter () override
	~Private ()

Private Slots
void	slotUpdatePreview ()

Private Member Functions
KDcrawIface::RawDecodingSettings	rawDecodingSettings ()

Private Attributes
KoDialog *	m_dialog
WdgRawImport *	m_rawWidget

Additional Inherited Members
Public Attributes inherited from KisImportExportFilter
bool	batchmode
QMap< QString, KisExportCheckBase * >	capabilities
QString	filename
KisImportUserFeedbackInterface *	importUserFeedBackInterface {nullptr}
QByteArray	mime
QString	realFilename
QPointer< KoUpdater >	updater
Static Public Attributes inherited from KisImportExportFilter
static const QString	CICPPrimariesTag = "CICPCompatiblePrimaries"
static const QString	CICPTransferCharacteristicsTag = "CICPCompatibleTransferFunction"
static const QString	ColorDepthIDTag = "ColorDepthID"
static const QString	ColorModelIDTag = "ColorModelID"
static const QString	HDRTag = "HDRSupported"
static const QString	ImageContainsTransparencyTag = "ImageContainsTransparency"
static const QString	sRGBTag = "sRGB"
Protected Member Functions inherited from KisImportExportFilter
void	addCapability (KisExportCheckBase *capability)
void	addSupportedColorModels (QList< QPair< KoID, KoID > > supportedColorModels, const QString &name, KisExportCheckBase::Level level=KisExportCheckBase::PARTIALLY)
bool	batchMode () const
QString	filename () const
KisImportUserFeedbackInterface *	importUserFeedBackInterface () const
virtual void	initializeCapabilities ()
	KisImportExportFilter (QObject *parent=0)
QByteArray	mimeType () const
QString	realFilename () const
void	setProgress (int value)
QString	verifyZiPBasedFiles (const QString &fileName, const QStringList &filesToCheck) const

Detailed Description

Definition at line 42 of file kis_raw_import.h.

Constructor & Destructor Documentation

KisRawImport()

KisRawImport::KisRawImport	(	QObject *	parent,
		const QVariantList &	)

Definition at line 60 of file kis_raw_import.cpp.

    : KisImportExportFilter(parent)
    , m_dialog(new KoDialog())
    , m_rawWidget(new WdgRawImport())
{
    m_dialog->setButtons(KoDialog::Ok | KoDialog::Cancel | KoDialog::Apply);
    m_dialog->setDefaultButton(KoDialog::Ok);
 
    m_dialog->setMainWidget(m_rawWidget);
    connect(m_dialog, &KoDialog::applyClicked, this, &KisRawImport::slotUpdatePreview);
    connect(m_rawWidget, &WdgRawImport::paint, this, &KisRawImport::slotUpdatePreview);
    connect(m_rawWidget->rawSettings, &DcrawSettingsWidget::signalSettingsChanged, [&]() {
        m_dialog->enableButtonApply(true);
    });
}

References KoDialog::Apply, KoDialog::applyClicked(), KoDialog::Cancel, connect(), KoDialog::Ok, WdgRawImport::paint(), KDcrawIface::DcrawSettingsWidget::signalSettingsChanged(), and slotUpdatePreview().

~KisRawImport()

KisRawImport::~KisRawImport ( )

override

Definition at line 76 of file kis_raw_import.cpp.

{
    delete m_dialog;
}

References m_dialog.

Member Function Documentation

convert()

KisImportExportErrorCode KisRawImport::convert ( KisDocument * document, QIODevice * io, KisPropertiesConfigurationSP configuration = 0 )

overridevirtual

The filter chain calls this method to perform the actual conversion. The passed mimetypes should be a pair of those you specified in your .desktop file. You have to implement this method to make the filter work.

Returns

The error status, see the #ConversionStatus enum. KisImportExportFilter::OK means that everything is alright.

Implements KisImportExportFilter.

Definition at line 91 of file kis_raw_import.cpp.

{
#if KDCRAW_VERSION < 0x010200
    m_rawWidget->rawSettings->setDefaultSettings();
#else
    m_rawWidget->rawSettings->resetToDefault();
#endif
 
    int r = QDialog::Accepted;
    if (!batchMode()) {
        r = m_dialog->exec();
    }
 
    if (r == QDialog::Accepted) {
        KisCursorOverrideLock cursorLock(Qt::WaitCursor);
 
        // Do the decoding
        QByteArray imageData;
        RawDecodingSettings settings = rawDecodingSettings();
        settings.sixteenBitsImage = true;
        int width = 0;
        int height = 0;
        int rgbmax = 0;
        MyKDcraw dcraw(updater());
        if (!dcraw.decodeRAWImage(filename(), settings, imageData, width, height, rgbmax))
            return ImportExportCodes::FileFormatIncorrect;
 
        const KoColorProfile *profile = nullptr;
 
        switch (settings.outputColorSpace) {
        case RawDecodingSettings::RAWCOLOR:
        case RawDecodingSettings::SRGB:
            profile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
            break;
        case RawDecodingSettings::ADOBERGB:
            profile = KoColorSpaceRegistry::instance()->profileByName("ClayRGB-elle-V2-g22.icc");
            break;
        case RawDecodingSettings::WIDEGAMMUT:
            profile = KoColorSpaceRegistry::instance()->profileByName("WideRGB-elle-V2-g22.icc");
            break;
        case RawDecodingSettings::PROPHOTO:
            profile = KoColorSpaceRegistry::instance()->profileByName("LargeRGB-elle-V2-g22.icc");
            break;
        case RawDecodingSettings::CUSTOMOUTPUTCS:
            QFileInfo info(settings.outputProfile);
 
            if (!info.exists()) {
                qWarning() << "WARNING: couldn't find custom profile" << settings.outputProfile;
                profile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
            } else {
                QFile profileFile(settings.outputProfile);
 
                if (profileFile.open(QFile::ReadOnly)) {
                    profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(),
                                                                                   Integer16BitsColorDepthID.id(),
                                                                                   profileFile.readAll());
                } else {
                    qWarning() << "WARNING: couldn't open custom profile file" << settings.outputProfile;
                }
            }
 
            if (!profile) {
                qWarning() << "WARNING: reset profile to sRGB";
                profile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
            }
 
            break;
        }
 
        // Init the image
        const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb16(profile);
        KisImageSP image = new KisImage(document->createUndoStore(), width, height, cs, filename());
        KIS_ASSERT_RECOVER_RETURN_VALUE(!image.isNull(), ImportExportCodes::InternalError);
 
        KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), quint8_MAX);
 
        image->addNode(layer, image->rootLayer());
        KIS_ASSERT_RECOVER_RETURN_VALUE(!layer.isNull(), ImportExportCodes::InternalError);
 
        KisPaintDeviceSP device = layer->paintDevice();
        KIS_ASSERT_RECOVER_RETURN_VALUE(!device.isNull(), ImportExportCodes::InternalError);
 
        const auto readLayer = [](KisLayerSP layer,
                                  const QByteArray &imageData,
                                  int width,
                                  int height,
                                  const QPointer<KoUpdater> &updater) -> void {
            const float original = static_cast<float>(updater->progress());
            // Leave 10% for the metadata
            const float step = (static_cast<float>(updater->maximum() * 0.9) - original) / (float)height;
            // Copy the data
            KisRandomAccessorSP it = layer->paintDevice()->createRandomAccessorNG();
 
            for (int y = 0; y < height;) {
                const int numContiguousRows = qMin(it->numContiguousRows(y), height - y);
                for (int x = 0; x < width;) {
                    const int numContiguousColumns = qMin(it->numContiguousColumns(x), width - x);
 
                    it->moveTo(x, y);
 
                    const int rowStride = it->rowStride(x, y);
 
                    quint8 *d = it->rawData();
 
                    for (int i = 0; i < numContiguousRows; i++) {
                        const auto *ptr =
                            reinterpret_cast<const typename KoBgrU16Traits::channels_type *>(imageData.data())
                            + static_cast<ptrdiff_t>(((y + i) * width + x) * 3);
 
                        for (int j = 0; j < numContiguousColumns; j++) {
                            auto *pixel = reinterpret_cast<typename KoBgrU16Traits::Pixel *>(d) + j;
#if KDCRAW_VERSION < 0x000400
                            pixel->red = correctIndian(ptr[2]);
                            pixel->green = correctIndian(ptr[1]);
                            pixel->blue = correctIndian(ptr[0]);
                            pixel->alpha = 0xFFFF;
#else
                            *pixel = {correctIndian(ptr[2]), correctIndian(ptr[1]), correctIndian(ptr[0]), 0xFFFF};
#endif
                            ptr += 3;
                        }
 
                        d += rowStride;
                    }
 
                    x += numContiguousColumns;
                }
 
                y += numContiguousRows;
                updater->setProgress(static_cast<int>(original + step * float(y)));
            }
        };
 
        readLayer(layer, imageData, width, height, updater());
 
        {
            // HACK!! Externally parse the Exif metadata
            // libtiff has no way to access the fields wholesale
            try {
                KisExiv2IODevice::ptr_type basicIoDevice(new KisExiv2IODevice(filename()));
 
#if EXIV2_TEST_VERSION(0,28,0)
                const std::unique_ptr<Exiv2::Image> readImg = Exiv2::ImageFactory::open(std::move(basicIoDevice));
#else
                const std::unique_ptr<Exiv2::Image> readImg(Exiv2::ImageFactory::open(basicIoDevice).release());
#endif
 
                readImg->readMetadata();
 
                const KisMetaData::IOBackend *io = KisMetadataBackendRegistry::instance()->value("exif");
 
                // All IFDs are paint layer children of root
                KisNodeSP node = image->rootLayer()->firstChild();
 
                QBuffer ioDevice;
 
                {
                    // Synthesize the Exif blob
                    Exiv2::ExifData tempData;
                    Exiv2::Blob tempBlob;
 
                    // NOTE: do not use std::copy_if, auto_ptrs beware
                    for (const Exiv2::Exifdatum &i : readImg->exifData()) {
                        const uint16_t tag = i.tag();
 
                        if (tag == Exif::Image::ImageWidth || tag == Exif::Image::ImageLength
                            || tag == Exif::Image::BitsPerSample || tag == Exif::Image::Compression
                            || tag == Exif::Image::PhotometricInterpretation || tag == Exif::Image::Orientation
                            || tag == Exif::Image::SamplesPerPixel || tag == Exif::Image::PlanarConfiguration
                            || tag == Exif::Image::YCbCrSubSampling || tag == Exif::Image::YCbCrPositioning
                            || tag == Exif::Image::XResolution || tag == Exif::Image::YResolution
                            || tag == Exif::Image::ResolutionUnit || tag == Exif::Image::TransferFunction
                            || tag == Exif::Image::WhitePoint || tag == Exif::Image::PrimaryChromaticities
                            || tag == Exif::Image::YCbCrCoefficients || tag == Exif::Image::ReferenceBlackWhite
                            || tag == Exif::Image::InterColorProfile) {
                            dbgMetaData << "Ignoring TIFF-specific" << i.key().c_str();
                            continue;
                        }
 
                        tempData.add(i);
                    }
 
                    // Encode into temporary blob
                    Exiv2::ExifParser::encode(tempBlob, Exiv2::littleEndian, tempData);
 
                    // Reencode into Qt land
                    ioDevice.setData(reinterpret_cast<char *>(tempBlob.data()), static_cast<int>(tempBlob.size()));
                }
 
                // Get layer
                KisLayer *layer = qobject_cast<KisLayer *>(node.data());
                KIS_ASSERT_RECOVER(layer)
                {
                    errFile << "Attempted to import metadata on an empty document";
                    return ImportExportCodes::InternalError;
                }
 
                // Inject the data as any other IOBackend
                io->loadFrom(layer->metaData(), &ioDevice);
#if EXIV2_TEST_VERSION(0,28,0)
            } catch (Exiv2::Error &e) {
                errFile << "Failed injecting TIFF metadata:" << Exiv2::Error(e.code()).what();
#else
            } catch (Exiv2::AnyError &e) {
                errFile << "Failed metadata import:" << e.code() << e.what();
#endif
            }
        }
 
        document->setCurrentImage(image);
        updater()->setProgress(updater()->maximum());
        return ImportExportCodes::OK;
    }
 
    return ImportExportCodes::Cancelled;
}

References KisNodeFacade::addNode(), KisImportExportFilter::batchMode(), Exif::Image::BitsPerSample, ImportExportCodes::Cancelled, Exif::Image::Compression, correctIndian(), KoColorSpaceRegistry::createColorProfile(), KisPaintDevice::createRandomAccessorNG(), KisImportExportFilter::d, KisSharedPtr< T >::data(), dbgMetaData, errFile, ImportExportCodes::FileFormatIncorrect, KisImportExportFilter::filename, KisNode::firstChild(), KoID::id(), Exif::Image::ImageLength, Exif::Image::ImageWidth, KisMetadataBackendRegistry::instance(), KoColorSpaceRegistry::instance(), Integer16BitsColorDepthID, Exif::Image::InterColorProfile, ImportExportCodes::InternalError, KisSharedPtr< T >::isNull(), KIS_ASSERT_RECOVER, KIS_ASSERT_RECOVER_RETURN_VALUE, KisMetaData::IOBackend::loadFrom(), m_dialog, m_rawWidget, KisLayer::metaData(), KisRandomConstAccessorNG::moveTo(), KisImage::nextLayerName(), KisRandomConstAccessorNG::numContiguousColumns(), KisRandomConstAccessorNG::numContiguousRows(), ImportExportCodes::OK, Exif::Image::Orientation, KoColorSpaceRegistry::p709SRGBProfile(), KisPaintLayer::paintDevice, Exif::Image::PhotometricInterpretation, Exif::Image::PlanarConfiguration, Exif::Image::PrimaryChromaticities, KoColorSpaceRegistry::profileByName(), quint8_MAX, KisBaseAccessor::rawData(), rawDecodingSettings(), Exif::Image::ReferenceBlackWhite, Exif::Image::ResolutionUnit, KoColorSpaceRegistry::rgb16(), RGBAColorModelID, KisImage::rootLayer(), KisRandomConstAccessorNG::rowStride(), Exif::Image::SamplesPerPixel, Exif::Image::TransferFunction, KisImportExportFilter::updater, KoGenericRegistry< T >::value(), Exif::Image::WhitePoint, Exif::Image::XResolution, Exif::Image::YCbCrCoefficients, Exif::Image::YCbCrPositioning, Exif::Image::YCbCrSubSampling, and Exif::Image::YResolution.

rawDecodingSettings()

RawDecodingSettings KisRawImport::rawDecodingSettings ( )

private

Definition at line 336 of file kis_raw_import.cpp.

{
#if KDCRAW_VERSION < 0x010200
    RawDecodingSettings settings;
    settings.sixteenBitsImage = true;
    settings.brightness = m_rawWidget->rawSettings->brightness();
    settings.RAWQuality = m_rawWidget->rawSettings->quality();
    settings.outputColorSpace = m_rawWidget->rawSettings->outputColorSpace();
    settings.RGBInterpolate4Colors = m_rawWidget->rawSettings->useFourColor();
    settings.DontStretchPixels = m_rawWidget->rawSettings->useDontStretchPixels();
    settings.unclipColors = m_rawWidget->rawSettings->unclipColor();
    settings.whiteBalance = m_rawWidget->rawSettings->whiteBalance();
    settings.customWhiteBalance = m_rawWidget->rawSettings->customWhiteBalance();
    settings.customWhiteBalanceGreen = m_rawWidget->rawSettings->customWhiteBalanceGreen();
 
    settings.enableBlackPoint = m_rawWidget->rawSettings->useBlackPoint();
    settings.blackPoint = m_rawWidget->rawSettings->blackPoint();
 
    settings.enableNoiseReduction = m_rawWidget->rawSettings->useNoiseReduction();
    settings.NRThreshold = m_rawWidget->rawSettings->NRThreshold();
 
    settings.enableCACorrection = m_rawWidget->rawSettings->useCACorrection();
    settings.caMultiplier[0] = m_rawWidget->rawSettings->caRedMultiplier();
    settings.caMultiplier[1] = m_rawWidget->rawSettings->caBlueMultiplier();
 
    return settings;
#else
    return m_rawWidget->rawSettings->settings();
#endif
}

References m_rawWidget.

slotUpdatePreview

void KisRawImport::slotUpdatePreview ( )

privateslot

Definition at line 308 of file kis_raw_import.cpp.

{
    QByteArray imageData;
    RawDecodingSettings settings = rawDecodingSettings();
    settings.sixteenBitsImage = false;
    int width = 0;
    int height = 0;
    int rgbmax = 0;
    KDcraw dcraw;
    if (dcraw.decodeHalfRAWImage(filename(), settings, imageData, width, height, rgbmax)) {
        QImage image(width, height, QImage::Format_RGB32);
        quint8 *ptr = reinterpret_cast<quint8 *>(imageData.data());
        for (int y = 0; y < height; ++y) {
            QRgb *pixel = reinterpret_cast<QRgb *>(image.scanLine(y));
            for (int x = 0; x < width; ++x) {
                pixel[x] = qRgb(ptr[0], ptr[1], ptr[2]);
                ptr += 3;
            }
        }
        const QSize previewSize = m_rawWidget->preview->size() * m_rawWidget->preview->devicePixelRatioF();
        QPixmap img = QPixmap::fromImage(image).scaled(previewSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
        img.setDevicePixelRatio(m_rawWidget->preview->devicePixelRatioF());
        m_rawWidget->preview->setPixmap(img);
    }
 
    m_dialog->enableButtonApply(false);
}

References KoDialog::enableButtonApply(), KisImportExportFilter::filename, m_dialog, m_rawWidget, and rawDecodingSettings().

Member Data Documentation

m_dialog

KoDialog* KisRawImport::m_dialog

private

Definition at line 58 of file kis_raw_import.h.

m_rawWidget

WdgRawImport* KisRawImport::m_rawWidget

private

Definition at line 59 of file kis_raw_import.h.

---

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

• plugins/impex/raw/kis_raw_import.h
• plugins/impex/raw/kis_raw_import.cpp