KisQmicImportTools Namespace Reference

Functions
KUndo2Command *	applyLayerNameChanges (const KisQMicImage &srcGmicImage, KisNode *node, KisSelectionSP selection)
void	gmicImageToPaintDevice (const KisQMicImage &srcGmicImage, KisPaintDeviceSP dst, KisSelectionSP selection, const QRect &dstRect)
KisNodeListSP	inputNodes (KisImageSP image, InputLayerMode inputMode, KisNodeSP currentNode)

Function Documentation

applyLayerNameChanges()

KUndo2Command * KisQmicImportTools::applyLayerNameChanges	(	const KisQMicImage &	srcGmicImage,
		KisNode *	node,
		KisSelectionSP	selection )

Definition at line 32 of file kis_qmic_import_tools.cpp.

{
    dbgPlugins << "KisQmicImportTools::applyLayerNameChanges";
 
    auto *cmd = new KisCommandUtils::CompositeCommand();
 
    dbgPlugins << "Layer name: " << srcGmicImage.m_layerName;
 
    {
        const QRegularExpression modeRe(R"(mode\‍(\s*([^)]*)\s*\))");
        QRegularExpressionMatch match;
        if (srcGmicImage.m_layerName.contains(modeRe, &match)) {
            QString modeStr = match.captured(1).trimmed();
            auto translatedMode =
                KisQmicSimpleConvertor::stringToBlendingMode(modeStr);
            dbgPlugins << "Detected mode: " << modeStr << " => "
                       << translatedMode;
            if (!translatedMode.isNull()) {
                cmd->addCommand(
                    new KisNodeCompositeOpCommand(node, translatedMode));
            }
        }
    }
 
    {
        const QRegularExpression opacityRe(R"(opacity\‍(\s*([^)]*)\s*\))");
        QRegularExpressionMatch match;
        if (srcGmicImage.m_layerName.contains(opacityRe, &match)) {
            const float opacity = match.captured(1).toFloat();
            dbgPlugins << "Detected opacity: " << opacity
                       << std::lround(opacity / 100.f * 255.f);
            cmd->addCommand(
                new KisNodeOpacityCommand(node,
                                          static_cast<quint8>(std::lround(
                                              float(opacity * 255) / 100.f))));
        }
    }
 
    {
const QRegularExpression nameRe(R"(name\‍(\s*([^)]*)\s*\))");
 
        QRegularExpressionMatch match;
        if (srcGmicImage.m_layerName.contains(nameRe, &match)) {
            const auto name = KisQmicSimpleConvertor::gMicNameToName(match.captured(1));
            dbgPlugins << "Detected layer name: " << name;
            cmd->addCommand(new KisNodeRenameCommand(node, node->name(), name));
            // apply command
        }
    }
 
    if (!selection) {
        // Some GMic filters encode layer position into the layer name.
        // E.g. from extract foreground: "name([unnamed]
        // [foreground]),pos(55,35)"
        const QRegularExpression positionPattern(
            R"(pos\‍(\s*(-?\d*)[^)](-?\d*)\s*\))");
        const QRegularExpressionMatch match =
            positionPattern.match(srcGmicImage.m_layerName);
        if (match.hasMatch()) {
            const auto x = match.captured(1).toInt();
            const auto y = match.captured(2).toInt();
            const QPoint oldPos(node->x(), node->y());
            const QPoint newPos(x, y);
            dbgPlugins << "Detected layer position: " << oldPos << newPos
                       << node->paintDevice()->exactBounds();
            cmd->addCommand(new KisNodeMoveCommand2(node, oldPos, newPos));
        }
    }
 
    return cmd;
}

References dbgPlugins, KisPaintDevice::exactBounds(), KisQmicSimpleConvertor::gMicNameToName(), KisQMicImage::m_layerName, KisBaseNode::name(), KisBaseNode::paintDevice(), KisQmicSimpleConvertor::stringToBlendingMode(), KisBaseNode::x(), and KisBaseNode::y().

gmicImageToPaintDevice()

void KisQmicImportTools::gmicImageToPaintDevice	(	const KisQMicImage &	srcGmicImage,
		KisPaintDeviceSP	dst,
		KisSelectionSP	selection,
		const QRect &	dstRect )

Definition at line 106 of file kis_qmic_import_tools.cpp.

{
    dbgPlugins << "KisQmicImportTools::gmicImageToPaintDevice()" << dstRect;
 
    if (selection) {
        KisPaintDeviceSP src = new KisPaintDevice(dst->colorSpace());
        KisQmicSimpleConvertor::convertFromGmicFast(srcGmicImage, src, 255.0f);
        KisPainter painter(dst, selection);
        painter.setCompositeOpId(COMPOSITE_COPY);
        painter.bitBlt(dstRect.topLeft(),
                       src,
                       QRect(QPoint(0, 0), dstRect.size()));
    } else {
        KisQmicSimpleConvertor::convertFromGmicFast(srcGmicImage, dst, 255.0f);
    }
}

References KisPainter::bitBlt(), KisPaintDevice::colorSpace(), COMPOSITE_COPY, KisQmicSimpleConvertor::convertFromGmicFast(), dbgPlugins, and KisPainter::setCompositeOpId().

inputNodes()

KisNodeListSP KisQmicImportTools::inputNodes	(	KisImageSP	image,
		InputLayerMode	inputMode,
		KisNodeSP	currentNode )

Definition at line 127 of file kis_qmic_import_tools.cpp.

{
    /*
        ACTIVE_LAYER,
        ALL_LAYERS,
        ACTIVE_LAYER_BELOW_LAYER,
        ACTIVE_LAYER_ABOVE_LAYER,
        ALL_VISIBLE_LAYERS,
        ALL_INVISIBLE_LAYERS,
        ALL_VISIBLE_LAYERS_DECR,
        ALL_INVISIBLE_DECR,
        ALL_DECR
    */
    const auto isAvailable = [](KisNodeSP node) -> bool {
        auto *paintLayer = dynamic_cast<KisPaintLayer *>(node.data());
        return paintLayer && paintLayer->visible(false);
    };
 
    KisNodeListSP result(new QList<KisNodeSP>());
    switch (inputMode) {
    case InputLayerMode::NoInput: {
        break;
    }
    case InputLayerMode::Active: {
        if (isAvailable(currentNode)) {
            result->prepend(currentNode);
        }
        break; // drop down in case of one more layer modes
    }
    case InputLayerMode::All: {
        result = [&]() {
            KisNodeListSP r(new QList<KisNodeSP>());
            KisLayerUtils::recursiveApplyNodes(
                image->root(),
                [&](KisNodeSP item) {
                    auto *paintLayer =
                        dynamic_cast<KisPaintLayer *>(item.data());
                    if (paintLayer) {
                        r->prepend(item);
                    }
                });
            return r;
        }();
        break;
    }
    case InputLayerMode::ActiveAndBelow: {
        if (isAvailable(currentNode)) {
            result->prepend(currentNode);
            if (isAvailable(currentNode->prevSibling())) {
                result->prepend(currentNode->prevSibling());
            }
        }
        break;
    }
    case InputLayerMode::ActiveAndAbove: {
        if (isAvailable(currentNode)) {
            result->prepend(currentNode);
            if (isAvailable(currentNode->nextSibling())) {
                result->prepend(currentNode->nextSibling());
            }
        }
        break;
    }
    case InputLayerMode::AllVisible:
    case InputLayerMode::AllInvisible: {
        const bool visibility = (inputMode == InputLayerMode::AllInvisible);
 
        result = [&]() {
            KisNodeListSP r(new QList<KisNodeSP>());
            KisLayerUtils::recursiveApplyNodes(
                image->root(),
                [&](KisNodeSP item) {
                    auto *paintLayer =
                        dynamic_cast<KisPaintLayer *>(item.data());
                    if (paintLayer
                        && paintLayer->visible(false) == visibility) {
                        r->prepend(item);
                    }
                });
            return r;
        }();
        break;
    }
    case InputLayerMode::Unspecified:
    default: {
        qWarning()
            << "Inputmode" << static_cast<int>(inputMode)
            << "must be specified by GMic or is not implemented in Krita";
        break;
    }
    }
    return result;
}

References Active, ActiveAndAbove, ActiveAndBelow, All, AllInvisible, AllVisible, KisNode::nextSibling(), NoInput, KisNode::prevSibling(), KisLayerUtils::recursiveApplyNodes(), KisNodeFacade::root, and KisBaseNode::visible().