KisImageInterface Class Reference

#include <kis_qmic_interface.h>

Inheritance diagram for KisImageInterface:

Classes
struct	Private

Public Member Functions
void	gmic_qt_detach ()
QVector< KisQMicImageSP >	gmic_qt_get_cropped_images (int mode, QRectF &cropRect)
QSize	gmic_qt_get_image_size (int mode)
void	gmic_qt_output_images (int mode, QVector< KisQMicImageSP > layers)
	KisImageInterface (KisViewManager *parent=nullptr)
	~KisImageInterface () override

Private Attributes
const QScopedPointer< Private >	p

Detailed Description

Definition at line 63 of file kis_qmic_interface.h.

Constructor & Destructor Documentation

KisImageInterface()

KisImageInterface::KisImageInterface

(

KisViewManager *

parent = nullptr

)

Definition at line 36 of file kis_qmic_interface.cpp.

    : p(new Private)
{
    p->m_viewManager = parent;
    KIS_ASSERT(p->m_viewManager);
}

References KIS_ASSERT, and p.

~KisImageInterface()

KisImageInterface::~KisImageInterface ( )

overridedefault

Member Function Documentation

gmic_qt_detach()

void KisImageInterface::gmic_qt_detach

(

)

Definition at line 210 of file kis_qmic_interface.cpp.

{
    p->m_sharedMemorySegments.clear();
}

References p.

gmic_qt_get_cropped_images()

QVector< KisQMicImageSP > KisImageInterface::gmic_qt_get_cropped_images	(	int	mode,
		QRectF &	cropRect )

Definition at line 127 of file kis_qmic_interface.cpp.

{
    // Create the shared memory segments, and create a new "message" to send back
 
    QVector<KisQMicImageSP> message;
 
    if (!p->m_viewManager)
        return {};
 
    if (!p->m_viewManager->image()->tryBarrierLock(true)) return {};
 
    KisImageBarrierLock lock(p->m_viewManager->image(), std::adopt_lock);
 
    p->m_inputMode = static_cast<InputLayerMode>(inputMode);
 
    dbgPlugins << "prepareCroppedImages()" << message << rc << inputMode;
 
    KisNodeListSP nodes =
        KisQmicImportTools::inputNodes(p->m_viewManager->image(),
                                       p->m_inputMode,
                                       p->m_viewManager->activeNode());
    if (nodes->isEmpty()) {
        return {};
    }
 
    for (auto &node : *nodes) {
         if (node && node->paintDevice()) {
            KisSelectionSP selection = p->m_viewManager->image()->globalSelection();
 
            const QRect cropRect = [&]() {
                if (selection) {
                    return selection->selectedExactRect();
                } else {
                    // XXX: This is a lie, see gmic_qt_get_image_size as to why
                    const QRect nodeBounds = node->exactBounds();
                    const QRect imageBounds = node->image()->bounds();
 
                    if (imageBounds.contains(nodeBounds)) {
                        return imageBounds;
                    } else {
                        return nodeBounds.united(imageBounds);
                    }
                }
            }();
 
            dbgPlugins << "Converting node" << node->name() << cropRect;
 
            const QRectF mappedRect = KisAlgebra2D::mapToRect(cropRect).mapRect(rc);
            const QRect resultRect = mappedRect.toAlignedRect();
 
            QString noParenthesisName(node->name());
            noParenthesisName.replace(QChar('('), QChar(21)).replace(QChar(')'), QChar(22));
 
            const auto translatedMode = KisQmicSimpleConvertor::blendingModeToString(node->compositeOpId());
 
            const QString name = QString("mode(%1),opacity(%2),pos(%3,%4),name(%5)")
                               .arg(translatedMode)
                               .arg(node->percentOpacity())
                               .arg(cropRect.x())
                               .arg(cropRect.y())
                               .arg(noParenthesisName);
 
            auto m = KisQMicImageSP::create(name, resultRect.width(), resultRect.height(), 4);
            p->m_sharedMemorySegments << m;
 
            {
                QMutexLocker lock(&m->m_mutex);
 
                KisQmicSimpleConvertor::convertToGmicImageFast(
                    node->paintDevice(),
                    *m.data(),
                    resultRect);
            }
 
            message << m;
        }
    }
 
    dbgPlugins << message;
 
    return message;
}

References KisQmicSimpleConvertor::blendingModeToString(), KisQmicSimpleConvertor::convertToGmicImageFast(), dbgPlugins, KisQmicImportTools::inputNodes(), KisAlgebra2D::mapToRect(), p, and KisSelection::selectedExactRect().

gmic_qt_get_image_size()

QSize KisImageInterface::gmic_qt_get_image_size

(

int

mode

)

Definition at line 45 of file kis_qmic_interface.cpp.

{
    if (!p->m_viewManager)
        return {};
 
    KisSelectionSP selection = p->m_viewManager->image()->globalSelection();
 
    if (selection) {
        QRect selectionRect = selection->selectedExactRect();
        return selectionRect.size();
    } else {
        p->m_inputMode = static_cast<InputLayerMode>(mode);
 
        QSize size(0, 0);
 
        dbgPlugins << "getImageSize()" << mode;
 
        KisNodeListSP nodes =
            KisQmicImportTools::inputNodes(p->m_viewManager->image(),
                                           p->m_inputMode,
                                           p->m_viewManager->activeNode());
        if (nodes->isEmpty()) {
            return size;
        }
 
        switch (p->m_inputMode) {
        case InputLayerMode::NoInput:
        case InputLayerMode::AllInvisible:
            break;
        case InputLayerMode::Active:
        case InputLayerMode::ActiveAndBelow: {
            // The last layer in the list is always the layer the user
            // has selected in Paint.NET, so it will be treated as the
            // active layer. The clipboard layer (if present) will be
            // placed above the active layer.
            const auto activeLayer = nodes->last();
 
            // G'MIC takes as the image size the size of the active layer.
            // This is a lie since a query to All will imply a query to Active
            // through CroppedActiveLayerProxy, and the latter will return a
            // bogus size if we reply straight with the paint device's bounds.
            if (activeLayer && activeLayer->paintDevice()) {
                const QSize layerSize = activeLayer->exactBounds().size();
                const QSize imageSize = activeLayer->image()->bounds().size();
                size = size.expandedTo(layerSize).expandedTo(imageSize);
            }
        } break;
        case InputLayerMode::All:
        case InputLayerMode::ActiveAndAbove:
        case InputLayerMode::AllVisible:
            for (auto &node : *nodes) {
                if (node && node->paintDevice()) {
                    // XXX: when using All, G'MIC will instead do another query
                    // through CroppedActiveLayerProxy to determine the image's
                    // "size". So we need to be both consistent with the image's
                    // bounds, but also extend them in case the layer's
                    // partially offscreen.
                    const QSize layerSize = node->exactBounds().size();
                    const QSize imageSize = node->image()->bounds().size();
                    size = size.expandedTo(layerSize).expandedTo(imageSize);
                }
            }
            break;
        case InputLayerMode::AllVisiblesDesc_DEPRECATED:
        case InputLayerMode::AllInvisiblesDesc_DEPRECATED:
        case InputLayerMode::AllDesc_DEPRECATED: {
            warnPlugins << "Inputmode" << static_cast<int>(p->m_inputMode)
                        << "is not supported by GMic anymore";
            break;
        }
        default: {
            warnPlugins
                << "Inputmode" << static_cast<int>(p->m_inputMode)
                << "must be specified by GMic or is not implemented in Krita";
            break;
        }
        }
 
        return size;
    }
}

References Active, ActiveAndAbove, ActiveAndBelow, All, AllDesc_DEPRECATED, AllInvisible, AllInvisiblesDesc_DEPRECATED, AllVisible, AllVisiblesDesc_DEPRECATED, dbgPlugins, KisQmicImportTools::inputNodes(), NoInput, p, KisSelection::selectedExactRect(), and warnPlugins.

gmic_qt_output_images()

void KisImageInterface::gmic_qt_output_images	(	int	mode,
		QVector< KisQMicImageSP >	layers )

Definition at line 215 of file kis_qmic_interface.cpp.

{
    // Parse the message. read the shared memory segments, fix up the current image and send an ack
    dbgPlugins << "gmic_qt_output_images";
    p->m_outputMode = (OutputMode)mode;
    if (p->m_outputMode != OutputMode::InPlace) {
        errPlugins << "Requested mode" << static_cast<int>(p->m_outputMode) << "which is not implemented yet";
        p->m_outputMode = OutputMode::InPlace;
    }
 
    dbgPlugins << "slotStartApplicator();" << layers;
    if (!p->m_viewManager)
        return;
 
    dbgPlugins << "Got" << layers.size() << "gmic images";
 
    {
        // Start the applicator
        KUndo2MagicString actionName = kundo2_i18n("G'MIC filter");
        KisNodeSP rootNode = p->m_viewManager->image()->root();
        KisNodeListSP mappedLayers =
            KisQmicImportTools::inputNodes(p->m_viewManager->image(),
                                           p->m_inputMode,
                                           p->m_viewManager->activeNode());
        // p->m_gmicApplicator->setProperties(p->m_viewManager->image(), rootNode, images, actionName, layers);
        // p->m_gmicApplicator->apply();
 
        KisImageSignalVector emitSignals;
        emitSignals << ComplexSizeChangedSignal();
 
        KisProcessingApplicator applicator(p->m_viewManager->image(),
                                           rootNode,
                                           KisProcessingApplicator::RECURSIVE | KisProcessingApplicator::NO_UI_UPDATES,
                                           emitSignals,
                                           actionName);
        dbgPlugins << "Created applicator " << &applicator;
 
        QRect layerSize;
        KisSelectionSP selection = p->m_viewManager->image()->globalSelection();
        if (selection) {
            layerSize = selection->selectedExactRect();
        } else {
            layerSize = QRect(0, 0, p->m_viewManager->image()->width(), p->m_viewManager->image()->height());
        }
 
        // This is a three-stage process.
 
        // 1. Layer sizes must be adjusted individually
        // 2. synchronize layer count and convert excess GMic nodes to paint
        // layers
        // 3. visit the existing nodes and reuse them to apply the remaining
        // changes from GMic
        applicator.applyCommand(
            new KisQmicSynchronizeLayersCommand(mappedLayers,
                                                layers,
                                                p->m_viewManager->image(),
                                                layerSize,
                                                selection),
            KisStrokeJobData::SEQUENTIAL,
            KisStrokeJobData::EXCLUSIVE);
 
        applicator.end();
    }
}

References KisProcessingApplicator::applyCommand(), dbgPlugins, KisProcessingApplicator::end(), errPlugins, KisStrokeJobData::EXCLUSIVE, KisBaseNode::image, InPlace, KisQmicImportTools::inputNodes(), kundo2_i18n(), KisProcessingApplicator::NO_UI_UPDATES, p, KisProcessingApplicator::RECURSIVE, KisNodeFacade::root, KisSelection::selectedExactRect(), and KisStrokeJobData::SEQUENTIAL.

Member Data Documentation

p

const QScopedPointer<Private> KisImageInterface::p

private

Definition at line 78 of file kis_qmic_interface.h.

---

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

• plugins/extensions/qmic/kis_qmic_interface.h
• plugins/extensions/qmic/kis_qmic_interface.cpp