KisQmicSimpleConvertor Class Reference

#include <kis_qmic_simple_convertor.h>

Static Public Member Functions
static QString	blendingModeToString (QString blendMode)
static void	convertFromGmicFast (const KisQMicImage &gmicImage, KisPaintDeviceSP dst, float gmicUnitValue)
	Fast versions.
static void	convertFromGmicImage (const KisQMicImage &gmicImage, KisPaintDeviceSP dst, float gmicMaxChannelValue)
static void	convertFromQImage (const QImage &image, KisQMicImage &gmicImage, float gmicUnitValue=1.0)
static void	convertToGmicImage (KisPaintDeviceSP dev, KisQMicImage &gmicImage, QRect rc=QRect())
static void	convertToGmicImageFast (KisPaintDeviceSP dev, KisQMicImage &gmicImage, QRect rc=QRect())
static QImage	convertToQImage (const KisQMicImage &gmicImage, float gmicMaxChannelValue=255.0)
static QString	gMicNameToName (QString name)
static QString	nameToGMicName (QString name)
static QString	stringToBlendingMode (QString str)

Detailed Description

Definition at line 18 of file kis_qmic_simple_convertor.h.

Member Function Documentation

blendingModeToString()

QString KisQmicSimpleConvertor::blendingModeToString ( QString blendMode )

static

Definition at line 1087 of file kis_qmic_simple_convertor.cpp.

{
    static auto reverseModeMap = reverseMap();
    if (reverseModeMap.find(blendMode) != reverseModeMap.end())
        return reverseModeMap.at(blendMode);
    return "alpha";
}

References reverseMap().

convertFromGmicFast()

void KisQmicSimpleConvertor::convertFromGmicFast ( const KisQMicImage & gmicImage, KisPaintDeviceSP dst, float gmicUnitValue )

static

Fast versions.

Definition at line 368 of file kis_qmic_simple_convertor.cpp.

{
    dbgPlugins << "convertFromGmicFast";
    const KoColorSpace *dstColorSpace = dst->colorSpace();
    const KoColorTransformationSP gmicToDstPixelFormat(
        createTransformationFromGmic(dstColorSpace,
                                     gmicImage.m_spectrum,
                                     gmicUnitValue));
    if (!gmicToDstPixelFormat) {
        dbgPlugins << "Fall-back to slow color conversion";
        convertFromGmicImage(gmicImage, dst, gmicUnitValue);
        return;
    }
 
    dst->clear();
    dst->moveTo(0, 0);
 
    const qint32 x = 0;
    const qint32 y = 0;
    const auto width = static_cast<size_t>(gmicImage.m_width);
    const auto height = static_cast<size_t>(gmicImage.m_height);
 
    const auto *rgbaFloat32bitcolorSpace =
        KoColorSpaceRegistry::instance()->colorSpace(
            RGBAColorModelID.id(),
            Float32BitsColorDepthID.id(),
            KoColorSpaceRegistry::instance()->rgb8()->profile());
    // this function always convert to rgba or rgb with various color depth
    const quint32 dstNumChannels = rgbaFloat32bitcolorSpace->channelCount();
 
    // number of channels that we will copy
    const int numChannels = gmicImage.m_spectrum;
 
    // gmic image has 4, 3, 2, 1 channel
    std::vector<float *> planes(dstNumChannels);
    const size_t channelOffset = width * height;
    for (int channelIndex = 0; channelIndex < gmicImage.m_spectrum;
         channelIndex++) {
        planes[channelIndex] = gmicImage.m_data + channelOffset * channelIndex;
    }
 
    for (int channelIndex = gmicImage.m_spectrum;
         channelIndex < (int)dstNumChannels;
         channelIndex++) {
        planes[channelIndex] = 0; // turn off
    }
 
    size_t dataY = 0;
    int imageY = y;
    size_t rowsRemaining = height;
 
    const auto floatPixelSize = rgbaFloat32bitcolorSpace->pixelSize();
 
    KisRandomAccessorSP it = dst->createRandomAccessorNG();
    const auto tileWidth =
        static_cast<size_t>(it->numContiguousColumns(dst->x()));
    const auto tileHeight =
        static_cast<size_t>(it->numContiguousRows(dst->y()));
    Q_ASSERT(tileWidth == 64);
    Q_ASSERT(tileHeight == 64);
    std::vector<quint8> convertedTile(
        static_cast<size_t>(rgbaFloat32bitcolorSpace->pixelSize()) * tileWidth
        * tileHeight);
 
    // grayscale and rgb case does not have alpha, so let's fill 4th channel of
    // rgba tile with opacity opaque
    if (gmicImage.m_spectrum == 1 || gmicImage.m_spectrum == 3) {
        const auto nPixels = tileWidth * tileHeight;
        auto *srcPixel =
            reinterpret_cast<KoRgbF32Traits::Pixel *>(convertedTile.data());
        for (size_t pixelIndex = 0; pixelIndex < nPixels;
             pixelIndex++, srcPixel++) {
            srcPixel->alpha = gmicUnitValue;
        }
    }
 
    while (rowsRemaining > 0) {
        size_t dataX = 0;
        qint32 imageX = x;
        size_t columnsRemaining = width;
        const auto numContiguousImageRows =
            static_cast<size_t>(it->numContiguousRows(imageY));
 
        size_t rowsToWork = qMin(numContiguousImageRows, rowsRemaining);
 
        while (columnsRemaining > 0) {
            const auto numContiguousImageColumns =
                static_cast<size_t>(it->numContiguousColumns(imageX));
            auto columnsToWork =
                qMin(numContiguousImageColumns, columnsRemaining);
 
            const auto dataIdx = dataX + dataY * width;
            const auto tileRowStride =
                (tileWidth - columnsToWork) * floatPixelSize;
 
            auto *tileItStart = convertedTile.data();
            // copy gmic channels to float tile
            const auto channelSize = sizeof(float);
            for (int i = 0; i < numChannels; i++) {
                float *planeIt = planes[i] + dataIdx;
                const auto dataStride = width - columnsToWork;
                quint8 *tileIt = tileItStart;
 
                for (size_t row = 0; row < rowsToWork; row++) {
                    for (size_t col = 0; col < columnsToWork; col++) {
                        memcpy(tileIt, planeIt, channelSize);
                        tileIt += floatPixelSize;
                        planeIt += 1;
                    }
 
                    tileIt += tileRowStride;
                    planeIt += dataStride;
                }
                tileItStart += channelSize;
            }
 
            it->moveTo(imageX, imageY);
            quint8 *dstTileItStart = it->rawData();
            tileItStart =
                convertedTile.data(); // back to the start of the converted tile
            // copy float tile to dst colorspace based on input colorspace (rgb
            // or grayscale)
            for (size_t row = 0; row < rowsToWork; row++) {
                gmicToDstPixelFormat->transform(
                    tileItStart,
                    dstTileItStart,
                    static_cast<int>(columnsToWork));
                dstTileItStart += dstColorSpace->pixelSize() * tileWidth;
                tileItStart += floatPixelSize * tileWidth;
            }
 
            imageX += static_cast<int>(columnsToWork);
            dataX += columnsToWork;
            columnsRemaining -= columnsToWork;
        }
 
        imageY += static_cast<int>(rowsToWork);
        dataY += rowsToWork;
        rowsRemaining -= rowsToWork;
    }
 
    dst->crop(x, y, static_cast<qint32>(width), static_cast<qint32>(height));
}

References KoColorSpace::channelCount(), KisPaintDevice::clear(), KisPaintDevice::colorSpace(), KoColorSpaceRegistry::colorSpace(), convertFromGmicImage(), KisPaintDevice::createRandomAccessorNG(), createTransformationFromGmic(), KisPaintDevice::crop(), dbgPlugins, Float32BitsColorDepthID, KoID::id(), KoColorSpaceRegistry::instance(), KisQMicImage::m_data, KisQMicImage::m_height, KisQMicImage::m_spectrum, KisQMicImage::m_width, KisPaintDevice::moveTo(), KisRandomConstAccessorNG::moveTo(), KisRandomConstAccessorNG::numContiguousColumns(), KisRandomConstAccessorNG::numContiguousRows(), KoColorSpace::pixelSize(), KoColorSpace::profile(), KisBaseAccessor::rawData(), KoColorSpaceRegistry::rgb8(), RGBAColorModelID, KisPaintDevice::x(), and KisPaintDevice::y().

convertFromGmicImage()

void KisQmicSimpleConvertor::convertFromGmicImage ( const KisQMicImage & gmicImage, KisPaintDeviceSP dst, float gmicMaxChannelValue )

static

Definition at line 751 of file kis_qmic_simple_convertor.cpp.

{
    dbgPlugins << "convertFromGmicSlow";
    Q_ASSERT(!dst.isNull());
    const KoColorSpace *rgbaFloat32bitcolorSpace =
        KoColorSpaceRegistry::instance()->colorSpace(
            RGBAColorModelID.id(),
            Float32BitsColorDepthID.id(),
            KoColorSpaceRegistry::instance()->rgb8()->profile());
    const KoColorSpace *dstColorSpace = dst->colorSpace();
 
    KisPaintDeviceSP dev = dst;
    const size_t greenOffset =
        static_cast<size_t>(gmicImage.m_width) * gmicImage.m_height;
    const size_t blueOffset = greenOffset * 2;
    const size_t alphaOffset = greenOffset * 3;
    QRect rc(0,
             0,
             static_cast<int>(gmicImage.m_width),
             static_cast<int>(gmicImage.m_height));
 
    KisRandomAccessorSP it = dev->createRandomAccessorNG();
    float r = 0;
    float g = 0;
    float b = 0;
    float a = 1.0;
 
    const size_t optimalBufferSize =
        64; // most common numContiguousColumns, tile size?
    std::vector<quint8> floatRGBApixelStorage(
        rgbaFloat32bitcolorSpace->pixelSize() * optimalBufferSize);
    quint8 *floatRGBApixel = floatRGBApixelStorage.data();
    const auto pixelSize = rgbaFloat32bitcolorSpace->pixelSize();
 
    const auto renderingIntent =
        KoColorConversionTransformation::internalRenderingIntent();
    const auto conversionFlags =
        KoColorConversionTransformation::internalConversionFlags();
 
    // Krita needs rgba in 0.0...1.0
    const float multiplied =
        KoColorSpaceMathsTraits<float>::unitValue / gmicMaxChannelValue;
 
    switch (gmicImage.m_spectrum) {
    case 1: {
        // convert grayscale to rgba
        for (int y = 0; y < rc.height(); y++) {
            int x = 0;
            while (x < rc.width()) {
                it->moveTo(x, y);
                auto numContiguousColumns =
                    qMin(static_cast<size_t>(it->numContiguousColumns(x)),
                         optimalBufferSize);
                numContiguousColumns =
                    qMin(numContiguousColumns,
                         static_cast<size_t>(rc.width() - x));
 
                size_t pos = static_cast<size_t>(y) * gmicImage.m_width
                    + static_cast<size_t>(x);
                for (size_t bx = 0; bx < numContiguousColumns; bx++) {
                    r = g = b = gmicImage.m_data[pos] * multiplied;
                    a = KoColorSpaceMathsTraits<float>::unitValue;
 
                    memcpy(floatRGBApixel + bx * pixelSize, &r, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 4, &g, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 8, &b, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 12, &a, 4);
                    pos++;
                }
                rgbaFloat32bitcolorSpace->convertPixelsTo(
                    floatRGBApixel,
                    it->rawData(),
                    dstColorSpace,
                    static_cast<quint32>(numContiguousColumns),
                    renderingIntent,
                    conversionFlags);
                x += static_cast<int>(numContiguousColumns);
            }
        }
        break;
    }
    case 2: {
        // convert grayscale alpha to rgba
        for (int y = 0; y < rc.height(); y++) {
            int x = 0;
            while (x < rc.width()) {
                it->moveTo(x, y);
                auto numContiguousColumns =
                    qMin(static_cast<size_t>(it->numContiguousColumns(x)),
                         optimalBufferSize);
                numContiguousColumns =
                    qMin(numContiguousColumns,
                         static_cast<size_t>(rc.width() - x));
 
                size_t pos = static_cast<size_t>(y) * gmicImage.m_width
                    + static_cast<size_t>(x);
                for (size_t bx = 0; bx < numContiguousColumns; bx++) {
                    r = g = b = gmicImage.m_data[pos] * multiplied;
                    a = gmicImage.m_data[pos + greenOffset] * multiplied;
 
                    memcpy(floatRGBApixel + bx * pixelSize, &r, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 4, &g, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 8, &b, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 12, &a, 4);
                    pos++;
                }
                rgbaFloat32bitcolorSpace->convertPixelsTo(
                    floatRGBApixel,
                    it->rawData(),
                    dstColorSpace,
                    static_cast<quint32>(numContiguousColumns),
                    renderingIntent,
                    conversionFlags);
                x += static_cast<int>(numContiguousColumns);
            }
        }
        break;
    }
    case 3: {
        // convert rgb -> rgba
        for (int y = 0; y < rc.height(); y++) {
            int x = 0;
            while (x < rc.width()) {
                it->moveTo(x, y);
                auto numContiguousColumns =
                    qMin(static_cast<size_t>(it->numContiguousColumns(x)),
                         optimalBufferSize);
                numContiguousColumns =
                    qMin(numContiguousColumns,
                         static_cast<size_t>(rc.width() - x));
 
                size_t pos = static_cast<size_t>(y) * gmicImage.m_width
                    + static_cast<size_t>(x);
                for (size_t bx = 0; bx < numContiguousColumns; bx++) {
                    r = gmicImage.m_data[pos] * multiplied;
                    g = gmicImage.m_data[pos + greenOffset] * multiplied;
                    b = gmicImage.m_data[pos + blueOffset] * multiplied;
                    a = gmicMaxChannelValue * multiplied;
 
                    memcpy(floatRGBApixel + bx * pixelSize, &r, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 4, &g, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 8, &b, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 12, &a, 4);
                    pos++;
                }
                rgbaFloat32bitcolorSpace->convertPixelsTo(
                    floatRGBApixel,
                    it->rawData(),
                    dstColorSpace,
                    static_cast<quint32>(numContiguousColumns),
                    renderingIntent,
                    conversionFlags);
                x += static_cast<int>(numContiguousColumns);
            }
        }
        break;
    }
    case 4: {
        for (int y = 0; y < rc.height(); y++) {
            int x = 0;
            while (x < rc.width()) {
                it->moveTo(x, y);
                auto numContiguousColumns =
                    qMin(static_cast<size_t>(it->numContiguousColumns(x)),
                         optimalBufferSize);
                numContiguousColumns =
                    qMin(numContiguousColumns,
                         static_cast<size_t>(rc.width() - x));
 
                size_t pos = static_cast<size_t>(y) * gmicImage.m_width
                    + static_cast<size_t>(x);
                for (size_t bx = 0; bx < numContiguousColumns; bx++) {
                    r = gmicImage.m_data[pos] * multiplied;
                    g = gmicImage.m_data[pos + greenOffset] * multiplied;
                    b = gmicImage.m_data[pos + blueOffset] * multiplied;
                    a = gmicImage.m_data[pos + alphaOffset] * multiplied;
 
                    memcpy(floatRGBApixel + bx * pixelSize, &r, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 4, &g, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 8, &b, 4);
                    memcpy(floatRGBApixel + bx * pixelSize + 12, &a, 4);
                    pos++;
                }
                rgbaFloat32bitcolorSpace->convertPixelsTo(
                    floatRGBApixel,
                    it->rawData(),
                    dstColorSpace,
                    static_cast<quint32>(numContiguousColumns),
                    renderingIntent,
                    conversionFlags);
                x += static_cast<int>(numContiguousColumns);
            }
        }
        break;
    }
 
    default: {
        dbgPlugins << "Unsupported gmic output format : " << gmicImage.m_width
                   << gmicImage.m_height << gmicImage.m_spectrum;
    }
    }
}

References KisPaintDevice::colorSpace(), KoColorSpaceRegistry::colorSpace(), KoColorSpace::convertPixelsTo(), KisPaintDevice::createRandomAccessorNG(), dbgPlugins, Float32BitsColorDepthID, KoID::id(), KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KisSharedPtr< T >::isNull(), KisQMicImage::m_data, KisQMicImage::m_height, KisQMicImage::m_spectrum, KisQMicImage::m_width, KisRandomConstAccessorNG::moveTo(), KisRandomConstAccessorNG::numContiguousColumns(), KoColorSpace::pixelSize(), KoColorSpace::profile(), KisBaseAccessor::rawData(), KoColorSpaceRegistry::rgb8(), and RGBAColorModelID.

convertFromQImage()

void KisQmicSimpleConvertor::convertFromQImage ( const QImage & image, KisQMicImage & gmicImage, float gmicUnitValue = 1.0 )

static

Definition at line 988 of file kis_qmic_simple_convertor.cpp.

{
    const auto greenOffset =
        static_cast<size_t>(gmicImage.m_width) * gmicImage.m_height;
    const size_t blueOffset = greenOffset * 2;
    const size_t alphaOffset = greenOffset * 3;
 
    // QImage has 0..255
    const float qimageUnitValue = 255.0f;
    const float multiplied = gmicUnitValue / qimageUnitValue;
 
    Q_ASSERT(image.width() == int(gmicImage.m_width));
    Q_ASSERT(image.height() == int(gmicImage.m_height));
    Q_ASSERT(image.format() == QImage::Format_ARGB32);
 
    switch (gmicImage.m_spectrum) {
    case 1: {
        for (int y = 0; y < image.height(); y++) {
            const QRgb *pixel =
                reinterpret_cast<const QRgb *>(image.scanLine(y));
            for (int x = 0; x < image.width(); x++) {
                const auto pos = static_cast<size_t>(y) * gmicImage.m_width
                    + static_cast<size_t>(x);
                gmicImage.m_data[pos] =
                    static_cast<float>(qGray(pixel[x])) * multiplied;
            }
        }
        break;
    }
    case 2: {
        for (int y = 0; y < image.height(); y++) {
            const QRgb *pixel =
                reinterpret_cast<const QRgb *>(image.scanLine(y));
            for (int x = 0; x < image.width(); x++) {
                const auto pos = static_cast<size_t>(y) * gmicImage.m_width
                    + static_cast<size_t>(x);
                gmicImage.m_data[pos] =
                    static_cast<float>(qGray(pixel[x])) * multiplied;
                gmicImage.m_data[pos + greenOffset] =
                    static_cast<float>(qAlpha(pixel[x])) * multiplied;
            }
        }
        break;
    }
    case 3: {
        for (int y = 0; y < image.height(); y++) {
            const QRgb *pixel =
                reinterpret_cast<const QRgb *>(image.scanLine(y));
            for (int x = 0; x < image.width(); x++) {
                const auto pos = static_cast<size_t>(y) * gmicImage.m_width
                    + static_cast<size_t>(x);
                gmicImage.m_data[pos] =
                    static_cast<float>(qRed(pixel[x])) * multiplied;
                gmicImage.m_data[pos + greenOffset] =
                    static_cast<float>(qGreen(pixel[x])) * multiplied;
                gmicImage.m_data[pos + blueOffset] =
                    static_cast<float>(qBlue(pixel[x])) * multiplied;
            }
        }
        break;
    }
    case 4: {
        for (int y = 0; y < image.height(); y++) {
            const QRgb *pixel =
                reinterpret_cast<const QRgb *>(image.scanLine(y));
            for (int x = 0; x < image.width(); x++) {
                const auto pos = static_cast<size_t>(y) * gmicImage.m_width
                    + static_cast<size_t>(x);
                gmicImage.m_data[pos] =
                    static_cast<float>(qRed(pixel[x])) * multiplied;
                gmicImage.m_data[pos + greenOffset] =
                    static_cast<float>(qGreen(pixel[x])) * multiplied;
                gmicImage.m_data[pos + blueOffset] =
                    static_cast<float>(qBlue(pixel[x])) * multiplied;
                gmicImage.m_data[pos + alphaOffset] =
                    static_cast<float>(qAlpha(pixel[x])) * multiplied;
            }
        }
        break;
    }
    default: {
        Q_ASSERT(false);
        dbgKrita << "Unexpected gmic image format";
        break;
    }
    }
}

References dbgKrita, KisQMicImage::m_data, KisQMicImage::m_height, KisQMicImage::m_spectrum, and KisQMicImage::m_width.

convertToGmicImage()

void KisQmicSimpleConvertor::convertToGmicImage ( KisPaintDeviceSP dev, KisQMicImage & gmicImage, QRect rc = QRect() )

static

Definition at line 662 of file kis_qmic_simple_convertor.cpp.

{
    Q_ASSERT(!dev.isNull());
    Q_ASSERT(gmicImage.m_spectrum == 4); // rgba
 
    if (rc.isEmpty()) {
        rc = QRect(0,
                   0,
                   static_cast<int>(gmicImage.m_width),
                   static_cast<int>(gmicImage.m_height));
    }
 
    const KoColorSpace *rgbaFloat32bitcolorSpace =
        KoColorSpaceRegistry::instance()->colorSpace(
            RGBAColorModelID.id(),
            Float32BitsColorDepthID.id(),
            KoColorSpaceRegistry::instance()->rgb8()->profile());
    Q_CHECK_PTR(rgbaFloat32bitcolorSpace);
 
    const KoColorTransformationSP pixelToGmicPixelFormat(
        createTransformation(rgbaFloat32bitcolorSpace));
 
    const size_t greenOffset =
        static_cast<size_t>(gmicImage.m_width) * gmicImage.m_height;
    const size_t blueOffset = greenOffset * 2;
    const size_t alphaOffset = greenOffset * 3;
 
    const auto renderingIntent =
        KoColorConversionTransformation::internalRenderingIntent();
    const auto conversionFlags =
        KoColorConversionTransformation::internalConversionFlags();
 
    const KoColorSpace *colorSpace = dev->colorSpace();
    KisRandomConstAccessorSP it = dev->createRandomConstAccessorNG();
 
    const size_t optimalBufferSize =
        64; // most common numContiguousColumns, tile size?
    std::vector<quint8> floatRGBApixelStorage(
        rgbaFloat32bitcolorSpace->pixelSize() * optimalBufferSize);
    quint8 *floatRGBApixel = floatRGBApixelStorage.data();
 
    const auto pixelSize = rgbaFloat32bitcolorSpace->pixelSize();
    for (int y = 0; y < rc.height(); y++) {
        int x = 0;
        while (x < rc.width()) {
            it->moveTo(rc.x() + x, rc.y() + y);
            auto numContiguousColumns =
                qMin(static_cast<size_t>(it->numContiguousColumns(rc.x() + x)),
                     optimalBufferSize);
            numContiguousColumns =
                qMin(numContiguousColumns, static_cast<size_t>(rc.width() - x));
 
            colorSpace->convertPixelsTo(
                it->rawDataConst(),
                floatRGBApixel,
                rgbaFloat32bitcolorSpace,
                static_cast<quint32>(numContiguousColumns),
                renderingIntent,
                conversionFlags);
            pixelToGmicPixelFormat->transform(
                floatRGBApixel,
                floatRGBApixel,
                static_cast<qint32>(numContiguousColumns));
 
            auto pos = static_cast<size_t>(y) * gmicImage.m_width
                + static_cast<size_t>(x);
            for (size_t bx = 0; bx < numContiguousColumns; bx++) {
                memcpy(gmicImage.m_data + pos,
                       floatRGBApixel + bx * pixelSize,
                       4);
                memcpy(gmicImage.m_data + pos + greenOffset,
                       floatRGBApixel + bx * pixelSize + 4,
                       4);
                memcpy(gmicImage.m_data + pos + blueOffset,
                       floatRGBApixel + bx * pixelSize + 8,
                       4);
                memcpy(gmicImage.m_data + pos + alphaOffset,
                       floatRGBApixel + bx * pixelSize + 12,
                       4);
                pos++;
            }
 
            x += static_cast<int>(numContiguousColumns);
        }
    }
}

References KisPaintDevice::colorSpace(), KoColorSpaceRegistry::colorSpace(), KoColorSpace::convertPixelsTo(), KisPaintDevice::createRandomConstAccessorNG(), createTransformation(), Float32BitsColorDepthID, KoID::id(), KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KisSharedPtr< T >::isNull(), KisQMicImage::m_data, KisQMicImage::m_height, KisQMicImage::m_spectrum, KisQMicImage::m_width, KisRandomConstAccessorNG::moveTo(), KisRandomConstAccessorNG::numContiguousColumns(), KoColorSpace::pixelSize(), KoColorSpace::profile(), KisBaseConstAccessor::rawDataConst(), KoColorSpaceRegistry::rgb8(), and RGBAColorModelID.

convertToGmicImageFast()

void KisQmicSimpleConvertor::convertToGmicImageFast ( KisPaintDeviceSP dev, KisQMicImage & gmicImage, QRect rc = QRect() )

static

Definition at line 514 of file kis_qmic_simple_convertor.cpp.

{
    KoColorTransformationSP pixelToGmicPixelFormat(
        createTransformation(dev->colorSpace()));
    if (!pixelToGmicPixelFormat) {
        dbgPlugins << "Fall-back to slow color conversion method";
        convertToGmicImage(dev, gmicImage, rc);
        return;
    }
 
    if (rc.isEmpty()) {
        dbgPlugins
            << "Image rectangle is empty! Using supplied gmic layer dimension";
        rc = QRect(0,
                   0,
                   static_cast<int>(gmicImage.m_width),
                   static_cast<int>(gmicImage.m_height));
    }
 
    const auto x = rc.x();
    const auto y = rc.y();
    const size_t width = rc.width() < 0 ? 0 : static_cast<size_t>(rc.width());
    const size_t height =
        rc.height() < 0 ? 0 : static_cast<size_t>(rc.height());
 
    const qint32 numChannels = 4;
 
    const size_t greenOffset =
        static_cast<size_t>(gmicImage.m_width) * gmicImage.m_height;
    const size_t blueOffset = greenOffset * 2;
    const size_t alphaOffset = greenOffset * 3;
 
    const std::array<float *, 4> planes = {gmicImage.m_data,
                                           gmicImage.m_data + greenOffset,
                                           gmicImage.m_data + blueOffset,
                                           gmicImage.m_data + alphaOffset};
 
    KisRandomConstAccessorSP it = dev->createRandomConstAccessorNG();
    const auto tileWidth = it->numContiguousColumns(dev->x());
    const auto tileHeight = it->numContiguousRows(dev->y());
 
    Q_ASSERT(tileWidth == 64);
    Q_ASSERT(tileHeight == 64);
 
    const KoColorSpace *rgbaFloat32bitcolorSpace =
        KoColorSpaceRegistry::instance()->colorSpace(
            RGBAColorModelID.id(),
            Float32BitsColorDepthID.id(),
            KoColorSpaceRegistry::instance()->rgb8()->profile());
    Q_CHECK_PTR(rgbaFloat32bitcolorSpace);
    const auto dstPixelSize = rgbaFloat32bitcolorSpace->pixelSize();
    const auto srcPixelSize = dev->pixelSize();
 
    std::vector<quint8> dstTile(dstPixelSize * static_cast<size_t>(tileWidth)
                                * static_cast<size_t>(tileHeight));
 
    size_t dataY = 0;
    int imageY = y;
    int imageX = x;
    it->moveTo(imageX, imageY);
    size_t rowsRemaining = height;
 
    while (rowsRemaining > 0) {
        size_t dataX = 0;
        imageX = x;
        size_t columnsRemaining = width;
        const auto numContiguousImageRows = it->numContiguousRows(imageY);
 
        const auto rowsToWork =
            qMin(numContiguousImageRows, static_cast<qint32>(rowsRemaining));
        const auto convertedTileY = tileHeight - rowsToWork;
        Q_ASSERT(convertedTileY >= 0);
 
        while (columnsRemaining > 0) {
            const auto numContiguousImageColumns =
                static_cast<size_t>(it->numContiguousColumns(imageX));
            const auto columnsToWork =
                qMin(numContiguousImageColumns, columnsRemaining);
            const auto convertedTileX =
                tileWidth - static_cast<qint32>(columnsToWork);
            Q_ASSERT(convertedTileX >= 0);
 
            const auto dataIdx = dataX + dataY * width;
            const auto dstTileIndex =
                convertedTileX + convertedTileY * tileWidth;
            const auto tileRowStride =
                (static_cast<size_t>(tileWidth) - columnsToWork) * dstPixelSize;
            const auto srcTileRowStride =
                (static_cast<size_t>(tileWidth) - columnsToWork) * srcPixelSize;
 
            it->moveTo(imageX, imageY);
            quint8 *tileItStart = dstTile.data() + dstTileIndex * dstPixelSize;
 
            // transform tile row by row
            auto *dstTileIt = tileItStart;
            const auto *srcTileIt = it->rawDataConst();
 
            auto row = rowsToWork;
            while (row > 0) {
                pixelToGmicPixelFormat->transform(
                    srcTileIt,
                    dstTileIt,
                    static_cast<qint32>(columnsToWork));
                srcTileIt += columnsToWork * srcPixelSize;
                srcTileIt += srcTileRowStride;
 
                dstTileIt += columnsToWork * dstPixelSize;
                dstTileIt += tileRowStride;
 
                row--;
            }
 
            // here we want to copy floats to dstTile, so tileItStart has to
            // point to float buffer
            const auto channelSize = sizeof(float);
            for (size_t i = 0; i < numChannels; i++) {
                float *planeIt = planes.at(i) + dataIdx;
                const auto dataStride = (width - columnsToWork);
                quint8 *tileIt = tileItStart;
 
                for (int row = 0; row < rowsToWork; row++) {
                    for (size_t col = 0; col < columnsToWork; col++) {
                        memcpy(planeIt, tileIt, channelSize);
                        tileIt += dstPixelSize;
                        planeIt += 1;
                    }
 
                    tileIt += tileRowStride;
                    planeIt += dataStride;
                }
                // skip channel in tile: red, green, blue, alpha
                tileItStart += channelSize;
            }
 
            imageX += static_cast<int>(columnsToWork);
            dataX += columnsToWork;
            columnsRemaining -= columnsToWork;
        }
 
        imageY += static_cast<int>(rowsToWork);
        dataY += rowsToWork;
        rowsRemaining -= rowsToWork;
    }
}

References KisPaintDevice::colorSpace(), KoColorSpaceRegistry::colorSpace(), convertToGmicImage(), KisPaintDevice::createRandomConstAccessorNG(), createTransformation(), dbgPlugins, Float32BitsColorDepthID, KoID::id(), KoColorSpaceRegistry::instance(), KisQMicImage::m_data, KisQMicImage::m_height, KisQMicImage::m_width, KisRandomConstAccessorNG::moveTo(), KisRandomConstAccessorNG::numContiguousColumns(), KisRandomConstAccessorNG::numContiguousRows(), KisPaintDevice::pixelSize(), KoColorSpace::pixelSize(), KoColorSpace::profile(), KisBaseConstAccessor::rawDataConst(), KoColorSpaceRegistry::rgb8(), RGBAColorModelID, KisPaintDevice::x(), and KisPaintDevice::y().

convertToQImage()

QImage KisQmicSimpleConvertor::convertToQImage ( const KisQMicImage & gmicImage, float gmicMaxChannelValue = 255.0 )

static

Definition at line 956 of file kis_qmic_simple_convertor.cpp.

{
    QImage image = QImage(static_cast<int>(gmicImage.m_width),
                          static_cast<int>(gmicImage.m_height),
                          QImage::Format_ARGB32);
 
    dbgPlugins << image.format() << "first pixel:" << gmicImage.m_data[0]
               << gmicImage.m_width << gmicImage.m_height
               << gmicImage.m_spectrum;
 
    const size_t greenOffset =
        static_cast<size_t>(gmicImage.m_width) * gmicImage.m_height;
    const size_t blueOffset = greenOffset * 2;
 
    // always put 255 to qimage
    const float multiplied = 255.0f / gmicActualMaxChannelValue;
 
    for (int y = 0; y < gmicImage.m_height; y++) {
        QRgb *pixel =
            reinterpret_cast<QRgb *>(image.scanLine(static_cast<int>(y)));
        for (int x = 0; x < gmicImage.m_width; x++) {
            const auto pos = y * gmicImage.m_width + x;
            const float r = gmicImage.m_data[pos] * multiplied;
            const float g = gmicImage.m_data[pos + greenOffset] * multiplied;
            const float b = gmicImage.m_data[pos + blueOffset] * multiplied;
            pixel[x] = qRgb(int(r), int(g), int(b));
        }
    }
    return image;
}

References dbgPlugins, KisQMicImage::m_data, KisQMicImage::m_height, KisQMicImage::m_spectrum, and KisQMicImage::m_width.

gMicNameToName()

QString KisQmicSimpleConvertor::gMicNameToName ( QString name )

static

Decode the GMic-encoded name back into the one with parenthesis

See also

nameToGMicName()

Definition at line 1108 of file kis_qmic_simple_convertor.cpp.

{
    name.replace(QChar(21), QChar('(')).replace(QChar(22), QChar(')'));
    return name;
}

nameToGMicName()

QString KisQmicSimpleConvertor::nameToGMicName ( QString name )

static

A special function that removes all parenthesis from the layer name, since parenthesis are used in GMic to encode layer properties.

The function basically replaces '(' and ')' symbols with \u0015 and \u0016 correspondingly.

Definition at line 1102 of file kis_qmic_simple_convertor.cpp.

{
    name.replace(QChar('('), QChar(21)).replace(QChar(')'), QChar(22));
    return name;
}

stringToBlendingMode()

QString KisQmicSimpleConvertor::stringToBlendingMode ( QString str )

static

Definition at line 1095 of file kis_qmic_simple_convertor.cpp.

{
    if (blendingModeMap.find(blendMode) != blendingModeMap.end())
        return blendingModeMap.at(blendMode);
    return COMPOSITE_OVER;
}

References blendingModeMap, and COMPOSITE_OVER.

---

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

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