Add remaining methods for MutableParallelogram

This adds populateFrom() and fromSegmentAndPadding()

PiperOrigin-RevId: 682408129

Author: Ink Open Source

ink/geometry/internal/jni/BUILD.bazel

@@ -250,6 +250,7 @@ cc_library(
         ":vec_jni_helper",
         "//ink/geometry:angle",
         "//ink/geometry:envelope",
+        "//ink/geometry:point",
         "//ink/geometry:quad",
         "//ink/geometry:vec",
         "//ink/jni/internal:jni_defines",

ink/geometry/internal/jni/affine_transform_jni.cc

@@ -30,7 +30,8 @@ using ::ink::Quad;
 
 extern "C" {
 
-JNI_METHOD(geometry, AffineTransformHelper, void, nativeApplyParallelogram)
+JNI_METHOD(geometry_internal, AffineTransformNative, void,
+           nativeApplyParallelogram)
 (JNIEnv* env, jclass clazz, jfloat affine_transform_A,
  jfloat affine_transform_B, jfloat affine_transform_C,
  jfloat affine_transform_D, jfloat affine_transform_E,

ink/geometry/internal/jni/parallelogram_jni.cc

@@ -14,12 +14,14 @@
 
 #include <jni.h>
 
+#include <array>
 #include <utility>
 
 #include "ink/geometry/angle.h"
 #include "ink/geometry/envelope.h"
 #include "ink/geometry/internal/jni/rect_jni_helper.h"
 #include "ink/geometry/internal/jni/vec_jni_helper.h"
+#include "ink/geometry/point.h"
 #include "ink/geometry/quad.h"
 #include "ink/geometry/vec.h"
 #include "ink/jni/internal/jni_defines.h"
@@ -28,14 +30,16 @@ namespace {
 
 using ::ink::Angle;
 using ::ink::Envelope;
+using ::ink::Point;
 using ::ink::Quad;
 using ::ink::Vec;
 
 }  // namespace
 
 extern "C" {
 
-JNI_METHOD(geometry, ParallelogramNative, jobject, nativeCreateBoundingBox)
+JNI_METHOD(geometry_internal, ParallelogramNative, jobject,
+           nativeCreateBoundingBox)
 (JNIEnv* env, jclass clazz, jfloat center_x, jfloat center_y, jfloat width,
  jfloat height, jfloat rotation, jfloat shear_factor,
  jclass immutable_box_class, jclass immutable_vec_class) {
@@ -48,7 +52,8 @@ JNI_METHOD(geometry, ParallelogramNative, jobject, nativeCreateBoundingBox)
                                           immutable_vec_class);
 }
 
-JNI_METHOD(geometry, ParallelogramNative, void, nativePopulateBoundingBox)
+JNI_METHOD(geometry_internal, ParallelogramNative, void,
+           nativePopulateBoundingBox)
 (JNIEnv* env, jclass clazz, jfloat center_x, jfloat center_y, jfloat width,
  jfloat height, jfloat rotation, jfloat shear_factor, jobject mutable_box) {
   Quad quad = Quad::FromCenterDimensionsRotationAndShear(
@@ -59,7 +64,8 @@ JNI_METHOD(geometry, ParallelogramNative, void, nativePopulateBoundingBox)
                                Envelope(quad).AsRect().value());
 }
 
-JNI_METHOD(geometry, ParallelogramNative, jobjectArray, nativeCreateSemiAxes)
+JNI_METHOD(geometry_internal, ParallelogramNative, jobjectArray,
+           nativeCreateSemiAxes)
 (JNIEnv* env, jclass clazz, jfloat center_x, jfloat center_y, jfloat width,
  jfloat height, jfloat rotation, jfloat shear_factor,
  jclass immutable_vec_class) {
@@ -78,7 +84,7 @@ JNI_METHOD(geometry, ParallelogramNative, jobjectArray, nativeCreateSemiAxes)
   return vector_array;
 }
 
-JNI_METHOD(geometry, ParallelogramNative, void, nativePopulateSemiAxes)
+JNI_METHOD(geometry_internal, ParallelogramNative, void, nativePopulateSemiAxes)
 (JNIEnv* env, jclass clazz, jfloat center_x, jfloat center_y, jfloat width,
  jfloat height, jfloat rotation, jfloat shear_factor, jobject out_axis1,
  jobject out_axis2) {
@@ -90,4 +96,47 @@ JNI_METHOD(geometry, ParallelogramNative, void, nativePopulateSemiAxes)
   ink::FillJMutableVecFromVec(env, out_axis2, axes.second);
 }
 
+JNI_METHOD(geometry_internal, ParallelogramNative, jobjectArray,
+           nativeCreateCorners)
+(JNIEnv* env, jclass clazz, jfloat center_x, jfloat center_y, jfloat width,
+ jfloat height, jfloat rotation, jfloat shear_factor,
+ jclass immutable_vec_class) {
+  Quad quad = Quad::FromCenterDimensionsRotationAndShear(
+      {center_x, center_y}, width, height, Angle::Radians(rotation),
+      shear_factor);
+  std::array<Point, 4> corners = quad.Corners();
+  jobjectArray vector_array =
+      env->NewObjectArray(4, immutable_vec_class, nullptr);
+  for (int i = 0; i < 4; ++i) {
+    env->SetObjectArrayElement(vector_array, i,
+                               ink::CreateJImmutableVecFromPoint(
+                                   env, corners[i], immutable_vec_class));
+  }
+  return vector_array;
+}
+
+JNI_METHOD(geometry_internal, ParallelogramNative, void, nativePopulateCorners)
+(JNIEnv* env, jclass clazz, jfloat center_x, jfloat center_y, jfloat width,
+ jfloat height, jfloat rotation, jfloat shear_factor, jobject out_corner1,
+ jobject out_corner2, jobject out_corner3, jobject out_corner4) {
+  Quad quad = Quad::FromCenterDimensionsRotationAndShear(
+      {center_x, center_y}, width, height, Angle::Radians(rotation),
+      shear_factor);
+  std::array<Point, 4> corners = quad.Corners();
+  ink::FillJMutableVecFromPoint(env, out_corner1, corners[0]);
+  ink::FillJMutableVecFromPoint(env, out_corner2, corners[1]);
+  ink::FillJMutableVecFromPoint(env, out_corner3, corners[2]);
+  ink::FillJMutableVecFromPoint(env, out_corner4, corners[3]);
+}
+
+JNI_METHOD(geometry_internal, ParallelogramNative, jboolean, nativeContains)
+(JNIEnv* env, jclass clazz, jfloat center_x, jfloat center_y, jfloat width,
+ jfloat height, jfloat rotation, jfloat shear_factor, jfloat point_x,
+ jfloat point_y) {
+  Quad quad = Quad::FromCenterDimensionsRotationAndShear(
+      {center_x, center_y}, width, height, Angle::Radians(rotation),
+      shear_factor);
+  return quad.Contains({point_x, point_y});
+}
+
 }  // extern "C"

ink/geometry/internal/jni/rect_jni.cc

@@ -28,7 +28,7 @@ using ::ink::Rect;
 
 extern "C" {
 
-JNI_METHOD(geometry, BoxHelper, jobject, nativeCreateCenter)
+JNI_METHOD(geometry_internal, BoxNative, jobject, nativeCreateCenter)
 (JNIEnv* env, jclass clazz, float rect_x_min, jfloat rect_y_min,
  jfloat rect_x_max, jfloat rect_y_max, jclass immutable_vec_class) {
   Rect rect =
@@ -38,7 +38,7 @@ JNI_METHOD(geometry, BoxHelper, jobject, nativeCreateCenter)
   return ink::CreateJImmutableVecFromPoint(env, point, immutable_vec_class);
 }
 
-JNI_METHOD(geometry, BoxHelper, void, nativePopulateCenter)
+JNI_METHOD(geometry_internal, BoxNative, void, nativePopulateCenter)
 (JNIEnv* env, jclass clazz, float rect_x_min, jfloat rect_y_min,
  jfloat rect_x_max, jfloat rect_y_max, jobject mutable_vec) {
   Rect rect =
@@ -48,15 +48,15 @@ JNI_METHOD(geometry, BoxHelper, void, nativePopulateCenter)
   ink::FillJMutableVecFromPoint(env, mutable_vec, point);
 }
 
-JNI_METHOD(geometry, BoxHelper, jboolean, nativeContainsPoint)
+JNI_METHOD(geometry_internal, BoxNative, jboolean, nativeContainsPoint)
 (JNIEnv* env, jclass clazz, jfloat rect_x_min, jfloat rect_y_min,
  jfloat rect_x_max, jfloat rect_y_max, jfloat point_x, jfloat point_y) {
   Rect rect =
       Rect::FromTwoPoints({rect_x_min, rect_y_min}, {rect_x_max, rect_y_max});
   return rect.Contains(Point{point_x, point_y});
 }
 
-JNI_METHOD(geometry, BoxHelper, jboolean, nativeContainsBox)
+JNI_METHOD(geometry_internal, BoxNative, jboolean, nativeContainsBox)
 (JNIEnv* env, jclass clazz, jfloat rect_x_min, jfloat rect_y_min,
  jfloat rect_x_max, jfloat rect_y_max, jfloat other_x_min, jfloat other_y_min,
  jfloat other_x_max, jfloat other_y_max) {

ink/geometry/internal/jni/vec_jni.cc

@@ -26,29 +26,29 @@ using ::ink::Vec;
 
 extern "C" {
 
-JNI_METHOD(geometry, VecNative, jobject, unitVec)
+JNI_METHOD(geometry_internal, VecNative, jobject, unitVec)
 (JNIEnv* env, jclass clazz, jfloat vec_X, jfloat vec_Y,
  jclass immutable_vec_class) {
   return CreateJImmutableVecFromVec(env, Vec{vec_X, vec_Y}.AsUnitVec(),
                                     immutable_vec_class);
 }
 
-JNI_METHOD(geometry, VecNative, void, populateUnitVec)
+JNI_METHOD(geometry_internal, VecNative, void, populateUnitVec)
 (JNIEnv* env, jclass clazz, jfloat vec_X, jfloat vec_Y,
  jobject output_mutable_vec) {
   FillJMutableVecFromVec(env, output_mutable_vec,
                          Vec{vec_X, vec_Y}.AsUnitVec());
 }
 
-JNI_METHOD(geometry, VecNative, jfloat, absoluteAngleBetween)
+JNI_METHOD(geometry_internal, VecNative, jfloat, absoluteAngleBetween)
 (JNIEnv* env, jclass clazz, jfloat first_vec_X, jfloat first_vec_Y,
  jfloat second_vec_X, jfloat second_vec_Y) {
   return Vec::AbsoluteAngleBetween(Vec{first_vec_X, first_vec_Y},
                                    Vec{second_vec_X, second_vec_Y})
       .ValueInRadians();
 }
 
-JNI_METHOD(geometry, VecNative, jfloat, signedAngleBetween)
+JNI_METHOD(geometry_internal, VecNative, jfloat, signedAngleBetween)
 (JNIEnv* env, jclass clazz, jfloat first_vec_X, jfloat first_vec_Y,
  jfloat second_vec_X, jfloat second_vec_Y) {
   return Vec::SignedAngleBetween(Vec{first_vec_X, first_vec_Y},