예제 #1
0
QVariant KisGmicFilterModel::data(const QModelIndex& index, int role) const
{
    if (!index.isValid())
        return QVariant();

    if (role == Qt::DisplayRole) {
        Component *item = static_cast<Component*>(index.internalPointer());
        return item->data(index.column());
    }

    if (role == CommandRole) {
        Component *item = static_cast<Component*>(index.internalPointer());
        Command * commandItem = dynamic_cast<Command *>(item);
        if (commandItem) {
            //KisGmicSettingsWidget * filterSettingsWidget = new  KisGmicSettingsWidget(commandItem);
            /*if (filterSettingsWidget)
            {
                dbgPlugins << "Sending QWidget";
                return QVariant::fromValue(filterSettingsWidget);
            }*/
            return QVariant::fromValue(commandItem);
        }
    }

    if (role == FilterSettingsRole) {
        Component *item = static_cast<Component*>(index.internalPointer());
        Command * commandItem = dynamic_cast<Command *>(item);
        if (commandItem)
        {
            //TODO: fix memory leak by using QScopedPointer
            KisGmicFilterSetting * settings = new KisGmicFilterSetting;
            commandItem->writeConfiguration(settings);

            if (m_blacklister) {
                if (m_blacklister->isBlacklisted(commandItem->name(), commandItem->parent()->name())) {
                    settings->setBlacklisted(true);
                }
            }

            return QVariant::fromValue<KisGmicFilterSetting *>(settings);
        }

    }


    return QVariant();
}
예제 #2
0
void KisGmicTests::testColorizeFilter()
{
    QString filterName = "Colorize [comics]";
    QString filterCategory = "Black & white";

    Component * c = KisGmicBlacklister::findFilter(m_root, filterCategory, filterName);

    KisGmicFilterSetting filterSettings;
    if (c == 0)
    {
            qDebug() << "Filter not found!";
    }else
    {
        Command * cmd = static_cast<Command *>(c);
        cmd->setParameter("Input layers", "Lineart + color spots");
        cmd->setParameter("Output layers", "Lineart + color spots + extrapolated colors");
        cmd->setParameter("Smoothness", "0.05");
        cmd->writeConfiguration(&filterSettings);
    }

    QVERIFY(!filterSettings.gmicCommand().isEmpty());

    // load 3 layers here
    QStringList layerNames;
    layerNames << "02_Artline.png";
    layerNames << "01_ColorMarks.png";
    layerNames << "00_BG.png";

    m_images.assign(layerNames.size());

    int layerIndex = 0;
    for (int i = 0; i < layerNames.size(); i++)
    {
        const QString& layerName = layerNames.at(i);
        QImage layerImage = QImage(QString(FILES_DATA_DIR) + QDir::separator() + layerName).convertToFormat(QImage::Format_ARGB32);
        gmic_image<float> gmicImage;
        gmicImage.assign(layerImage.width(), layerImage.height(), 1, 4);

        KisGmicSimpleConvertor::convertFromQImage(layerImage, gmicImage);
        m_images[layerIndex] = gmicImage;
        layerIndex++;
    }

    filterWithGmic(&filterSettings, "multi_colorize", m_images);
}
예제 #3
0
void KisGmicWidget::applyFilterSlot()
{
    const QModelIndex index = m_filterTree->selectionModel()->currentIndex();
    QVariant settings = index.data(FilterSettingsRole);
    if (settings.isValid())
    {
        KisGmicFilterSetting * filterSettings = settings.value<KisGmicFilterSetting * >();
        filterSettings->setInputLayerMode(m_inputOutputOptions->inputMode());
        filterSettings->setOutputMode(m_inputOutputOptions->outputMode());


        dbgPlugins << "Valid settings!";
        dbgPlugins << "GMIC command : " << filterSettings->gmicCommand();

        emit sigApplyCommand(filterSettings);
    }
    else
    {
        dbgPlugins << "Filter is not selected!";
    }

}
예제 #4
0
void KisGmicTests::testAllFilters()
{

    QQueue<Component *> q;
    q.enqueue(m_root);

    KisGmicFilterSetting filterSettings;
    int filterCount = 0;

    int failed = 0;
    int success = 0;

    QVector<QString> failedFilters;

    while (!q.isEmpty())
    {
        Component * c = q.dequeue();
        if (c->childCount() == 0)
        {
            Command * cmd = static_cast<Command *>(c);
            cmd->writeConfiguration(&filterSettings);
            //qDebug() << "Filter: " << c->name() << filterSettings.gmicCommand();
            if (!filterSettings.gmicCommand().startsWith("-_none_"))
            {
                filterCount++;

#ifdef RUN_FILTERS
                QString filterName = KisGmicBlacklister::toPlainText(cmd->name());
                QString categoryName = KisGmicBlacklister::toPlainText(cmd->parent()->name()); // parent is category

                if (isAlreadyThere( filePathify( filterName ) ))
                {
                    qDebug() << "Already works, skipping filter" << filterName;
                    success++;
                }
                else if (m_blacklister->isBlacklisted(filterName, categoryName))
                {
                    qDebug() << "Blacklisted filter, increase fails" << filterName;
                    failed++;
                    failedFilters.append(categoryName+":"+filterName);
                }
                else
                {
                    qDebug() << "Filtering with:";
                    qDebug() << QString("<category name=\"%0\">").arg(categoryName);
                    qDebug() << QString("<filter name=\"%0\" />").arg(filterName);

                    // clear previous data?
                    m_images.assign(1);
                    // copy?
                    m_images._data[0] = m_gmicImage;
                    bool result = filterWithGmic(&filterSettings, filterName, m_images);
                    result ? success++ : failed++;
                    qDebug() << "Progress status:" << "Failed:" << failed << " Success: " << success;
                    if (result == false)
                    {
                        failedFilters.append(categoryName+":"+filterName);
                    }
                }
#endif
            }
        }
        else
        {
            for (int i=0; i < c->childCount(); i++)
            {
                q.enqueue(c->child(i));
            }
        }
    }

#ifdef RUN_FILTERS
    qDebug() << "Finish status:" << "Failed:" << failed << " Success: " << success;
    qDebug() << "== Failed filters ==";
    foreach (const QString &item, failedFilters)
    {
        qDebug() << item;
    }


#else
    Q_UNUSED(success);
    Q_UNUSED(failed);
#endif


#ifndef gmic_version
#error gmic_version has to be defined in gmic.h
#endif

    int GMIC_FILTER_COUNT;
    int gmicVersion = gmic_version;
    switch (gmicVersion)
    {
        case 1570:
        {
            GMIC_FILTER_COUNT = 260;
            break;
        }
        case 1584:
        {
            GMIC_FILTER_COUNT = 288;
            break;
        }
        case 1590:
        {
            GMIC_FILTER_COUNT = 298;
            break;
        }
        default:
        {
            GMIC_FILTER_COUNT = 260;
            break;
        }
    }

    // If this fails:
    // gmic version changed and gmic was updated, right? Then please update GMIC_FILTER_COUNT. Or you caused regression in gmic def parser..
    // For now run test KisGmicTests::testAllFilters to find correct value for GMIC_FILTER_COUNT
    // If it is suspicious value (e.g. smaller then previous releases), the gmic_def.gmic file maybe changed format and should not be updated
    // without updating Krita's gmic parser
    QCOMPARE(filterCount,GMIC_FILTER_COUNT);
}