63template<
typename Value,
typename Function,
typename Reduction>
65 const Value &identity,
66 const Function &function,
67 const Reduction &reduction)
73 [&](
const IndexRange sub_range,
const Value &initial_value) {
74 Value
result = initial_value;
75 for (
const int64_t i : sub_range) {
87 const int2 &calibration_size,
91 auto distortion_function = [&](
const float2 &coordinates) {
97 const float2 calibrated_coordinates = normalized_coordinates *
float2(calibration_size);
99 float2 distorted_coordinates;
102 distortion, calibrated_coordinates, distorted_coordinates);
106 distortion, calibrated_coordinates, distorted_coordinates);
111 const float2 distorted_normalized_coordinates = distorted_coordinates /
113 const float2 distorted_display_coordinates = distorted_normalized_coordinates *
115 return distorted_display_coordinates;
121 std::numeric_limits<float>::lowest(),
122 [&](
const int i,
float &accumulated_value) {
123 const float2 position = float2(domain.data_size.x, i);
124 accumulated_value = math::max(accumulated_value, distortion_function(position).x);
131 std::numeric_limits<float>::max(),
132 [&](
const int i,
float &accumulated_value) {
133 const float2 position = float2(0.0f, i);
134 accumulated_value = math::min(accumulated_value, distortion_function(position).x);
141 std::numeric_limits<float>::max(),
142 [&](
const int i,
float &accumulated_value) {
143 const float2 position = float2(i, 0.0f);
144 accumulated_value = math::min(accumulated_value, distortion_function(position).y);
151 std::numeric_limits<float>::lowest(),
152 [&](
const int i,
float &accumulated_value) {
153 const float2 position = float2(i, domain.data_size.y);
154 accumulated_value = math::max(accumulated_value, distortion_function(position).y);
170 Domain output_domain = domain;
173 return output_domain;
180 int2 calibration_size)
184 &movie_clip->
tracking, calibration_size.x, calibration_size.y);
194 const float2 display_coordinates = float2(texel + output_domain.data_offset) + 0.5f;
195 const float2 normalized_coordinates = display_coordinates / float2(domain.display_size);
196 const float2 calibrated_coordinates = normalized_coordinates * float2(calibration_size);
200 float2 distorted_coordinates;
201 if (type == DistortionType::Undistort) {
202 BKE_tracking_distortion_distort_v2(
203 distortion, calibrated_coordinates, distorted_coordinates);
206 BKE_tracking_distortion_undistort_v2(
207 distortion, calibrated_coordinates, distorted_coordinates);
212 const float2 distorted_normalized_coordinates = distorted_coordinates /
214 const float2 distorted_display_coordinates = distorted_normalized_coordinates *
216 const float2 distorted_data_coordinates = distorted_display_coordinates -
219 distortion_grid_cpu.
store_pixel(texel, sampling_coordinates);
224 if (context.use_gpu()) {
226 this->
result.share_data(distortion_grid_gpu);
230 this->
result.share_data(distortion_grid_cpu);
233 distortion_grid_cpu.release();
248 map_.remove_if([](
auto item) {
return !item.value->needed; });
252 for (
auto &value : map_.values()) {
253 value->needed =
false;
275 auto &distortion_grid = *map_.lookup_or_add_cb(key, [&]() {
276 return std::make_unique<DistortionGrid>(context, movie_clip, domain, type, calibration_size);
279 distortion_grid.needed =
true;
280 return distortion_grid.result;
constexpr IndexRange()=default
Result & get(Context &context, MovieClip *movie_clip, Domain domain, DistortionType type, int frame_number)
MovieTrackingCamera camera
DistortionGridKey(const MovieTrackingCamera &camera, Domain domain, DistortionType type, int2 calibration_size)
DistortionGrid(Context &context, MovieClip *movie_clip, Domain domain, DistortionType type, int2 calibration_size)
Result upload_to_gpu(const bool from_pool) const
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)
static Value parallel_reduce(const int2 range, const Value &identity, const Function &function, const Reduction &reduction)
bool operator==(const BokehKernelKey &a, const BokehKernelKey &b)
static Domain compute_output_domain(MovieDistortion *distortion, const int2 &calibration_size, const DistortionType &type, const Domain &domain)
static int2 get_movie_clip_size(MovieClip *movie_clip, int frame_number)
void parallel_for(const int2 range, const Function &function)
T min(const T &a, const T &b)
T max(const T &a, const T &b)
Value parallel_reduce(IndexRange range, int64_t grain_size, const Value &identity, const Function &function, const Reduction &reduction)
unsigned __int64 uint64_t
bool BKE_tracking_camera_distortion_equal(const MovieTrackingCamera *a, const MovieTrackingCamera *b)
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
void BKE_tracking_distortion_distort_v2(MovieDistortion *distortion, const float co[2], float r_co[2])
void BKE_tracking_distortion_undistort_v2(MovieDistortion *distortion, const float co[2], float r_co[2])
void BKE_movieclip_user_set_frame(MovieClipUser *user, int framenr)
MovieDistortion * BKE_tracking_distortion_new(MovieTracking *tracking, int calibration_width, int calibration_height)
void BKE_tracking_distortion_free(MovieDistortion *distortion)
uint64_t BKE_tracking_camera_distortion_hash(const MovieTrackingCamera *camera)
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
struct MovieTracking tracking
MovieTrackingCamera camera