1 files changed, 61 insertions, 20 deletions

diff --git a/src/com/android/gallery3d/filtershow/imageshow/GeometryMath.java b/src/com/android/gallery3d/filtershow/imageshow/GeometryMath.java
index 33a3f73cb..568dadfc3 100644
--- a/src/com/android/gallery3d/filtershow/imageshow/GeometryMath.java
+++ b/src/com/android/gallery3d/filtershow/imageshow/GeometryMath.java
@@ -16,6 +16,7 @@
 
 package com.android.gallery3d.filtershow.imageshow;
 
+import android.graphics.Rect;
 import android.graphics.RectF;
 
 public class GeometryMath {
@@ -25,11 +26,37 @@ public class GeometryMath {
         return Math.max(Math.min(i, high), low);
     }
 
-    protected static float[] shortestVectorFromPointToLine(float[] point, float[] l1, float[] l2) {
-        float x1 = l1[0];
-        float x2 = l2[0];
-        float y1 = l1[1];
-        float y2 = l2[1];
+    public static float[] lineIntersect(float[] line1, float[] line2) {
+        float a0 = line1[0];
+        float a1 = line1[1];
+        float b0 = line1[2];
+        float b1 = line1[3];
+        float c0 = line2[0];
+        float c1 = line2[1];
+        float d0 = line2[2];
+        float d1 = line2[3];
+        float t0 = a0 - b0;
+        float t1 = a1 - b1;
+        float t2 = b0 - d0;
+        float t3 = d1 - b1;
+        float t4 = c0 - d0;
+        float t5 = c1 - d1;
+
+        float denom = t1 * t4 - t0 * t5;
+        if (denom == 0)
+            return null;
+        float u = (t3 * t4 + t5 * t2) / denom;
+        float[] intersect = {
+                b0 + u * t0, b1 + u * t1
+        };
+        return intersect;
+    }
+
+    public static float[] shortestVectorFromPointToLine(float[] point, float[] line) {
+        float x1 = line[0];
+        float x2 = line[2];
+        float y1 = line[1];
+        float y2 = line[3];
         float xdelt = x2 - x1;
         float ydelt = y2 - y1;
         if (xdelt == 0 && ydelt == 0)
@@ -39,64 +66,78 @@ public class GeometryMath {
         float[] ret = {
                 (x1 + u * (x2 - x1)), (y1 + u * (y2 - y1))
         };
-        float [] vec = {ret[0] - point[0], ret[1] - point[1] };
+        float[] vec = {
+                ret[0] - point[0], ret[1] - point[1]
+        };
         return vec;
     }
 
     // A . B
-    public static float dotProduct(float[] a, float[] b){
+    public static float dotProduct(float[] a, float[] b) {
         return a[0] * b[0] + a[1] * b[1];
     }
 
-    public static float[] normalize(float[] a){
+    public static float[] normalize(float[] a) {
         float length = (float) Math.sqrt(a[0] * a[0] + a[1] * a[1]);
-        float[] b = { a[0] / length, a[1] / length };
+        float[] b = {
+                a[0] / length, a[1] / length
+        };
         return b;
     }
 
     // A onto B
-    public static float scalarProjection(float[] a, float[] b){
+    public static float scalarProjection(float[] a, float[] b) {
         float length = (float) Math.sqrt(b[0] * b[0] + b[1] * b[1]);
         return dotProduct(a, b) / length;
     }
 
-    public static float[] getVectorFromPoints(float [] point1, float [] point2){
-        float [] p = { point2[0] - point1[0], point2[1] - point1[1] };
+    public static float[] getVectorFromPoints(float[] point1, float[] point2) {
+        float[] p = {
+                point2[0] - point1[0], point2[1] - point1[1]
+        };
         return p;
     }
 
-    public static float[] getUnitVectorFromPoints(float [] point1, float [] point2){
-        float [] p = { point2[0] - point1[0], point2[1] - point1[1] };
+    public static float[] getUnitVectorFromPoints(float[] point1, float[] point2) {
+        float[] p = {
+                point2[0] - point1[0], point2[1] - point1[1]
+        };
         float length = (float) Math.sqrt(p[0] * p[0] + p[1] * p[1]);
         p[0] = p[0] / length;
         p[1] = p[1] / length;
         return p;
     }
 
-    public static RectF scaleRect(RectF r, float scale){
+    public static RectF scaleRect(RectF r, float scale) {
         return new RectF(r.left * scale, r.top * scale, r.right * scale, r.bottom * scale);
     }
 
     // A - B
-    public static float[] vectorSubtract(float [] a, float [] b){
+    public static float[] vectorSubtract(float[] a, float[] b) {
         int len = a.length;
         if (len != b.length)
             return null;
-        float [] ret = new float[len];
-        for (int i = 0; i < len; i++){
+        float[] ret = new float[len];
+        for (int i = 0; i < len; i++) {
             ret[i] = a[i] - b[i];
         }
         return ret;
     }
 
-    public static float vectorLength(float [] a){
+    public static float vectorLength(float[] a) {
         return (float) Math.sqrt(a[0] * a[0] + a[1] * a[1]);
     }
 
     public static float scale(float oldWidth, float oldHeight, float newWidth, float newHeight) {
         if (oldHeight == 0 || oldWidth == 0)
             return 1;
-        return Math.min(newWidth / oldWidth , newHeight / oldHeight);
+        return Math.min(newWidth / oldWidth, newHeight / oldHeight);
+    }
+
+    public static Rect roundNearest(RectF r) {
+        Rect q = new Rect(Math.round(r.left), Math.round(r.top), Math.round(r.right),
+                Math.round(r.bottom));
+        return q;
     }
 
 }