Cleanup: comments (long lines) in blenkernel
[blender.git] / source / blender / blenkernel / intern / mask_evaluate.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2012 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  *
23  * Functions for evaluating the mask beziers into points for the outline and feather.
24  */
25
26 #include <stddef.h>
27 #include <string.h>
28
29 #include "MEM_guardedalloc.h"
30
31 #include "BLI_utildefines.h"
32 #include "BLI_math.h"
33
34 #include "DNA_mask_types.h"
35 #include "DNA_object_types.h"
36
37 #include "BKE_curve.h"
38 #include "BKE_mask.h"
39
40 #include "DEG_depsgraph.h"
41 #include "DEG_depsgraph_query.h"
42
43 unsigned int BKE_mask_spline_resolution(MaskSpline *spline, int width, int height)
44 {
45   float max_segment = 0.01f;
46   unsigned int i, resol = 1;
47
48   if (width != 0 && height != 0) {
49     max_segment = 1.0f / (float)max_ii(width, height);
50   }
51
52   for (i = 0; i < spline->tot_point; i++) {
53     MaskSplinePoint *point = &spline->points[i];
54     BezTriple *bezt_curr, *bezt_next;
55     float a, b, c, len;
56     unsigned int cur_resol;
57
58     bezt_curr = &point->bezt;
59     bezt_next = BKE_mask_spline_point_next_bezt(spline, spline->points, point);
60
61     if (bezt_next == NULL) {
62       break;
63     }
64
65     a = len_v3v3(bezt_curr->vec[1], bezt_curr->vec[2]);
66     b = len_v3v3(bezt_curr->vec[2], bezt_next->vec[0]);
67     c = len_v3v3(bezt_next->vec[0], bezt_next->vec[1]);
68
69     len = a + b + c;
70     cur_resol = len / max_segment;
71
72     resol = MAX2(resol, cur_resol);
73
74     if (resol >= MASK_RESOL_MAX) {
75       break;
76     }
77   }
78
79   return CLAMPIS(resol, 1, MASK_RESOL_MAX);
80 }
81
82 unsigned int BKE_mask_spline_feather_resolution(MaskSpline *spline, int width, int height)
83 {
84   const float max_segment = 0.005;
85   unsigned int resol = BKE_mask_spline_resolution(spline, width, height);
86   float max_jump = 0.0f;
87   int i;
88
89   /* avoid checking the featrher if we already hit the maximum value */
90   if (resol >= MASK_RESOL_MAX) {
91     return MASK_RESOL_MAX;
92   }
93
94   for (i = 0; i < spline->tot_point; i++) {
95     MaskSplinePoint *point = &spline->points[i];
96     float prev_u, prev_w;
97     int j;
98
99     prev_u = 0.0f;
100     prev_w = point->bezt.weight;
101
102     for (j = 0; j < point->tot_uw; j++) {
103       const float w_diff = (point->uw[j].w - prev_w);
104       const float u_diff = (point->uw[j].u - prev_u);
105
106       /* avoid divide by zero and very high values,
107        * though these get clamped eventually */
108       if (u_diff > FLT_EPSILON) {
109         float jump = fabsf(w_diff / u_diff);
110
111         max_jump = max_ff(max_jump, jump);
112       }
113
114       prev_u = point->uw[j].u;
115       prev_w = point->uw[j].w;
116     }
117   }
118
119   resol += max_jump / max_segment;
120
121   return CLAMPIS(resol, 1, MASK_RESOL_MAX);
122 }
123
124 int BKE_mask_spline_differentiate_calc_total(const MaskSpline *spline, const unsigned int resol)
125 {
126   if (spline->flag & MASK_SPLINE_CYCLIC) {
127     return spline->tot_point * resol;
128   }
129   else {
130     return ((spline->tot_point - 1) * resol) + 1;
131   }
132 }
133
134 float (*BKE_mask_spline_differentiate_with_resolution(MaskSpline *spline,
135                                                       unsigned int *tot_diff_point,
136                                                       const unsigned int resol))[2]
137 {
138   MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
139
140   MaskSplinePoint *point_curr, *point_prev;
141   float(*diff_points)[2], (*fp)[2];
142   const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
143   int a;
144
145   if (spline->tot_point <= 1) {
146     /* nothing to differentiate */
147     *tot_diff_point = 0;
148     return NULL;
149   }
150
151   /* len+1 because of 'forward_diff_bezier' function */
152   *tot_diff_point = tot;
153   diff_points = fp = MEM_mallocN((tot + 1) * sizeof(*diff_points), "mask spline vets");
154
155   a = spline->tot_point - 1;
156   if (spline->flag & MASK_SPLINE_CYCLIC) {
157     a++;
158   }
159
160   point_prev = points_array;
161   point_curr = point_prev + 1;
162
163   while (a--) {
164     BezTriple *bezt_prev;
165     BezTriple *bezt_curr;
166     int j;
167
168     if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC)) {
169       point_curr = points_array;
170     }
171
172     bezt_prev = &point_prev->bezt;
173     bezt_curr = &point_curr->bezt;
174
175     for (j = 0; j < 2; j++) {
176       BKE_curve_forward_diff_bezier(bezt_prev->vec[1][j],
177                                     bezt_prev->vec[2][j],
178                                     bezt_curr->vec[0][j],
179                                     bezt_curr->vec[1][j],
180                                     &(*fp)[j],
181                                     resol,
182                                     2 * sizeof(float));
183     }
184
185     fp += resol;
186
187     if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
188       copy_v2_v2(*fp, bezt_curr->vec[1]);
189     }
190
191     point_prev = point_curr;
192     point_curr++;
193   }
194
195   return diff_points;
196 }
197
198 float (*BKE_mask_spline_differentiate(
199     MaskSpline *spline, int width, int height, unsigned int *tot_diff_point))[2]
200 {
201   int unsigned resol = BKE_mask_spline_resolution(spline, width, height);
202
203   return BKE_mask_spline_differentiate_with_resolution(spline, tot_diff_point, resol);
204 }
205
206 /* ** feather points self-intersection collapse routine ** */
207
208 typedef struct FeatherEdgesBucket {
209   int tot_segment;
210   int (*segments)[2];
211   int alloc_segment;
212 } FeatherEdgesBucket;
213
214 static void feather_bucket_add_edge(FeatherEdgesBucket *bucket, int start, int end)
215 {
216   const int alloc_delta = 256;
217
218   if (bucket->tot_segment >= bucket->alloc_segment) {
219     if (!bucket->segments) {
220       bucket->segments = MEM_callocN(alloc_delta * sizeof(*bucket->segments),
221                                      "feather bucket segments");
222     }
223     else {
224       bucket->segments = MEM_reallocN(
225           bucket->segments, (alloc_delta + bucket->tot_segment) * sizeof(*bucket->segments));
226     }
227
228     bucket->alloc_segment += alloc_delta;
229   }
230
231   bucket->segments[bucket->tot_segment][0] = start;
232   bucket->segments[bucket->tot_segment][1] = end;
233
234   bucket->tot_segment++;
235 }
236
237 static void feather_bucket_check_intersect(float (*feather_points)[2],
238                                            int tot_feather_point,
239                                            FeatherEdgesBucket *bucket,
240                                            int cur_a,
241                                            int cur_b)
242 {
243   int i;
244
245   const float *v1 = (float *)feather_points[cur_a];
246   const float *v2 = (float *)feather_points[cur_b];
247
248   for (i = 0; i < bucket->tot_segment; i++) {
249     int check_a = bucket->segments[i][0];
250     int check_b = bucket->segments[i][1];
251
252     const float *v3 = (float *)feather_points[check_a];
253     const float *v4 = (float *)feather_points[check_b];
254
255     if (check_a >= cur_a - 1 || cur_b == check_a) {
256       continue;
257     }
258
259     if (isect_seg_seg_v2_simple(v1, v2, v3, v4)) {
260       int k;
261       float p[2];
262       float min_a[2], max_a[2];
263       float min_b[2], max_b[2];
264
265       isect_seg_seg_v2_point(v1, v2, v3, v4, p);
266
267       INIT_MINMAX2(min_a, max_a);
268       INIT_MINMAX2(min_b, max_b);
269
270       /* collapse loop with smaller AABB */
271       for (k = 0; k < tot_feather_point; k++) {
272         if (k >= check_b && k <= cur_a) {
273           minmax_v2v2_v2(min_a, max_a, feather_points[k]);
274         }
275         else {
276           minmax_v2v2_v2(min_b, max_b, feather_points[k]);
277         }
278       }
279
280       if (max_a[0] - min_a[0] < max_b[0] - min_b[0] || max_a[1] - min_a[1] < max_b[1] - min_b[1]) {
281         for (k = check_b; k <= cur_a; k++) {
282           copy_v2_v2(feather_points[k], p);
283         }
284       }
285       else {
286         for (k = 0; k <= check_a; k++) {
287           copy_v2_v2(feather_points[k], p);
288         }
289
290         if (cur_b != 0) {
291           for (k = cur_b; k < tot_feather_point; k++) {
292             copy_v2_v2(feather_points[k], p);
293           }
294         }
295       }
296     }
297   }
298 }
299
300 static int feather_bucket_index_from_coord(const float co[2],
301                                            const float min[2],
302                                            const float bucket_scale[2],
303                                            const int buckets_per_side)
304 {
305   int x = (int)((co[0] - min[0]) * bucket_scale[0]);
306   int y = (int)((co[1] - min[1]) * bucket_scale[1]);
307
308   if (x == buckets_per_side) {
309     x--;
310   }
311
312   if (y == buckets_per_side) {
313     y--;
314   }
315
316   return y * buckets_per_side + x;
317 }
318
319 static void feather_bucket_get_diagonal(FeatherEdgesBucket *buckets,
320                                         int start_bucket_index,
321                                         int end_bucket_index,
322                                         int buckets_per_side,
323                                         FeatherEdgesBucket **r_diagonal_bucket_a,
324                                         FeatherEdgesBucket **r_diagonal_bucket_b)
325 {
326   int start_bucket_x = start_bucket_index % buckets_per_side;
327   int start_bucket_y = start_bucket_index / buckets_per_side;
328
329   int end_bucket_x = end_bucket_index % buckets_per_side;
330   int end_bucket_y = end_bucket_index / buckets_per_side;
331
332   int diagonal_bucket_a_index = start_bucket_y * buckets_per_side + end_bucket_x;
333   int diagonal_bucket_b_index = end_bucket_y * buckets_per_side + start_bucket_x;
334
335   *r_diagonal_bucket_a = &buckets[diagonal_bucket_a_index];
336   *r_diagonal_bucket_b = &buckets[diagonal_bucket_b_index];
337 }
338
339 void BKE_mask_spline_feather_collapse_inner_loops(MaskSpline *spline,
340                                                   float (*feather_points)[2],
341                                                   const unsigned int tot_feather_point)
342 {
343 #define BUCKET_INDEX(co) feather_bucket_index_from_coord(co, min, bucket_scale, buckets_per_side)
344
345   int buckets_per_side, tot_bucket;
346   float bucket_size, bucket_scale[2];
347
348   FeatherEdgesBucket *buckets;
349
350   unsigned int i;
351   float min[2], max[2];
352   float max_delta_x = -1.0f, max_delta_y = -1.0f, max_delta;
353
354   if (tot_feather_point < 4) {
355     /* self-intersection works only for quads at least,
356      * in other cases polygon can't be self-intersecting anyway
357      */
358
359     return;
360   }
361
362   /* find min/max corners of mask to build buckets in that space */
363   INIT_MINMAX2(min, max);
364
365   for (i = 0; i < tot_feather_point; i++) {
366     unsigned int next = i + 1;
367     float delta;
368
369     minmax_v2v2_v2(min, max, feather_points[i]);
370
371     if (next == tot_feather_point) {
372       if (spline->flag & MASK_SPLINE_CYCLIC) {
373         next = 0;
374       }
375       else {
376         break;
377       }
378     }
379
380     delta = fabsf(feather_points[i][0] - feather_points[next][0]);
381     if (delta > max_delta_x) {
382       max_delta_x = delta;
383     }
384
385     delta = fabsf(feather_points[i][1] - feather_points[next][1]);
386     if (delta > max_delta_y) {
387       max_delta_y = delta;
388     }
389   }
390
391   /* prevent divisionsby zero by ensuring bounding box is not collapsed */
392   if (max[0] - min[0] < FLT_EPSILON) {
393     max[0] += 0.01f;
394     min[0] -= 0.01f;
395   }
396
397   if (max[1] - min[1] < FLT_EPSILON) {
398     max[1] += 0.01f;
399     min[1] -= 0.01f;
400   }
401
402   /* use dynamically calculated buckets per side, so we likely wouldn't
403    * run into a situation when segment doesn't fit two buckets which is
404    * pain collecting candidates for intersection
405    */
406
407   max_delta_x /= max[0] - min[0];
408   max_delta_y /= max[1] - min[1];
409
410   max_delta = MAX2(max_delta_x, max_delta_y);
411
412   buckets_per_side = min_ii(512, 0.9f / max_delta);
413
414   if (buckets_per_side == 0) {
415     /* happens when some segment fills the whole bounding box across some of dimension */
416
417     buckets_per_side = 1;
418   }
419
420   tot_bucket = buckets_per_side * buckets_per_side;
421   bucket_size = 1.0f / buckets_per_side;
422
423   /* pre-compute multipliers, to save mathematical operations in loops */
424   bucket_scale[0] = 1.0f / ((max[0] - min[0]) * bucket_size);
425   bucket_scale[1] = 1.0f / ((max[1] - min[1]) * bucket_size);
426
427   /* fill in buckets' edges */
428   buckets = MEM_callocN(sizeof(FeatherEdgesBucket) * tot_bucket, "feather buckets");
429
430   for (i = 0; i < tot_feather_point; i++) {
431     int start = i, end = i + 1;
432     int start_bucket_index, end_bucket_index;
433
434     if (end == tot_feather_point) {
435       if (spline->flag & MASK_SPLINE_CYCLIC) {
436         end = 0;
437       }
438       else {
439         break;
440       }
441     }
442
443     start_bucket_index = BUCKET_INDEX(feather_points[start]);
444     end_bucket_index = BUCKET_INDEX(feather_points[end]);
445
446     feather_bucket_add_edge(&buckets[start_bucket_index], start, end);
447
448     if (start_bucket_index != end_bucket_index) {
449       FeatherEdgesBucket *end_bucket = &buckets[end_bucket_index];
450       FeatherEdgesBucket *diagonal_bucket_a, *diagonal_bucket_b;
451
452       feather_bucket_get_diagonal(buckets,
453                                   start_bucket_index,
454                                   end_bucket_index,
455                                   buckets_per_side,
456                                   &diagonal_bucket_a,
457                                   &diagonal_bucket_b);
458
459       feather_bucket_add_edge(end_bucket, start, end);
460       feather_bucket_add_edge(diagonal_bucket_a, start, end);
461       feather_bucket_add_edge(diagonal_bucket_a, start, end);
462     }
463   }
464
465   /* check all edges for intersection with edges from their buckets */
466   for (i = 0; i < tot_feather_point; i++) {
467     int cur_a = i, cur_b = i + 1;
468     int start_bucket_index, end_bucket_index;
469
470     FeatherEdgesBucket *start_bucket;
471
472     if (cur_b == tot_feather_point) {
473       cur_b = 0;
474     }
475
476     start_bucket_index = BUCKET_INDEX(feather_points[cur_a]);
477     end_bucket_index = BUCKET_INDEX(feather_points[cur_b]);
478
479     start_bucket = &buckets[start_bucket_index];
480
481     feather_bucket_check_intersect(feather_points, tot_feather_point, start_bucket, cur_a, cur_b);
482
483     if (start_bucket_index != end_bucket_index) {
484       FeatherEdgesBucket *end_bucket = &buckets[end_bucket_index];
485       FeatherEdgesBucket *diagonal_bucket_a, *diagonal_bucket_b;
486
487       feather_bucket_get_diagonal(buckets,
488                                   start_bucket_index,
489                                   end_bucket_index,
490                                   buckets_per_side,
491                                   &diagonal_bucket_a,
492                                   &diagonal_bucket_b);
493
494       feather_bucket_check_intersect(feather_points, tot_feather_point, end_bucket, cur_a, cur_b);
495       feather_bucket_check_intersect(
496           feather_points, tot_feather_point, diagonal_bucket_a, cur_a, cur_b);
497       feather_bucket_check_intersect(
498           feather_points, tot_feather_point, diagonal_bucket_b, cur_a, cur_b);
499     }
500   }
501
502   /* free buckets */
503   for (i = 0; i < tot_bucket; i++) {
504     if (buckets[i].segments) {
505       MEM_freeN(buckets[i].segments);
506     }
507   }
508
509   MEM_freeN(buckets);
510
511 #undef BUCKET_INDEX
512 }
513
514 /** only called from #BKE_mask_spline_feather_differentiated_points_with_resolution() ! */
515 static float (*mask_spline_feather_differentiated_points_with_resolution__even(
516     MaskSpline *spline,
517     unsigned int *tot_feather_point,
518     const unsigned int resol,
519     const bool do_feather_isect))[2]
520 {
521   MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
522   MaskSplinePoint *point_curr, *point_prev;
523   float(*feather)[2], (*fp)[2];
524
525   const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
526   int a;
527
528   /* tot+1 because of 'forward_diff_bezier' function */
529   feather = fp = MEM_mallocN((tot + 1) * sizeof(*feather), "mask spline feather diff points");
530
531   a = spline->tot_point - 1;
532   if (spline->flag & MASK_SPLINE_CYCLIC) {
533     a++;
534   }
535
536   point_prev = points_array;
537   point_curr = point_prev + 1;
538
539   while (a--) {
540     /* BezTriple *bezt_prev; */ /* UNUSED */
541     /* BezTriple *bezt_curr; */ /* UNUSED */
542     int j;
543
544     if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC)) {
545       point_curr = points_array;
546     }
547
548     /* bezt_prev = &point_prev->bezt; */
549     /* bezt_curr = &point_curr->bezt; */
550
551     for (j = 0; j < resol; j++, fp++) {
552       float u = (float)j / resol, weight;
553       float co[2], n[2];
554
555       /* TODO - these calls all calculate similar things
556        * could be unified for some speed */
557       BKE_mask_point_segment_co(spline, point_prev, u, co);
558       BKE_mask_point_normal(spline, point_prev, u, n);
559       weight = BKE_mask_point_weight(spline, point_prev, u);
560
561       madd_v2_v2v2fl(*fp, co, n, weight);
562     }
563
564     if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
565       float u = 1.0f, weight;
566       float co[2], n[2];
567
568       BKE_mask_point_segment_co(spline, point_prev, u, co);
569       BKE_mask_point_normal(spline, point_prev, u, n);
570       weight = BKE_mask_point_weight(spline, point_prev, u);
571
572       madd_v2_v2v2fl(*fp, co, n, weight);
573     }
574
575     point_prev = point_curr;
576     point_curr++;
577   }
578
579   *tot_feather_point = tot;
580
581   if ((spline->flag & MASK_SPLINE_NOINTERSECT) && do_feather_isect) {
582     BKE_mask_spline_feather_collapse_inner_loops(spline, feather, tot);
583   }
584
585   return feather;
586 }
587
588 /** only called from #BKE_mask_spline_feather_differentiated_points_with_resolution() ! */
589 static float (*mask_spline_feather_differentiated_points_with_resolution__double(
590     MaskSpline *spline,
591     unsigned int *tot_feather_point,
592     const unsigned int resol,
593     const bool do_feather_isect))[2]
594 {
595   MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
596
597   MaskSplinePoint *point_curr, *point_prev;
598   float(*feather)[2], (*fp)[2];
599   const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
600   int a;
601
602   if (spline->tot_point <= 1) {
603     /* nothing to differentiate */
604     *tot_feather_point = 0;
605     return NULL;
606   }
607
608   /* len+1 because of 'forward_diff_bezier' function */
609   *tot_feather_point = tot;
610   feather = fp = MEM_mallocN((tot + 1) * sizeof(*feather), "mask spline vets");
611
612   a = spline->tot_point - 1;
613   if (spline->flag & MASK_SPLINE_CYCLIC) {
614     a++;
615   }
616
617   point_prev = points_array;
618   point_curr = point_prev + 1;
619
620   while (a--) {
621     BezTriple local_prevbezt;
622     BezTriple local_bezt;
623     float point_prev_n[2], point_curr_n[2], tvec[2];
624     float weight_prev, weight_curr;
625     float len_base, len_feather, len_scalar;
626
627     BezTriple *bezt_prev;
628     BezTriple *bezt_curr;
629     int j;
630
631     if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC)) {
632       point_curr = points_array;
633     }
634
635     bezt_prev = &point_prev->bezt;
636     bezt_curr = &point_curr->bezt;
637
638     /* modified copy for feather */
639     local_prevbezt = *bezt_prev;
640     local_bezt = *bezt_curr;
641
642     bezt_prev = &local_prevbezt;
643     bezt_curr = &local_bezt;
644
645     /* calc the normals */
646     sub_v2_v2v2(tvec, bezt_prev->vec[1], bezt_prev->vec[0]);
647     normalize_v2(tvec);
648     point_prev_n[0] = -tvec[1];
649     point_prev_n[1] = tvec[0];
650
651     sub_v2_v2v2(tvec, bezt_curr->vec[1], bezt_curr->vec[0]);
652     normalize_v2(tvec);
653     point_curr_n[0] = -tvec[1];
654     point_curr_n[1] = tvec[0];
655
656     weight_prev = bezt_prev->weight;
657     weight_curr = bezt_curr->weight;
658
659     mul_v2_fl(point_prev_n, weight_prev);
660     mul_v2_fl(point_curr_n, weight_curr);
661
662     /* before we transform verts */
663     len_base = len_v2v2(bezt_prev->vec[1], bezt_curr->vec[1]);
664
665     // add_v2_v2(bezt_prev->vec[0], point_prev_n);  // not needed
666     add_v2_v2(bezt_prev->vec[1], point_prev_n);
667     add_v2_v2(bezt_prev->vec[2], point_prev_n);
668
669     add_v2_v2(bezt_curr->vec[0], point_curr_n);
670     add_v2_v2(bezt_curr->vec[1], point_curr_n);
671     // add_v2_v2(bezt_curr->vec[2], point_curr_n); // not needed
672
673     len_feather = len_v2v2(bezt_prev->vec[1], bezt_curr->vec[1]);
674
675     /* scale by chane in length */
676     len_scalar = len_feather / len_base;
677     dist_ensure_v2_v2fl(bezt_prev->vec[2],
678                         bezt_prev->vec[1],
679                         len_scalar * len_v2v2(bezt_prev->vec[2], bezt_prev->vec[1]));
680     dist_ensure_v2_v2fl(bezt_curr->vec[0],
681                         bezt_curr->vec[1],
682                         len_scalar * len_v2v2(bezt_curr->vec[0], bezt_curr->vec[1]));
683
684     for (j = 0; j < 2; j++) {
685       BKE_curve_forward_diff_bezier(bezt_prev->vec[1][j],
686                                     bezt_prev->vec[2][j],
687                                     bezt_curr->vec[0][j],
688                                     bezt_curr->vec[1][j],
689                                     &(*fp)[j],
690                                     resol,
691                                     2 * sizeof(float));
692     }
693
694     /* scale by the uw's */
695     if (point_prev->tot_uw) {
696       for (j = 0; j < resol; j++, fp++) {
697         float u = (float)j / resol;
698         float weight_uw, weight_scalar;
699         float co[2];
700
701         /* TODO - these calls all calculate similar things
702          * could be unified for some speed */
703         BKE_mask_point_segment_co(spline, point_prev, u, co);
704
705         weight_uw = BKE_mask_point_weight(spline, point_prev, u);
706         weight_scalar = BKE_mask_point_weight_scalar(spline, point_prev, u);
707
708         dist_ensure_v2_v2fl(*fp, co, len_v2v2(*fp, co) * (weight_uw / weight_scalar));
709       }
710     }
711     else {
712       fp += resol;
713     }
714
715     if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
716       copy_v2_v2(*fp, bezt_curr->vec[1]);
717     }
718
719     point_prev = point_curr;
720     point_curr++;
721   }
722
723   if ((spline->flag & MASK_SPLINE_NOINTERSECT) && do_feather_isect) {
724     BKE_mask_spline_feather_collapse_inner_loops(spline, feather, tot);
725   }
726
727   return feather;
728 }
729
730 /**
731  * values align with #BKE_mask_spline_differentiate_with_resolution
732  * when \a resol arguments match.
733  */
734 float (
735     *BKE_mask_spline_feather_differentiated_points_with_resolution(MaskSpline *spline,
736                                                                    unsigned int *tot_feather_point,
737                                                                    const unsigned int resol,
738                                                                    const bool do_feather_isect))[2]
739 {
740   switch (spline->offset_mode) {
741     case MASK_SPLINE_OFFSET_EVEN:
742       return mask_spline_feather_differentiated_points_with_resolution__even(
743           spline, tot_feather_point, resol, do_feather_isect);
744     case MASK_SPLINE_OFFSET_SMOOTH:
745     default:
746       return mask_spline_feather_differentiated_points_with_resolution__double(
747           spline, tot_feather_point, resol, do_feather_isect);
748   }
749 }
750
751 float (*BKE_mask_spline_feather_points(MaskSpline *spline, int *tot_feather_point))[2]
752 {
753   MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
754
755   int i, tot = 0;
756   float(*feather)[2], (*fp)[2];
757
758   /* count */
759   for (i = 0; i < spline->tot_point; i++) {
760     MaskSplinePoint *point = &points_array[i];
761
762     tot += point->tot_uw + 1;
763   }
764
765   /* create data */
766   feather = fp = MEM_mallocN(tot * sizeof(*feather), "mask spline feather points");
767
768   for (i = 0; i < spline->tot_point; i++) {
769     MaskSplinePoint *point = &points_array[i];
770     BezTriple *bezt = &point->bezt;
771     float weight, n[2];
772     int j;
773
774     BKE_mask_point_normal(spline, point, 0.0f, n);
775     weight = BKE_mask_point_weight(spline, point, 0.0f);
776
777     madd_v2_v2v2fl(*fp, bezt->vec[1], n, weight);
778     fp++;
779
780     for (j = 0; j < point->tot_uw; j++) {
781       float u = point->uw[j].u;
782       float co[2];
783
784       BKE_mask_point_segment_co(spline, point, u, co);
785       BKE_mask_point_normal(spline, point, u, n);
786       weight = BKE_mask_point_weight(spline, point, u);
787
788       madd_v2_v2v2fl(*fp, co, n, weight);
789       fp++;
790     }
791   }
792
793   *tot_feather_point = tot;
794
795   return feather;
796 }
797
798 /* *** mask point functions which involve evaluation *** */
799 float *BKE_mask_point_segment_feather_diff(MaskSpline *spline,
800                                            MaskSplinePoint *point,
801                                            int width,
802                                            int height,
803                                            unsigned int *tot_feather_point)
804 {
805   float *feather, *fp;
806   unsigned int resol = BKE_mask_spline_feather_resolution(spline, width, height);
807   unsigned int i;
808
809   feather = fp = MEM_callocN(2 * resol * sizeof(float), "mask point spline feather diff points");
810
811   for (i = 0; i < resol; i++, fp += 2) {
812     float u = (float)(i % resol) / resol, weight;
813     float co[2], n[2];
814
815     BKE_mask_point_segment_co(spline, point, u, co);
816     BKE_mask_point_normal(spline, point, u, n);
817     weight = BKE_mask_point_weight(spline, point, u);
818
819     fp[0] = co[0] + n[0] * weight;
820     fp[1] = co[1] + n[1] * weight;
821   }
822
823   *tot_feather_point = resol;
824
825   return feather;
826 }
827
828 float *BKE_mask_point_segment_diff(MaskSpline *spline,
829                                    MaskSplinePoint *point,
830                                    int width,
831                                    int height,
832                                    unsigned int *tot_diff_point)
833 {
834   MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
835
836   BezTriple *bezt, *bezt_next;
837   float *diff_points, *fp;
838   int j, resol = BKE_mask_spline_resolution(spline, width, height);
839
840   bezt = &point->bezt;
841   bezt_next = BKE_mask_spline_point_next_bezt(spline, points_array, point);
842
843   if (!bezt_next) {
844     return NULL;
845   }
846
847   /* resol+1 because of 'forward_diff_bezier' function */
848   *tot_diff_point = resol + 1;
849   diff_points = fp = MEM_callocN((resol + 1) * 2 * sizeof(float), "mask segment vets");
850
851   for (j = 0; j < 2; j++) {
852     BKE_curve_forward_diff_bezier(bezt->vec[1][j],
853                                   bezt->vec[2][j],
854                                   bezt_next->vec[0][j],
855                                   bezt_next->vec[1][j],
856                                   fp + j,
857                                   resol,
858                                   2 * sizeof(float));
859   }
860
861   copy_v2_v2(fp + 2 * resol, bezt_next->vec[1]);
862
863   return diff_points;
864 }
865
866 static void mask_evaluate_apply_point_parent(MaskSplinePoint *point, float ctime)
867 {
868   float parent_matrix[3][3];
869   BKE_mask_point_parent_matrix_get(point, ctime, parent_matrix);
870   mul_m3_v2(parent_matrix, point->bezt.vec[0]);
871   mul_m3_v2(parent_matrix, point->bezt.vec[1]);
872   mul_m3_v2(parent_matrix, point->bezt.vec[2]);
873 }
874
875 void BKE_mask_layer_evaluate_animation(MaskLayer *masklay, const float ctime)
876 {
877   /* animation if available */
878   MaskLayerShape *masklay_shape_a;
879   MaskLayerShape *masklay_shape_b;
880   int found;
881   if ((found = BKE_mask_layer_shape_find_frame_range(
882            masklay, ctime, &masklay_shape_a, &masklay_shape_b))) {
883     if (found == 1) {
884 #if 0
885       printf("%s: exact %d %d (%d)\n",
886              __func__,
887              (int)ctime,
888              BLI_listbase_count(&masklay->splines_shapes),
889              masklay_shape_a->frame);
890 #endif
891       BKE_mask_layer_shape_to_mask(masklay, masklay_shape_a);
892     }
893     else if (found == 2) {
894       float w = masklay_shape_b->frame - masklay_shape_a->frame;
895 #if 0
896       printf("%s: tween %d %d (%d %d)\n",
897              __func__,
898              (int)ctime,
899              BLI_listbase_count(&masklay->splines_shapes),
900              masklay_shape_a->frame,
901              masklay_shape_b->frame);
902 #endif
903       BKE_mask_layer_shape_to_mask_interp(
904           masklay, masklay_shape_a, masklay_shape_b, (ctime - masklay_shape_a->frame) / w);
905     }
906     else {
907       /* always fail, should never happen */
908       BLI_assert(found == 2);
909     }
910   }
911 }
912
913 void BKE_mask_layer_evaluate_deform(MaskLayer *masklay, const float ctime)
914 {
915   BKE_mask_layer_calc_handles(masklay);
916   for (MaskSpline *spline = masklay->splines.first; spline != NULL; spline = spline->next) {
917     bool need_handle_recalc = false;
918     BKE_mask_spline_ensure_deform(spline);
919     for (int i = 0; i < spline->tot_point; i++) {
920       MaskSplinePoint *point = &spline->points[i];
921       MaskSplinePoint *point_deform = &spline->points_deform[i];
922       BKE_mask_point_free(point_deform);
923       *point_deform = *point;
924       point_deform->uw = point->uw ? MEM_dupallocN(point->uw) : NULL;
925       mask_evaluate_apply_point_parent(point_deform, ctime);
926       if (ELEM(point->bezt.h1, HD_AUTO, HD_VECT)) {
927         need_handle_recalc = true;
928       }
929     }
930     /* if the spline has auto or vector handles, these need to be
931      * recalculated after deformation.
932      */
933     if (need_handle_recalc) {
934       for (int i = 0; i < spline->tot_point; i++) {
935         MaskSplinePoint *point_deform = &spline->points_deform[i];
936         if (ELEM(point_deform->bezt.h1, HD_AUTO, HD_VECT)) {
937           BKE_mask_calc_handle_point(spline, point_deform);
938         }
939       }
940     }
941     /* end extra calc handles loop */
942   }
943 }
944
945 void BKE_mask_eval_animation(struct Depsgraph *depsgraph, Mask *mask)
946 {
947   float ctime = DEG_get_ctime(depsgraph);
948   DEG_debug_print_eval(depsgraph, __func__, mask->id.name, mask);
949   for (MaskLayer *mask_layer = mask->masklayers.first; mask_layer != NULL;
950        mask_layer = mask_layer->next) {
951     BKE_mask_layer_evaluate_animation(mask_layer, ctime);
952   }
953 }
954
955 void BKE_mask_eval_update(struct Depsgraph *depsgraph, Mask *mask)
956 {
957   float ctime = DEG_get_ctime(depsgraph);
958   DEG_debug_print_eval(depsgraph, __func__, mask->id.name, mask);
959   for (MaskLayer *mask_layer = mask->masklayers.first; mask_layer != NULL;
960        mask_layer = mask_layer->next) {
961     BKE_mask_layer_evaluate_deform(mask_layer, ctime);
962   }
963 }