Krita Source Code Documentation
Loading...
Searching...
No Matches
Classes | Public Types | Static Public Member Functions | List of all members
AlphaDarkenCompositor128< channels_type, ParamsWrapperT > Struct Template Reference

#include <KoOptimizedCompositeOpAlphaDarken128.h>

Classes

struct  Pixel
 

Public Types

using ParamsWrapper = ParamsWrapperT
 

Static Public Member Functions

template<bool haveMask, typename _impl >
static ALWAYS_INLINE void compositeOnePixelScalar (const quint8 *s, quint8 *d, const quint8 *mask, float opacity, const ParamsWrapper &oparams)
 
template<bool haveMask, bool src_aligned, typename _impl >
static ALWAYS_INLINE void compositeVector (const quint8 *src, quint8 *dst, const quint8 *mask, float opacity, const ParamsWrapper &oparams)
 

Detailed Description

template<typename channels_type, typename ParamsWrapperT>
struct AlphaDarkenCompositor128< channels_type, ParamsWrapperT >

Definition at line 17 of file KoOptimizedCompositeOpAlphaDarken128.h.

Member Typedef Documentation

◆ ParamsWrapper

template<typename channels_type , typename ParamsWrapperT >
using AlphaDarkenCompositor128< channels_type, ParamsWrapperT >::ParamsWrapper = ParamsWrapperT

Definition at line 18 of file KoOptimizedCompositeOpAlphaDarken128.h.

Member Function Documentation

◆ compositeOnePixelScalar()

template<typename channels_type , typename ParamsWrapperT >
template<bool haveMask, typename _impl >
static ALWAYS_INLINE void AlphaDarkenCompositor128< channels_type, ParamsWrapperT >::compositeOnePixelScalar ( const quint8 * s,
quint8 * d,
const quint8 * mask,
float opacity,
const ParamsWrapper & oparams )
inlinestatic

Composes one pixel of the source into the destination

Definition at line 138 of file KoOptimizedCompositeOpAlphaDarken128.h.

139 {
140 using namespace Arithmetic;
141 const qint32 alpha_pos = 3;
142
143 const auto *src = reinterpret_cast<const channels_type*>(s);
144 auto *dst = reinterpret_cast<channels_type*>(d);
145
146 float dstAlphaNorm = dst[alpha_pos];
147 PixelWrapper<channels_type, _impl>::normalizeAlpha(dstAlphaNorm);
148
149 const float uint8Rec1 = 1.0f / 255.0f;
150 float mskAlphaNorm = haveMask ? float(*mask) * uint8Rec1 * src[alpha_pos] : src[alpha_pos];
151 PixelWrapper<channels_type, _impl>::normalizeAlpha(mskAlphaNorm);
152
153 Q_UNUSED(opacity);
154 opacity = oparams.opacity;
155
156 const float srcAlphaNorm = mskAlphaNorm * opacity;
157
158 if (dstAlphaNorm != 0) {
159 dst[0] = PixelWrapper<channels_type, _impl>::lerpMixedUintFloat(dst[0], src[0], srcAlphaNorm);
160 dst[1] = PixelWrapper<channels_type, _impl>::lerpMixedUintFloat(dst[1], src[1], srcAlphaNorm);
161 dst[2] = PixelWrapper<channels_type, _impl>::lerpMixedUintFloat(dst[2], src[2], srcAlphaNorm);
162 } else {
163 const auto *s = reinterpret_cast<const Pixel*>(src);
164 auto *d = reinterpret_cast<Pixel*>(dst);
165 *d = *s;
166 }
167
168 const float flow = oparams.flow;
169 const float averageOpacity = oparams.averageOpacity;
170
171 const float fullFlowAlpha = [&]() {
172 if (averageOpacity > opacity) {
173 return averageOpacity > dstAlphaNorm ? lerp(srcAlphaNorm, averageOpacity, dstAlphaNorm / averageOpacity) : dstAlphaNorm;
174 } else {
175 return opacity > dstAlphaNorm ? lerp(dstAlphaNorm, opacity, mskAlphaNorm) : dstAlphaNorm;
176 }
177 }();
178
179 dstAlphaNorm = [&]() {
180 if (flow == 1.0f) {
181 return fullFlowAlpha;
182 } else {
183 const float zeroFlowAlpha = ParamsWrapper::calculateZeroFlowAlpha(srcAlphaNorm, dstAlphaNorm);
184 return lerp(zeroFlowAlpha, fullFlowAlpha, flow);
185 }
186 }();
187
188 PixelWrapper<channels_type, _impl>::denormalizeAlpha(dstAlphaNorm);
189 dst[alpha_pos] = PixelWrapper<channels_type, _impl>::roundFloatToUint(dstAlphaNorm);
190 }
lerp
QPointF lerp(const QPointF &p1, const QPointF &p2, qreal t)
Definition SvgMeshPatch.cpp:15
resize_to_all_layers.d
d
Definition resize_to_all_layers.py:15

References lerp().

◆ compositeVector()

template<typename channels_type , typename ParamsWrapperT >
template<bool haveMask, bool src_aligned, typename _impl >
static ALWAYS_INLINE void AlphaDarkenCompositor128< channels_type, ParamsWrapperT >::compositeVector ( const quint8 * src,
quint8 * dst,
const quint8 * mask,
float opacity,
const ParamsWrapper & oparams )
inlinestatic

This is a vector equivalent of compositeOnePixelScalar(). It is considered to process float_v::size pixels in a single pass.

o the haveMask parameter points whether the real (non-null) mask pointer is passed to the function. o the src pointer may be aligned to vector boundary or may be not. In case not, it must be pointed with a special parameter src_aligned. o the dst pointer must always(!) be aligned to the boundary of a streaming vector. Unaligned writes are really expensive.

Definition at line 40 of file KoOptimizedCompositeOpAlphaDarken128.h.

41 {
42 using float_v = typename KoStreamedMath<_impl>::float_v;
43 using float_m = typename float_v::batch_bool_type;
44
45 float_v src_c1;
46 float_v src_c2;
47 float_v src_c3;
48 float_v src_alpha;
49
50 PixelWrapper<channels_type, _impl> dataWrapper;
51 dataWrapper.read(src, src_c1, src_c2, src_c3, src_alpha);
52
53 const float_v msk_norm_alpha = [&](){;
54 if (haveMask) {
55 const float_v uint8Rec1(1.0f / 255.0f);
56 const float_v mask_vec = KoStreamedMath<_impl>::fetch_mask_8(mask);
57 return mask_vec * uint8Rec1 * src_alpha;
58 }
59 else {
60 return src_alpha;
61 }
62 }();
63
64 // we don't use directly passed value
65 Q_UNUSED(opacity);
66
67 // instead we use value calculated by ParamsWrapper
68 opacity = oparams.opacity;
69 const float_v opacity_vec(opacity);
70
71 src_alpha = msk_norm_alpha * opacity_vec;
72
73 const float_v zeroValue(static_cast<float>(KoColorSpaceMathsTraits<channels_type>::zeroValue));
74
75 float_v dst_c1;
76 float_v dst_c2;
77 float_v dst_c3;
78 float_v dst_alpha;
79
80 dataWrapper.read(dst, dst_c1, dst_c2, dst_c3, dst_alpha);
81
82 const float_m empty_dst_pixels_mask = dst_alpha == zeroValue;
83
84 if (!xsimd::all(empty_dst_pixels_mask)) {
85 if (xsimd::none(empty_dst_pixels_mask)) {
86 dst_c1 = (src_c1 - dst_c1) * src_alpha + dst_c1;
87 dst_c2 = (src_c2 - dst_c2) * src_alpha + dst_c2;
88 dst_c3 = (src_c3 - dst_c3) * src_alpha + dst_c3;
89 }
90 else {
91 dst_c1 = xsimd::select(empty_dst_pixels_mask, src_c1, (src_c1 - dst_c1) * src_alpha + dst_c1);
92 dst_c2 = xsimd::select(empty_dst_pixels_mask, src_c2, (src_c2 - dst_c2) * src_alpha + dst_c2);
93 dst_c3 = xsimd::select(empty_dst_pixels_mask, src_c3, (src_c3 - dst_c3) * src_alpha + dst_c3);
94 }
95 }
96 else {
97 dst_c1 = src_c1;
98 dst_c2 = src_c2;
99 dst_c3 = src_c3;
100 }
101
102 const float_v fullFlowAlpha = [&]() {
103 if (oparams.averageOpacity > opacity) {
104 const float_v average_opacity_vec(oparams.averageOpacity);
105 const float_m fullFlowAlpha_mask = average_opacity_vec > dst_alpha;
106 return xsimd::select(fullFlowAlpha_mask,
107 (average_opacity_vec - src_alpha)
108 * (dst_alpha / average_opacity_vec)
109 + src_alpha,
110 dst_alpha);
111 } else {
112 const float_m fullFlowAlpha_mask = opacity_vec > dst_alpha;
113 return xsimd::select(
114 fullFlowAlpha_mask,
115 (opacity_vec - dst_alpha) * msk_norm_alpha + dst_alpha,
116 dst_alpha);
117 }
118 }();
119
120 dst_alpha = [&]() {
121 if (oparams.flow == 1.0) {
122 return fullFlowAlpha;
123 }
124 else {
125 const float_v zeroFlowAlpha = ParamsWrapper::calculateZeroFlowAlpha(src_alpha, dst_alpha);
126 const float_v flow_norm_vec(oparams.flow);
127 return (fullFlowAlpha - zeroFlowAlpha) * flow_norm_vec + zeroFlowAlpha;
128 }
129 }();
130
131 dataWrapper.write(dst, dst_c1, dst_c2, dst_c3, dst_alpha);
132 }
KoStreamedMath::float_v
xsimd::batch< float, _impl > float_v
Definition KoStreamedMath.h:157
KoStreamedMath::fetch_mask_8
static float_v fetch_mask_8(const quint8 *data)
Definition KoStreamedMath.h:238

References KoStreamedMath< _impl >::fetch_mask_8().

The documentation for this struct was generated from the following file: