87 image_buffer, &track, marker,
true,
false);
88 if (!pattern_image_buffer) {
95 const float *float_data = pattern_image_buffer->
float_data();
96 for (
int i = 0; i < pattern_image_buffer->
x * pattern_image_buffer->
y; i++) {
98 mean_color +=
float4(&float_data[i * 4]);
104 mean_color += linear_color;
107 mean_color /= pattern_image_buffer->
x * pattern_image_buffer->
y;
109 marker_colors.append(mean_color);
122 const int scene_frame = context.get_frame_number();
125 return movie_clip_user;
131 const float smoothness)
141 movie_clip, movie_clip_user, movie_tracking_object, marker_positions, marker_colors);
143 if (marker_positions.is_empty()) {
148 if (context.use_gpu()) {
149 this->compute_gpu(context, smoothness, marker_positions, marker_colors);
152 this->compute_cpu(smoothness, marker_positions, marker_colors);
156void KeyingScreen::compute_gpu(
Context &context,
157 const float smoothness,
172 if (marker_positions.
size() % 2 == 1) {
173 marker_positions.append(
float2(0.0f));
178 marker_positions.
data(),
185 marker_colors.
data(),
204void KeyingScreen::compute_cpu(
const float smoothness,
205 const Vector<float2> &marker_positions,
206 const Vector<float4> &marker_colors)
208 float squared_shape_parameter =
math::square(1.0f / smoothness);
216 float sum_of_weights = 0.0f;
218 for (
const int64_t i : marker_positions.index_range()) {
219 float2 marker_position = marker_positions[i];
220 float2 difference = normalized_pixel_location - marker_position;
221 float squared_distance =
math::dot(difference, difference);
222 float gaussian =
math::exp(-squared_distance * squared_shape_parameter);
224 float4 marker_color = marker_colors[i];
226 sum_of_weights += gaussian;
246 for (
auto &cached_keying_screens_for_id : map_.values()) {
247 cached_keying_screens_for_id.remove_if([](
auto item) {
return !item.value->needed; });
249 map_.remove_if([](
auto item) {
return item.value.is_empty(); });
253 for (
auto &cached_keying_screens_for_id : map_.values()) {
254 for (
auto &value : cached_keying_screens_for_id.values()) {
255 value->needed =
false;
269 const std::string library_key = movie_clip->
id.
lib ? movie_clip->
id.
lib->
id.
name :
"";
270 const std::string id_key = std::string(movie_clip->
id.
name) + library_key;
271 const std::string object_key = id_key + movie_tracking_object->
name;
272 auto &cached_keying_screens_for_id = map_.lookup_or_add_default(object_key);
275 if (!cached_keying_screens_for_id.is_empty() &&
278 cached_keying_screens_for_id.clear();
281 auto &keying_screen = *cached_keying_screens_for_id.lookup_or_add_cb(key, [&]() {
282 return std::make_unique<KeyingScreen>(context, movie_clip, movie_tracking_object, smoothness);
288 keying_screen.needed =
true;
289 return keying_screen.result;
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Result & get(Context &context, MovieClip *movie_clip, MovieTrackingObject *movie_tracking_object, float smoothness)
KeyingScreenKey(int frame, float smoothness)
KeyingScreen(Context &context, MovieClip *movie_clip, MovieTrackingObject *movie_tracking_object, const float smoothness)
void store_pixel(const int2 &texel, const T &pixel_value)
void allocate_texture(const Domain domain, const bool from_pool=true, const std::optional< ResultStorageType > storage_type=std::nullopt)
void unbind_as_image() const
void bind_as_image(gpu::Shader *shader, const char *image_name, bool read=false) const
#define weighted_sum(val0, val1, val2, val3, weights)
void compute_dispatch_threads_at_least(gpu::Shader *shader, int2 threads_range, int2 local_size=int2(16))
static MovieClipUser get_movie_clip_user(Context &context, MovieClip *movie_clip)
ColorSceneLinear4f< eAlpha::Premultiplied > Color
bool operator==(const BokehKernelKey &a, const BokehKernelKey &b)
static void compute_marker_points(MovieClip *movie_clip, MovieClipUser &movie_clip_user, MovieTrackingObject *movie_tracking_object, Vector< float2 > &marker_positions, Vector< float4 > &marker_colors)
void parallel_for(const int2 range, const Function &function)
T clamp(const T &a, const T &min, const T &max)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
VecBase< uint8_t, 4 > uchar4
unsigned __int64 uint64_t
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
gpu::StorageBuf * GPU_storagebuf_create_ex(size_t size, const void *data, GPUUsageType usage, const char *name)
MINLINE void srgb_to_linearrgb_uchar4(float linear[4], const unsigned char srgb[4])
int GPU_shader_get_ssbo_binding(gpu::Shader *shader, const char *name)
VecBase< float, 4 > float4
void IMB_freeImBuf(ImBuf *ibuf)
VecBase< float, 2 > float2
ImBuf * BKE_movieclip_get_ibuf(MovieClip *clip, const MovieClipUser *user)
void GPU_shader_bind(gpu::Shader *shader, const gpu::shader::SpecializationConstants *constants_state=nullptr)
void GPU_shader_uniform_1i(gpu::Shader *sh, const char *name, int value)
void GPU_storagebuf_bind(gpu::StorageBuf *ssbo, int slot)
void GPU_storagebuf_unbind(gpu::StorageBuf *ssbo)
void BKE_movieclip_user_set_frame(MovieClipUser *user, int framenr)
float BKE_movieclip_remap_scene_to_clip_frame(const MovieClip *clip, float framenr)
void GPU_shader_uniform_1f(gpu::Shader *sh, const char *name, float value)
void GPU_storagebuf_free(gpu::StorageBuf *ssbo)
ImBuf * BKE_tracking_get_pattern_imbuf(const ImBuf *ibuf, const MovieTrackingTrack *track, const MovieTrackingMarker *marker, bool anchored, bool disable_channels)
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
const uint8_t * byte_data() const
const float * float_data() const
MovieClip_Runtime runtime
ListBaseT< MovieTrackingTrack > tracks