Added the rest of the Geometryfilter stubs.

Bug: 7224232
Bug: 7218935
Change-Id: I9ebbc4a98b5696e1514995e465aa4e145fdfa4f8

1 files changed, 118 insertions, 8 deletions

diff --git a/src/com/android/gallery3d/filtershow/filters/ImageFilterGeometry.java b/src/com/android/gallery3d/filtershow/filters/ImageFilterGeometry.java
index 69a8f20d8..1368255a6 100644
--- a/src/com/android/gallery3d/filtershow/filters/ImageFilterGeometry.java
+++ b/src/com/android/gallery3d/filtershow/filters/ImageFilterGeometry.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 package com.android.gallery3d.filtershow.filters;
 
@@ -5,13 +20,21 @@ import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
+import android.graphics.RectF;
+import android.util.Log;
 
 import com.android.gallery3d.filtershow.imageshow.GeometryMetadata;
 import com.android.gallery3d.filtershow.imageshow.GeometryMetadata.FLIP;
+import com.android.gallery3d.filtershow.imageshow.ImageGeometry;
 
 public class ImageFilterGeometry extends ImageFilter {
     private final Bitmap.Config mConfig = Bitmap.Config.ARGB_8888;
     private GeometryMetadata mGeometry = null;
+    private static final String LOGTAG = "ImageFilterGeometry";
+    private static final boolean LOGV = false;
+    private static final int BOTH = 3;
+    private static final int VERTICAL = 2;
+    private static final int HORIZONTAL = 1;
 
     public ImageFilterGeometry() {
         mName = "Geometry";
@@ -23,22 +46,109 @@ public class ImageFilterGeometry extends ImageFilter {
         return filter;
     }
 
-    public void setGeometryMetadata(GeometryMetadata m){
+    public void setGeometryMetadata(GeometryMetadata m) {
         mGeometry = m;
     }
 
     native protected void nativeApplyFilterFlip(Bitmap src, int srcWidth, int srcHeight,
             Bitmap dst, int dstWidth, int dstHeight, int flip);
 
+    native protected void nativeApplyFilterRotate(Bitmap src, int srcWidth, int srcHeight,
+            Bitmap dst, int dstWidth, int dstHeight, float rotate);
+
+    native protected void nativeApplyFilterCrop(Bitmap src, int srcWidth, int srcHeight,
+            Bitmap dst, int dstWidth, int dstHeight, int offsetWidth, int offsetHeight);
+
+    native protected void nativeApplyFilterStraighten(Bitmap src, int srcWidth, int srcHeight,
+            Bitmap dst, int dstWidth, int dstHeight, float straightenAngle);
+
     @Override
-    public Bitmap apply(Bitmap bitmap, float scaleFactor, boolean highQuality) {
-        if(mGeometry.getFlipType() == FLIP.NONE){
-            return bitmap;
+    public Bitmap apply(Bitmap originalBitmap, float scaleFactor, boolean highQuality) {
+        Rect cropBounds = new Rect();
+        Rect originalBounds = new Rect();
+        FLIP flipType = mGeometry.getFlipType();
+        float rAngle = mGeometry.getRotation();
+        float sAngle = mGeometry.getStraightenRotation();
+        mGeometry.getCropBounds().roundOut(cropBounds);
+        mGeometry.getPhotoBounds().roundOut(originalBounds);
+        boolean flip = flipType != FLIP.NONE;
+        boolean rotate = rAngle != 0;
+        boolean crop = !cropBounds.equals(originalBounds);
+        boolean straighten = sAngle != 0;
+
+        int jniFlipType = 0;
+        switch (flipType) {
+            case BOTH:
+                jniFlipType = BOTH;
+                break;
+            case VERTICAL:
+                jniFlipType = VERTICAL;
+                break;
+            case HORIZONTAL:
+                jniFlipType = HORIZONTAL;
+                break;
+            default:
+                jniFlipType = 0;
+                break;
+        }
+        int bmWidth = originalBitmap.getWidth();
+        int bmHeight = originalBitmap.getHeight();
+        if (!(flip || rotate || crop || straighten)) {
+            return originalBitmap;
+        }
+        if (originalBounds.width() != bmWidth || originalBounds.height() != bmHeight) {
+            if (LOGV)
+                Log.v(LOGTAG, "PHOTOBOUNDS WIDTH/HEIGHT NOT SAME AS BITMAP WIDTH/HEIGHT");
+            return originalBitmap;
+        }
+        Bitmap modBitmap = originalBitmap;
+        Rect modifiedBounds = new Rect(originalBounds);
+        if (flip) {
+            modBitmap = originalBitmap.copy(mConfig, true);
+            nativeApplyFilterFlip(originalBitmap, bmWidth, bmHeight, modBitmap,
+                    bmWidth, bmHeight, jniFlipType);
+        }
+        if (rotate) {
+            // Fails for non-90 degree rotations
+            Bitmap modBitmapRotate = null;
+            if (((int) (sAngle / 90)) % 2 == 0) {
+                modBitmapRotate = Bitmap.createBitmap(bmWidth, bmHeight, mConfig);
+                nativeApplyFilterRotate(modBitmap, bmWidth, bmHeight, modBitmapRotate,
+                        bmWidth, bmHeight, mGeometry.getRotation());
+                modifiedBounds = new Rect(0, 0, bmWidth, bmHeight);
+            } else {
+                modBitmapRotate = Bitmap.createBitmap(bmHeight, bmWidth, mConfig);
+                nativeApplyFilterRotate(modBitmap, bmWidth, bmHeight, modBitmapRotate,
+                        bmHeight, bmWidth, mGeometry.getRotation());
+                modifiedBounds = new Rect(0, 0, bmHeight, bmWidth);
+            }
+            modBitmap = modBitmapRotate;
+        }
+        if (straighten) {
+            Rect straightenBounds = new Rect();
+            ImageGeometry.getUntranslatedStraightenCropBounds(new RectF(modifiedBounds), sAngle)
+                    .roundOut(straightenBounds);
+            Bitmap modBitmapStraighten = Bitmap.createBitmap(straightenBounds.width(),
+                    straightenBounds.height(), mConfig);
+            nativeApplyFilterStraighten(modBitmap, modifiedBounds.width(), modifiedBounds.height(),
+                    modBitmapStraighten,
+                    straightenBounds.width(), straightenBounds.height(),
+                    mGeometry.getStraightenRotation());
+            modifiedBounds = straightenBounds;
+            modBitmap = modBitmapStraighten;
+        }
+        if (crop) {
+            Bitmap modBitmapCrop = Bitmap.createBitmap(cropBounds.width(), cropBounds.height(),
+                    mConfig);
+            // Force crop bounds to be within straighten bounds.
+            if (!modifiedBounds.intersect(cropBounds)) {
+                return modBitmap;
+            }
+            nativeApplyFilterCrop(modBitmap, bmWidth, bmHeight, modBitmapCrop,
+                    cropBounds.width(), cropBounds.height(), cropBounds.left, cropBounds.top);
+            modBitmap = modBitmapCrop;
         }
-        Bitmap flipBitmap = bitmap.copy(mConfig, true);
-        nativeApplyFilterFlip(bitmap, bitmap.getWidth(), bitmap.getHeight(), flipBitmap,
-                flipBitmap.getWidth(), flipBitmap.getHeight(), 1);
-        return flipBitmap;
+        return modBitmap;
     }
 
 }