A more complex CL to avoid exposing the 'bounds' arrays from several of the

geometry class (paving the way for them to be made immutable later).
-------------
Created by MOE: http://code.google.com/p/moe-java
MOE_MIGRATED_REVID=24952612

Author: hagbard

src/com/google/common/geometry/R1Interval.java

@@ -22,13 +22,16 @@
  *
  */
 
-public strictfp class R1Interval {
-  private final double[] bounds = new double[2];
+public final strictfp class R1Interval {
+
+  // TODO(dbeaumont): Make these final and make this class fully immutable.
+  private double lo;
+  private double hi;
 
   /** Interval constructor. If lo > hi, the interval is empty. */
   public R1Interval(double lo, double hi) {
-    bounds[0] = lo;
-    bounds[1] = hi;
+    this.lo = lo;
+    this.hi = hi;
   }
 
   /**
@@ -60,27 +63,19 @@ public static R1Interval fromPointPair(double p1, double p2) {
   }
 
   public double lo() {
-    return bounds[0];
+    return lo;
   }
 
   public double hi() {
-    return bounds[1];
-  }
-
-  public double bound(int i) {
-    return bounds[i];
-  }
-
-  public double[] bounds() {
-    return bounds;
+    return hi;
   }
 
   public void setLo(double p) {
-    bounds[0] = p;
+    this.lo = p;
   }
 
   public void setHi(double p) {
-    bounds[1] = p;
+    this.hi = p;
   }
 
   /**
@@ -98,7 +93,6 @@ public double getCenter() {
     return 0.5 * (lo() + hi());
   }
 
-
   /**
    * Return the length of the interval. The length of an empty interval is
    * negative.
@@ -107,7 +101,6 @@ public double getLength() {
     return hi() - lo();
   }
 
-
   public boolean contains(double p) {
     return p >= lo() && p <= hi();
   }
@@ -221,8 +214,8 @@ public int hashCode() {
     }
 
     long value = 17;
-    value = 37 * value + Double.doubleToLongBits(bounds[0]);
-    value = 37 * value + Double.doubleToLongBits(bounds[1]);
+    value = 37 * value + Double.doubleToLongBits(lo);
+    value = 37 * value + Double.doubleToLongBits(hi);
     return (int) (value ^ (value >>> 32));
   }
 

src/com/google/common/geometry/R2Vector.java

@@ -21,9 +21,13 @@
  * norm, comparison etc.
  *
  */
-public strictfp class R2Vector {
-  double x;
-  double y;
+public final strictfp class R2Vector {
+  final double x;
+  final double y;
+
+  public R2Vector() {
+    this(0, 0);
+  }
 
   public R2Vector(double x, double y) {
     this.x = x;
@@ -38,9 +42,6 @@ public R2Vector(double[] coord) {
     y = coord[1];
   }
 
-  public R2Vector() {
-  }
-
   public double get(int index) {
     if (index > 1) {
       throw new ArrayIndexOutOfBoundsException(index);
@@ -57,11 +58,11 @@ public static R2Vector mul(final R2Vector p, double m) {
   }
 
   public double norm2() {
-    return x * x + y * y;
+    return (x * x) + (y * y);
   }
 
   public static double dotProd(final R2Vector p1, final R2Vector p2) {
-    return p1.x * p2.x + p1.y * p2.y;
+    return (p1.x * p2.x) + (p1.y * p2.y);
   }
 
   public double dotProd(R2Vector that) {

src/com/google/common/geometry/S1Interval.java

@@ -36,9 +36,11 @@
  *
  */
 
-public strictfp class S1Interval implements Cloneable {
+public final strictfp class S1Interval implements Cloneable {
 
-  private final double[] bounds = new double[2];
+  // TODO(dbeaumont): Make this class immutable and fix callers.
+  private double lo;
+  private double hi;
 
   /**
    * Both endpoints must be in the range -Pi to Pi inclusive. The value -Pi is
@@ -50,32 +52,33 @@ public S1Interval(double lo, double hi) {
 
   /**
    * Copy constructor. Assumes that the given interval is valid.
+   *
+   * TODO(dbeaumont): Make this class immutable and remove this method.
    */
   public S1Interval(S1Interval interval) {
-    bounds[0] = interval.bounds[0];
-    bounds[1] = interval.bounds[1];
+    this.lo = interval.lo;
+    this.hi = interval.hi;
   }
 
   /**
    * Internal constructor that assumes that both arguments are in the correct
    * range, i.e. normalization from -Pi to Pi is already done.
    */
   private S1Interval(double lo, double hi, boolean checked) {
-    bounds[0] = lo;
-    bounds[1] = hi;
-
+    double newLo = lo;
+    double newHi = hi;
     if (!checked) {
       if (lo == -S2.M_PI && hi != S2.M_PI) {
-        setLo(S2.M_PI);
+        newLo = S2.M_PI;
       }
       if (hi == -S2.M_PI && lo != S2.M_PI) {
-        setHi(S2.M_PI);
+        newHi = S2.M_PI;
       }
     }
-    // assert (isValid());
+    this.lo = newLo;
+    this.hi = newHi;
   }
 
-
   public static S1Interval empty() {
     return new S1Interval(S2.M_PI, -S2.M_PI, true);
   }
@@ -112,30 +115,21 @@ public static S1Interval fromPointPair(double p1, double p2) {
     }
   }
 
-
   public double lo() {
-    return bounds[0];
+    return lo;
   }
 
   public double hi() {
-    return bounds[1];
+    return hi;
   }
 
-  public double bound(int i) {
-    return bounds[i];
-  }
-
-  public double[] bounds() {
-    return bounds;
-  }
-
-  public void setLo(double p) {
-    bounds[0] = p;
+  public void setLo(double lo) {
+    this.lo = lo;
     // assert (isValid());
   }
 
-  public void setHi(double p) {
-    bounds[1] = p;
+  public void setHi(double hi) {
+    this.hi = hi;
     // assert (isValid());
   }
 
@@ -148,7 +142,6 @@ public boolean isValid() {
         && !(lo() == -S2.M_PI && hi() != S2.M_PI) && !(hi() == -S2.M_PI && lo() != S2.M_PI));
   }
 
-
   /** Return true if the interval contains all points on the unit circle. */
   public boolean isFull() {
     return hi() - lo() == 2 * S2.M_PI;
@@ -166,7 +159,6 @@ public boolean isInverted() {
     return lo() > hi();
   }
 
-
   /**
    * Return the midpoint of the interval. For full and empty intervals, the
    * result is arbitrary.
@@ -194,7 +186,6 @@ public double getLength() {
     return (length > 0) ? length : -1;
   }
 
-
   /**
    * Return the complement of the interior of the interval. An interval and its
    * complement have the same boundary but do not share any interior values. The
@@ -221,7 +212,6 @@ public boolean contains(double p) {
     return fastContains(p);
   }
 
-
   /**
    * Return true if the interval (which is closed) contains the point 'p'. Skips
    * the normalization of 'p' from -Pi to Pi.
@@ -235,7 +225,6 @@ public boolean fastContains(double p) {
     }
   }
 
-
   /** Return true if the interior of the interval contains the point 'p'. */
   public boolean interiorContains(double p) {
     // Works for empty, full, and singleton intervals.
@@ -251,7 +240,6 @@ public boolean interiorContains(double p) {
     }
   }
 
-
   /**
    * Return true if the interval contains the given interval 'y'. Works for
    * empty, full, and singleton intervals.
@@ -332,7 +320,6 @@ public boolean interiorIntersects(final S1Interval y) {
     }
   }
 
-
   /**
    * Expand the interval by the minimum amount necessary so that it contains the
    * given point "p" (an angle in the range [-Pi, Pi]).
@@ -388,7 +375,6 @@ public S1Interval expanded(double radius) {
     return result;
   }
 
-
   /**
    * Return the smallest interval that contains this interval and the given
    * interval "y".
@@ -432,7 +418,6 @@ public S1Interval union(final S1Interval y) {
     }
   }
 
-
   /**
    * Return the smallest interval that contains the intersection of this
    * interval with "y". Note that the region of intersection may consist of two
@@ -472,7 +457,6 @@ public S1Interval intersection(final S1Interval y) {
     return empty();
   }
 
-
   /**
    * Return true if the length of the symmetric difference between the two
    * intervals is at most the given tolerance.

src/com/google/common/geometry/S2Cell.java

@@ -23,11 +23,10 @@
  *
  */
 
-public strictfp class S2Cell implements S2Region {
+public final strictfp class S2Cell implements S2Region {
 
   private static final int MAX_CELL_SIZE = 1 << S2CellId.MAX_LEVEL;
 
-  // This structure occupies 44 bytes plus one pointer for the vtable.
   byte face;
   byte level;
   byte orientation;
@@ -182,17 +181,17 @@ public S2Point getCenterRaw() {
   public R2Vector getCenterUV() {
     MutableInteger i = new MutableInteger(0);
     MutableInteger j = new MutableInteger(0);
-    R2Vector centerUv = new R2Vector();
     cellId.toFaceIJOrientation(i, j, null);
     int cellSize = 1 << (S2CellId.MAX_LEVEL - level);
 
-    int sij = (i.intValue() & -cellSize) * 2 + cellSize - MAX_CELL_SIZE;
-    centerUv.x = S2Projections.stToUV((1.0 / MAX_CELL_SIZE) * sij);
+    // TODO(dbeaumont): Figure out a better naming of the variables here (and elsewhere).
+    int si = (i.intValue() & -cellSize) * 2 + cellSize - MAX_CELL_SIZE;
+    double x = S2Projections.stToUV((1.0 / MAX_CELL_SIZE) * si);
 
-    sij = (j.intValue() & -cellSize) * 2 + cellSize - MAX_CELL_SIZE;
-    centerUv.y = S2Projections.stToUV((1.0 / MAX_CELL_SIZE) * sij);
+    int sj = (j.intValue() & -cellSize) * 2 + cellSize - MAX_CELL_SIZE;
+    double y = S2Projections.stToUV((1.0 / MAX_CELL_SIZE) * sj);
 
-    return centerUv;
+    return new R2Vector(x, y);
   }
 
   /**
@@ -365,8 +364,8 @@ public boolean contains(S2Point p) {
     // We can't just call XYZtoFaceUV, because for points that lie on the
     // boundary between two faces (i.e. u or v is +1/-1) we need to return
     // true for both adjacent cells.
-    R2Vector uvPoint = new R2Vector();
-    if (!S2Projections.faceXyzToUv(face, p, uvPoint)) {
+    R2Vector uvPoint = S2Projections.faceXyzToUv(face, p);
+    if (uvPoint == null) {
       return false;
     }
     return (uvPoint.x >= uv[0][0] && uvPoint.x <= uv[0][1] && uvPoint.y >= uv[1][0]

src/com/google/common/geometry/S2CellId.java

@@ -48,7 +48,7 @@
  *
  *
  */
-public strictfp class S2CellId implements Comparable<S2CellId> {
+public final strictfp class S2CellId implements Comparable<S2CellId> {
 
   // Although only 60 bits are needed to represent the index of a leaf
   // cell, we need an extra bit in order to represent the position of
@@ -146,8 +146,8 @@ public static S2CellId fromFacePosLevel(int face, long pos, int level) {
    * necessarily unit length).
    */
   public static S2CellId fromPoint(S2Point p) {
-    R2Vector uv = new R2Vector();
-    int face = S2Projections.xyzToFaceUV(p, uv);
+    int face = S2Projections.xyzToFace(p);
+    R2Vector uv = S2Projections.validFaceXyzToUv(face, p);
     int i = stToIJ(S2Projections.uvToST(uv.x));
     int j = stToIJ(S2Projections.uvToST(uv.y));
     return fromFaceIJ(face, i, j);
@@ -863,8 +863,9 @@ private static S2CellId fromFaceIJWrap(int face, int i, int j) {
 
     // Find the leaf cell coordinates on the adjacent face, and convert
     // them to a cell id at the appropriate level.
-    R2Vector st = new R2Vector();
-    face = S2Projections.xyzToFaceUV(S2Projections.faceUvToXyz(face, s, t), st);
+    S2Point p = S2Projections.faceUvToXyz(face, s, t);
+    face = S2Projections.xyzToFace(p);
+    R2Vector st = S2Projections.validFaceXyzToUv(face, p);
     return fromFaceIJ(face, stToIJ(st.x), stToIJ(st.y));
   }
 
@@ -960,5 +961,4 @@ public int compareTo(S2CellId that) {
     return unsignedLongLessThan(this.id, that.id) ? -1 :
         unsignedLongGreaterThan(this.id, that.id) ? 1 : 0;
   }
-
 }