LayerSplit Class Reference

#include <layersplit.h>

Inheritance diagram for LayerSplit:

Public Member Functions
	LayerSplit (QObject *parent, const QVariantList &)
	~LayerSplit () override
Public Member Functions inherited from KisActionPlugin
	KisActionPlugin (QObject *parent=0)
	~KisActionPlugin () override

Private Slots
void	slotLayerSplit ()

Additional Inherited Members
Protected Member Functions inherited from KisActionPlugin
void	addAction (const QString &name, KisAction *action)
void	addOperation (KisOperation *operation)
void	addUIFactory (KisOperationUIFactory *factory)
KisAction *	createAction (const QString &name)
QPointer< KisViewManager >	viewManager () const

Detailed Description

Definition at line 14 of file layersplit.h.

Constructor & Destructor Documentation

LayerSplit()

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

Definition at line 45 of file layersplit.cpp.

    : KisActionPlugin(parent)
{
    KisAction *action  = createAction("layersplit");
    connect(action, SIGNAL(triggered()), this, SLOT(slotLayerSplit()));
}

References connect().

~LayerSplit()

LayerSplit::~LayerSplit ( )

override

Definition at line 52 of file layersplit.cpp.

{
}

Member Function Documentation

slotLayerSplit

void LayerSplit::slotLayerSplit ( )

privateslot

Definition at line 69 of file layersplit.cpp.

{
    DlgLayerSplit dlg;
 
    if (dlg.exec() == QDialog::Accepted) {
 
        bool modeToLayer = !dlg.m_modeToMask;
        dlg.hide();
 
        KisImageSP image = viewManager()->image();
        if (!image) return;
 
        KisNodeSP node = viewManager()->activeNode();
        if (!node) return;
 
        // Convert to paint layer prior to splitting if current node is a colorize mask
        if (node->inherits("KisColorizeMask")) {
            std::future<KisNodeSP> convertedNode = KisLayerUtils::convertToPaintLayer(image, node);
            node = convertedNode.get();
        }
 
        if (!node) return;
 
        KisImageBarrierLock lock(image);
 
        KisPaintDeviceSP projection = node->projection();
        if (!projection) return;
 
        QList<Layer> colorMap;
 
        const KoColorSpace *cs = projection->colorSpace();
        QRect rc = image->bounds();
 
        int fuzziness = dlg.fuzziness();
 
        KisCursorOverrideLock cursorLock(Qt::WaitCursor);
 
        QPointer<KoUpdater> updater;
        if( modeToLayer){
            updater = viewManager()->createUnthreadedUpdater(i18n("Split into Layers"));
        }
        else {
            updater = viewManager()->createUnthreadedUpdater(i18n("Split into Masks"));
        }
 
        updater->setProgress(0);
 
        KisRandomConstAccessorSP acc = projection->createRandomConstAccessorNG();
 
        for (int row = rc.y(); row < rc.height(); ++row) {
 
            for (int col = rc.x(); col < rc.width(); ++col) {
 
                acc->moveTo(col, row);
 
                KoColor c(cs);
                c.setColor(acc->rawDataConst(), cs);
 
                if (c.opacityU8() == OPACITY_TRANSPARENT_U8) {
                    continue;
                }
 
                if (dlg.disregardOpacity()) {
                    c.setOpacity(OPACITY_OPAQUE_U8);
                }
 
                bool found = false;
                Q_FOREACH (const Layer &l, colorMap) {
                    if (fuzziness == 0) {
 
                        found = (l.color == c);
                    }
                    else {
                        quint8 match = cs->difference(l.color.data(), c.data());
                        found = (match <= fuzziness);
                    }
                    if (found) {
                        KisRandomAccessorSP dstAcc = l.accessor;
                        dstAcc->moveTo(col, row);
                        memcpy(dstAcc->rawData(), acc->rawDataConst(), cs->pixelSize());
                        const_cast<Layer*>(&l)->pixelsWritten++;
                        break;
                    }
                }
 
                if (!found) {
                    QString name = "";
                    if (dlg.palette()) {
                       name = dlg.palette()->getClosestSwatchInfo(c).swatch.name();
                    }
 
                    if (name.toLower() == "untitled" || name.toLower() == "none" || name.toLower() == "") {
                        name = KoColor::toQString(c);
                    }
                    Layer l;
                    l.color = c;
                    l.device = new KisPaintDevice(cs, name);
                    l.accessor = l.device->createRandomAccessorNG();
                    l.accessor->moveTo(col, row);
                    memcpy(l.accessor->rawData(), acc->rawDataConst(), cs->pixelSize());
                    l.pixelsWritten = 1;
                    colorMap << l;
                }
            }
 
            if (updater->interrupted()) {
                return;
            }
 
            updater->setProgress((row - rc.y()) * 100 / rc.height() - rc.y());
        }
 
        updater->setProgress(100);
 
        dbgKrita << "Created" << colorMap.size() << "layers";
//        Q_FOREACH (const Layer &l, colorMap) {
//            dbgKrita << "\t" << l.device->objectName() << ":" << l.pixelsWritten;
//        }
 
        if (dlg.sortLayers()) {
            std::sort(colorMap.begin(), colorMap.end());
        }
 
        KisUndoAdapter *undo = image->undoAdapter();
        undo->beginMacro(kundo2_i18n("Split Layer"));
        KisNodeCommandsAdapter adapter(viewManager());
 
        if(modeToLayer){
            KisGroupLayerSP baseGroup = dynamic_cast<KisGroupLayer*>(node->parent().data());
            if (!baseGroup) {
                // Masks are never nested
                baseGroup = dynamic_cast<KisGroupLayer*>(node->parent()->parent().data());
            }
 
            if (dlg.hideOriginal()) {
                node->setVisible(false);
            }
 
            if (dlg.createBaseGroup()) {
                KisGroupLayerSP grp = new KisGroupLayer(image, i18n("Color"), OPACITY_OPAQUE_U8);
                adapter.addNode(grp, baseGroup, 1);
                baseGroup = grp;
            }
 
            Q_FOREACH (const Layer &l, colorMap) {
                KisGroupLayerSP grp = baseGroup;
                if (dlg.createSeparateGroups()) {
                    grp = new KisGroupLayer(image, l.device->objectName(), OPACITY_OPAQUE_U8);
                    adapter.addNode(grp, baseGroup, 1);
                }
                KisPaintLayerSP paintLayer = new KisPaintLayer(image, l.device->objectName(), OPACITY_OPAQUE_U8, l.device);
                adapter.addNode(paintLayer, grp, 0);
                paintLayer->setAlphaLocked(dlg.lockAlpha());
            }
        }
        else{
            KisLayerSP baseGroup = dynamic_cast<KisLayer*>(node.data());
            Q_FOREACH (const Layer &l, colorMap) {
                KisSelectionMaskSP mask = new KisSelectionMask(image);
                mask->setName( l.device->objectName());
 
                KisPaintDeviceSP temp = KisPainter::convertToAlphaAsPureAlpha(l.device);
                mask->initSelection(temp , baseGroup);
                adapter.addNode(mask, baseGroup,0);
                mask->setActive(true);
            }
        }
 
        undo->endMacro();
   }
}

References Layer::accessor, KisNodeCommandsAdapter::addNode(), KisImage::bounds(), Layer::color, KisPaintDevice::colorSpace(), KisPainter::convertToAlphaAsPureAlpha(), KisLayerUtils::convertToPaintLayer(), DlgLayerSplit::createBaseGroup(), KisPaintDevice::createRandomAccessorNG(), KisPaintDevice::createRandomConstAccessorNG(), DlgLayerSplit::createSeparateGroups(), KisSharedPtr< T >::data(), KisWeakSharedPtr< T >::data(), KoColor::data(), dbgKrita, Layer::device, KoColorSpace::difference(), DlgLayerSplit::disregardOpacity(), DlgLayerSplit::fuzziness(), DlgLayerSplit::hideOriginal(), KisMask::initSelection(), kundo2_i18n(), DlgLayerSplit::lockAlpha(), DlgLayerSplit::m_modeToMask, KisRandomConstAccessorNG::moveTo(), OPACITY_OPAQUE_U8, OPACITY_TRANSPARENT_U8, KoColor::opacityU8(), DlgLayerSplit::palette(), KisNode::parent, KoColorSpace::pixelSize(), Layer::pixelsWritten, KisBaseNode::projection(), KisBaseAccessor::rawData(), KisBaseConstAccessor::rawDataConst(), KisSelectionMask::setActive(), KisPaintLayer::setAlphaLocked(), KoColor::setColor(), KisBaseNode::setName(), KoColor::setOpacity(), KisBaseNode::setVisible(), DlgLayerSplit::sortLayers(), KoColor::toQString(), KisImage::undoAdapter(), and KisActionPlugin::viewManager().

---

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

• plugins/extensions/layersplit/layersplit.h
• plugins/extensions/layersplit/layersplit.cpp