ClangFormat: apply to source, most of intern
[blender.git] / source / blender / blenkernel / intern / mask_evaluate.c
index 12ddb1b..2b84c1f 100644 (file)
@@ -17,7 +17,8 @@
  * All rights reserved.
  */
 
-/** \file \ingroup bke
+/** \file
+ * \ingroup bke
  *
  * Functions for evaluating the mask beziers into points for the outline and feather.
  */
 
 unsigned int BKE_mask_spline_resolution(MaskSpline *spline, int width, int height)
 {
-       float max_segment = 0.01f;
-       unsigned int i, resol = 1;
+  float max_segment = 0.01f;
+  unsigned int i, resol = 1;
 
-       if (width != 0 && height != 0) {
-               max_segment = 1.0f / (float)max_ii(width, height);
-       }
+  if (width != 0 && height != 0) {
+    max_segment = 1.0f / (float)max_ii(width, height);
+  }
 
-       for (i = 0; i < spline->tot_point; i++) {
-               MaskSplinePoint *point = &spline->points[i];
-               BezTriple *bezt_curr, *bezt_next;
-               float a, b, c, len;
-               unsigned int cur_resol;
+  for (i = 0; i < spline->tot_point; i++) {
+    MaskSplinePoint *point = &spline->points[i];
+    BezTriple *bezt_curr, *bezt_next;
+    float a, b, c, len;
+    unsigned int cur_resol;
 
-               bezt_curr = &point->bezt;
-               bezt_next = BKE_mask_spline_point_next_bezt(spline, spline->points, point);
+    bezt_curr = &point->bezt;
+    bezt_next = BKE_mask_spline_point_next_bezt(spline, spline->points, point);
 
-               if (bezt_next == NULL) {
-                       break;
-               }
+    if (bezt_next == NULL) {
+      break;
+    }
 
-               a = len_v3v3(bezt_curr->vec[1], bezt_curr->vec[2]);
-               b = len_v3v3(bezt_curr->vec[2], bezt_next->vec[0]);
-               c = len_v3v3(bezt_next->vec[0], bezt_next->vec[1]);
+    a = len_v3v3(bezt_curr->vec[1], bezt_curr->vec[2]);
+    b = len_v3v3(bezt_curr->vec[2], bezt_next->vec[0]);
+    c = len_v3v3(bezt_next->vec[0], bezt_next->vec[1]);
 
-               len = a + b + c;
-               cur_resol = len / max_segment;
+    len = a + b + c;
+    cur_resol = len / max_segment;
 
-               resol = MAX2(resol, cur_resol);
+    resol = MAX2(resol, cur_resol);
 
-               if (resol >= MASK_RESOL_MAX) {
-                       break;
-               }
-       }
+    if (resol >= MASK_RESOL_MAX) {
+      break;
+    }
+  }
 
-       return CLAMPIS(resol, 1, MASK_RESOL_MAX);
+  return CLAMPIS(resol, 1, MASK_RESOL_MAX);
 }
 
 unsigned int BKE_mask_spline_feather_resolution(MaskSpline *spline, int width, int height)
 {
-       const float max_segment = 0.005;
-       unsigned int resol = BKE_mask_spline_resolution(spline, width, height);
-       float max_jump = 0.0f;
-       int i;
+  const float max_segment = 0.005;
+  unsigned int resol = BKE_mask_spline_resolution(spline, width, height);
+  float max_jump = 0.0f;
+  int i;
 
-       /* avoid checking the featrher if we already hit the maximum value */
-       if (resol >= MASK_RESOL_MAX) {
-               return MASK_RESOL_MAX;
-       }
+  /* avoid checking the featrher if we already hit the maximum value */
+  if (resol >= MASK_RESOL_MAX) {
+    return MASK_RESOL_MAX;
+  }
 
-       for (i = 0; i < spline->tot_point; i++) {
-               MaskSplinePoint *point = &spline->points[i];
-               float prev_u, prev_w;
-               int j;
+  for (i = 0; i < spline->tot_point; i++) {
+    MaskSplinePoint *point = &spline->points[i];
+    float prev_u, prev_w;
+    int j;
 
-               prev_u = 0.0f;
-               prev_w = point->bezt.weight;
+    prev_u = 0.0f;
+    prev_w = point->bezt.weight;
 
-               for (j = 0; j < point->tot_uw; j++) {
-                       const float w_diff = (point->uw[j].w - prev_w);
-                       const float u_diff = (point->uw[j].u - prev_u);
+    for (j = 0; j < point->tot_uw; j++) {
+      const float w_diff = (point->uw[j].w - prev_w);
+      const float u_diff = (point->uw[j].u - prev_u);
 
-                       /* avoid divide by zero and very high values,
-                        * though these get clamped eventually */
-                       if (u_diff > FLT_EPSILON) {
-                               float jump = fabsf(w_diff / u_diff);
+      /* avoid divide by zero and very high values,
+       * though these get clamped eventually */
+      if (u_diff > FLT_EPSILON) {
+        float jump = fabsf(w_diff / u_diff);
 
-                               max_jump = max_ff(max_jump, jump);
-                       }
+        max_jump = max_ff(max_jump, jump);
+      }
 
-                       prev_u = point->uw[j].u;
-                       prev_w = point->uw[j].w;
-               }
-       }
+      prev_u = point->uw[j].u;
+      prev_w = point->uw[j].w;
+    }
+  }
 
-       resol += max_jump / max_segment;
+  resol += max_jump / max_segment;
 
-       return CLAMPIS(resol, 1, MASK_RESOL_MAX);
+  return CLAMPIS(resol, 1, MASK_RESOL_MAX);
 }
 
 int BKE_mask_spline_differentiate_calc_total(const MaskSpline *spline, const unsigned int resol)
 {
-       if (spline->flag & MASK_SPLINE_CYCLIC) {
-               return spline->tot_point * resol;
-       }
-       else {
-               return ((spline->tot_point - 1) * resol) + 1;
-       }
+  if (spline->flag & MASK_SPLINE_CYCLIC) {
+    return spline->tot_point * resol;
+  }
+  else {
+    return ((spline->tot_point - 1) * resol) + 1;
+  }
 }
 
 float (*BKE_mask_spline_differentiate_with_resolution(MaskSpline *spline,
                                                       unsigned int *tot_diff_point,
-                                                      const unsigned int resol
-                                                      ))[2]
+                                                      const unsigned int resol))[2]
 {
-       MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
-
-       MaskSplinePoint *point_curr, *point_prev;
-       float (*diff_points)[2], (*fp)[2];
-       const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
-       int a;
-
-       if (spline->tot_point <= 1) {
-               /* nothing to differentiate */
-               *tot_diff_point = 0;
-               return NULL;
-       }
-
-       /* len+1 because of 'forward_diff_bezier' function */
-       *tot_diff_point = tot;
-       diff_points = fp = MEM_mallocN((tot + 1) * sizeof(*diff_points), "mask spline vets");
-
-       a = spline->tot_point - 1;
-       if (spline->flag & MASK_SPLINE_CYCLIC)
-               a++;
-
-       point_prev = points_array;
-       point_curr = point_prev + 1;
-
-       while (a--) {
-               BezTriple *bezt_prev;
-               BezTriple *bezt_curr;
-               int j;
-
-               if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC))
-                       point_curr = points_array;
-
-               bezt_prev = &point_prev->bezt;
-               bezt_curr = &point_curr->bezt;
-
-               for (j = 0; j < 2; j++) {
-                       BKE_curve_forward_diff_bezier(bezt_prev->vec[1][j], bezt_prev->vec[2][j],
-                                                     bezt_curr->vec[0][j], bezt_curr->vec[1][j],
-                                                     &(*fp)[j], resol, 2 * sizeof(float));
-               }
-
-               fp += resol;
-
-               if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
-                       copy_v2_v2(*fp, bezt_curr->vec[1]);
-               }
-
-               point_prev = point_curr;
-               point_curr++;
-       }
-
-       return diff_points;
+  MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
+
+  MaskSplinePoint *point_curr, *point_prev;
+  float(*diff_points)[2], (*fp)[2];
+  const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
+  int a;
+
+  if (spline->tot_point <= 1) {
+    /* nothing to differentiate */
+    *tot_diff_point = 0;
+    return NULL;
+  }
+
+  /* len+1 because of 'forward_diff_bezier' function */
+  *tot_diff_point = tot;
+  diff_points = fp = MEM_mallocN((tot + 1) * sizeof(*diff_points), "mask spline vets");
+
+  a = spline->tot_point - 1;
+  if (spline->flag & MASK_SPLINE_CYCLIC)
+    a++;
+
+  point_prev = points_array;
+  point_curr = point_prev + 1;
+
+  while (a--) {
+    BezTriple *bezt_prev;
+    BezTriple *bezt_curr;
+    int j;
+
+    if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC))
+      point_curr = points_array;
+
+    bezt_prev = &point_prev->bezt;
+    bezt_curr = &point_curr->bezt;
+
+    for (j = 0; j < 2; j++) {
+      BKE_curve_forward_diff_bezier(bezt_prev->vec[1][j],
+                                    bezt_prev->vec[2][j],
+                                    bezt_curr->vec[0][j],
+                                    bezt_curr->vec[1][j],
+                                    &(*fp)[j],
+                                    resol,
+                                    2 * sizeof(float));
+    }
+
+    fp += resol;
+
+    if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
+      copy_v2_v2(*fp, bezt_curr->vec[1]);
+    }
+
+    point_prev = point_curr;
+    point_curr++;
+  }
+
+  return diff_points;
 }
 
-float (*BKE_mask_spline_differentiate(MaskSpline *spline, int width, int height,
-                                      unsigned int *tot_diff_point
-                                      ))[2]
+float (*BKE_mask_spline_differentiate(
+    MaskSpline *spline, int width, int height, unsigned int *tot_diff_point))[2]
 {
-       int unsigned resol = BKE_mask_spline_resolution(spline, width, height);
+  int unsigned resol = BKE_mask_spline_resolution(spline, width, height);
 
-       return BKE_mask_spline_differentiate_with_resolution(spline, tot_diff_point, resol);
+  return BKE_mask_spline_differentiate_with_resolution(spline, tot_diff_point, resol);
 }
 
 /* ** feather points self-intersection collapse routine ** */
 
 typedef struct FeatherEdgesBucket {
-       int tot_segment;
-       int (*segments)[2];
-       int alloc_segment;
+  int tot_segment;
+  int (*segments)[2];
+  int alloc_segment;
 } FeatherEdgesBucket;
 
 static void feather_bucket_add_edge(FeatherEdgesBucket *bucket, int start, int end)
 {
-       const int alloc_delta = 256;
+  const int alloc_delta = 256;
 
-       if (bucket->tot_segment >= bucket->alloc_segment) {
-               if (!bucket->segments) {
-                       bucket->segments = MEM_callocN(alloc_delta * sizeof(*bucket->segments), "feather bucket segments");
-               }
-               else {
-                       bucket->segments = MEM_reallocN(bucket->segments,
-                                                       (alloc_delta + bucket->tot_segment) * sizeof(*bucket->segments));
-               }
+  if (bucket->tot_segment >= bucket->alloc_segment) {
+    if (!bucket->segments) {
+      bucket->segments = MEM_callocN(alloc_delta * sizeof(*bucket->segments),
+                                     "feather bucket segments");
+    }
+    else {
+      bucket->segments = MEM_reallocN(
+          bucket->segments, (alloc_delta + bucket->tot_segment) * sizeof(*bucket->segments));
+    }
 
-               bucket->alloc_segment += alloc_delta;
-       }
+    bucket->alloc_segment += alloc_delta;
+  }
 
-       bucket->segments[bucket->tot_segment][0] = start;
-       bucket->segments[bucket->tot_segment][1] = end;
+  bucket->segments[bucket->tot_segment][0] = start;
+  bucket->segments[bucket->tot_segment][1] = end;
 
-       bucket->tot_segment++;
+  bucket->tot_segment++;
 }
 
-static void feather_bucket_check_intersect(
-        float (*feather_points)[2], int tot_feather_point, FeatherEdgesBucket *bucket,
-        int cur_a, int cur_b)
+static void feather_bucket_check_intersect(float (*feather_points)[2],
+                                           int tot_feather_point,
+                                           FeatherEdgesBucket *bucket,
+                                           int cur_a,
+                                           int cur_b)
 {
-       int i;
-
-       const float *v1 = (float *) feather_points[cur_a];
-       const float *v2 = (float *) feather_points[cur_b];
-
-       for (i = 0; i < bucket->tot_segment; i++) {
-               int check_a = bucket->segments[i][0];
-               int check_b = bucket->segments[i][1];
-
-               const float *v3 = (float *) feather_points[check_a];
-               const float *v4 = (float *) feather_points[check_b];
-
-               if (check_a >= cur_a - 1 || cur_b == check_a)
-                       continue;
-
-               if (isect_seg_seg_v2_simple(v1, v2, v3, v4)) {
-                       int k;
-                       float p[2];
-                       float min_a[2], max_a[2];
-                       float min_b[2], max_b[2];
-
-                       isect_seg_seg_v2_point(v1, v2, v3, v4, p);
-
-                       INIT_MINMAX2(min_a, max_a);
-                       INIT_MINMAX2(min_b, max_b);
-
-                       /* collapse loop with smaller AABB */
-                       for (k = 0; k < tot_feather_point; k++) {
-                               if (k >= check_b && k <= cur_a) {
-                                       minmax_v2v2_v2(min_a, max_a, feather_points[k]);
-                               }
-                               else {
-                                       minmax_v2v2_v2(min_b, max_b, feather_points[k]);
-                               }
-                       }
-
-                       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])
-                       {
-                               for (k = check_b; k <= cur_a; k++) {
-                                       copy_v2_v2(feather_points[k], p);
-                               }
-                       }
-                       else {
-                               for (k = 0; k <= check_a; k++) {
-                                       copy_v2_v2(feather_points[k], p);
-                               }
-
-                               if (cur_b != 0) {
-                                       for (k = cur_b; k < tot_feather_point; k++) {
-                                               copy_v2_v2(feather_points[k], p);
-                                       }
-                               }
-                       }
-               }
-       }
+  int i;
+
+  const float *v1 = (float *)feather_points[cur_a];
+  const float *v2 = (float *)feather_points[cur_b];
+
+  for (i = 0; i < bucket->tot_segment; i++) {
+    int check_a = bucket->segments[i][0];
+    int check_b = bucket->segments[i][1];
+
+    const float *v3 = (float *)feather_points[check_a];
+    const float *v4 = (float *)feather_points[check_b];
+
+    if (check_a >= cur_a - 1 || cur_b == check_a)
+      continue;
+
+    if (isect_seg_seg_v2_simple(v1, v2, v3, v4)) {
+      int k;
+      float p[2];
+      float min_a[2], max_a[2];
+      float min_b[2], max_b[2];
+
+      isect_seg_seg_v2_point(v1, v2, v3, v4, p);
+
+      INIT_MINMAX2(min_a, max_a);
+      INIT_MINMAX2(min_b, max_b);
+
+      /* collapse loop with smaller AABB */
+      for (k = 0; k < tot_feather_point; k++) {
+        if (k >= check_b && k <= cur_a) {
+          minmax_v2v2_v2(min_a, max_a, feather_points[k]);
+        }
+        else {
+          minmax_v2v2_v2(min_b, max_b, feather_points[k]);
+        }
+      }
+
+      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]) {
+        for (k = check_b; k <= cur_a; k++) {
+          copy_v2_v2(feather_points[k], p);
+        }
+      }
+      else {
+        for (k = 0; k <= check_a; k++) {
+          copy_v2_v2(feather_points[k], p);
+        }
+
+        if (cur_b != 0) {
+          for (k = cur_b; k < tot_feather_point; k++) {
+            copy_v2_v2(feather_points[k], p);
+          }
+        }
+      }
+    }
+  }
 }
 
-static int feather_bucket_index_from_coord(
-        const float co[2], const float min[2], const float bucket_scale[2],
-        const int buckets_per_side)
+static int feather_bucket_index_from_coord(const float co[2],
+                                           const float min[2],
+                                           const float bucket_scale[2],
+                                           const int buckets_per_side)
 {
-       int x = (int) ((co[0] - min[0]) * bucket_scale[0]);
-       int y = (int) ((co[1] - min[1]) * bucket_scale[1]);
+  int x = (int)((co[0] - min[0]) * bucket_scale[0]);
+  int y = (int)((co[1] - min[1]) * bucket_scale[1]);
 
-       if (x == buckets_per_side)
-               x--;
+  if (x == buckets_per_side)
+    x--;
 
-       if (y == buckets_per_side)
-               y--;
+  if (y == buckets_per_side)
+    y--;
 
-       return y * buckets_per_side + x;
+  return y * buckets_per_side + x;
 }
 
-static void feather_bucket_get_diagonal(
-        FeatherEdgesBucket *buckets, int start_bucket_index, int end_bucket_index, int buckets_per_side,
-        FeatherEdgesBucket **r_diagonal_bucket_a, FeatherEdgesBucket **r_diagonal_bucket_b)
+static void feather_bucket_get_diagonal(FeatherEdgesBucket *buckets,
+                                        int start_bucket_index,
+                                        int end_bucket_index,
+                                        int buckets_per_side,
+                                        FeatherEdgesBucket **r_diagonal_bucket_a,
+                                        FeatherEdgesBucket **r_diagonal_bucket_b)
 {
-       int start_bucket_x = start_bucket_index % buckets_per_side;
-       int start_bucket_y = start_bucket_index / buckets_per_side;
+  int start_bucket_x = start_bucket_index % buckets_per_side;
+  int start_bucket_y = start_bucket_index / buckets_per_side;
 
-       int end_bucket_x = end_bucket_index % buckets_per_side;
-       int end_bucket_y = end_bucket_index / buckets_per_side;
+  int end_bucket_x = end_bucket_index % buckets_per_side;
+  int end_bucket_y = end_bucket_index / buckets_per_side;
 
-       int diagonal_bucket_a_index = start_bucket_y * buckets_per_side + end_bucket_x;
-       int diagonal_bucket_b_index = end_bucket_y * buckets_per_side + start_bucket_x;
+  int diagonal_bucket_a_index = start_bucket_y * buckets_per_side + end_bucket_x;
+  int diagonal_bucket_b_index = end_bucket_y * buckets_per_side + start_bucket_x;
 
-       *r_diagonal_bucket_a = &buckets[diagonal_bucket_a_index];
-       *r_diagonal_bucket_b = &buckets[diagonal_bucket_b_index];
+  *r_diagonal_bucket_a = &buckets[diagonal_bucket_a_index];
+  *r_diagonal_bucket_b = &buckets[diagonal_bucket_b_index];
 }
 
-void BKE_mask_spline_feather_collapse_inner_loops(
-        MaskSpline *spline, float (*feather_points)[2], const unsigned int tot_feather_point)
+void BKE_mask_spline_feather_collapse_inner_loops(MaskSpline *spline,
+                                                  float (*feather_points)[2],
+                                                  const unsigned int tot_feather_point)
 {
-#define BUCKET_INDEX(co) \
-       feather_bucket_index_from_coord(co, min, bucket_scale, buckets_per_side)
-
-       int buckets_per_side, tot_bucket;
-       float bucket_size, bucket_scale[2];
+#define BUCKET_INDEX(co) feather_bucket_index_from_coord(co, min, bucket_scale, buckets_per_side)
 
-       FeatherEdgesBucket *buckets;
+  int buckets_per_side, tot_bucket;
+  float bucket_size, bucket_scale[2];
 
-       unsigned int i;
-       float min[2], max[2];
-       float max_delta_x = -1.0f, max_delta_y = -1.0f, max_delta;
+  FeatherEdgesBucket *buckets;
 
-       if (tot_feather_point < 4) {
-               /* self-intersection works only for quads at least,
-                * in other cases polygon can't be self-intersecting anyway
-                */
+  unsigned int i;
+  float min[2], max[2];
+  float max_delta_x = -1.0f, max_delta_y = -1.0f, max_delta;
 
-               return;
-       }
+  if (tot_feather_point < 4) {
+    /* self-intersection works only for quads at least,
+     * in other cases polygon can't be self-intersecting anyway
+     */
 
-       /* find min/max corners of mask to build buckets in that space */
-       INIT_MINMAX2(min, max);
+    return;
+  }
 
-       for (i = 0; i < tot_feather_point; i++) {
-               unsigned int next = i + 1;
-               float delta;
+  /* find min/max corners of mask to build buckets in that space */
+  INIT_MINMAX2(min, max);
 
-               minmax_v2v2_v2(min, max, feather_points[i]);
+  for (i = 0; i < tot_feather_point; i++) {
+    unsigned int next = i + 1;
+    float delta;
 
-               if (next == tot_feather_point) {
-                       if (spline->flag & MASK_SPLINE_CYCLIC)
-                               next = 0;
-                       else
-                               break;
-               }
+    minmax_v2v2_v2(min, max, feather_points[i]);
 
-               delta = fabsf(feather_points[i][0] - feather_points[next][0]);
-               if (delta > max_delta_x)
-                       max_delta_x = delta;
+    if (next == tot_feather_point) {
+      if (spline->flag & MASK_SPLINE_CYCLIC)
+        next = 0;
+      else
+        break;
+    }
 
-               delta = fabsf(feather_points[i][1] - feather_points[next][1]);
-               if (delta > max_delta_y)
-                       max_delta_y = delta;
-       }
+    delta = fabsf(feather_points[i][0] - feather_points[next][0]);
+    if (delta > max_delta_x)
+      max_delta_x = delta;
 
-       /* prevent divisionsby zero by ensuring bounding box is not collapsed */
-       if (max[0] - min[0] < FLT_EPSILON) {
-               max[0] += 0.01f;
-               min[0] -= 0.01f;
-       }
+    delta = fabsf(feather_points[i][1] - feather_points[next][1]);
+    if (delta > max_delta_y)
+      max_delta_y = delta;
+  }
 
-       if (max[1] - min[1] < FLT_EPSILON) {
-               max[1] += 0.01f;
-               min[1] -= 0.01f;
-       }
+  /* prevent divisionsby zero by ensuring bounding box is not collapsed */
+  if (max[0] - min[0] < FLT_EPSILON) {
+    max[0] += 0.01f;
+    min[0] -= 0.01f;
+  }
 
-       /* use dynamically calculated buckets per side, so we likely wouldn't
-        * run into a situation when segment doesn't fit two buckets which is
-        * pain collecting candidates for intersection
-        */
+  if (max[1] - min[1] < FLT_EPSILON) {
+    max[1] += 0.01f;
+    min[1] -= 0.01f;
+  }
 
-       max_delta_x /= max[0] - min[0];
-       max_delta_y /= max[1] - min[1];
+  /* use dynamically calculated buckets per side, so we likely wouldn't
+   * run into a situation when segment doesn't fit two buckets which is
+   * pain collecting candidates for intersection
+   */
 
-       max_delta = MAX2(max_delta_x, max_delta_y);
+  max_delta_x /= max[0] - min[0];
+  max_delta_y /= max[1] - min[1];
 
-       buckets_per_side = min_ii(512, 0.9f / max_delta);
+  max_delta = MAX2(max_delta_x, max_delta_y);
 
-       if (buckets_per_side == 0) {
-               /* happens when some segment fills the whole bounding box across some of dimension */
+  buckets_per_side = min_ii(512, 0.9f / max_delta);
 
-               buckets_per_side = 1;
-       }
+  if (buckets_per_side == 0) {
+    /* happens when some segment fills the whole bounding box across some of dimension */
 
-       tot_bucket = buckets_per_side * buckets_per_side;
-       bucket_size = 1.0f / buckets_per_side;
+    buckets_per_side = 1;
+  }
 
-       /* pre-compute multipliers, to save mathematical operations in loops */
-       bucket_scale[0] = 1.0f / ((max[0] - min[0]) * bucket_size);
-       bucket_scale[1] = 1.0f / ((max[1] - min[1]) * bucket_size);
+  tot_bucket = buckets_per_side * buckets_per_side;
+  bucket_size = 1.0f / buckets_per_side;
 
-       /* fill in buckets' edges */
-       buckets = MEM_callocN(sizeof(FeatherEdgesBucket) * tot_bucket, "feather buckets");
+  /* pre-compute multipliers, to save mathematical operations in loops */
+  bucket_scale[0] = 1.0f / ((max[0] - min[0]) * bucket_size);
+  bucket_scale[1] = 1.0f / ((max[1] - min[1]) * bucket_size);
 
-       for (i = 0; i < tot_feather_point; i++) {
-               int start = i, end = i + 1;
-               int start_bucket_index, end_bucket_index;
+  /* fill in buckets' edges */
+  buckets = MEM_callocN(sizeof(FeatherEdgesBucket) * tot_bucket, "feather buckets");
 
-               if (end == tot_feather_point) {
-                       if (spline->flag & MASK_SPLINE_CYCLIC)
-                               end = 0;
-                       else
-                               break;
-               }
+  for (i = 0; i < tot_feather_point; i++) {
+    int start = i, end = i + 1;
+    int start_bucket_index, end_bucket_index;
 
-               start_bucket_index = BUCKET_INDEX(feather_points[start]);
-               end_bucket_index = BUCKET_INDEX(feather_points[end]);
+    if (end == tot_feather_point) {
+      if (spline->flag & MASK_SPLINE_CYCLIC)
+        end = 0;
+      else
+        break;
+    }
 
-               feather_bucket_add_edge(&buckets[start_bucket_index], start, end);
+    start_bucket_index = BUCKET_INDEX(feather_points[start]);
+    end_bucket_index = BUCKET_INDEX(feather_points[end]);
 
-               if (start_bucket_index != end_bucket_index) {
-                       FeatherEdgesBucket *end_bucket = &buckets[end_bucket_index];
-                       FeatherEdgesBucket *diagonal_bucket_a, *diagonal_bucket_b;
+    feather_bucket_add_edge(&buckets[start_bucket_index], start, end);
 
-                       feather_bucket_get_diagonal(buckets, start_bucket_index, end_bucket_index, buckets_per_side,
-                                                   &diagonal_bucket_a, &diagonal_bucket_b);
+    if (start_bucket_index != end_bucket_index) {
+      FeatherEdgesBucket *end_bucket = &buckets[end_bucket_index];
+      FeatherEdgesBucket *diagonal_bucket_a, *diagonal_bucket_b;
 
-                       feather_bucket_add_edge(end_bucket, start, end);
-                       feather_bucket_add_edge(diagonal_bucket_a, start, end);
-                       feather_bucket_add_edge(diagonal_bucket_a, start, end);
-               }
-       }
+      feather_bucket_get_diagonal(buckets,
+                                  start_bucket_index,
+                                  end_bucket_index,
+                                  buckets_per_side,
+                                  &diagonal_bucket_a,
+                                  &diagonal_bucket_b);
 
-       /* check all edges for intersection with edges from their buckets */
-       for (i = 0; i < tot_feather_point; i++) {
-               int cur_a = i, cur_b = i + 1;
-               int start_bucket_index, end_bucket_index;
+      feather_bucket_add_edge(end_bucket, start, end);
+      feather_bucket_add_edge(diagonal_bucket_a, start, end);
+      feather_bucket_add_edge(diagonal_bucket_a, start, end);
+    }
+  }
 
-               FeatherEdgesBucket *start_bucket;
+  /* check all edges for intersection with edges from their buckets */
+  for (i = 0; i < tot_feather_point; i++) {
+    int cur_a = i, cur_b = i + 1;
+    int start_bucket_index, end_bucket_index;
 
-               if (cur_b == tot_feather_point)
-                       cur_b = 0;
+    FeatherEdgesBucket *start_bucket;
 
-               start_bucket_index = BUCKET_INDEX(feather_points[cur_a]);
-               end_bucket_index = BUCKET_INDEX(feather_points[cur_b]);
+    if (cur_b == tot_feather_point)
+      cur_b = 0;
 
-               start_bucket = &buckets[start_bucket_index];
+    start_bucket_index = BUCKET_INDEX(feather_points[cur_a]);
+    end_bucket_index = BUCKET_INDEX(feather_points[cur_b]);
+
+    start_bucket = &buckets[start_bucket_index];
 
-               feather_bucket_check_intersect(feather_points, tot_feather_point, start_bucket, cur_a, cur_b);
+    feather_bucket_check_intersect(feather_points, tot_feather_point, start_bucket, cur_a, cur_b);
 
-               if (start_bucket_index != end_bucket_index) {
-                       FeatherEdgesBucket *end_bucket = &buckets[end_bucket_index];
-                       FeatherEdgesBucket *diagonal_bucket_a, *diagonal_bucket_b;
+    if (start_bucket_index != end_bucket_index) {
+      FeatherEdgesBucket *end_bucket = &buckets[end_bucket_index];
+      FeatherEdgesBucket *diagonal_bucket_a, *diagonal_bucket_b;
 
-                       feather_bucket_get_diagonal(buckets, start_bucket_index, end_bucket_index, buckets_per_side,
-                                                   &diagonal_bucket_a, &diagonal_bucket_b);
+      feather_bucket_get_diagonal(buckets,
+                                  start_bucket_index,
+                                  end_bucket_index,
+                                  buckets_per_side,
+                                  &diagonal_bucket_a,
+                                  &diagonal_bucket_b);
 
-                       feather_bucket_check_intersect(feather_points, tot_feather_point, end_bucket, cur_a, cur_b);
-                       feather_bucket_check_intersect(feather_points, tot_feather_point, diagonal_bucket_a, cur_a, cur_b);
-                       feather_bucket_check_intersect(feather_points, tot_feather_point, diagonal_bucket_b, cur_a, cur_b);
-               }
-       }
+      feather_bucket_check_intersect(feather_points, tot_feather_point, end_bucket, cur_a, cur_b);
+      feather_bucket_check_intersect(
+          feather_points, tot_feather_point, diagonal_bucket_a, cur_a, cur_b);
+      feather_bucket_check_intersect(
+          feather_points, tot_feather_point, diagonal_bucket_b, cur_a, cur_b);
+    }
+  }
 
-       /* free buckets */
-       for (i = 0; i < tot_bucket; i++) {
-               if (buckets[i].segments)
-                       MEM_freeN(buckets[i].segments);
-       }
+  /* free buckets */
+  for (i = 0; i < tot_bucket; i++) {
+    if (buckets[i].segments)
+      MEM_freeN(buckets[i].segments);
+  }
 
-       MEM_freeN(buckets);
+  MEM_freeN(buckets);
 
 #undef BUCKET_INDEX
 }
 
 /** only called from #BKE_mask_spline_feather_differentiated_points_with_resolution() ! */
 static float (*mask_spline_feather_differentiated_points_with_resolution__even(
-        MaskSpline *spline, unsigned int *tot_feather_point,
-        const unsigned int resol, const bool do_feather_isect))[2]
+    MaskSpline *spline,
+    unsigned int *tot_feather_point,
+    const unsigned int resol,
+    const bool do_feather_isect))[2]
 {
-       MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
-       MaskSplinePoint *point_curr, *point_prev;
-       float (*feather)[2], (*fp)[2];
-
-       const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
-       int a;
+  MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
+  MaskSplinePoint *point_curr, *point_prev;
+  float(*feather)[2], (*fp)[2];
 
-       /* tot+1 because of 'forward_diff_bezier' function */
-       feather = fp = MEM_mallocN((tot + 1) * sizeof(*feather), "mask spline feather diff points");
+  const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
+  int a;
 
-       a = spline->tot_point - 1;
-       if (spline->flag & MASK_SPLINE_CYCLIC)
-               a++;
+  /* tot+1 because of 'forward_diff_bezier' function */
+  feather = fp = MEM_mallocN((tot + 1) * sizeof(*feather), "mask spline feather diff points");
 
-       point_prev = points_array;
-       point_curr = point_prev + 1;
+  a = spline->tot_point - 1;
+  if (spline->flag & MASK_SPLINE_CYCLIC)
+    a++;
 
-       while (a--) {
-               /* BezTriple *bezt_prev; */  /* UNUSED */
-               /* BezTriple *bezt_curr; */      /* UNUSED */
-               int j;
+  point_prev = points_array;
+  point_curr = point_prev + 1;
 
-               if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC))
-                       point_curr = points_array;
+  while (a--) {
+    /* BezTriple *bezt_prev; */ /* UNUSED */
+    /* BezTriple *bezt_curr; */ /* UNUSED */
+    int j;
 
+    if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC))
+      point_curr = points_array;
 
-               /* bezt_prev = &point_prev->bezt; */
-               /* bezt_curr = &point_curr->bezt; */
+    /* bezt_prev = &point_prev->bezt; */
+    /* bezt_curr = &point_curr->bezt; */
 
-               for (j = 0; j < resol; j++, fp++) {
-                       float u = (float) j / resol, weight;
-                       float co[2], n[2];
+    for (j = 0; j < resol; j++, fp++) {
+      float u = (float)j / resol, weight;
+      float co[2], n[2];
 
-                       /* TODO - these calls all calculate similar things
-                        * could be unified for some speed */
-                       BKE_mask_point_segment_co(spline, point_prev, u, co);
-                       BKE_mask_point_normal(spline, point_prev, u, n);
-                       weight = BKE_mask_point_weight(spline, point_prev, u);
+      /* TODO - these calls all calculate similar things
+       * could be unified for some speed */
+      BKE_mask_point_segment_co(spline, point_prev, u, co);
+      BKE_mask_point_normal(spline, point_prev, u, n);
+      weight = BKE_mask_point_weight(spline, point_prev, u);
 
-                       madd_v2_v2v2fl(*fp, co, n, weight);
-               }
+      madd_v2_v2v2fl(*fp, co, n, weight);
+    }
 
-               if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
-                       float u = 1.0f, weight;
-                       float co[2], n[2];
+    if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
+      float u = 1.0f, weight;
+      float co[2], n[2];
 
-                       BKE_mask_point_segment_co(spline, point_prev, u, co);
-                       BKE_mask_point_normal(spline, point_prev, u, n);
-                       weight = BKE_mask_point_weight(spline, point_prev, u);
+      BKE_mask_point_segment_co(spline, point_prev, u, co);
+      BKE_mask_point_normal(spline, point_prev, u, n);
+      weight = BKE_mask_point_weight(spline, point_prev, u);
 
-                       madd_v2_v2v2fl(*fp, co, n, weight);
-               }
+      madd_v2_v2v2fl(*fp, co, n, weight);
+    }
 
-               point_prev = point_curr;
-               point_curr++;
-       }
+    point_prev = point_curr;
+    point_curr++;
+  }
 
-       *tot_feather_point = tot;
+  *tot_feather_point = tot;
 
-       if ((spline->flag & MASK_SPLINE_NOINTERSECT) && do_feather_isect) {
-               BKE_mask_spline_feather_collapse_inner_loops(spline, feather, tot);
-       }
+  if ((spline->flag & MASK_SPLINE_NOINTERSECT) && do_feather_isect) {
+    BKE_mask_spline_feather_collapse_inner_loops(spline, feather, tot);
+  }
 
-       return feather;
+  return feather;
 }
 
 /** only called from #BKE_mask_spline_feather_differentiated_points_with_resolution() ! */
 static float (*mask_spline_feather_differentiated_points_with_resolution__double(
-        MaskSpline *spline, unsigned int *tot_feather_point,
-        const unsigned int resol, const bool do_feather_isect))[2]
+    MaskSpline *spline,
+    unsigned int *tot_feather_point,
+    const unsigned int resol,
+    const bool do_feather_isect))[2]
 {
-       MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
-
-       MaskSplinePoint *point_curr, *point_prev;
-       float (*feather)[2], (*fp)[2];
-       const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
-       int a;
-
-       if (spline->tot_point <= 1) {
-               /* nothing to differentiate */
-               *tot_feather_point = 0;
-               return NULL;
-       }
-
-       /* len+1 because of 'forward_diff_bezier' function */
-       *tot_feather_point = tot;
-       feather = fp = MEM_mallocN((tot + 1) * sizeof(*feather), "mask spline vets");
-
-       a = spline->tot_point - 1;
-       if (spline->flag & MASK_SPLINE_CYCLIC)
-               a++;
-
-       point_prev = points_array;
-       point_curr = point_prev + 1;
-
-       while (a--) {
-               BezTriple local_prevbezt;
-               BezTriple local_bezt;
-               float point_prev_n[2], point_curr_n[2], tvec[2];
-               float weight_prev, weight_curr;
-               float len_base, len_feather, len_scalar;
-
-               BezTriple *bezt_prev;
-               BezTriple *bezt_curr;
-               int j;
-
-               if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC))
-                       point_curr = points_array;
-
-               bezt_prev = &point_prev->bezt;
-               bezt_curr = &point_curr->bezt;
-
-               /* modified copy for feather */
-               local_prevbezt = *bezt_prev;
-               local_bezt     = *bezt_curr;
-
-               bezt_prev = &local_prevbezt;
-               bezt_curr = &local_bezt;
-
-               /* calc the normals */
-               sub_v2_v2v2(tvec, bezt_prev->vec[1], bezt_prev->vec[0]);
-               normalize_v2(tvec);
-               point_prev_n[0] = -tvec[1];
-               point_prev_n[1] =  tvec[0];
-
-               sub_v2_v2v2(tvec, bezt_curr->vec[1], bezt_curr->vec[0]);
-               normalize_v2(tvec);
-               point_curr_n[0] = -tvec[1];
-               point_curr_n[1] =  tvec[0];
-
-               weight_prev = bezt_prev->weight;
-               weight_curr = bezt_curr->weight;
-
-               mul_v2_fl(point_prev_n, weight_prev);
-               mul_v2_fl(point_curr_n, weight_curr);
-
-               /* before we transform verts */
-               len_base = len_v2v2(bezt_prev->vec[1], bezt_curr->vec[1]);
-
-               // add_v2_v2(bezt_prev->vec[0], point_prev_n);  // not needed
-               add_v2_v2(bezt_prev->vec[1], point_prev_n);
-               add_v2_v2(bezt_prev->vec[2], point_prev_n);
-
-               add_v2_v2(bezt_curr->vec[0], point_curr_n);
-               add_v2_v2(bezt_curr->vec[1], point_curr_n);
-               // add_v2_v2(bezt_curr->vec[2], point_curr_n); // not needed
-
-               len_feather = len_v2v2(bezt_prev->vec[1], bezt_curr->vec[1]);
-
-               /* scale by chane in length */
-               len_scalar = len_feather / len_base;
-               dist_ensure_v2_v2fl(bezt_prev->vec[2], bezt_prev->vec[1], len_scalar * len_v2v2(bezt_prev->vec[2], bezt_prev->vec[1]));
-               dist_ensure_v2_v2fl(bezt_curr->vec[0], bezt_curr->vec[1], len_scalar * len_v2v2(bezt_curr->vec[0], bezt_curr->vec[1]));
-
-
-               for (j = 0; j < 2; j++) {
-                       BKE_curve_forward_diff_bezier(bezt_prev->vec[1][j], bezt_prev->vec[2][j],
-                                                     bezt_curr->vec[0][j], bezt_curr->vec[1][j],
-                                                     &(*fp)[j], resol, 2 * sizeof(float));
-               }
-
-
-               /* scale by the uw's */
-               if (point_prev->tot_uw) {
-                       for (j = 0; j < resol; j++, fp++) {
-                               float u = (float) j / resol;
-                               float weight_uw, weight_scalar;
-                               float co[2];
-
-                               /* TODO - these calls all calculate similar things
-                                * could be unified for some speed */
-                               BKE_mask_point_segment_co(spline, point_prev, u, co);
-
-                               weight_uw     = BKE_mask_point_weight(spline, point_prev, u);
-                               weight_scalar = BKE_mask_point_weight_scalar(spline, point_prev, u);
-
-                               dist_ensure_v2_v2fl(*fp, co, len_v2v2(*fp, co) * (weight_uw / weight_scalar));
-                       }
-               }
-               else {
-                       fp += resol;
-               }
-
-               if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
-                       copy_v2_v2(*fp, bezt_curr->vec[1]);
-               }
-
-               point_prev = point_curr;
-               point_curr++;
-       }
-
-       if ((spline->flag & MASK_SPLINE_NOINTERSECT) && do_feather_isect) {
-               BKE_mask_spline_feather_collapse_inner_loops(spline, feather, tot);
-       }
-
-       return feather;
+  MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
+
+  MaskSplinePoint *point_curr, *point_prev;
+  float(*feather)[2], (*fp)[2];
+  const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
+  int a;
+
+  if (spline->tot_point <= 1) {
+    /* nothing to differentiate */
+    *tot_feather_point = 0;
+    return NULL;
+  }
+
+  /* len+1 because of 'forward_diff_bezier' function */
+  *tot_feather_point = tot;
+  feather = fp = MEM_mallocN((tot + 1) * sizeof(*feather), "mask spline vets");
+
+  a = spline->tot_point - 1;
+  if (spline->flag & MASK_SPLINE_CYCLIC)
+    a++;
+
+  point_prev = points_array;
+  point_curr = point_prev + 1;
+
+  while (a--) {
+    BezTriple local_prevbezt;
+    BezTriple local_bezt;
+    float point_prev_n[2], point_curr_n[2], tvec[2];
+    float weight_prev, weight_curr;
+    float len_base, len_feather, len_scalar;
+
+    BezTriple *bezt_prev;
+    BezTriple *bezt_curr;
+    int j;
+
+    if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC))
+      point_curr = points_array;
+
+    bezt_prev = &point_prev->bezt;
+    bezt_curr = &point_curr->bezt;
+
+    /* modified copy for feather */
+    local_prevbezt = *bezt_prev;
+    local_bezt = *bezt_curr;
+
+    bezt_prev = &local_prevbezt;
+    bezt_curr = &local_bezt;
+
+    /* calc the normals */
+    sub_v2_v2v2(tvec, bezt_prev->vec[1], bezt_prev->vec[0]);
+    normalize_v2(tvec);
+    point_prev_n[0] = -tvec[1];
+    point_prev_n[1] = tvec[0];
+
+    sub_v2_v2v2(tvec, bezt_curr->vec[1], bezt_curr->vec[0]);
+    normalize_v2(tvec);
+    point_curr_n[0] = -tvec[1];
+    point_curr_n[1] = tvec[0];
+
+    weight_prev = bezt_prev->weight;
+    weight_curr = bezt_curr->weight;
+
+    mul_v2_fl(point_prev_n, weight_prev);
+    mul_v2_fl(point_curr_n, weight_curr);
+
+    /* before we transform verts */
+    len_base = len_v2v2(bezt_prev->vec[1], bezt_curr->vec[1]);
+
+    // add_v2_v2(bezt_prev->vec[0], point_prev_n);  // not needed
+    add_v2_v2(bezt_prev->vec[1], point_prev_n);
+    add_v2_v2(bezt_prev->vec[2], point_prev_n);
+
+    add_v2_v2(bezt_curr->vec[0], point_curr_n);
+    add_v2_v2(bezt_curr->vec[1], point_curr_n);
+    // add_v2_v2(bezt_curr->vec[2], point_curr_n); // not needed
+
+    len_feather = len_v2v2(bezt_prev->vec[1], bezt_curr->vec[1]);
+
+    /* scale by chane in length */
+    len_scalar = len_feather / len_base;
+    dist_ensure_v2_v2fl(bezt_prev->vec[2],
+                        bezt_prev->vec[1],
+                        len_scalar * len_v2v2(bezt_prev->vec[2], bezt_prev->vec[1]));
+    dist_ensure_v2_v2fl(bezt_curr->vec[0],
+                        bezt_curr->vec[1],
+                        len_scalar * len_v2v2(bezt_curr->vec[0], bezt_curr->vec[1]));
+
+    for (j = 0; j < 2; j++) {
+      BKE_curve_forward_diff_bezier(bezt_prev->vec[1][j],
+                                    bezt_prev->vec[2][j],
+                                    bezt_curr->vec[0][j],
+                                    bezt_curr->vec[1][j],
+                                    &(*fp)[j],
+                                    resol,
+                                    2 * sizeof(float));
+    }
+
+    /* scale by the uw's */
+    if (point_prev->tot_uw) {
+      for (j = 0; j < resol; j++, fp++) {
+        float u = (float)j / resol;
+        float weight_uw, weight_scalar;
+        float co[2];
+
+        /* TODO - these calls all calculate similar things
+         * could be unified for some speed */
+        BKE_mask_point_segment_co(spline, point_prev, u, co);
+
+        weight_uw = BKE_mask_point_weight(spline, point_prev, u);
+        weight_scalar = BKE_mask_point_weight_scalar(spline, point_prev, u);
+
+        dist_ensure_v2_v2fl(*fp, co, len_v2v2(*fp, co) * (weight_uw / weight_scalar));
+      }
+    }
+    else {
+      fp += resol;
+    }
+
+    if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
+      copy_v2_v2(*fp, bezt_curr->vec[1]);
+    }
+
+    point_prev = point_curr;
+    point_curr++;
+  }
+
+  if ((spline->flag & MASK_SPLINE_NOINTERSECT) && do_feather_isect) {
+    BKE_mask_spline_feather_collapse_inner_loops(spline, feather, tot);
+  }
+
+  return feather;
 }
 
 /**
  * values align with #BKE_mask_spline_differentiate_with_resolution
  * when \a resol arguments match.
  */
-float (*BKE_mask_spline_feather_differentiated_points_with_resolution(
-        MaskSpline *spline, unsigned int *tot_feather_point,
-        const unsigned int resol, const bool do_feather_isect))[2]
+float (
+    *BKE_mask_spline_feather_differentiated_points_with_resolution(MaskSpline *spline,
+                                                                   unsigned int *tot_feather_point,
+                                                                   const unsigned int resol,
+                                                                   const bool do_feather_isect))[2]
 {
-       switch (spline->offset_mode) {
-               case MASK_SPLINE_OFFSET_EVEN:
-                       return mask_spline_feather_differentiated_points_with_resolution__even(spline, tot_feather_point, resol, do_feather_isect);
-               case MASK_SPLINE_OFFSET_SMOOTH:
-               default:
-                       return mask_spline_feather_differentiated_points_with_resolution__double(spline, tot_feather_point, resol, do_feather_isect);
-       }
+  switch (spline->offset_mode) {
+    case MASK_SPLINE_OFFSET_EVEN:
+      return mask_spline_feather_differentiated_points_with_resolution__even(
+          spline, tot_feather_point, resol, do_feather_isect);
+    case MASK_SPLINE_OFFSET_SMOOTH:
+    default:
+      return mask_spline_feather_differentiated_points_with_resolution__double(
+          spline, tot_feather_point, resol, do_feather_isect);
+  }
 }
 
 float (*BKE_mask_spline_feather_points(MaskSpline *spline, int *tot_feather_point))[2]
 {
-       MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
+  MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
 
-       int i, tot = 0;
-       float (*feather)[2], (*fp)[2];
+  int i, tot = 0;
+  float(*feather)[2], (*fp)[2];
 
-       /* count */
-       for (i = 0; i < spline->tot_point; i++) {
-               MaskSplinePoint *point = &points_array[i];
+  /* count */
+  for (i = 0; i < spline->tot_point; i++) {
+    MaskSplinePoint *point = &points_array[i];
 
-               tot += point->tot_uw + 1;
-       }
+    tot += point->tot_uw + 1;
+  }
 
-       /* create data */
-       feather = fp = MEM_mallocN(tot * sizeof(*feather), "mask spline feather points");
+  /* create data */
+  feather = fp = MEM_mallocN(tot * sizeof(*feather), "mask spline feather points");
 
-       for (i = 0; i < spline->tot_point; i++) {
-               MaskSplinePoint *point = &points_array[i];
-               BezTriple *bezt = &point->bezt;
-               float weight, n[2];
-               int j;
+  for (i = 0; i < spline->tot_point; i++) {
+    MaskSplinePoint *point = &points_array[i];
+    BezTriple *bezt = &point->bezt;
+    float weight, n[2];
+    int j;
 
-               BKE_mask_point_normal(spline, point, 0.0f, n);
-               weight = BKE_mask_point_weight(spline, point, 0.0f);
+    BKE_mask_point_normal(spline, point, 0.0f, n);
+    weight = BKE_mask_point_weight(spline, point, 0.0f);
 
-               madd_v2_v2v2fl(*fp, bezt->vec[1], n, weight);
-               fp++;
+    madd_v2_v2v2fl(*fp, bezt->vec[1], n, weight);
+    fp++;
 
-               for (j = 0; j < point->tot_uw; j++) {
-                       float u = point->uw[j].u;
-                       float co[2];
+    for (j = 0; j < point->tot_uw; j++) {
+      float u = point->uw[j].u;
+      float co[2];
 
-                       BKE_mask_point_segment_co(spline, point, u, co);
-                       BKE_mask_point_normal(spline, point, u, n);
-                       weight = BKE_mask_point_weight(spline, point, u);
+      BKE_mask_point_segment_co(spline, point, u, co);
+      BKE_mask_point_normal(spline, point, u, n);
+      weight = BKE_mask_point_weight(spline, point, u);
 
-                       madd_v2_v2v2fl(*fp, co, n, weight);
-                       fp++;
-               }
-       }
+      madd_v2_v2v2fl(*fp, co, n, weight);
+      fp++;
+    }
+  }
 
-       *tot_feather_point = tot;
+  *tot_feather_point = tot;
 
-       return feather;
+  return feather;
 }
 
 /* *** mask point functions which involve evaluation *** */
-float *BKE_mask_point_segment_feather_diff(MaskSpline *spline, MaskSplinePoint *point,
-                                           int width, int height,
+float *BKE_mask_point_segment_feather_diff(MaskSpline *spline,
+                                           MaskSplinePoint *point,
+                                           int width,
+                                           int height,
                                            unsigned int *tot_feather_point)
 {
-       float *feather, *fp;
-       unsigned int resol = BKE_mask_spline_feather_resolution(spline, width, height);
-       unsigned int i;
+  float *feather, *fp;
+  unsigned int resol = BKE_mask_spline_feather_resolution(spline, width, height);
+  unsigned int i;
 
-       feather = fp = MEM_callocN(2 * resol * sizeof(float), "mask point spline feather diff points");
+  feather = fp = MEM_callocN(2 * resol * sizeof(float), "mask point spline feather diff points");
 
-       for (i = 0; i < resol; i++, fp += 2) {
-               float u = (float)(i % resol) / resol, weight;
-               float co[2], n[2];
+  for (i = 0; i < resol; i++, fp += 2) {
+    float u = (float)(i % resol) / resol, weight;
+    float co[2], n[2];
 
-               BKE_mask_point_segment_co(spline, point, u, co);
-               BKE_mask_point_normal(spline, point, u, n);
-               weight = BKE_mask_point_weight(spline, point, u);
+    BKE_mask_point_segment_co(spline, point, u, co);
+    BKE_mask_point_normal(spline, point, u, n);
+    weight = BKE_mask_point_weight(spline, point, u);
 
-               fp[0] = co[0] + n[0] * weight;
-               fp[1] = co[1] + n[1] * weight;
-       }
+    fp[0] = co[0] + n[0] * weight;
+    fp[1] = co[1] + n[1] * weight;
+  }
 
-       *tot_feather_point = resol;
+  *tot_feather_point = resol;
 
-       return feather;
+  return feather;
 }
 
-float *BKE_mask_point_segment_diff(MaskSpline *spline, MaskSplinePoint *point,
-                                   int width, int height, unsigned int *tot_diff_point)
+float *BKE_mask_point_segment_diff(MaskSpline *spline,
+                                   MaskSplinePoint *point,
+                                   int width,
+                                   int height,
+                                   unsigned int *tot_diff_point)
 {
-       MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
+  MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
 
-       BezTriple *bezt, *bezt_next;
-       float *diff_points, *fp;
-       int j, resol = BKE_mask_spline_resolution(spline, width, height);
+  BezTriple *bezt, *bezt_next;
+  float *diff_points, *fp;
+  int j, resol = BKE_mask_spline_resolution(spline, width, height);
 
-       bezt = &point->bezt;
-       bezt_next = BKE_mask_spline_point_next_bezt(spline, points_array, point);
+  bezt = &point->bezt;
+  bezt_next = BKE_mask_spline_point_next_bezt(spline, points_array, point);
 
-       if (!bezt_next)
-               return NULL;
+  if (!bezt_next)
+    return NULL;
 
-       /* resol+1 because of 'forward_diff_bezier' function */
-       *tot_diff_point = resol + 1;
-       diff_points = fp = MEM_callocN((resol + 1) * 2 * sizeof(float), "mask segment vets");
+  /* resol+1 because of 'forward_diff_bezier' function */
+  *tot_diff_point = resol + 1;
+  diff_points = fp = MEM_callocN((resol + 1) * 2 * sizeof(float), "mask segment vets");
 
-       for (j = 0; j < 2; j++) {
-               BKE_curve_forward_diff_bezier(bezt->vec[1][j], bezt->vec[2][j],
-                                             bezt_next->vec[0][j], bezt_next->vec[1][j],
-                                             fp + j, resol, 2 * sizeof(float));
-       }
+  for (j = 0; j < 2; j++) {
+    BKE_curve_forward_diff_bezier(bezt->vec[1][j],
+                                  bezt->vec[2][j],
+                                  bezt_next->vec[0][j],
+                                  bezt_next->vec[1][j],
+                                  fp + j,
+                                  resol,
+                                  2 * sizeof(float));
+  }
 
-       copy_v2_v2(fp + 2 * resol, bezt_next->vec[1]);
+  copy_v2_v2(fp + 2 * resol, bezt_next->vec[1]);
 
-       return diff_points;
+  return diff_points;
 }
 
 static void mask_evaluate_apply_point_parent(MaskSplinePoint *point, float ctime)
 {
-       float parent_matrix[3][3];
-       BKE_mask_point_parent_matrix_get(point, ctime, parent_matrix);
-       mul_m3_v2(parent_matrix, point->bezt.vec[0]);
-       mul_m3_v2(parent_matrix, point->bezt.vec[1]);
-       mul_m3_v2(parent_matrix, point->bezt.vec[2]);
+  float parent_matrix[3][3];
+  BKE_mask_point_parent_matrix_get(point, ctime, parent_matrix);
+  mul_m3_v2(parent_matrix, point->bezt.vec[0]);
+  mul_m3_v2(parent_matrix, point->bezt.vec[1]);
+  mul_m3_v2(parent_matrix, point->bezt.vec[2]);
 }
 
 void BKE_mask_layer_evaluate_animation(MaskLayer *masklay, const float ctime)
 {
-       /* animation if available */
-       MaskLayerShape *masklay_shape_a;
-       MaskLayerShape *masklay_shape_b;
-       int found;
-       if ((found = BKE_mask_layer_shape_find_frame_range(
-               masklay, ctime, &masklay_shape_a, &masklay_shape_b)))
-       {
-               if (found == 1) {
+  /* animation if available */
+  MaskLayerShape *masklay_shape_a;
+  MaskLayerShape *masklay_shape_b;
+  int found;
+  if ((found = BKE_mask_layer_shape_find_frame_range(
+           masklay, ctime, &masklay_shape_a, &masklay_shape_b))) {
+    if (found == 1) {
 #if 0
-                       printf("%s: exact %d %d (%d)\n",
-                              __func__,
-                              (int)ctime,
-                              BLI_listbase_count(&masklay->splines_shapes),
-                              masklay_shape_a->frame);
+      printf("%s: exact %d %d (%d)\n",
+             __func__,
+             (int)ctime,
+             BLI_listbase_count(&masklay->splines_shapes),
+             masklay_shape_a->frame);
 #endif
-                       BKE_mask_layer_shape_to_mask(masklay, masklay_shape_a);
-               }
-               else if (found == 2) {
-                       float w = masklay_shape_b->frame - masklay_shape_a->frame;
+      BKE_mask_layer_shape_to_mask(masklay, masklay_shape_a);
+    }
+    else if (found == 2) {
+      float w = masklay_shape_b->frame - masklay_shape_a->frame;
 #if 0
-                       printf("%s: tween %d %d (%d %d)\n",
-                              __func__,
-                              (int)ctime,
-                              BLI_listbase_count(&masklay->splines_shapes),
-                              masklay_shape_a->frame, masklay_shape_b->frame);
+      printf("%s: tween %d %d (%d %d)\n",
+             __func__,
+             (int)ctime,
+             BLI_listbase_count(&masklay->splines_shapes),
+             masklay_shape_a->frame, masklay_shape_b->frame);
 #endif
-                       BKE_mask_layer_shape_to_mask_interp(
-                               masklay,
-                               masklay_shape_a, masklay_shape_b,
-                               (ctime - masklay_shape_a->frame) / w);
-               }
-               else {
-                       /* always fail, should never happen */
-                       BLI_assert(found == 2);
-               }
-       }
+      BKE_mask_layer_shape_to_mask_interp(
+          masklay, masklay_shape_a, masklay_shape_b, (ctime - masklay_shape_a->frame) / w);
+    }
+    else {
+      /* always fail, should never happen */
+      BLI_assert(found == 2);
+    }
+  }
 }
 
 void BKE_mask_layer_evaluate_deform(MaskLayer *masklay, const float ctime)
 {
-       BKE_mask_layer_calc_handles(masklay);
-       for (MaskSpline *spline = masklay->splines.first;
-            spline != NULL;
-            spline = spline->next)
-       {
-               bool need_handle_recalc = false;
-               BKE_mask_spline_ensure_deform(spline);
-               for (int i = 0; i < spline->tot_point; i++) {
-                       MaskSplinePoint *point = &spline->points[i];
-                       MaskSplinePoint *point_deform = &spline->points_deform[i];
-                       BKE_mask_point_free(point_deform);
-                       *point_deform = *point;
-                       point_deform->uw = point->uw ? MEM_dupallocN(point->uw) : NULL;
-                       mask_evaluate_apply_point_parent(point_deform, ctime);
-                       if (ELEM(point->bezt.h1, HD_AUTO, HD_VECT)) {
-                               need_handle_recalc = true;
-                       }
-               }
-               /* if the spline has auto or vector handles, these need to be
-                * recalculated after deformation.
-                */
-               if (need_handle_recalc) {
-                       for (int i = 0; i < spline->tot_point; i++) {
-                               MaskSplinePoint *point_deform = &spline->points_deform[i];
-                               if (ELEM(point_deform->bezt.h1, HD_AUTO, HD_VECT)) {
-                                       BKE_mask_calc_handle_point(spline, point_deform);
-                               }
-                       }
-               }
-               /* end extra calc handles loop */
-       }
+  BKE_mask_layer_calc_handles(masklay);
+  for (MaskSpline *spline = masklay->splines.first; spline != NULL; spline = spline->next) {
+    bool need_handle_recalc = false;
+    BKE_mask_spline_ensure_deform(spline);
+    for (int i = 0; i < spline->tot_point; i++) {
+      MaskSplinePoint *point = &spline->points[i];
+      MaskSplinePoint *point_deform = &spline->points_deform[i];
+      BKE_mask_point_free(point_deform);
+      *point_deform = *point;
+      point_deform->uw = point->uw ? MEM_dupallocN(point->uw) : NULL;
+      mask_evaluate_apply_point_parent(point_deform, ctime);
+      if (ELEM(point->bezt.h1, HD_AUTO, HD_VECT)) {
+        need_handle_recalc = true;
+      }
+    }
+    /* if the spline has auto or vector handles, these need to be
+     * recalculated after deformation.
+     */
+    if (need_handle_recalc) {
+      for (int i = 0; i < spline->tot_point; i++) {
+        MaskSplinePoint *point_deform = &spline->points_deform[i];
+        if (ELEM(point_deform->bezt.h1, HD_AUTO, HD_VECT)) {
+          BKE_mask_calc_handle_point(spline, point_deform);
+        }
+      }
+    }
+    /* end extra calc handles loop */
+  }
 }
 
 void BKE_mask_eval_animation(struct Depsgraph *depsgraph, Mask *mask)
 {
-       float ctime = DEG_get_ctime(depsgraph);
-       DEG_debug_print_eval(depsgraph, __func__, mask->id.name, mask);
-       for (MaskLayer *mask_layer = mask->masklayers.first;
-            mask_layer != NULL;
-            mask_layer = mask_layer->next)
-       {
-               BKE_mask_layer_evaluate_animation(mask_layer, ctime);
-       }
+  float ctime = DEG_get_ctime(depsgraph);
+  DEG_debug_print_eval(depsgraph, __func__, mask->id.name, mask);
+  for (MaskLayer *mask_layer = mask->masklayers.first; mask_layer != NULL;
+       mask_layer = mask_layer->next) {
+    BKE_mask_layer_evaluate_animation(mask_layer, ctime);
+  }
 }
 
 void BKE_mask_eval_update(struct Depsgraph *depsgraph, Mask *mask)
 {
-       float ctime = DEG_get_ctime(depsgraph);
-       DEG_debug_print_eval(depsgraph, __func__, mask->id.name, mask);
-       for (MaskLayer *mask_layer = mask->masklayers.first;
-            mask_layer != NULL;
-            mask_layer = mask_layer->next)
-       {
-               BKE_mask_layer_evaluate_deform(mask_layer, ctime);
-       }
+  float ctime = DEG_get_ctime(depsgraph);
+  DEG_debug_print_eval(depsgraph, __func__, mask->id.name, mask);
+  for (MaskLayer *mask_layer = mask->masklayers.first; mask_layer != NULL;
+       mask_layer = mask_layer->next) {
+    BKE_mask_layer_evaluate_deform(mask_layer, ctime);
+  }
 }