Add remaining methods for ImmutableAffineTransform

This change adds shearX(), shearY(), and rotate

PiperOrigin-RevId: 683686679

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",
@@ -268,8 +269,10 @@ cc_library(
     srcs = ["parallelogram_jni_helper.cc"],
     hdrs = ["parallelogram_jni_helper.h"],
     deps = [
+        ":vec_jni_helper",
         "//ink/geometry:point",
         "//ink/geometry:quad",
+        "//ink/jni/internal:jni_defines",
         "@com_google_absl//absl/log:absl_check",
     ] + select({
         "@platforms//os:android": [],

ink/geometry/internal/jni/affine_transform_jni.cc

@@ -30,7 +30,28 @@ using ::ink::Quad;
 
 extern "C" {
 
-JNI_METHOD(geometry, AffineTransformHelper, void, nativeApplyParallelogram)
+JNI_METHOD(geometry_internal, AffineTransformNative, jobject,
+           createFromApplyParallelogram)
+(JNIEnv* env, jclass clazz, jfloat affine_transform_A,
+ jfloat affine_transform_B, jfloat affine_transform_C,
+ jfloat affine_transform_D, jfloat affine_transform_E,
+ jfloat affine_transform_F, jfloat quad_center_x, jfloat quad_center_y,
+ jfloat quad_width, jfloat quad_height, jfloat quad_rotation,
+ jfloat quad_shear_factor, jclass immutable_parallelogram_class,
+ jclass immutable_vec_class) {
+  return ink::CreateJImmutableParallelogram(
+      env,
+      AffineTransform(affine_transform_A, affine_transform_B,
+                      affine_transform_C, affine_transform_D,
+                      affine_transform_E, affine_transform_F)
+          .Apply(Quad::FromCenterDimensionsRotationAndShear(
+              {.x = quad_center_x, .y = quad_center_y}, quad_width, quad_height,
+              Angle::Radians(quad_rotation), quad_shear_factor)),
+      immutable_parallelogram_class, immutable_vec_class);
+}
+
+JNI_METHOD(geometry_internal, AffineTransformNative, void,
+           populateFromApplyParallelogram)
 (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,15 @@ 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, createBoundingBox)
 (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 +51,7 @@ JNI_METHOD(geometry, ParallelogramNative, jobject, nativeCreateBoundingBox)
                                           immutable_vec_class);
 }
 
-JNI_METHOD(geometry, ParallelogramNative, void, nativePopulateBoundingBox)
+JNI_METHOD(geometry_internal, ParallelogramNative, void, populateBoundingBox)
 (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 +62,7 @@ JNI_METHOD(geometry, ParallelogramNative, void, nativePopulateBoundingBox)
                                Envelope(quad).AsRect().value());
 }
 
-JNI_METHOD(geometry, ParallelogramNative, jobjectArray, nativeCreateSemiAxes)
+JNI_METHOD(geometry_internal, ParallelogramNative, jobjectArray, createSemiAxes)
 (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 +81,7 @@ JNI_METHOD(geometry, ParallelogramNative, jobjectArray, nativeCreateSemiAxes)
   return vector_array;
 }
 
-JNI_METHOD(geometry, ParallelogramNative, void, nativePopulateSemiAxes)
+JNI_METHOD(geometry_internal, ParallelogramNative, void, populateSemiAxes)
 (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 +93,46 @@ JNI_METHOD(geometry, ParallelogramNative, void, nativePopulateSemiAxes)
   ink::FillJMutableVecFromVec(env, out_axis2, axes.second);
 }
 
+JNI_METHOD(geometry_internal, ParallelogramNative, jobjectArray, createCorners)
+(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, populateCorners)
+(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, contains)
+(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/parallelogram_jni_helper.cc

@@ -17,10 +17,31 @@
 #include <jni.h>
 
 #include "absl/log/absl_check.h"
+#include "ink/geometry/internal/jni/vec_jni_helper.h"
 #include "ink/geometry/point.h"
 #include "ink/geometry/quad.h"
+#include "ink/jni/internal/jni_defines.h"
 
 namespace ink {
+
+jobject CreateJImmutableParallelogram(JNIEnv* env, const Quad& quad,
+                                      jclass immutable_parallelogram_class,
+                                      jclass immutable_vec_class) {
+  ABSL_CHECK(immutable_parallelogram_class);
+
+  jmethodID from_center_dim_rot_shear_method = env->GetStaticMethodID(
+      immutable_parallelogram_class, "fromCenterDimensionsRotationAndShear",
+      "(L" INK_PACKAGE "/geometry/ImmutableVec;FFFF)L" INK_PACKAGE
+      "/geometry/ImmutableParallelogram;");
+  ABSL_CHECK(from_center_dim_rot_shear_method);
+  return env->CallStaticObjectMethod(
+      immutable_parallelogram_class, from_center_dim_rot_shear_method,
+      ink::CreateJImmutableVecFromPoint(env, {quad.Center().x, quad.Center().y},
+                                        immutable_vec_class),
+      quad.Width(), quad.Height(), quad.Rotation().ValueInRadians(),
+      quad.ShearFactor());
+}
+
 void FillJMutableParallelogram(JNIEnv* env, const Quad& quad,
                                jobject mutable_parallelogram) {
   jclass mutable_parallelogram_class =

ink/geometry/internal/jni/parallelogram_jni_helper.h

@@ -20,6 +20,9 @@
 #include "ink/geometry/quad.h"
 
 namespace ink {
+jobject CreateJImmutableParallelogram(JNIEnv* env, const Quad& quad,
+                                      jclass immutable_parallelogram_class,
+                                      jclass immutable_vec_class);
 
 void FillJMutableParallelogram(JNIEnv* env, const Quad& quad,
                                jobject mutable_parallelogram);

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, createCenter)
 (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, populateCenter)
 (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, containsPoint)
 (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, containsBox)
 (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},