Mesh Creation Error Handling

PiperOrigin-RevId: 720327720

Author: Ink Open Source

ink/geometry/internal/jni/BUILD.bazel

@@ -343,11 +343,13 @@ cc_library(
     deps = [
         ":vec_jni_helper",
         "//ink/geometry:mesh",
+        "//ink/geometry:mesh_format",
         "//ink/geometry:partitioned_mesh",
         "//ink/geometry:point",
         "//ink/geometry:tessellator",
         "//ink/geometry/internal:polyline_processing",
         "//ink/jni/internal:jni_defines",
+        "//ink/jni/internal:jni_throw_util",
         "//ink/strokes/input:stroke_input_batch",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/types:span",

ink/geometry/internal/jni/polyline_processing_jni.cc

@@ -22,10 +22,12 @@
 #include "absl/types/span.h"
 #include "ink/geometry/internal/polyline_processing.h"
 #include "ink/geometry/mesh.h"
+#include "ink/geometry/mesh_format.h"
 #include "ink/geometry/partitioned_mesh.h"
 #include "ink/geometry/point.h"
 #include "ink/geometry/tessellator.h"
 #include "ink/jni/internal/jni_defines.h"
+#include "ink/jni/internal/jni_throw_util.h"
 #include "ink/strokes/input/stroke_input_batch.h"
 
 namespace {
@@ -45,6 +47,14 @@ JNI_METHOD(strokes, MeshCreationNative, jlong,
   const auto* input = reinterpret_cast<const StrokeInputBatch*>(
       stroke_input_batch_native_pointer);
 
+  // If the input is empty then this will return an empty PartitionedMesh with
+  // no location and no area. This will not intersect with anything if used for
+  // hit testing.
+  if (input->IsEmpty()) {
+    return reinterpret_cast<jlong>(
+        std::make_unique<PartitionedMesh>(PartitionedMesh()).release());
+  }
+
   std::vector<Point> points;
   points.reserve(input->Size());
   for (size_t i = 0; i < input->Size(); ++i) {
@@ -54,10 +64,38 @@ JNI_METHOD(strokes, MeshCreationNative, jlong,
   std::vector<Point> processed_points =
       ink::geometry_internal::CreateClosedShape(points);
 
-  absl::StatusOr<Mesh> mesh = ink::CreateMeshFromPolyline(processed_points);
+  absl::StatusOr<Mesh> mesh;
+  // If there are fewer than 3 points the tessellator can't be used to create a
+  // mesh. Instead, the mesh is created with a single triangle that has repeated
+  // and overlapping points. This effectively creates a point-like or
+  // segment-like mesh. The resulting mesh will have an area of 0 but can still
+  // be used for hit testing via intersection.
+  if (processed_points.size() < 3) {
+    const size_t size = processed_points.size();
+    std::vector<float> x_values;
+    std::vector<float> y_values;
+    x_values.reserve(3);
+    y_values.reserve(3);
+    for (int i = 0; i < 3; ++i) {
+      // If there are 2 points remaining then the first point will appear twice.
+      // If there is only 1 point all 3 points will be the same.
+      x_values.push_back(processed_points[i % size].x);
+      y_values.push_back(processed_points[i % size].y);
+    }
+    mesh = Mesh::Create(ink::MeshFormat(), {x_values, y_values}, {0, 1, 2});
+  } else {
+    mesh = ink::CreateMeshFromPolyline(processed_points);
+  }
+  if (!ink::jni::CheckOkOrThrow(env, mesh.status())) {
+    return 0;
+  }
 
   absl::StatusOr<PartitionedMesh> partitioned_mesh =
       PartitionedMesh::FromMeshes(absl::MakeSpan(&mesh.value(), 1));
+  if (!ink::jni::CheckOkOrThrow(env, partitioned_mesh.status())) {
+    return 0;
+  }
+
   auto partitioned_mesh_ptr =
       std::make_unique<PartitionedMesh>(partitioned_mesh.value());
   return reinterpret_cast<jlong>(partitioned_mesh_ptr.release());

ink/geometry/internal/polyline_processing.cc

@@ -457,8 +457,17 @@ std::vector<Point> ProcessPolylineForMeshCreation(
 }
 
 std::vector<Point> CreateClosedShape(absl::Span<const Point> points) {
+  if (points.size() < 3) {
+    return std::vector<Point>(points.begin(), points.end());
+  }
   PolylineData polyline = CreateNewPolylineData(points);
-
+  if (polyline.segments.size() < 2) {
+    if (polyline.segments.size() == 1) {
+      return {polyline.segments.front().segment.start,
+              polyline.segments.front().segment.end};
+    }
+    return {points.front()};
+  }
   // Calculate the total walk distance of the polyline.
   for (size_t i = 0; i < polyline.segments.size(); ++i) {
     polyline.total_walk_distance += polyline.segments[i].length;

ink/geometry/internal/polyline_processing.h

@@ -114,7 +114,10 @@ std::vector<Point> ProcessPolylineForMeshCreation(
     float min_trimming_ratio);
 
 // A version of ProcessPolylineForMeshCreation thats uses default parameters
-// which have been tested to work well for most shapes.
+// which have been tested to work well for most shapes. If there are fewer than
+// 3 input points, or if there are fewer than 3 points remaining after removing
+// points with the same (x,y) coordinates as the previous point, this function
+// will return the remaining points.
 std::vector<Point> CreateClosedShape(absl::Span<const Point> points);
 }  // namespace ink::geometry_internal