#include <kis_channel_separator.h>

Public Member Functions
	KisChannelSeparator (KisViewManager *view)

void	separate (KoUpdater *progress, enumSepAlphaOptions alphaOps, enumSepSource sourceOps, bool downscale, bool toColor, bool activateCurrentChannel)

virtual	~KisChannelSeparator ()

Private Attributes
KisViewManager *	m_viewManager

Detailed Description

Definition at line 28 of file kis_channel_separator.h.

Constructor & Destructor Documentation

◆ KisChannelSeparator()

KisChannelSeparator::KisChannelSeparator ( KisViewManager * view )

Definition at line 51 of file kis_channel_separator.cc.

    : m_viewManager(view)
{
}

◆ ~KisChannelSeparator()

virtual KisChannelSeparator::~KisChannelSeparator ( )

inlinevirtual

Definition at line 34 of file kis_channel_separator.h.

34{}

Member Function Documentation

◆ separate()

void KisChannelSeparator::separate	(	KoUpdater *	progress,
		enumSepAlphaOptions	alphaOps,
		enumSepSource	sourceOps,
		bool	downscale,
		bool	toColor,
		bool	activateCurrentChannel )

We should process the entire image, even when its pixels are transparent, because we might be pulling colors from under a zero-alpha channel.

Definition at line 56 of file kis_channel_separator.cc.

{
    KisImageSP image = m_viewManager->image();
    if (!image) return;
 
    KisPaintDeviceSP src;
 
    // Use the flattened image, if required
    switch (sourceOps) {
    case ALL_LAYERS:
        // the content will be locked later
        src = image->projection();
        break;
    case CURRENT_LAYER:
        src = m_viewManager->activeDevice();
        break;
    default:
        break;
    }
 
    if (!src) return;
 
    progressUpdater->setProgress(1);
 
    const KoColorSpace * dstCs = 0;
 
    quint32 numberOfChannels = src->channelCount();
    const KoColorSpace * srcCs  = src->colorSpace();
    const QList<KoChannelInfo *> channels = srcCs->channels();
    vKisPaintDeviceSP paintDevices;
 
    const QRect rect = image->bounds();
 
    KisImageBarrierLock lock(image);
    int i = 0;
    for (QList<KoChannelInfo *>::const_iterator it =  channels.constBegin(); it != channels.constEnd(); ++it) {
 
 
        KoChannelInfo *ch = (*it);
 
        bool channelToColor = (toColor && ch->channelType() != KoChannelInfo::ALPHA);
 
        if (ch->channelType() == KoChannelInfo::ALPHA && alphaOps != CREATE_ALPHA_SEPARATION) {
            continue;
        }
 
        qint32 channelSize = ch->size();
        qint32 channelPos = ch->pos();
        qint32 destSize = 1;
 
        KisPaintDeviceSP dev;
        if (channelToColor) {
            // We don't downscale if we separate to color channels
            dev = new KisPaintDevice(srcCs);
        } else {
            if (channelSize == 1 || downscale) {
                dev = new KisPaintDevice(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer8BitsColorDepthID.id(), 0));
            } else {
                dev = new KisPaintDevice(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer16BitsColorDepthID.id(), 0));
                destSize = 2;
            }
        }
 
        dstCs = dev->colorSpace();
 
        paintDevices.push_back(dev);
 
        KisHLineConstIteratorSP srcIt = src->createHLineConstIteratorNG(rect.x(), rect.y(), rect.width());
        KisHLineIteratorSP dstIt = dev->createHLineIteratorNG(rect.x(), rect.y(), rect.width());
 
        for (qint32 row = 0; row < rect.height(); ++row) {
            do {
                if (channelToColor) {
                    dstCs->singleChannelPixel(dstIt->rawData(), srcIt->oldRawData(), channelPos);
 
                    if (alphaOps == COPY_ALPHA_TO_SEPARATIONS) {
                        dstCs->setOpacity(dstIt->rawData(), srcCs->opacityU8(srcIt->oldRawData()), 1);
                    } else {
                        dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                    }
                } else {
 
                    // To grayscale
 
                    // Decide whether we need downscaling
                    if (channelSize == 1 && destSize == 1) {
 
                        // Both 8-bit channels
                        dstIt->rawData()[0] = srcIt->oldRawData()[channelPos];
 
                        if (alphaOps == COPY_ALPHA_TO_SEPARATIONS) {
                            dstCs->setOpacity(dstIt->rawData(), srcCs->opacityU8(srcIt->oldRawData()), 1);
                        } else {
                            dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                        }
                    } else if (channelSize == 2 && destSize == 2) {
 
                        // Both 16-bit
                        dstIt->rawData()[0] = srcIt->oldRawData()[channelPos];
                        dstIt->rawData()[1] = srcIt->oldRawData()[channelPos + 1];
 
                        if (alphaOps == COPY_ALPHA_TO_SEPARATIONS) {
                            dstCs->setOpacity(dstIt->rawData(), srcCs->opacityU8(srcIt->oldRawData()), 1);
                        } else {
                            dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                        }
                    } else if (channelSize != 1 && destSize == 1) {
                        // Downscale
                        memset(dstIt->rawData(), srcCs->scaleToU8(srcIt->oldRawData(), channelPos), 1);
 
                        dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                    } else if (channelSize != 2 && destSize == 2) {
                        // Upscale
                        dstIt->rawData()[0] = srcCs->scaleToU8(srcIt->oldRawData(), channelPos);
 
                        dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
 
                    }
                }
 
            } while (dstIt->nextPixel() && srcIt->nextPixel());
            dstIt->nextRow();
            srcIt->nextRow();
        }
        ++i;
 
        progressUpdater->setProgress((i * 100) / numberOfChannels);
        if (progressUpdater->interrupted()) {
            break;
        }
    }
 
    vKisPaintDeviceSP::const_iterator paintDeviceIterator = paintDevices.cbegin();
 
    if (!progressUpdater->interrupted()) {
        KisNodeCommandsAdapter adapter(m_viewManager);
        adapter.beginMacro(kundo2_i18n("Separate Image"));
 
        for (QList<KoChannelInfo *>::const_iterator it =  channels.constBegin(); it != channels.constEnd(); ++it) {
 
            KoChannelInfo *ch = (*it);
            if (ch->channelType() == KoChannelInfo::ALPHA && alphaOps != CREATE_ALPHA_SEPARATION) {
                // Don't make an separate separation of the alpha channel if the user didn't ask for it.
                continue;
            }
 
            KisPaintLayerSP l = new KisPaintLayer(image, ch->name(), OPACITY_OPAQUE_U8, *paintDeviceIterator);
 
            if (toColor && ch->channelType() != KoChannelInfo::ALPHA && activateCurrentChannel) {
                QBitArray channelFlags(channels.count());
                int i = 0;
                for (QList<KoChannelInfo *>::const_iterator it2 =  channels.constBegin(); it2 != channels.constEnd(); ++it2) {
                    channelFlags.setBit(i, (it == it2));
                    i++;
                }
                l->setChannelFlags(channelFlags);
            }
 
            adapter.addNode(l.data(), image->rootLayer(), 0);
            ++paintDeviceIterator;
        }
 
        adapter.endMacro();
    }
 
    progressUpdater->setProgress(100);
 
 
}

References KisViewManager::activeDevice(), KisNodeCommandsAdapter::addNode(), ALL_LAYERS, KoChannelInfo::ALPHA, KisNodeCommandsAdapter::beginMacro(), KisImage::bounds(), KoColorSpace::channels, KoChannelInfo::channelType(), KisPaintDevice::colorSpace(), COPY_ALPHA_TO_SEPARATIONS, CREATE_ALPHA_SEPARATION, KisPaintDevice::createHLineIteratorNG(), CURRENT_LAYER, KisSharedPtr< T >::data(), downscale, KisNodeCommandsAdapter::endMacro(), GrayAColorModelID, KoID::id(), KisViewManager::image(), KoColorSpaceRegistry::instance(), Integer16BitsColorDepthID, Integer8BitsColorDepthID, KoUpdater::interrupted(), kundo2_i18n(), m_viewManager, KoChannelInfo::name(), KisBaseConstIteratorNG::nextPixel(), KisHLineConstIteratorNG::nextRow(), KisBaseConstAccessor::oldRawData(), OPACITY_OPAQUE_U8, KoColorSpace::opacityU8(), KoChannelInfo::pos(), KisImage::projection(), KisImage::rootLayer(), KoColorSpace::scaleToU8(), KisLayer::setChannelFlags(), KoColorSpace::setOpacity(), KoUpdater::setProgress(), KoColorSpace::singleChannelPixel(), and KoChannelInfo::size().

Member Data Documentation

◆ m_viewManager

KisViewManager* KisChannelSeparator::m_viewManager

private

Definition at line 40 of file kis_channel_separator.h.

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

plugins/extensions/separate_channels/kis_channel_separator.h
plugins/extensions/separate_channels/kis_channel_separator.cc

Public Member Functions

Private Attributes