KisMaskingBrushCompositeDetail Namespace Reference

Classes
struct	CompositeFunction
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_BURN, false, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_BURN, true, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_BURN, true, true >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_DARKEN, false, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_DARKEN, true, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_DARKEN, true, true >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_DODGE, false, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_DODGE, true, use_soft_texturing >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_HARD_MIX_PHOTOSHOP, false, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_HARD_MIX_PHOTOSHOP, true, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_HARD_MIX_PHOTOSHOP, true, true >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_HARD_MIX_SOFTER_PHOTOSHOP, false, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_HARD_MIX_SOFTER_PHOTOSHOP, true, use_soft_texturing >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_HEIGHT, true, use_soft_texturing >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_HEIGHT_PHOTOSHOP, true, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_HEIGHT_PHOTOSHOP, true, true >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_LINEAR_BURN, false, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_LINEAR_BURN, true, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_LINEAR_BURN, true, true >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_LINEAR_DODGE, false, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_LINEAR_DODGE, true, use_soft_texturing >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_LINEAR_HEIGHT, true, use_soft_texturing >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_LINEAR_HEIGHT_PHOTOSHOP, true, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_LINEAR_HEIGHT_PHOTOSHOP, true, true >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_MULT, false, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_MULT, true, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_MULT, true, true >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_OVERLAY, false, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_OVERLAY, true, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_OVERLAY, true, true >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_SUBTRACT, false, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_SUBTRACT, true, false >
struct	CompositeFunction< channels_type, KIS_MASKING_BRUSH_COMPOSITE_SUBTRACT, true, true >
struct	StrengthCompositeFunctionBase

Functions
template<class T >
T	colorBurnAlpha (T src, T dst)
template<class T >
T	colorBurnAlphaHelper (T src, T dst)
template<class T >
std::enable_if< std::numeric_limits< T >::is_integer, T >::type	colorDodgeAlpha (T src, T dst)
template<class T >
std::enable_if<!std::numeric_limits< T >::is_integer, T >::type	colorDodgeAlpha (T src, T dst)
template<class T >
T	colorDodgeAlphaHelper (T src, T dst)
template<class T >
T	hardMixSofterPhotoshopAlpha (T src, T dst)

Function Documentation

colorBurnAlpha()

template<class T >

T KisMaskingBrushCompositeDetail::colorBurnAlpha ( T src, T dst )

inline

Definition at line 272 of file KisMaskingBrushCompositeOp.h.

{
    using namespace Arithmetic;
    using namespace KoCompositeOpClampPolicy;
    return CFColorBurn<T>::composeChannel(src, dst);
}

References CFColorBurn< T >::composeChannel().

colorBurnAlphaHelper()

template<class T >

T KisMaskingBrushCompositeDetail::colorBurnAlphaHelper ( T src, T dst )

inline

A special Color Burn variant for alpha channel.

The meaning of alpha channel is a bit different from the one in color. Color burn can quickly make the values less than 0 so, contrary to the color values case, we should clamp to the unit range

Definition at line 257 of file KisMaskingBrushCompositeOp.h.

{
    using composite_type = typename KoColorSpaceMathsTraits<T>::compositetype;
    using namespace Arithmetic;
    // Handle the case where the denominator is 0. See color dodge for a
    // detailed explanation
    if(isZeroValueFuzzy<T>(src)) {
        return isUnitValueFuzzy<T>(dst) ? zeroValue<T>() : unitValue<T>();
    }
    return kisBoundFast(composite_type(KoColorSpaceMathsTraits<T>::zeroValue),
                        div(inv(dst), src),
                        composite_type(KoColorSpaceMathsTraits<T>::unitValue));
}

References kisBoundFast().

colorDodgeAlpha() [1/2]

template<class T >

std::enable_if< std::numeric_limits< T >::is_integer, T >::type KisMaskingBrushCompositeDetail::colorDodgeAlpha ( T src, T dst )

inline

Definition at line 207 of file KisMaskingBrushCompositeOp.h.

{
    return colorDodgeAlphaHelper(src, dst);
}

References colorDodgeAlphaHelper().

colorDodgeAlpha() [2/2]

template<class T >

std::enable_if<!std::numeric_limits< T >::is_integer, T >::type KisMaskingBrushCompositeDetail::colorDodgeAlpha ( T src, T dst )

inline

Definition at line 215 of file KisMaskingBrushCompositeOp.h.

{
    const T result = colorDodgeAlphaHelper(src, dst);
    // Constantly dividing by small numbers can quickly make the result
    // become infinity or NaN, so we check that and correct (kind of clamping)
    return std::isfinite(result) ? result : KoColorSpaceMathsTraits<T>::unitValue;
}

References colorDodgeAlphaHelper().

colorDodgeAlphaHelper()

template<class T >

T KisMaskingBrushCompositeDetail::colorDodgeAlphaHelper ( T src, T dst )

inline

A special Color Dodge variant for alpha channel.

The meaning of alpha channel is a bit different from the one in color. Color dodge can quickly make the values higher than 1 or less than 0 so, contrary to the color values case, we should clamp to the unit range

Definition at line 181 of file KisMaskingBrushCompositeOp.h.

{
    using composite_type = typename KoColorSpaceMathsTraits<T>::compositetype;
    using namespace Arithmetic;
    // Handle the case where the denominator is 0.
    // When src is 1 then the denominator (1 - src) becomes 0, and to avoid
    // dividing by 0 we treat the denominator as an infinitely small number,
    // so the result of the formula would approach infinity.
    // For alpha values, the result should be clamped to the unit range,
    // contrary to the color version, where the values should be clamped to
    // the min/max range.
    // Another special case is when both numerator and denominator are 0. In
    // this case we also treat the denominator as an infinitely small number,
    // and the numerator can remain as 0, so dividing 0 over a number (no matter
    // how small it is) gives 0.
    if (isUnitValueFuzzy<T>(src)) {
        return isZeroValueFuzzy<T>(dst) ? zeroValue<T>() : unitValue<T>();
    }
    return kisBoundFast(composite_type(KoColorSpaceMathsTraits<T>::zeroValue),
                        div(dst, inv(src)),
                        composite_type(KoColorSpaceMathsTraits<T>::unitValue));
}

References kisBoundFast().

hardMixSofterPhotoshopAlpha()

template<class T >

T KisMaskingBrushCompositeDetail::hardMixSofterPhotoshopAlpha ( T src, T dst )

inline

A special Hard Mix Softer variant for alpha channel

The meaning of alpha channel is a bit different from the one in color. We have to clamp the values to the unit range

Definition at line 464 of file KisMaskingBrushCompositeOp.h.

                                                   {
    using namespace Arithmetic;
    typedef typename KoColorSpaceMathsTraits<T>::compositetype composite_type;
    const composite_type srcScaleFactor = static_cast<composite_type>(2);
    const composite_type dstScaleFactor = static_cast<composite_type>(3);
    return kisBoundFast(composite_type(KoColorSpaceMathsTraits<T>::zeroValue),
                        dstScaleFactor * dst - srcScaleFactor * inv(src),
                        composite_type(KoColorSpaceMathsTraits<T>::unitValue));
}

References kisBoundFast().