GeoHash (geohash-java 1.1.0 API)

java.lang.Object
- ch.hsr.geohash.GeoHash

All Implemented Interfaces:: Serializable, Comparable<GeoHash>

public final class GeoHash
extends Object
implements Comparable<GeoHash>, Serializable

See Also:: Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

protected long bits

static long FIRST_BIT_FLAGGED

protected byte significantBits

Fields
Modifier and Type	Field and Description
`protected long`	`bits`
`static long`	`FIRST_BIT_FLAGGED`
`protected byte`	`significantBits`

Constructor Summary

Constructors
Modifier Constructor and Description

protected GeoHash()

Constructors
Modifier	Constructor and Description
`protected`	`GeoHash()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addOffBitToEnd()`
`protected void`	`addOnBitToEnd()`
`int`	`compareTo(GeoHash o)`
`boolean`	`contains(WGS84Point point)` find out if the given point lies within this hashes bounding box. Note: this operation checks the bounding boxes coordinates, i.e.
`boolean`	`enclosesCircleAroundPoint(WGS84Point point, double radius)`
`boolean`	`equals(Object obj)`
`static GeoHash`	`fromBinaryString(String binaryString)`
`static GeoHash`	`fromGeohashString(String geohash)` build a new `GeoHash` from a base32-encoded `String`. This will also set up the hashes bounding box and other values, so it can also be used with functions like within().
`static GeoHash`	`fromLongValue(long hashVal, int significantBits)`
`static GeoHash`	`fromOrd(long ord, int significantBits)`
`static String`	`geoHashStringWithCharacterPrecision(double latitude, double longitude, int numberOfCharacters)` This method uses the given number of characters as the desired precision value.
`GeoHash[]`	`getAdjacent()` returns the 8 adjacent hashes for this one.
`BoundingBox`	`getBoundingBox()`
`WGS84Point`	`getBoundingBoxCenterPoint()` return the center of this `GeoHash`s bounding box.
`int`	`getCharacterPrecision()` Returns the number of characters that represent this hash.
`GeoHash`	`getEasternNeighbour()`
`GeoHash`	`getNorthernNeighbour()`
`protected int[]`	`getNumberOfLatLonBits()`
`WGS84Point`	`getPoint()` returns the `WGS84Point` that was originally used to set up this. If it was built from a base32-`String`, this is the center point of the bounding box.
`protected long[]`	`getRightAlignedLatitudeBits()`
`protected long[]`	`getRightAlignedLongitudeBits()`
`GeoHash`	`getSouthernNeighbour()`
`GeoHash`	`getWesternNeighbour()`
`int`	`hashCode()`
`long`	`longValue()`
`GeoHash`	`next()`
`GeoHash`	`next(int step)`
`long`	`ord()`
`GeoHash`	`prev()`
`protected GeoHash`	`recombineLatLonBitsToHash(long[] latBits, long[] lonBits)`
`int`	`significantBits()` how many significant bits are there in this `GeoHash`?
`static long`	`stepsBetween(GeoHash one, GeoHash two)` Counts the number of geohashes contained between the two (ie how many times next() is called to increment from one to two) This value depends on the number of significant bits.
`String`	`toBase32()` get the base32 string for this `GeoHash`. this method only makes sense, if this hash has a multiple of 5 significant bits.
`String`	`toBinaryString()`
`String`	`toString()`
`static GeoHash`	`withBitPrecision(double latitude, double longitude, int numberOfBits)` create a new `GeoHash` with the given number of bits accuracy.
`static GeoHash`	`withCharacterPrecision(double latitude, double longitude, int numberOfCharacters)` This method uses the given number of characters as the desired precision value.
`boolean`	`within(GeoHash boundingBox)` returns true iff this is within the given geohash bounding box.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - FIRST_BIT_FLAGGED
```
public static final long FIRST_BIT_FLAGGED
```
    See Also:
    
    Constant Field Values
  - bits
```
protected long bits
```
  - significantBits
```
protected byte significantBits
```
- Constructor Detail
  - GeoHash
```
protected GeoHash()
```
- Method Detail
  - withCharacterPrecision
```
public static GeoHash withCharacterPrecision(double latitude,
                                             double longitude,
                                             int numberOfCharacters)
```
    This method uses the given number of characters as the desired precision value. The hash can only be 64bits long, thus a maximum precision of 12 characters can be achieved.
  - withBitPrecision
```
public static GeoHash withBitPrecision(double latitude,
                                       double longitude,
                                       int numberOfBits)
```
    create a new GeoHash with the given number of bits accuracy. This at the same time defines this hash's bounding box.
  - fromBinaryString
```
public static GeoHash fromBinaryString(String binaryString)
```
  - fromGeohashString
```
public static GeoHash fromGeohashString(String geohash)
```
    build a new GeoHash from a base32-encoded String.
    This will also set up the hashes bounding box and other values, so it can also be used with functions like within().
  - fromLongValue
```
public static GeoHash fromLongValue(long hashVal,
                                    int significantBits)
```
  - geoHashStringWithCharacterPrecision
```
public static String geoHashStringWithCharacterPrecision(double latitude,
                                                         double longitude,
                                                         int numberOfCharacters)
```
    This method uses the given number of characters as the desired precision value. The hash can only be 64bits long, thus a maximum precision of 12 characters can be achieved.
  - next
```
public GeoHash next(int step)
```
  - next
```
public GeoHash next()
```
  - prev
```
public GeoHash prev()
```
  - ord
```
public long ord()
```
  - getCharacterPrecision
```
public int getCharacterPrecision()
```
    Returns the number of characters that represent this hash.
    
    Throws:
    
    IllegalStateException - when the hash cannot be encoded in base32, i.e. when the precision is not a multiple of 5.
  - fromOrd
```
public static GeoHash fromOrd(long ord,
                              int significantBits)
```
  - stepsBetween
```
public static long stepsBetween(GeoHash one,
                                GeoHash two)
```
    Counts the number of geohashes contained between the two (ie how many times next() is called to increment from one to two) This value depends on the number of significant bits.
    
    Parameters:
    
    one -
    
    two -
    
    Returns:
    
    number of steps
  - getAdjacent
```
public GeoHash[] getAdjacent()
```
    returns the 8 adjacent hashes for this one. They are in the following order:
    N, NE, E, SE, S, SW, W, NW
  - significantBits
```
public int significantBits()
```
    how many significant bits are there in this GeoHash?
  - longValue
```
public long longValue()
```
  - toBase32
```
public String toBase32()
```
    get the base32 string for this GeoHash.
    this method only makes sense, if this hash has a multiple of 5 significant bits.
    
    Throws:
    
    IllegalStateException - when the number of significant bits is not a multiple of 5.
  - within
```
public boolean within(GeoHash boundingBox)
```
    returns true iff this is within the given geohash bounding box.
  - contains
```
public boolean contains(WGS84Point point)
```
    find out if the given point lies within this hashes bounding box.
    Note: this operation checks the bounding boxes coordinates, i.e. does not use the GeoHashs special abilities.s
  - getPoint
```
public WGS84Point getPoint()
```
    returns the WGS84Point that was originally used to set up this.
    If it was built from a base32-String, this is the center point of the bounding box.
  - getBoundingBoxCenterPoint
```
public WGS84Point getBoundingBoxCenterPoint()
```
    return the center of this GeoHashs bounding box. this is rarely the same point that was used to build the hash.
  - getBoundingBox
```
public BoundingBox getBoundingBox()
```
  - enclosesCircleAroundPoint
```
public boolean enclosesCircleAroundPoint(WGS84Point point,
                                         double radius)
```
  - recombineLatLonBitsToHash
```
protected GeoHash recombineLatLonBitsToHash(long[] latBits,
                                            long[] lonBits)
```
  - getNorthernNeighbour
```
public GeoHash getNorthernNeighbour()
```
  - getSouthernNeighbour
```
public GeoHash getSouthernNeighbour()
```
  - getEasternNeighbour
```
public GeoHash getEasternNeighbour()
```
  - getWesternNeighbour
```
public GeoHash getWesternNeighbour()
```
  - getRightAlignedLatitudeBits
```
protected long[] getRightAlignedLatitudeBits()
```
  - getRightAlignedLongitudeBits
```
protected long[] getRightAlignedLongitudeBits()
```
  - getNumberOfLatLonBits
```
protected int[] getNumberOfLatLonBits()
```
  - addOnBitToEnd
```
protected final void addOnBitToEnd()
```
  - addOffBitToEnd
```
protected final void addOffBitToEnd()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toBinaryString
```
public String toBinaryString()
```
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - compareTo
```
public int compareTo(GeoHash o)
```
    Specified by:
    
    compareTo in interface Comparable<GeoHash>

Class GeoHash

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

FIRST_BIT_FLAGGED

bits

significantBits

Constructor Detail

GeoHash

Method Detail

withCharacterPrecision

withBitPrecision

fromBinaryString

fromGeohashString

fromLongValue

geoHashStringWithCharacterPrecision

next

next

prev

ord

getCharacterPrecision

fromOrd

stepsBetween

getAdjacent

significantBits

longValue

toBase32

within

contains

getPoint

getBoundingBoxCenterPoint

getBoundingBox

enclosesCircleAroundPoint

recombineLatLonBitsToHash

getNorthernNeighbour

getSouthernNeighbour

getEasternNeighbour

getWesternNeighbour

getRightAlignedLatitudeBits

getRightAlignedLongitudeBits

getNumberOfLatLonBits

addOnBitToEnd

addOffBitToEnd

toString

toBinaryString

equals

hashCode

compareTo