Merge pull request square#1032 from JohnWowUs/fix-rotate-dimension

Generalized dimension recalculation on rotation fixes

Author: dnkoutso

picasso/src/main/java/com/squareup/picasso/BitmapHunter.java

@@ -504,16 +504,69 @@ static Bitmap transformResult(Request data, Bitmap result, int exifOrientation)
 
     Matrix matrix = new Matrix();
 
-    if (data.needsMatrixTransform()) {
+    if (data.needsMatrixTransform() || exifOrientation != 0) {
       int targetWidth = data.targetWidth;
       int targetHeight = data.targetHeight;
 
       float targetRotation = data.rotationDegrees;
       if (targetRotation != 0) {
+        double cosR = Math.cos(Math.toRadians(targetRotation));
+        double sinR = Math.sin(Math.toRadians(targetRotation));
         if (data.hasRotationPivot) {
           matrix.setRotate(targetRotation, data.rotationPivotX, data.rotationPivotY);
+          // Recalculate dimensions after rotation around pivot point
+          double x1T = data.rotationPivotX * (1.0 - cosR) + (data.rotationPivotY * sinR);
+          double y1T = data.rotationPivotY * (1.0 - cosR) - (data.rotationPivotX * sinR);
+          double x2T = x1T + (data.targetWidth * cosR);
+          double y2T = y1T + (data.targetWidth * sinR);
+          double x3T = x1T + (data.targetWidth * cosR) - (data.targetHeight * sinR);
+          double y3T = y1T + (data.targetWidth * sinR) + (data.targetHeight * cosR);
+          double x4T = x1T - (data.targetHeight * sinR);
+          double y4T = y1T + (data.targetHeight * cosR);
+
+          double maxX = Math.max(x4T, Math.max(x3T, Math.max(x1T, x2T)));
+          double minX = Math.min(x4T, Math.min(x3T, Math.min(x1T, x2T)));
+          double maxY = Math.max(y4T, Math.max(y3T, Math.max(y1T, y2T)));
+          double minY = Math.min(y4T, Math.min(y3T, Math.min(y1T, y2T)));
+          targetWidth = (int) Math.floor(maxX - minX);
+          targetHeight  = (int) Math.floor(maxY - minY);
         } else {
           matrix.setRotate(targetRotation);
+          // Recalculate dimensions after rotation (around origin)
+          double x1T = 0.0;
+          double y1T = 0.0;
+          double x2T = (data.targetWidth * cosR);
+          double y2T = (data.targetWidth * sinR);
+          double x3T = (data.targetWidth * cosR) - (data.targetHeight * sinR);
+          double y3T = (data.targetWidth * sinR) + (data.targetHeight * cosR);
+          double x4T = -(data.targetHeight * sinR);
+          double y4T = (data.targetHeight * cosR);
+
+          double maxX = Math.max(x4T, Math.max(x3T, Math.max(x1T, x2T)));
+          double minX = Math.min(x4T, Math.min(x3T, Math.min(x1T, x2T)));
+          double maxY = Math.max(y4T, Math.max(y3T, Math.max(y1T, y2T)));
+          double minY = Math.min(y4T, Math.min(y3T, Math.min(y1T, y2T)));
+          targetWidth = (int) Math.floor(maxX - minX);
+          targetHeight  = (int) Math.floor(maxY - minY);
+        }
+      }
+
+      // EXIf interpretation should be done before cropping in case the dimensions need to
+      // be recalculated
+      if (exifOrientation != 0) {
+        int exifRotation = getExifRotation(exifOrientation);
+        int exifTranslation = getExifTranslation(exifOrientation);
+        if (exifRotation != 0) {
+          matrix.preRotate(exifRotation);
+          if (exifRotation == 90 || exifRotation == 270) {
+             // Recalculate dimensions after exif rotation
+             int tmpHeight = targetHeight;
+             targetHeight = targetWidth;
+             targetWidth = tmpHeight;
+          }
+        }
+        if (exifTranslation != 1) {
+          matrix.postScale(exifTranslation, 1);
         }
       }
 
@@ -569,14 +622,6 @@ static Bitmap transformResult(Request data, Bitmap result, int exifOrientation)
       }
     }
 
-    if (exifOrientation != 0) {
-      matrix.preRotate(getExifRotation(exifOrientation));
-      int exifTranslation = getExifTranslation(exifOrientation);
-      if (exifTranslation != 1) {
-        matrix.postScale(exifTranslation, 1);
-      }
-    }
-
     Bitmap newResult =
         Bitmap.createBitmap(result, drawX, drawY, drawWidth, drawHeight, matrix, true);
     if (newResult != result) {

picasso/src/test/java/com/squareup/picasso/BitmapHunterTest.java

@@ -422,6 +422,66 @@ public class BitmapHunterTest {
     assertThat(shadowMatrix.getPreOperations()).containsOnly("rotate 90.0");
   }
 
+ @Test public void exifRotationSizing() throws Exception {
+    Request data = new Request.Builder(URI_1).resize(5, 10).build();
+    Bitmap source = Bitmap.createBitmap(10, 10, ARGB_8888);
+    Bitmap result = transformResult(data, source, ORIENTATION_ROTATE_90);
+    ShadowBitmap shadowBitmap = shadowOf(result);
+    assertThat(shadowBitmap.getCreatedFromBitmap()).isSameAs(source);
+
+    Matrix matrix = shadowBitmap.getCreatedFromMatrix();
+    ShadowMatrix shadowMatrix = shadowOf(matrix);
+    assertThat(shadowMatrix.getPreOperations()).contains("scale 1.0 0.5");
+  }
+
+ @Test public void exifRotationNoSizing() throws Exception {
+    Request data = new Request.Builder(URI_1).build();
+    Bitmap source = Bitmap.createBitmap(10, 10, ARGB_8888);
+    Bitmap result = transformResult(data, source, ORIENTATION_ROTATE_90);
+    ShadowBitmap shadowBitmap = shadowOf(result);
+    assertThat(shadowBitmap.getCreatedFromBitmap()).isSameAs(source);
+
+    Matrix matrix = shadowBitmap.getCreatedFromMatrix();
+    ShadowMatrix shadowMatrix = shadowOf(matrix);
+    assertThat(shadowMatrix.getPreOperations()).contains("rotate 90.0");
+  }
+
+ @Test public void rotation90Sizing() throws Exception {
+    Request data = new Request.Builder(URI_1).rotate(90).resize(5, 10).build();
+    Bitmap source = Bitmap.createBitmap(10, 10, ARGB_8888);
+    Bitmap result = transformResult(data, source, 0);
+    ShadowBitmap shadowBitmap = shadowOf(result);
+    assertThat(shadowBitmap.getCreatedFromBitmap()).isSameAs(source);
+
+    Matrix matrix = shadowBitmap.getCreatedFromMatrix();
+    ShadowMatrix shadowMatrix = shadowOf(matrix);
+    assertThat(shadowMatrix.getPreOperations()).contains("scale 1.0 0.5");
+  }
+
+ @Test public void rotation180Sizing() throws Exception {
+    Request data = new Request.Builder(URI_1).rotate(180).resize(5, 10).build();
+    Bitmap source = Bitmap.createBitmap(10, 10, ARGB_8888);
+    Bitmap result = transformResult(data, source, 0);
+    ShadowBitmap shadowBitmap = shadowOf(result);
+    assertThat(shadowBitmap.getCreatedFromBitmap()).isSameAs(source);
+
+    Matrix matrix = shadowBitmap.getCreatedFromMatrix();
+    ShadowMatrix shadowMatrix = shadowOf(matrix);
+    assertThat(shadowMatrix.getPreOperations()).contains("scale 0.5 1.0");
+  }
+
+ @Test public void rotation90WithPivotSizing() throws Exception {
+    Request data = new Request.Builder(URI_1).rotate(90,0,10).resize(5, 10).build();
+    Bitmap source = Bitmap.createBitmap(10, 10, ARGB_8888);
+    Bitmap result = transformResult(data, source, 0);
+    ShadowBitmap shadowBitmap = shadowOf(result);
+    assertThat(shadowBitmap.getCreatedFromBitmap()).isSameAs(source);
+
+    Matrix matrix = shadowBitmap.getCreatedFromMatrix();
+    ShadowMatrix shadowMatrix = shadowOf(matrix);
+    assertThat(shadowMatrix.getPreOperations()).contains("scale 1.0 0.5");
+  }
+
   @Test public void exifVerticalFlip() {
     Request data = new Request.Builder(URI_1).rotate(-45).build();
     Bitmap source = Bitmap.createBitmap(10, 10, ARGB_8888);