CSVLoader Class Reference

#include <csv_loader.h>

Inheritance diagram for CSVLoader:

Public Member Functions
KisImportExportErrorCode	buildAnimation (QIODevice *io, const QString &filename)
	CSVLoader (KisDocument *doc, bool batchMode)
KisImageSP	image ()
	~CSVLoader () override

Private Slots
void	cancel ()

Private Member Functions
QString	convertBlending (const QString &)
KisImportExportErrorCode	createNewImage (int, int, float, const QString &)
KisImportExportErrorCode	decode (QIODevice *io, const QString &filename)
KisImportExportErrorCode	setLayer (CSVLayerRecord *, KisDocument *, const QString &)
QString	validPath (const QString &, const QString &)

Private Attributes
bool	m_batchMode
KisDocument *	m_doc
KisImageSP	m_image
bool	m_stop

Detailed Description

Definition at line 19 of file csv_loader.h.

Constructor & Destructor Documentation

CSVLoader()

CSVLoader::CSVLoader	(	KisDocument *	doc,
		bool	batchMode )

Definition at line 38 of file csv_loader.cpp.

    : m_image(0)
    , m_doc(doc)
    , m_batchMode(batchMode)
    , m_stop(false)
{
}

~CSVLoader()

CSVLoader::~CSVLoader ( )

override

Definition at line 46 of file csv_loader.cpp.

{
}

Member Function Documentation

buildAnimation()

KisImportExportErrorCode CSVLoader::buildAnimation	(	QIODevice *	io,
		const QString &	filename )

Definition at line 465 of file csv_loader.cpp.

{
    return decode(io, filename);
}

References decode().

cancel

void CSVLoader::cancel ( )

privateslot

Definition at line 475 of file csv_loader.cpp.

{
    m_stop = true;
}

References m_stop.

convertBlending()

QString CSVLoader::convertBlending ( const QString & blending )

private

Definition at line 339 of file csv_loader.cpp.

{
    if (blending == "Color") return COMPOSITE_OVER;
    if (blending == "Behind") return COMPOSITE_BEHIND;
    if (blending == "Erase") return COMPOSITE_ERASE;
    // "Shade"
    if (blending == "Light") return COMPOSITE_LINEAR_LIGHT;
    if (blending == "Colorize") return COMPOSITE_COLORIZE;
    if (blending == "Hue") return COMPOSITE_HUE;
    if (blending == "Add") return COMPOSITE_ADD;
    if (blending == "Sub") return COMPOSITE_INVERSE_SUBTRACT;
    if (blending == "Multiply") return COMPOSITE_MULT;
    if (blending == "Screen") return COMPOSITE_SCREEN;
    // "Replace"
    // "Substitute"
    if (blending == "Difference") return COMPOSITE_DIFF;
    if (blending == "Divide") return COMPOSITE_DIVIDE;
    if (blending == "Overlay") return COMPOSITE_OVERLAY;
    if (blending == "Light2") return COMPOSITE_DODGE;
    if (blending == "Shade2") return COMPOSITE_BURN;
    if (blending == "HardLight") return COMPOSITE_HARD_LIGHT;
    if (blending == "SoftLight") return COMPOSITE_SOFT_LIGHT_PHOTOSHOP;
    if (blending == "GrainExtract") return COMPOSITE_GRAIN_EXTRACT;
    if (blending == "GrainMerge") return COMPOSITE_GRAIN_MERGE;
    if (blending == "Sub2") return COMPOSITE_SUBTRACT;
    if (blending == "Darken") return COMPOSITE_DARKEN;
    if (blending == "Lighten") return COMPOSITE_LIGHTEN;
    if (blending == "Saturation") return COMPOSITE_SATURATION;
 
    return COMPOSITE_OVER;
}

References COMPOSITE_ADD, COMPOSITE_BEHIND, COMPOSITE_BURN, COMPOSITE_COLORIZE, COMPOSITE_DARKEN, COMPOSITE_DIFF, COMPOSITE_DIVIDE, COMPOSITE_DODGE, COMPOSITE_ERASE, COMPOSITE_GRAIN_EXTRACT, COMPOSITE_GRAIN_MERGE, COMPOSITE_HARD_LIGHT, COMPOSITE_HUE, COMPOSITE_INVERSE_SUBTRACT, COMPOSITE_LIGHTEN, COMPOSITE_LINEAR_LIGHT, COMPOSITE_MULT, COMPOSITE_OVER, COMPOSITE_OVERLAY, COMPOSITE_SATURATION, COMPOSITE_SCREEN, COMPOSITE_SOFT_LIGHT_PHOTOSHOP, and COMPOSITE_SUBTRACT.

createNewImage()

KisImportExportErrorCode CSVLoader::createNewImage ( int width, int height, float ratio, const QString & name )

private

Definition at line 447 of file csv_loader.cpp.

{
    //the CSV is RGBA 8bits, sRGB
 
    if (!m_image) {
        const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(
                                RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), 0);
 
        if (cs) m_image = new KisImage(m_doc->createUndoStore(), width, height, cs, name);
 
        if (!m_image) return ImportExportCodes::Failure;
 
        m_image->setResolution(ratio, 1.0);
        m_image->barrierLock();
    }
    return ImportExportCodes::OK;
}

References KisImage::barrierLock(), KoColorSpaceRegistry::colorSpace(), KisDocument::createUndoStore(), ImportExportCodes::Failure, KoID::id(), KoColorSpaceRegistry::instance(), Integer8BitsColorDepthID, m_doc, m_image, ImportExportCodes::OK, RGBAColorModelID, and KisImage::setResolution().

decode()

KisImportExportErrorCode CSVLoader::decode ( QIODevice * io, const QString & filename )

private

Definition at line 50 of file csv_loader.cpp.

{
    QString     field;
    int         idx;
    int         frame = 0;
 
    QString     projName;
    int         width = 0;
    int         height = 0;
    int         frameCount = 1;
    float       framerate = 24.0;
    float       pixelRatio = 1.0;
 
    int         projNameIdx = -1;
    int         widthIdx = -1;
    int         heightIdx = -1;
    int         frameCountIdx = -1;
    int         framerateIdx = -1;
    int         pixelRatioIdx = -1;
 
    QVector<CSVLayerRecord*> layers;
 
    KisCursorOverrideLock cursorLock(Qt::WaitCursor);
 
    idx = filename.lastIndexOf(QRegularExpression("[\\/]"));
    QString base = (idx == -1) ? QString() : filename.left(idx + 1); //include separator
    QString path = filename;
 
    if (path.right(4).toUpper() == ".CSV")
        path = path.left(path.size() - 4);
 
    //according to the QT docs, the slash is a universal directory separator
    path.append(".frames/");
 
    KisImportExportErrorCode retval = ImportExportCodes::OK;
 
    dbgFile << "pos:" << io->pos();
 
    CSVReadLine readLine;
    QScopedPointer<KisDocument> importDoc(KisPart::instance()->createDocument());
    importDoc->setInfiniteAutoSaveInterval();
    importDoc->setFileBatchMode(true);
 
    KisView *setView(0);
 
    if (!m_batchMode) {
        // TODO: use other systems of progress reporting (KisViewManager::createUnthreadedUpdater()
 
//        //show the statusbar message even if no view
//        Q_FOREACH (KisView* view, KisPart::instance()->views()) {
//            if (view && view->document() == m_doc) {
//                setView = view;
//                break;
//            }
//        }
 
//        if (!setView) {
//            QStatusBar *sb = KisPart::instance()->currentMainwindow()->statusBar();
//            if (sb) {
//                sb->showMessage(i18n("Loading CSV file..."));
//            }
//        } else {
//            Q_EMIT m_doc->statusBarMessage(i18n("Loading CSV file..."));
//        }
 
//        Q_EMIT m_doc->sigProgress(0);
//        connect(m_doc, SIGNAL(sigProgressCanceled()), this, SLOT(cancel()));
    }
    int step = 0;
 
    do {
        qApp->processEvents();
 
        if (m_stop) {
            retval = ImportExportCodes::Cancelled;
            break;
        }
 
        if ((idx = readLine.nextLine(io)) <= 0) {
            if ((idx < 0) ||(step < 5))
                retval = ImportExportCodes::FileFormatIncorrect;
            break;
        }
        field = readLine.nextField(); //first field of the line
 
        if (field.isNull()) continue; //empty row
 
        switch (step) {
 
        case 0 :    //skip first row
            step = 1;
            break;
 
        case 1 :    //scene header names
            step = 2;
 
            for (idx = 0; !field.isNull(); idx++) {
                if (field == "Project Name") {
                    projNameIdx = idx;
 
                } else if (field == "Width") {
                    widthIdx = idx;
 
                } else if (field == "Height") {
                    heightIdx = idx;
 
                } else if (field == "Frame Count") {
                    frameCountIdx = idx;
 
                } else if (field == "Frame Rate") {
                    framerateIdx = idx;
 
                } else if (field == "Pixel Aspect Ratio") {
                    pixelRatioIdx = idx;
                }
                field= readLine.nextField();
            }
            break;
 
        case 2 :    //scene header values
            step= 3;
 
            for (idx= 0; !field.isNull(); idx++) {
                if (idx == projNameIdx) {
                    projName = field;
 
                } else if (idx == widthIdx) {
                    width = field.toInt();
 
                } else if (idx == heightIdx) {
                    height = field.toInt();
 
                } else if (idx == frameCountIdx) {
                    frameCount = field.toInt();
 
                    if (frameCount < 1) frameCount= 1;
 
                } else if (idx == framerateIdx) {
                    framerate = field.toFloat();
 
                } else if (idx == pixelRatioIdx) {
                    pixelRatio = field.toFloat();
 
                }
                field= readLine.nextField();
            }
 
            if ((width < 1) || (height < 1)) {
               retval = ImportExportCodes::Failure;
               break;
            }
 
            retval = createNewImage(width, height, pixelRatio, projName.isNull() ? filename : projName);
            break;
 
        case 3 :    //create level headers
            if (field[0] != '#') break;
 
            for (; !(field = readLine.nextField()).isNull(); ) {
                CSVLayerRecord* layerRecord = new CSVLayerRecord();
                layers.append(layerRecord);
            }
            readLine.rewind();
            field = readLine.nextField();
            step = 4;
            Q_FALLTHROUGH();
 
        case 4 :    //level header
 
            if (field == "#Layers") {
                //layer name
                for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++)
                    layers.at(idx)->name = field;
 
                break;
            }
            if (field == "#Density") {
                //layer opacity
                for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++)
                    layers.at(idx)->density = field.toFloat();
 
                break;
            }
            if (field == "#Blending") {
                //layer blending mode
                for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++)
                    layers.at(idx)->blending = field;
 
                break;
            }
            if (field == "#Visible") {
                //layer visibility
                for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++)
                    layers.at(idx)->visible = field.toInt();
 
                break;
            }
            if (field == "#Folder") {
                //CSV 1.1 folder location
                for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++)
                    layers.at(idx)->path = validPath(field, base);
 
                break;
            }
            if ((field.size() < 2) || (field[0] != '#') || !field[1].isDigit()) break;
 
            step = 5;
 
            Q_FALLTHROUGH();
 
        case 5 :    //frames
 
            if ((field.size() < 2) || (field[0] != '#') || !field[1].isDigit()) break;
 
            for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++) {
                CSVLayerRecord* layer = layers.at(idx);
 
                if (layer->last != field) {
                    if (!m_batchMode) {
                        //Q_EMIT m_doc->sigProgress((frame * layers.size() + idx) * 100 /
                        //                        (frameCount * layers.size()));
                    }
                    retval = setLayer(layer, importDoc.data(), path);
                    layer->last = field;
                    layer->frame = frame;
                }
            }
            frame++;
            break;
        }
    } while (retval.isOk());
 
    //finish the layers
 
    if (retval.isOk()) {
        if (m_image) {
            KisImageAnimationInterface *animation = m_image->animationInterface();
 
            if (frame > frameCount)
                frameCount = frame;
 
            animation->setDocumentRange(KisTimeSpan::fromTimeToTime(0,frameCount - 1));
            animation->setFramerate((int)framerate);
        }
 
        for (idx = 0; idx < layers.size(); idx++) {
            CSVLayerRecord* layer = layers.at(idx);
            //empty layers without any pictures are dropped
 
            if ((layer->frame > 0) || !layer->last.isEmpty()) {
                retval = setLayer(layer, importDoc.data(), path);
 
                if (!retval.isOk())
                    break;
            }
        }
    }
 
    if (m_image) {
        //insert the existing layers by the right order
        for (idx = layers.size() - 1; idx >= 0; idx--) {
            CSVLayerRecord* layer = layers.at(idx);
 
            if (layer->layer) {
                m_image->addNode(layer->layer, m_image->root());
            }
        }
        m_image->unlock();
    }
    qDeleteAll(layers);
    io->close();
 
    if (!m_batchMode) {
        // disconnect(m_doc, SIGNAL(sigProgressCanceled()), this, SLOT(cancel()));
        // Q_EMIT m_doc->sigProgress(100);
 
        if (!setView) {
            QStatusBar *sb = KisPart::instance()->currentMainwindow()->statusBar();
            if (sb) {
                sb->clearMessage();
            }
        } else {
            Q_EMIT m_doc->clearStatusBarMessage();
        }
    }
 
    return retval;
}

References KisNodeFacade::addNode(), KisImage::animationInterface(), ImportExportCodes::Cancelled, KisDocument::clearStatusBarMessage(), createDocument(), createNewImage(), KisPart::currentMainwindow(), dbgFile, ImportExportCodes::Failure, ImportExportCodes::FileFormatIncorrect, CSVLayerRecord::frame, KisTimeSpan::fromTimeToTime(), KisPart::instance(), KisImportExportErrorCode::isOk(), CSVLayerRecord::last, CSVLayerRecord::layer, m_batchMode, m_doc, m_image, m_stop, CSVReadLine::nextField(), CSVReadLine::nextLine(), ImportExportCodes::OK, CSVReadLine::rewind(), KisNodeFacade::root, KisImageAnimationInterface::setDocumentRange(), KisImageAnimationInterface::setFramerate(), setLayer(), KisImage::unlock(), and validPath().

image()

KisImageSP CSVLoader::image

(

)

Definition at line 470 of file csv_loader.cpp.

{
    return m_image;
}

References m_image.

setLayer()

KisImportExportErrorCode CSVLoader::setLayer ( CSVLayerRecord * layer, KisDocument * importDoc, const QString & path )

private

Definition at line 400 of file csv_loader.cpp.

{
    bool result = true;
 
    if (layer->channel == 0) {
        //create a new document layer
 
        float opacity = layer->density;
 
        if (opacity > 1.0)
            opacity = 1.0;
        else if (opacity < 0.0)
            opacity = 0.0;
 
        const KoColorSpace* cs = m_image->colorSpace();
        const QString layerName = (layer->name).isEmpty() ? m_image->nextLayerName() : layer->name;
 
        KisPaintLayer* paintLayer = new KisPaintLayer(m_image, layerName,
                                                       (quint8)(opacity * OPACITY_OPAQUE_U8), cs);
 
        paintLayer->setCompositeOpId(convertBlending(layer->blending));
        paintLayer->setVisible(layer->visible);
        paintLayer->enableAnimation();
 
        layer->layer = paintLayer;
        layer->channel = qobject_cast<KisRasterKeyframeChannel*>
            (paintLayer->getKeyframeChannel(KisKeyframeChannel::Raster.id(), true));
    }
 
 
    if (!layer->last.isEmpty()) {
        //png image
        QString filename = layer->path.isNull() ? path : layer->path;
        filename.append(layer->last);
 
        result = importDoc->openPath(filename,
                                    KisDocument::DontAddToRecent);
        if (result)
            layer->channel->importFrame(layer->frame, importDoc->image()->projection(), nullptr);
 
    } else {
        //blank
        layer->channel->addKeyframe(layer->frame);
    }
    return (result) ? ImportExportCodes::OK : ImportExportCodes::Failure;
}

References KisKeyframeChannel::addKeyframe(), CSVLayerRecord::blending, CSVLayerRecord::channel, KisImage::colorSpace(), convertBlending(), CSVLayerRecord::density, KisDocument::DontAddToRecent, KisBaseNode::enableAnimation(), ImportExportCodes::Failure, CSVLayerRecord::frame, KisBaseNode::getKeyframeChannel(), KoID::id(), KisDocument::image, KisRasterKeyframeChannel::importFrame(), CSVLayerRecord::last, CSVLayerRecord::layer, m_image, CSVLayerRecord::name, KisImage::nextLayerName(), ImportExportCodes::OK, OPACITY_OPAQUE_U8, KisDocument::openPath(), CSVLayerRecord::path, KisImage::projection(), KisKeyframeChannel::Raster, KisBaseNode::setCompositeOpId(), KisBaseNode::setVisible(), and CSVLayerRecord::visible.

validPath()

QString CSVLoader::validPath ( const QString & path, const QString & base )

private

Definition at line 371 of file csv_loader.cpp.

{
    //replace Windows directory separators with the universal /
 
    QString tryPath= QString(path).replace(QString("\\"), QString("/"));
    int i = tryPath.lastIndexOf("/");
 
    if (i == (tryPath.size() - 1))
        tryPath= tryPath.left(i); //remove the ending separator if exists
 
    if (QFileInfo(tryPath).isDir())
        return tryPath.append("/");
 
    QString scan(tryPath);
    i = -1;
 
    while ((i= (scan.lastIndexOf("/",i) - 1)) > 0) {
        //avoid testing if the next level will be the default xxxx.layers folder
 
        if ((i >= 6) && (scan.mid(i - 6, 7) == ".layers")) continue;
 
        tryPath= QString(base).append(scan.mid(i + 2)); //base already ending with a /
 
        if (QFileInfo(tryPath).isDir())
            return tryPath.append("/");
    }
    return QString(); //NULL string
}

Member Data Documentation

m_batchMode

bool CSVLoader::m_batchMode

private

Definition at line 44 of file csv_loader.h.

m_doc

KisDocument* CSVLoader::m_doc

private

Definition at line 43 of file csv_loader.h.

m_image

KisImageSP CSVLoader::m_image

private

Definition at line 42 of file csv_loader.h.

m_stop

bool CSVLoader::m_stop

private

Definition at line 45 of file csv_loader.h.

---

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

• plugins/impex/csv/csv_loader.h
• plugins/impex/csv/csv_loader.cpp