Beispiel #1
0
  @Test
  public void testEqualsAndHashCode() {
    GeoHash hash1 = GeoHash.withBitPrecision(30, 30, 24);
    GeoHash hash2 = GeoHash.withBitPrecision(30, 30, 24);
    GeoHash hash3 = GeoHash.withBitPrecision(30, 30, 10);

    assertTrue(hash1.equals(hash2) && hash2.equals(hash1));
    assertFalse(hash1.equals(hash3) && hash3.equals(hash1));

    assertEquals(hash1.hashCode(), hash2.hashCode());
    assertFalse(hash1.hashCode() == hash3.hashCode());
  }
Beispiel #2
0
 @Test
 public void testGetLongitudeBits() {
   hash = GeoHash.withBitPrecision(30, 30, 16);
   long[] longitudeBits = hash.getRightAlignedLongitudeBits();
   assertEquals(0x95l, longitudeBits[0]);
   assertEquals(8, longitudeBits[1]);
 }
Beispiel #3
0
 @Test
 public void testNext() {
   double lat = 37.7;
   double lon = -122.52;
   GeoHash hash = GeoHash.withBitPrecision(lat, lon, 10);
   GeoHash next = hash.next();
   assertTrue(hash.compareTo(next) < 0);
 }
Beispiel #4
0
  @Test
  public void testConstructorWithBitPrecision() {
    GeoHash hash1 = GeoHash.withBitPrecision(45, 120, 20);
    assertEquals(hash1.significantBits, 20);
    System.out.println(hash1);
    System.out.println(hash1.toBase32());

    GeoHash hash2 = GeoHash.withBitPrecision(45, 120, 55);
    assertEquals(hash2.significantBits, 55);
    System.out.println(hash2);
    System.out.println(hash2.toBase32());

    assertTrue(hash2.within(hash1));

    // this should match Dave Troys Codebase. This is also his maximum
    // accuracy (12 5-nibbles).
    GeoHash hash3 = GeoHash.withBitPrecision(20, 31, 60);
    assertEquals("sew1c2vs2q5r", hash3.toBase32());
    System.out.println("--------------");
    String hash4 = new GeoHash().geoHashStringWithCharacterPrecision(45, 120, 64);
    System.out.println(hash4);
  }
Beispiel #5
0
  @Test
  public void testNextPrev() {
    double lat = 37.7;
    double lon = -122.52;
    GeoHash hash = GeoHash.withBitPrecision(lat, lon, 35);
    GeoHash next = hash.next(2);
    assertTrue(hash.compareTo(next) < 0);
    GeoHash prev1 = next.prev();
    GeoHash prev2 = prev1.next(-1);
    assertTrue(prev1.compareTo(next) < 0);
    System.out.println("hash: " + hash.toBase32());
    System.out.println("next: " + next.toBase32());
    System.out.println("prev1: " + prev1.toBase32());
    System.out.println("prev2: " + prev2.toBase32());

    assertTrue(prev2.compareTo(prev1) < 0);
    assertTrue(prev2.compareTo(hash) == 0);
  }
Beispiel #6
0
  private void checkMoveAroundStrip(String direction) throws Exception {
    for (int bits = 2; bits < 16; bits++) {
      double randomLatitude = (rand.nextDouble() - 0.5) * 180;
      double randomLongitude = (rand.nextDouble() - 0.5) * 360;

      // this divides the range by 2^bits
      GeoHash hash = GeoHash.withBitPrecision(randomLatitude, randomLongitude, bits);
      Method method = hash.getClass().getDeclaredMethod("get" + direction + "Neighbour");
      GeoHash result = hash;

      // moving this direction 2^bits times should yield the same hash
      // again
      for (int i = 0; i < Math.pow(2, bits); i++) {
        result = (GeoHash) method.invoke(result);
      }
      assertEquals(hash, result);
    }
  }
Beispiel #7
0
  @Test
  public void testStepsBetween() {
    GeoHash bl = GeoHash.withBitPrecision(37.7, -122.52, 35);
    GeoHash ur = GeoHash.withBitPrecision(37.84, -122.35, 35);

    long steps = GeoHash.stepsBetween(bl, bl);
    assertEquals(steps, 0);

    steps = GeoHash.stepsBetween(bl, bl.next(4));
    assertEquals(steps, 4);

    BoundingBoxGeoHashIterator iter =
        new BoundingBoxGeoHashIterator(new TwoGeoHashBoundingBox(bl, ur));
    int count = 0;
    while (iter.hasNext()) {
      iter.next();
      count++;
    }
    assertEquals(12875, count);

    int allHashes = 0;
    int inBbox = 1;
    int latMore = 0;
    int lonMore = 0;
    int bothMore = 0;
    int latLess = 0;
    int lonLess = 0;
    int bothLess = 0;
    int latLessLonMore = 0;
    int latMoreLonLess = 0;
    GeoHash idx = bl;
    BoundingBox iterBbox = iter.getBoundingBox().getBoundingBox();
    while (idx.compareTo(ur) < 0) {
      idx = idx.next();
      allHashes++;
      if (iterBbox.contains(idx.getPoint())) {
        inBbox++;
      }
      boolean latIsMore = false;
      boolean latIsLess = false;
      if (idx.getPoint().getLatitude() > iterBbox.getMaxLat()) {
        latIsMore = true;
        latMore++;
      } else if (idx.getPoint().getLatitude() < iterBbox.getMinLat()) {
        latIsLess = true;
        latLess++;
      }
      if (idx.getPoint().getLongitude() > iterBbox.getMaxLon()) {
        lonMore++;
        if (latIsMore) {
          bothMore++;
        }
        if (latIsLess) {
          latLessLonMore++;
        }
      } else if (idx.getPoint().getLongitude() < iterBbox.getMinLon()) {
        lonLess++;
        if (latIsLess) {
          bothLess++;
        }
        if (latIsMore) {
          latMoreLonLess++;
        }
      }
    }

    // Just trying to understand where these GeoHashes are with regard to
    // their bounding box.
    steps = GeoHash.stepsBetween(bl, ur);
    assertEquals(48472, steps);
    assertEquals(steps, allHashes);
    assertEquals(count, inBbox);
    assertEquals(14938, latMore);
    assertEquals(640, lonMore);
    assertEquals(0, bothMore);
    assertEquals(7680, latLess);
    assertEquals(24391, lonLess);
    assertEquals(0, bothLess);
    assertEquals(240, latLessLonMore);
    assertEquals(11811, latMoreLonLess);
    assertEquals(
        steps,
        lonLess + latLess + latMore + lonMore + inBbox - latLessLonMore - latMoreLonLess - 1);
  }
Beispiel #8
0
 @Test
 public void testGetCharacterPrecisionWorksWhenPrecisionIsMultipleOfFive() throws Exception {
   GeoHash hash = GeoHash.withBitPrecision(37.7, -122.52, 60);
   int precision = hash.getCharacterPrecision();
   assertEquals(precision, 12);
 }
Beispiel #9
0
 @Test(expected = IllegalStateException.class)
 public void testGetCharacterPrecisionThrows() throws Exception {
   GeoHash hash = GeoHash.withBitPrecision(37.7, -122.52, 32);
   hash.getCharacterPrecision();
 }
Beispiel #10
0
 @Test
 public void testSimpleWithin() {
   GeoHash hash = GeoHash.withBitPrecision(70, -120, 8);
   GeoHash inside = GeoHash.withBitPrecision(74, -130, 64);
   assertWithin(inside, hash);
 }
Beispiel #11
0
 @Test
 public void testLatLonBoundingBoxes() {
   hash = GeoHash.withBitPrecision(40, 120, 10);
   System.out.println(hash.toBase32());
   printBoundingBox(hash);
 }