Explicit integer types

@@ -71,0 +94,4 @@
+                                                   int &r_mu1)
+  {
+    const int64_t d_s0_center = math::distance_squared(s0, center);
+

@@ -71,0 +118,4 @@
+    }
+
+    /* Two intersections. */
+    const float i_sqrt = sqrtf(i);

@@ -74,3 +150,2 @@
    */
-  int intersections_with_segment(const float2 &point,
-                                 const float2 &point_after,
+  int intersections_with_segment(const int2 &point,

@@ -98,1 +160,3 @@
-      std::swap(r_mu0, r_mu1);
+
+    /* Compute the integer values of the intersection. */
+    const int segment_length = math::distance(point, point_after);

@@ -103,0 +186,4 @@
+     *  0 : in-between the endpoints,
+     *  1 : after the last endpoint.
+     */
+    const int side_mu0 = (mu0 <= 0) ? (-1) : ((mu0 >= segment_length) ? 1 : 0);

@@ -103,0 +227,4 @@
+
+    /* Only one intersection lies within the segment. Only one point should be erased, depending on
+     * the side of the other intersection. */
+    const int side_outside_intersection = is_mu0_inside ? side_mu1 : side_mu0;

@@ -117,4 +263,2 @@
-   * Note that for the two output arrays the last element may contain intersections if the
-   * corresponding curve is cyclic.
    */
   int intersections_with_curves(const bke::CurvesGeometry &src,

@@ -143,0 +288,4 @@
+          /* One-point stroke : just check if the point is inside the eraser. */
+          const int src_point = src_curve_points.first();
+          const float2 pos = screen_space_positions[src_point];
+          r_is_point_inside[src_point] = contains_point(pos);

@@ -236,0 +369,4 @@
+     */
+    int total_points_cut = 0;
+    for (const int src_point : src.points_range()) {
+      total_points_cut += int(is_point_cut[src_point]);

@@ -515,1 +654,4 @@
 
+    this->mouse_position_pixels = int2(round_fl_to_int(mouse_position[0]),
+                                       round_fl_to_int(mouse_position[1]));
+    const int eraser_radius_pixels = round_fl_to_int(eraser_radius);

@@ -123,1 +250,3 @@
-                                MutableSpan<float2> r_intersections_factors) const
+  int64_t intersections_with_curves(const bke::CurvesGeometry &src,
+                                    const Span<float2> screen_space_positions,
+                                    MutableSpan<int> r_nb_intersections,

@@ -128,1 +260,3 @@
-    threading::parallel_for(src.curves_range(), 256, [&](const IndexRange src_curves) {
+    Array<int2> screen_space_positions_pixel(src.points_num());
+    threading::parallel_for(src.points_range(), 1024, [&](const IndexRange src_points) {
+      for (const int src_point : src_points) {

@@ -142,1 +273,3 @@
-                    mu1);
+        if (src_curve_points.size() == 1) {
+          /* One-point stroke : just check if the point is inside the eraser. */
+          const int src_point = src_curve_points.first();

@@ -144,3 +282,1 @@
-                r_intersections_factors[src_point] = float2(mu0, mu1);
-              }
-            });
+        for (const int src_point : src_curve_points.drop_back(1)) {

@@ -148,3 +294,4 @@
         if (src_cyclic[src_curve]) {
           /* If the curve is cyclic, we need to check for the closing segment. */
           const int src_last_point = src_curve_points.last();
+          const int src_first_point = src_curve_points.first();

@@ -165,3 +313,3 @@
     /* Compute total number of intersections. */
-    int total_intersections = 0;
+    int64_t total_intersections = 0;
     for (const int src_point : src.points_range()) {

@@ -226,2 +336,4 @@
     /* Compute intersections between the eraser and the curves in the source domain. */
+    Array<bool> is_point_inside(src_points_num, false);
+    Array<bool> is_point_cut(src_points_num, false);
     Array<int> nb_intersections(src_points_num, 0);

@@ -236,0 +355,4 @@
+     * These points will be kept in the destination geometry, but change the topology of the curve.
+     */
+    int64_t total_points_cut = 0;
+    for (const int src_point : src.points_range()) {

@@ -257,2 +380,4 @@
+     * numbers for which the integer is the index of the corresponding segment in the source
+     * curves, and the float part is the (0,1) factor representing its position in the segment.
      */
     Array<std::pair<int, float>> dst_points_parameters(dst_points_num);

@@ -464,2 +589,3 @@
-           * stroke. */
+          /* If any segment of the stroke is closer to the eraser than its radius, then remove
+           * the stroke. */
           for (const int src_point : src_curve_points.drop_back(1)) {