Rotation #4

Author: SaadArdati

packages/box_transform/lib/src/geometry.dart

@@ -308,6 +308,9 @@ class Dimension {
   /// smallest integer values.
   Dimension floor() => Dimension(width.floorToDouble(), height.floorToDouble());
 
+  /// Returns a [Vector2] representation of this [Dimension].
+  Vector2 toVector() => Vector2(width, height);
+
   /// Linearly interpolate between two sizes
   ///
   /// If either size is null, this function interpolates from [Dimension.zero].
@@ -412,28 +415,26 @@ class Box {
   /// Construct a rectangle from given handle and its origin.
   factory Box.fromHandle(
       Vector2 origin, HandlePosition handle, double width, double height) {
-    switch (handle) {
-      case HandlePosition.none:
-        throw ArgumentError('HandlePosition.none is not supported!');
-      case HandlePosition.topLeft:
-        return Box.fromLTWH(origin.x - width, origin.y - height, width, height);
-      case HandlePosition.topRight:
-        return Box.fromLTWH(origin.x, origin.y - height, width, height);
-      case HandlePosition.bottomLeft:
-        return Box.fromLTWH(origin.x - width, origin.y, width, height);
-      case HandlePosition.bottomRight:
-        return Box.fromLTWH(origin.x, origin.y, width, height);
-      case HandlePosition.left:
-        return Box.fromLTWH(
-            origin.x - width, origin.y - height / 2, width, height);
-      case HandlePosition.top:
-        return Box.fromLTWH(
-            origin.x - width / 2, origin.y - height, width, height);
-      case HandlePosition.right:
-        return Box.fromLTWH(origin.x, origin.y - height / 2, width, height);
-      case HandlePosition.bottom:
-        return Box.fromLTWH(origin.x - width / 2, origin.y, width, height);
-    }
+    return switch (handle) {
+      HandlePosition.none =>
+        throw ArgumentError('HandlePosition.none is not supported!'),
+      HandlePosition.topLeft =>
+        Box.fromLTWH(origin.x - width, origin.y - height, width, height),
+      HandlePosition.topRight =>
+        Box.fromLTWH(origin.x, origin.y - height, width, height),
+      HandlePosition.bottomLeft =>
+        Box.fromLTWH(origin.x - width, origin.y, width, height),
+      HandlePosition.bottomRight =>
+        Box.fromLTWH(origin.x, origin.y, width, height),
+      HandlePosition.left =>
+        Box.fromLTWH(origin.x - width, origin.y - height / 2, width, height),
+      HandlePosition.top =>
+        Box.fromLTWH(origin.x - width / 2, origin.y - height, width, height),
+      HandlePosition.right =>
+        Box.fromLTWH(origin.x, origin.y - height / 2, width, height),
+      HandlePosition.bottom =>
+        Box.fromLTWH(origin.x - width / 2, origin.y, width, height)
+    };
   }
 
   /// The Vector2 of the left edge of this rectangle from the x axis.
@@ -607,6 +608,23 @@ class Box {
         _ => size.aspectRatio,
       };
 
+  /// Returns a list of the four corners of this rectangle.
+  List<Vector2> get points => [
+        topLeft,
+        topRight,
+        bottomRight,
+        bottomLeft,
+      ];
+
+  /// Returns a map of the four corners of this rectangle mapped as
+  /// a [Quadrant] to a [Vector2].
+  Map<Quadrant, Vector2> get sidedPoints => {
+        Quadrant.topLeft: topLeft,
+        Quadrant.topRight: topRight,
+        Quadrant.bottomRight: bottomRight,
+        Quadrant.bottomLeft: bottomLeft,
+      };
+
   /// Whether the point specified by the given Vector2 (which is assumed to be
   /// relative to the origin) lies between the left and right and the top and
   /// bottom edges of this rectangle.
@@ -669,6 +687,35 @@ class Box {
         bottom.floorToDouble(),
       );
 
+  /// Returns the relevant corner of this [Box] based on the given [quadrant].
+  Vector2 pointFromQuadrant(Quadrant quadrant) => switch (quadrant) {
+    Quadrant.topLeft => topLeft,
+    Quadrant.topRight => topRight,
+    Quadrant.bottomRight => bottomRight,
+    Quadrant.bottomLeft => bottomLeft,
+  };
+
+  /// Returns a value that represents the distances of the passed
+  /// [point] relative to the closest edge of this [Box]. If the point is
+  /// inside the box, the distance will be positive. If the point is outside
+  /// the box, the distance will be negative.
+  ///
+  /// Returns the [side] that the point is closest to and the distance to that
+  /// side.
+  (Side side, double) distanceOfPoint(Vector2 point) {
+    final double left = point.x - this.left;
+    final double right = this.right - point.x;
+    final double top = point.y - this.top;
+    final double bottom = this.bottom - point.y;
+
+    final double min = math.min(left, math.min(right, math.min(top, bottom)));
+
+    if (min == left) return (Side.left, left);
+    if (min == right) return (Side.right, right);
+    if (min == top) return (Side.top, top);
+    return (Side.bottom, bottom);
+  }
+
   /// Linearly interpolate between two rectangles.
   ///
   /// If either rect is null, [Box.zero] is used as a substitute.

packages/box_transform/lib/src/resizers/freeform_resizing.dart

@@ -27,12 +27,6 @@ final class FreeformResizer extends Resizer {
     final HandlePosition flippedHandle = handle.flip(flip);
 
     Box newRect = explodedRect;
-    // Box.fromLTRB(
-    //   max(explodedRect.left, clampingRect.left),
-    //   max(explodedRect.top, clampingRect.top),
-    //   min(explodedRect.right, clampingRect.right),
-    //   min(explodedRect.bottom, clampingRect.bottom),
-    // );
     newRect = repositionRotatedResizedBox(
       newRect: newRect,
       initialRect: initialRect,
@@ -43,33 +37,25 @@ final class FreeformResizer extends Resizer {
       unrotatedBox: newRect,
     );
     final bool isClamped = isRectClamped(
-      switch (bindingStrategy) {
-        BindingStrategy.originalBox => newRect,
-        BindingStrategy.boundingBox => newBoundingRect,
-      },
+      newBoundingRect,
+      // switch (bindingStrategy) {
+      //   BindingStrategy.originalBox => newRect,
+      //   BindingStrategy.boundingBox => newBoundingRect,
+      // },
       clampingRect,
     );
-    bool isBound = true;
     if (!isClamped) {
-      final Box initialBinding = switch (bindingStrategy) {
-        BindingStrategy.originalBox => initialRect,
-        BindingStrategy.boundingBox => initialBoundingRect,
-      };
-      final Box newBinding = switch (bindingStrategy) {
-        BindingStrategy.originalBox => newRect,
-        BindingStrategy.boundingBox => newBoundingRect,
-      };
-
       final Vector2 correctiveDelta = BoxTransformer.stopRectAtClampingRect(
-        rect: newBinding,
+        rect: newRect,
         clampingRect: clampingRect,
+        rotation: rotation,
       );
 
       newRect = BoxTransformer.applyDelta(
         initialRect: newRect,
         delta: correctiveDelta,
         handle: handle,
-        resizeMode: ResizeMode.freeform,
+        resizeMode: ResizeMode.scale,
         allowFlipping: false,
       );
 
@@ -78,6 +64,8 @@ final class FreeformResizer extends Resizer {
         unrotatedBox: newRect,
       );
     }
+
+    bool isBound = false;
     if (!constraints.isUnconstrained) {
       final Dimension constrainedSize = Dimension(
         newRect.width.clamp(constraints.minWidth, constraints.maxWidth),
@@ -103,11 +91,10 @@ final class FreeformResizer extends Resizer {
         rotation: rotation,
         unrotatedBox: newRect,
       );
-      isBound = isRectBound(
-        newBoundingRect,
+
+      isBound = isRectConstrained(
+        newRect,
         constraints,
-        clampingRect,
-        checkConstraints: newRect,
       );
 
       if (!isBound) {

packages/box_transform/lib/src/transformer.dart

@@ -119,36 +119,66 @@ class BoxTransformer {
   static Vector2 stopRectAtClampingRect({
     required Box rect,
     required Box clampingRect,
+    required double rotation,
   }) {
-    final (:side, :amount, :singleIntersection) =
-        getLargestIntersectionDelta(rect, clampingRect);
-
-    if (singleIntersection) {
-      return switch (side) {
-        Side.top || Side.bottom => Vector2(0, -amount),
-        Side.left || Side.right => Vector2(-amount, 0),
-      };
+    final Map<Quadrant, Vector2> rotatedPoints = {
+      for (final MapEntry(key: quadrant, value: point)
+          in rect.sidedPoints.entries)
+        quadrant: rotatePointAroundVec(rect.center, rotation, point)
+    };
+
+    // Check if any rotated point is outside the clamping rect.
+    (
+      Side side,
+      Quadrant quadrant,
+      Vector2 point,
+      double dist
+    )? biggestOutOfBounds;
+    for (final MapEntry(key: quadrant, value: point) in rotatedPoints.entries) {
+      if (biggestOutOfBounds == null) {
+        final (side, dist) = clampingRect.distanceOfPoint(point);
+        biggestOutOfBounds = (side, quadrant, point, dist);
+      } else {
+        final (side, dist) = clampingRect.distanceOfPoint(point);
+        final (_, biggestDist) =
+            clampingRect.distanceOfPoint(biggestOutOfBounds.$3);
+        if (dist < biggestDist) {
+          biggestOutOfBounds = (side, quadrant, point, dist);
+        }
+      }
     }
 
-    if (side.isVertical) {
-      final correctedHeight = rect.height - amount;
-      final aspectRatio = rect.width / correctedHeight;
-      final correctedWidth = rect.width * aspectRatio;
+    assert(biggestOutOfBounds != null);
 
-      final verticalDelta = rect.height - correctedHeight;
-      final horizontalDelta = rect.width - correctedWidth;
+    final side = biggestOutOfBounds!.$1;
+    final quadrant = biggestOutOfBounds.$2;
+    final point = biggestOutOfBounds.$3;
+    final dist = biggestOutOfBounds.$4;
 
-      return Vector2(horizontalDelta, verticalDelta) * -1;
-    } else {
-      final correctedWidth = rect.width - amount;
-      final aspectRatio = rect.height / correctedWidth;
-      final correctedHeight = rect.height * aspectRatio;
+    // Move the out of bounds vector by the perpendicular vector of the side
+    // that was hit.
+    final cardinalCorrection = switch (side) {
+      Side.left => Vector2(-dist, 0),
+      Side.right => Vector2(dist, 0),
+      Side.top => Vector2(0, -dist),
+      Side.bottom => Vector2(0, dist),
+    };
 
-      final horizontalDelta = rect.width - correctedWidth;
-      final verticalDelta = rect.height - correctedHeight;
+    final correctedRotatedPoint =
+        Vector2(point.x + cardinalCorrection.x, point.y + cardinalCorrection.y);
 
-      return Vector2(horizontalDelta, verticalDelta) * -1;
-    }
+    // Rotate back
+    final unrotated =
+        rotatePointAroundVec(rect.center, -rotation, correctedRotatedPoint);
+    final delta = unrotated - rect.pointFromQuadrant(quadrant);
+
+    print('     quad: ${rect.pointFromQuadrant(quadrant)..round()}');
+    print('unrotated: ${unrotated..round()}');
+
+    // Matrix2.rotation(rotation).transform(delta);
+    print('delta: $delta');
+
+    return delta;
   }
 
   /// Resizes the given [initialRect] with given [initialLocalPosition] of
@@ -233,17 +263,17 @@ class BoxTransformer {
       );
     }
 
-    final Box bindingRect = switch (bindingStrategy) {
+    final Box initialBindingRect = switch (bindingStrategy) {
       BindingStrategy.originalBox => initialRect,
       BindingStrategy.boundingBox => initialBoundingRect,
     };
-    final double bindingWidth = bindingRect.width;
-    final double bindingHeight = bindingRect.height;
+    final double initialBindingWidth = initialBindingRect.width;
+    final double initialBindingHeight = initialBindingRect.height;
 
     // Check if clampingRect is smaller than initialRect.
     // If it is, then we return the initialRect and not resize it.
-    if (clampingRect.width < bindingWidth ||
-        clampingRect.height < bindingHeight) {
+    if (clampingRect.width < initialBindingWidth ||
+        clampingRect.height < initialBindingHeight) {
       return ResizeResult(
         rect: initialRect,
         oldRect: initialRect,
@@ -569,40 +599,40 @@ class BoxTransformer {
     );
   }
 
-  static Dimension calculateBoundingSize({
-    required double rotation,
-    required Dimension unrotatedSize,
-  }) {
-    final double sinA = sin(rotation);
-    final double cosA = cos(rotation);
-
-    final double width = unrotatedSize.width;
-    final double height = unrotatedSize.height;
-    final double boundingWidth = (width * cosA).abs() + (height * sinA).abs();
-    final double boundingHeight = (width * sinA).abs() + (height * cosA).abs();
-
-    return Dimension(boundingWidth, boundingHeight);
-  }
-
-  static Box calculateUnrotatedRect({
-    required Box boundingBox,
-    required double rotation,
-    required double aspectRatio,
-  }) {
-    final Vector2 center = boundingBox.center;
-
-    final double width = boundingBox.width * cos(-rotation) +
-        boundingBox.height * sin(-rotation);
-
-    // derive from aspect ratio.
-    final double height = width / aspectRatio;
-
-    final Box unrotatedRect = Box.fromCenter(
-      center: center,
-      width: width,
-      height: height,
-    );
-
-    return unrotatedRect;
-  }
+// static Dimension calculateBoundingSize({
+//   required double rotation,
+//   required Dimension unrotatedSize,
+// }) {
+//   final double sinA = sin(rotation);
+//   final double cosA = cos(rotation);
+//
+//   final double width = unrotatedSize.width;
+//   final double height = unrotatedSize.height;
+//   final double boundingWidth = (width * cosA).abs() + (height * sinA).abs();
+//   final double boundingHeight = (width * sinA).abs() + (height * cosA).abs();
+//
+//   return Dimension(boundingWidth, boundingHeight);
+// }
+
+// static Box calculateUnrotatedRect({
+//   required Box boundingBox,
+//   required double rotation,
+//   required double aspectRatio,
+// }) {
+//   final Vector2 center = boundingBox.center;
+//
+//   final double width = boundingBox.width * cos(-rotation) +
+//       boundingBox.height * sin(-rotation);
+//
+//   // derive from aspect ratio.
+//   final double height = width / aspectRatio;
+//
+//   final Box unrotatedRect = Box.fromCenter(
+//     center: center,
+//     width: width,
+//     height: height,
+//   );
+//
+//   return unrotatedRect;
+// }
 }