kis_qmic_simple_convertor.cpp File Reference

#include "kis_qmic_simple_convertor.h"
#include <array>
#include <cstddef>
#include <map>
#include <memory>
#include <vector>
#include <kis_debug.h>
#include <kis_random_accessor_ng.h>
#include <KoColorModelStandardIds.h>
#include <KoColorSpace.h>
#include <KoColorSpaceRegistry.h>
#include <KoColorSpaceTraits.h>
#include <KoCompositeOpRegistry.h>

Go to the source code of this file.

Classes
class	KisColorFromFloat< _channel_type_, traits >
class	KisColorFromGrayScaleAlphaFloat< _channel_type_, traits >
class	KisColorFromGrayScaleFloat< _channel_type_, traits >
class	KisColorToFloatConvertor< _channel_type_, traits >

Macros
#define	SCALE_FROM_FLOAT(v)    KoColorSpaceMaths<float, _channel_type_>::scaleToA(v)
#define	SCALE_TO_FLOAT(v)   KoColorSpaceMaths<_channel_type_, float>::scaleToA(v)

Typedefs
using	KoColorTransformationSP = std::shared_ptr<KoColorTransformation>

Functions
static KoColorTransformation *	createTransformation (const KoColorSpace *colorSpace)
static KoColorTransformation *	createTransformationFromGmic (const KoColorSpace *colorSpace, int gmicSpectrum, float gmicUnitValue)
std::map< QString, QString >	reverseMap ()

Variables
const std::map< QString, QString >	blendingModeMap

Macro Definition Documentation

SCALE_FROM_FLOAT

#define SCALE_FROM_FLOAT

(

v

)

KoColorSpaceMaths<float, _channel_type_>::scaleToA(v)

Definition at line 26 of file kis_qmic_simple_convertor.cpp.

#define SCALE_FROM_FLOAT(v)                                                    \
    KoColorSpaceMaths<float, _channel_type_>::scaleToA(v)

SCALE_TO_FLOAT

#define SCALE_TO_FLOAT

(

v

)

KoColorSpaceMaths<_channel_type_, float>::scaleToA(v)

Definition at line 25 of file kis_qmic_simple_convertor.cpp.

Typedef Documentation

KoColorTransformationSP

using KoColorTransformationSP = std::shared_ptr<KoColorTransformation>

Definition at line 29 of file kis_qmic_simple_convertor.cpp.

Function Documentation

createTransformation()

static KoColorTransformation * createTransformation ( const KoColorSpace * colorSpace )

static

Definition at line 334 of file kis_qmic_simple_convertor.cpp.

{
    KoColorTransformation *colorTransformation = nullptr;
    if (colorSpace->colorModelId() != RGBAColorModelID) {
        dbgKrita << "Unsupported color space for fast pixel transformation to "
                    "gmic pixel format"
                 << colorSpace->id();
        return nullptr;
    }
 
    if (colorSpace->colorDepthId() == Float32BitsColorDepthID) {
        colorTransformation =
            new KisColorToFloatConvertor<float, KoRgbTraits<float>>();
    }
#ifdef HAVE_OPENEXR
    else if (colorSpace->colorDepthId() == Float16BitsColorDepthID) {
        colorTransformation =
            new KisColorToFloatConvertor<half, KoRgbTraits<half>>();
    }
#endif
    else if (colorSpace->colorDepthId() == Integer16BitsColorDepthID) {
        colorTransformation =
            new KisColorToFloatConvertor<quint16, KoBgrTraits<quint16>>();
    } else if (colorSpace->colorDepthId() == Integer8BitsColorDepthID) {
        colorTransformation =
            new KisColorToFloatConvertor<quint8, KoBgrTraits<quint8>>();
    } else {
        dbgKrita << "Unsupported color space " << colorSpace->id()
                 << " for fast pixel transformation to gmic pixel format";
        return nullptr;
    }
    return colorTransformation;
}

References KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), dbgKrita, Float16BitsColorDepthID, Float32BitsColorDepthID, KoColorSpace::id, Integer16BitsColorDepthID, Integer8BitsColorDepthID, and RGBAColorModelID.

createTransformationFromGmic()

static KoColorTransformation * createTransformationFromGmic ( const KoColorSpace * colorSpace, int gmicSpectrum, float gmicUnitValue )

static

Definition at line 252 of file kis_qmic_simple_convertor.cpp.

{
    KoColorTransformation *colorTransformation = nullptr;
    if (colorSpace->colorModelId() != RGBAColorModelID) {
        dbgKrita << "Unsupported color space for fast pixel transformation to "
                    "gmic pixel format"
                 << colorSpace->id();
        return nullptr;
    }
 
    if (colorSpace->colorDepthId() == Float32BitsColorDepthID) {
        if (gmicSpectrum == 3 || gmicSpectrum == 4) {
            colorTransformation =
                new KisColorFromFloat<float, KoRgbTraits<float>>(gmicUnitValue);
        } else if (gmicSpectrum == 1) {
            colorTransformation =
                new KisColorFromGrayScaleFloat<float, KoRgbTraits<float>>(
                    gmicUnitValue);
        } else if (gmicSpectrum == 2) {
            colorTransformation =
                new KisColorFromGrayScaleAlphaFloat<float, KoRgbTraits<float>>(
                    gmicUnitValue);
        }
    }
#ifdef HAVE_OPENEXR
    else if (colorSpace->colorDepthId() == Float16BitsColorDepthID) {
        if (gmicSpectrum == 3 || gmicSpectrum == 4) {
            colorTransformation =
                new KisColorFromFloat<half, KoRgbTraits<half>>(gmicUnitValue);
        } else if (gmicSpectrum == 1) {
            colorTransformation =
                new KisColorFromGrayScaleFloat<half, KoRgbTraits<half>>(
                    gmicUnitValue);
        } else if (gmicSpectrum == 2) {
            colorTransformation =
                new KisColorFromGrayScaleAlphaFloat<half, KoRgbTraits<half>>(
                    gmicUnitValue);
        }
    }
#endif
    else if (colorSpace->colorDepthId() == Integer16BitsColorDepthID) {
        if (gmicSpectrum == 3 || gmicSpectrum == 4) {
            colorTransformation =
                new KisColorFromFloat<quint16, KoBgrTraits<quint16>>(
                    gmicUnitValue);
        } else if (gmicSpectrum == 1) {
            colorTransformation =
                new KisColorFromGrayScaleFloat<quint16, KoBgrTraits<quint16>>(
                    gmicUnitValue);
        } else if (gmicSpectrum == 2) {
            colorTransformation =
                new KisColorFromGrayScaleAlphaFloat<quint16,
                                                    KoBgrTraits<quint16>>(
                    gmicUnitValue);
        }
    } else if (colorSpace->colorDepthId() == Integer8BitsColorDepthID) {
        if (gmicSpectrum == 3 || gmicSpectrum == 4) {
            colorTransformation =
                new KisColorFromFloat<quint8, KoBgrTraits<quint8>>(
                    gmicUnitValue);
        } else if (gmicSpectrum == 1) {
            colorTransformation =
                new KisColorFromGrayScaleFloat<quint8, KoBgrTraits<quint8>>(
                    gmicUnitValue);
        } else if (gmicSpectrum == 2) {
            colorTransformation =
                new KisColorFromGrayScaleAlphaFloat<quint8,
                                                    KoBgrTraits<quint8>>(
                    gmicUnitValue);
        }
    } else {
        dbgKrita << "Unsupported color space " << colorSpace->id()
                 << " for fast pixel transformation to gmic pixel format";
        return nullptr;
    }
 
    return colorTransformation;
}

References KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), dbgKrita, Float16BitsColorDepthID, Float32BitsColorDepthID, KoColorSpace::id, Integer16BitsColorDepthID, Integer8BitsColorDepthID, and RGBAColorModelID.

reverseMap()

std::map< QString, QString > reverseMap

(

)

Definition at line 1078 of file kis_qmic_simple_convertor.cpp.

{
    std::map<QString, QString> result{};
    for (const auto &pair : blendingModeMap) {
        result.emplace(pair.second, pair.first);
    }
    return result;
}

References blendingModeMap.

Variable Documentation

blendingModeMap

const std::map<QString, QString> blendingModeMap

Definition at line 193 of file kis_qmic_simple_convertor.cpp.

                                                 {
    {"add", COMPOSITE_ADD},
    //   {"alpha", ""}, // XXX
    {"and", COMPOSITE_AND},
    //   {"average", ""}, // XXX
    {"blue", COMPOSITE_COPY_BLUE},
    {"burn", COMPOSITE_BURN},
    {"darken", COMPOSITE_DARKEN},
    {"difference", COMPOSITE_DIFF},
    {"divide", COMPOSITE_DIVIDE},
    {"dodge", COMPOSITE_DODGE},
    //   {"edges", ""}, // XXX
    {"exclusion", COMPOSITE_EXCLUSION},
    {"freeze", COMPOSITE_FREEZE},
    {"grainextract", COMPOSITE_GRAIN_EXTRACT},
    {"grainmerge", COMPOSITE_GRAIN_MERGE},
    {"green", COMPOSITE_COPY_GREEN},
    {"hardlight", COMPOSITE_HARD_LIGHT},
    {"hardmix", COMPOSITE_HARD_MIX},
    {"hue", COMPOSITE_HUE},
    {"interpolation", COMPOSITE_INTERPOLATION},
    {"lighten", COMPOSITE_LIGHTEN},
    {"lightness", COMPOSITE_LIGHTNESS},
    {"linearburn", COMPOSITE_LINEAR_BURN},
    {"linearlight", COMPOSITE_LINEAR_LIGHT},
    {"luminance", COMPOSITE_LUMINIZE},
    {"multiply", COMPOSITE_MULT},
    {"negation", COMPOSITE_NEGATION},
    {"or", COMPOSITE_OR},
    {"overlay", COMPOSITE_OVERLAY},
    {"pinlight", COMPOSITE_PIN_LIGHT},
    {"red", COMPOSITE_COPY_RED},
    {"reflect", COMPOSITE_REFLECT},
    {"saturation", COMPOSITE_SATURATION},
    //   {"seamless", ""},       // XXX
    //   {"seamless_mixed", ""}, // XXX
    {"screen", COMPOSITE_SCREEN},
    //   {"shapeareamax", ""},                    // XXX
    //   {"shapeareamax0", ""},                   // XXX
    //   {"shapeareamin", ""},                    // XXX
    //   {"shapeareamin0", ""},                   // XXX
    //   {"shapeaverage", ""},                    // XXX
    //   {"shapeaverage0", ""},                   // XXX
    //   {"shapemedian", ""},                     // XXX
    //   {"shapemedian0", ""},                    // XXX
    //   {"shapemin", ""},                        // XXX
    //   {"shapemin0", ""},                       // XXX
    //   {"shapemax", ""},                        // XXX
    //   {"shapemax0", ""},                       // XXX
    //   {"softburn", ""},                        // XXX
    //   {"softdodge", ""},                       // XXX
    {"softlight", COMPOSITE_SOFT_LIGHT_SVG}, // XXX Is this correct?
    //   {"stamp", ""}, // XXX
    {"subtract", COMPOSITE_SUBTRACT},
    {"value", COMPOSITE_VALUE},
    {"vividlight", COMPOSITE_VIVID_LIGHT},
    {"xor", COMPOSITE_XOR}};