diff --git a/deps/geohash-int/geohash.c b/deps/geohash-int/geohash.c
index 66cff082c..e797fbc8f 100644
--- a/deps/geohash-int/geohash.c
+++ b/deps/geohash-int/geohash.c
@@ -43,17 +43,17 @@
* -----------------
*/
-void geohashGetCoordRange(GeoHashRange *lat_range, GeoHashRange *long_range) {
+void geohashGetCoordRange(GeoHashRange *long_range, GeoHashRange *lat_range) {
/* These are constraints from EPSG:900913 / EPSG:3785 / OSGEO:41001 */
/* We can't geocode at the north/south pole. */
- lat_range->max = 85.05112878;
- lat_range->min = -85.05112878;
long_range->max = 180.0;
long_range->min = -180.0;
+ lat_range->max = 85.05112878;
+ lat_range->min = -85.05112878;
}
-int geohashEncode(GeoHashRange *lat_range, GeoHashRange *long_range,
- double latitude, double longitude, uint8_t step,
+int geohashEncode(GeoHashRange *long_range, GeoHashRange *lat_range,
+ double longitude, double latitude, uint8_t step,
GeoHashBits *hash) {
uint8_t i;
@@ -96,22 +96,22 @@ int geohashEncode(GeoHashRange *lat_range, GeoHashRange *long_range,
return 1;
}
-int geohashEncodeType(double latitude, double longitude, uint8_t step, GeoHashBits *hash) {
+int geohashEncodeType(double longitude, double latitude, uint8_t step, GeoHashBits *hash) {
GeoHashRange r[2] = { { 0 } };
geohashGetCoordRange(&r[0], &r[1]);
- return geohashEncode(&r[0], &r[1], latitude, longitude, step, hash);
+ return geohashEncode(&r[0], &r[1], longitude, latitude, step, hash);
}
-int geohashEncodeWGS84(double latitude, double longitude, uint8_t step,
+int geohashEncodeWGS84(double longitude, double latitude, uint8_t step,
GeoHashBits *hash) {
- return geohashEncodeType(latitude, longitude, step, hash);
+ return geohashEncodeType(longitude, latitude, step, hash);
}
static inline uint8_t get_bit(uint64_t bits, uint8_t pos) {
return (bits >> pos) & 0x01;
}
-int geohashDecode(const GeoHashRange lat_range, const GeoHashRange long_range,
+int geohashDecode(const GeoHashRange long_range, const GeoHashRange lat_range,
const GeoHashBits hash, GeoHashArea *area) {
uint8_t i;
@@ -121,10 +121,10 @@ int geohashDecode(const GeoHashRange lat_range, const GeoHashRange long_range,
}
area->hash = hash;
- area->latitude.min = lat_range.min;
- area->latitude.max = lat_range.max;
area->longitude.min = long_range.min;
area->longitude.max = long_range.max;
+ area->latitude.min = lat_range.min;
+ area->latitude.max = lat_range.max;
for (i = 0; i < hash.step; i++) {
uint8_t lat_bit, long_bit;
@@ -159,28 +159,22 @@ int geohashDecodeWGS84(const GeoHashBits hash, GeoHashArea *area) {
return geohashDecodeType(hash, area);
}
-int geohashDecodeAreaToLatLong(const GeoHashArea *area, double *latlong) {
- double y, x;
-
- if (!latlong) return 0;
-
- y = (area->latitude.min + area->latitude.max) / 2;
- x = (area->longitude.min + area->longitude.max) / 2;
-
- latlong[0] = y;
- latlong[1] = x;
+int geohashDecodeAreaToLongLat(const GeoHashArea *area, double *xy) {
+ if (!xy) return 0;
+ xy[0] = (area->longitude.min + area->longitude.max) / 2;
+ xy[1] = (area->latitude.min + area->latitude.max) / 2;
return 1;
}
-int geohashDecodeToLatLongType(const GeoHashBits hash, double *latlong) {
+int geohashDecodeToLongLatType(const GeoHashBits hash, double *xy) {
GeoHashArea area = { { 0 } };
- if (!latlong || !geohashDecodeType(hash, &area))
+ if (!xy || !geohashDecodeType(hash, &area))
return 0;
- return geohashDecodeAreaToLatLong(&area, latlong);
+ return geohashDecodeAreaToLongLat(&area, xy);
}
-int geohashDecodeToLatLongWGS84(const GeoHashBits hash, double *latlong) {
- return geohashDecodeToLatLongType(hash, latlong);
+int geohashDecodeToLongLatWGS84(const GeoHashBits hash, double *xy) {
+ return geohashDecodeToLongLatType(hash, xy);
}
static void geohash_move_x(GeoHashBits *hash, int8_t d) {
diff --git a/deps/geohash-int/geohash.h b/deps/geohash-int/geohash.h
index 78310715f..2bf1f5df8 100644
--- a/deps/geohash-int/geohash.h
+++ b/deps/geohash-int/geohash.h
@@ -62,14 +62,14 @@ typedef struct {
} GeoHashBits;
typedef struct {
- double max;
double min;
+ double max;
} GeoHashRange;
typedef struct {
GeoHashBits hash;
- GeoHashRange latitude;
GeoHashRange longitude;
+ GeoHashRange latitude;
} GeoHashArea;
typedef struct {
@@ -87,22 +87,22 @@ typedef struct {
* 0:success
* -1:failed
*/
-void geohashGetCoordRange(GeoHashRange *lat_range, GeoHashRange *long_range);
-int geohashEncode(GeoHashRange *lat_range, GeoHashRange *long_range,
- double latitude, double longitude, uint8_t step,
+void geohashGetCoordRange(GeoHashRange *long_range, GeoHashRange *lat_range);
+int geohashEncode(GeoHashRange *long_range, GeoHashRange *lat_range,
+ double longitude, double latitude, uint8_t step,
GeoHashBits *hash);
-int geohashEncodeType(double latitude, double longitude,
+int geohashEncodeType(double longitude, double latitude,
uint8_t step, GeoHashBits *hash);
-int geohashEncodeWGS84(double latitude, double longitude, uint8_t step,
+int geohashEncodeWGS84(double longitude, double latitude, uint8_t step,
GeoHashBits *hash);
-int geohashDecode(const GeoHashRange lat_range, const GeoHashRange long_range,
+int geohashDecode(const GeoHashRange long_range, const GeoHashRange lat_range,
const GeoHashBits hash, GeoHashArea *area);
int geohashDecodeType(const GeoHashBits hash, GeoHashArea *area);
int geohashDecodeWGS84(const GeoHashBits hash, GeoHashArea *area);
-int geohashDecodeAreaToLatLong(const GeoHashArea *area, double *latlong);
-int geohashDecodeToLatLongType(const GeoHashBits hash, double *latlong);
-int geohashDecodeToLatLongWGS84(const GeoHashBits hash, double *latlong);
-int geohashDecodeToLatLongMercator(const GeoHashBits hash, double *latlong);
+int geohashDecodeAreaToLongLat(const GeoHashArea *area, double *xy);
+int geohashDecodeToLongLatType(const GeoHashBits hash, double *xy);
+int geohashDecodeToLongLatWGS84(const GeoHashBits hash, double *xy);
+int geohashDecodeToLongLatMercator(const GeoHashBits hash, double *xy);
void geohashNeighbors(const GeoHashBits *hash, GeoHashNeighbors *neighbors);
#if defined(__cplusplus)
diff --git a/deps/geohash-int/geohash_helper.c b/deps/geohash-int/geohash_helper.c
index b6a00b7b5..729f010ea 100644
--- a/deps/geohash-int/geohash_helper.c
+++ b/deps/geohash-int/geohash_helper.c
@@ -80,13 +80,13 @@ int geohashBitsComparator(const GeoHashBits *a, const GeoHashBits *b) {
return a->step != b->step ? a->step - b->step : a->bits - b->bits;
}
-int geohashBoundingBox(double latitude, double longitude, double radius_meters,
+int geohashBoundingBox(double longitude, double latitude, double radius_meters,
double *bounds) {
if (!bounds) return 0;
- double latr, lonr;
- latr = deg_rad(latitude);
+ double lonr, latr;
lonr = deg_rad(longitude);
+ latr = deg_rad(latitude);
double distance = radius_meters / EARTH_RADIUS_IN_METERS;
double min_latitude = latr - distance;
@@ -98,37 +98,36 @@ int geohashBoundingBox(double latitude, double longitude, double radius_meters,
min_longitude = lonr - difference_longitude;
max_longitude = lonr + difference_longitude;
- bounds[0] = rad_deg(min_latitude);
- bounds[1] = rad_deg(min_longitude);
- bounds[2] = rad_deg(max_latitude);
- bounds[3] = rad_deg(max_longitude);
-
+ bounds[0] = rad_deg(min_longitude);
+ bounds[1] = rad_deg(min_latitude);
+ bounds[2] = rad_deg(max_longitude);
+ bounds[3] = rad_deg(max_latitude);
return 1;
}
-GeoHashRadius geohashGetAreasByRadius(double latitude, double longitude, double radius_meters) {
- GeoHashRange lat_range, long_range;
+GeoHashRadius geohashGetAreasByRadius(double longitude, double latitude, double radius_meters) {
+ GeoHashRange long_range, lat_range;
GeoHashRadius radius = { { 0 } };
GeoHashBits hash = { 0 };
GeoHashNeighbors neighbors = { { 0 } };
GeoHashArea area = { { 0 } };
- double min_lat, max_lat, min_lon, max_lon;
+ double min_lon, max_lon, min_lat, max_lat;
double bounds[4];
int steps;
- geohashBoundingBox(latitude, longitude, radius_meters, bounds);
- min_lat = bounds[0];
- min_lon = bounds[1];
- max_lat = bounds[2];
- max_lon = bounds[3];
+ geohashBoundingBox(longitude, latitude, radius_meters, bounds);
+ min_lon = bounds[0];
+ min_lat = bounds[1];
+ max_lon = bounds[2];
+ max_lat = bounds[3];
steps = geohashEstimateStepsByRadius(radius_meters,latitude);
- geohashGetCoordRange(&lat_range, &long_range);
- geohashEncode(&lat_range, &long_range, latitude, longitude, steps, &hash);
+ geohashGetCoordRange(&long_range, &lat_range);
+ geohashEncode(&long_range, &lat_range, longitude, latitude, steps, &hash);
geohashNeighbors(&hash, &neighbors);
- geohashGetCoordRange(&lat_range, &long_range);
- geohashDecode(lat_range, long_range, hash, &area);
+ geohashGetCoordRange(&long_range, &lat_range);
+ geohashDecode(long_range, lat_range, hash, &area);
if (area.latitude.min < min_lat) {
GZERO(neighbors.south);
@@ -156,9 +155,9 @@ GeoHashRadius geohashGetAreasByRadius(double latitude, double longitude, double
return radius;
}
-GeoHashRadius geohashGetAreasByRadiusWGS84(double latitude, double longitude,
+GeoHashRadius geohashGetAreasByRadiusWGS84(double longitude, double latitude,
double radius_meters) {
- return geohashGetAreasByRadius(latitude, longitude, radius_meters);
+ return geohashGetAreasByRadius(longitude, latitude, radius_meters);
}
GeoHashFix52Bits geohashAlign52Bits(const GeoHashBits hash) {
@@ -167,8 +166,8 @@ GeoHashFix52Bits geohashAlign52Bits(const GeoHashBits hash) {
return bits;
}
-/* calculate distance using haversin great circle distance formula */
-double distanceEarth(double lat1d, double lon1d, double lat2d, double lon2d) {
+/* Calculate distance using haversin great circle distance formula. */
+double distanceEarth(double lon1d, double lat1d, double lon2d, double lat2d) {
double lat1r, lon1r, lat2r, lon2r, u, v;
lat1r = deg_rad(lat1d);
lon1r = deg_rad(lon1d);
@@ -183,7 +182,7 @@ double distanceEarth(double lat1d, double lon1d, double lat2d, double lon2d) {
int geohashGetDistanceIfInRadius(double x1, double y1,
double x2, double y2, double radius,
double *distance) {
- *distance = distanceEarth(y1, x1, y2, x2);
+ *distance = distanceEarth(x1, y1, x2, y2);
if (*distance > radius) return 0;
return 1;
}
@@ -193,14 +192,3 @@ int geohashGetDistanceIfInRadiusWGS84(double x1, double y1, double x2,
double *distance) {
return geohashGetDistanceIfInRadius(x1, y1, x2, y2, radius, distance);
}
-
-int geohashVerifyCoordinates(double x, double y) {
- GeoHashRange lat_range, long_range;
- geohashGetCoordRange(&lat_range, &long_range);
-
- if (x < long_range.min || x > long_range.max || y < lat_range.min ||
- y > lat_range.max) {
- return 0;
- }
- return 1;
-}
diff --git a/deps/geohash-int/geohash_helper.h b/deps/geohash-int/geohash_helper.h
index 9354a3238..0e38740de 100644
--- a/deps/geohash-int/geohash_helper.h
+++ b/deps/geohash-int/geohash_helper.h
@@ -49,29 +49,20 @@ typedef struct {
int GeoHashBitsComparator(const GeoHashBits *a, const GeoHashBits *b);
uint8_t geohashEstimateStepsByRadius(double range_meters, double lat);
-int geohashBoundingBox(double latitude, double longitude, double radius_meters,
+int geohashBoundingBox(double longitude, double latitude, double radius_meters,
double *bounds);
-GeoHashRadius geohashGetAreasByRadius(double latitude,
- double longitude, double radius_meters);
-GeoHashRadius geohashGetAreasByRadiusWGS84(double latitude, double longitude,
+GeoHashRadius geohashGetAreasByRadius(double longitude,
+ double latitude, double radius_meters);
+GeoHashRadius geohashGetAreasByRadiusWGS84(double longitude, double latitude,
double radius_meters);
-GeoHashRadius geohashGetAreasByRadiusMercator(double latitude, double longitude,
+GeoHashRadius geohashGetAreasByRadiusMercator(double longitude, double latitude,
double radius_meters);
GeoHashFix52Bits geohashAlign52Bits(const GeoHashBits hash);
-double geohashGetXMercator(double longtitude);
-double geohashGetYMercator(double latitude);
-double geohashGetXWGS84(double x);
-double geohashGetYWGS84(double y);
-int geohashVerifyCoordinates(double x, double y);
int geohashGetDistanceIfInRadius(double x1, double y1,
double x2, double y2, double radius,
double *distance);
int geohashGetDistanceIfInRadiusWGS84(double x1, double y1, double x2,
double y2, double radius,
double *distance);
-int geohashGetDistanceSquaredIfInRadiusMercator(double x1, double y1,
- double x2, double y2,
- double radius,
- double *distance);
#endif /* GEOHASH_HELPER_HPP_ */
diff --git a/src/geo.c b/src/geo.c
index eb813473e..40d962f31 100644
--- a/src/geo.c
+++ b/src/geo.c
@@ -82,18 +82,18 @@ void geoArrayFree(geoArray *ga) {
/* ====================================================================
* Helpers
* ==================================================================== */
-static inline int decodeGeohash(double bits, double *latlong) {
+static inline int decodeGeohash(double bits, double *xy) {
GeoHashBits hash = { .bits = (uint64_t)bits, .step = GEO_STEP_MAX };
- return geohashDecodeToLatLongWGS84(hash, latlong);
+ return geohashDecodeToLongLatWGS84(hash, xy);
}
/* Input Argument Helper */
/* Take a pointer to the latitude arg then use the next arg for longitude.
* On parse error REDIS_ERR is returned, otherwise REDIS_OK. */
-static inline int extractLatLongOrReply(redisClient *c, robj **argv,
- double *latlong) {
+static inline int extractLongLatOrReply(redisClient *c, robj **argv,
+ double *xy) {
for (int i = 0; i < 2; i++) {
- if (getDoubleFromObjectOrReply(c, argv[i], latlong + i, NULL) !=
+ if (getDoubleFromObjectOrReply(c, argv[i], xy + i, NULL) !=
REDIS_OK) {
return REDIS_ERR;
}
@@ -104,11 +104,11 @@ static inline int extractLatLongOrReply(redisClient *c, robj **argv,
/* Input Argument Helper */
/* Decode lat/long from a zset member's score.
* Returns REDIS_OK on successful decoding, otherwise REDIS_ERR is returned. */
-static int latLongFromMember(robj *zobj, robj *member, double *latlong) {
+static int longLatFromMember(robj *zobj, robj *member, double *xy) {
double score = 0;
if (zsetScore(zobj, member, &score) == REDIS_ERR) return REDIS_ERR;
- if (!decodeGeohash(score, latlong)) return REDIS_ERR;
+ if (!decodeGeohash(score, xy)) return REDIS_ERR;
return REDIS_OK;
}
@@ -166,13 +166,13 @@ static inline void addReplyDoubleDistance(redisClient *c, double d) {
* only if the point is within the search area.
*
* returns REDIS_OK if the point is included, or REIDS_ERR if it is outside. */
-int geoAppendIfWithinRadius(geoArray *ga, double lat, double lon, double radius, double score, sds member) {
- double distance, latlong[2];
+int geoAppendIfWithinRadius(geoArray *ga, double lon, double lat, double radius, double score, sds member) {
+ double distance, xy[2];
- if (!decodeGeohash(score,latlong)) return REDIS_ERR; /* Can't decode. */
+ if (!decodeGeohash(score,xy)) return REDIS_ERR; /* Can't decode. */
/* Note that geohashGetDistanceIfInRadiusWGS84() takes arguments in
* reverse order: longitude first, latitude later. */
- if (!geohashGetDistanceIfInRadiusWGS84(lon,lat,latlong[1], latlong[0],
+ if (!geohashGetDistanceIfInRadiusWGS84(lon,lat, xy[0], xy[1],
radius, &distance))
{
return REDIS_ERR;
@@ -180,8 +180,8 @@ int geoAppendIfWithinRadius(geoArray *ga, double lat, double lon, double radius,
/* Append the new element. */
geoPoint *gp = geoArrayAppend(ga);
- gp->latitude = latlong[0];
- gp->longitude = latlong[1];
+ gp->longitude = xy[0];
+ gp->latitude = xy[1];
gp->dist = distance;
gp->member = member;
gp->score = score;
@@ -200,7 +200,7 @@ int geoAppendIfWithinRadius(geoArray *ga, double lat, double lon, double radius,
* using multiple queries to the sorted set, that we later need to sort
* via qsort. Similarly we need to be able to reject points outside the search
* radius area ASAP in order to allocate and process more points than needed. */
-int geoGetPointsInRange(robj *zobj, double min, double max, double lat, double lon, double radius, geoArray *ga) {
+int geoGetPointsInRange(robj *zobj, double min, double max, double lon, double lat, double radius, geoArray *ga) {
/* minex 0 = include min in range; maxex 1 = exclude max in range */
/* That's: min <= val < max */
zrangespec range = { .min = min, .max = max, .minex = 0, .maxex = 1 };
@@ -232,7 +232,7 @@ int geoGetPointsInRange(robj *zobj, double min, double max, double lat, double l
ziplistGet(eptr, &vstr, &vlen, &vlong);
member = (vstr == NULL) ? sdsfromlonglong(vlong) :
sdsnewlen(vstr,vlen);
- if (geoAppendIfWithinRadius(ga,lat,lon,radius,score,member)
+ if (geoAppendIfWithinRadius(ga,lon,lat,radius,score,member)
== REDIS_ERR) sdsfree(member);
zzlNext(zl, &eptr, &sptr);
}
@@ -255,7 +255,7 @@ int geoGetPointsInRange(robj *zobj, double min, double max, double lat, double l
member = (o->encoding == REDIS_ENCODING_INT) ?
sdsfromlonglong((long)o->ptr) :
sdsdup(o->ptr);
- if (geoAppendIfWithinRadius(ga,lat,lon,radius,ln->score,member)
+ if (geoAppendIfWithinRadius(ga,lon,lat,radius,ln->score,member)
== REDIS_ERR) sdsfree(member);
ln = ln->level[0].forward;
}
@@ -266,7 +266,7 @@ int geoGetPointsInRange(robj *zobj, double min, double max, double lat, double l
/* Obtain all members between the min/max of this geohash bounding box.
* Populate a geoArray of GeoPoints by calling geoGetPointsInRange().
* Return the number of points added to the array. */
-int membersOfGeoHashBox(robj *zobj, GeoHashBits hash, geoArray *ga, double lat, double lon, double radius) {
+int membersOfGeoHashBox(robj *zobj, GeoHashBits hash, geoArray *ga, double lon, double lat, double radius) {
GeoHashFix52Bits min, max;
/* We want to compute the sorted set scores that will include all the
@@ -293,11 +293,11 @@ int membersOfGeoHashBox(robj *zobj, GeoHashBits hash, geoArray *ga, double lat,
hash.bits++;
max = geohashAlign52Bits(hash);
- return geoGetPointsInRange(zobj, min, max, lat, lon, radius, ga);
+ return geoGetPointsInRange(zobj, min, max, lon, lat, radius, ga);
}
/* Search all eight neighbors + self geohash box */
-int membersOfAllNeighbors(robj *zobj, GeoHashRadius n, double lat, double lon, double radius, geoArray *ga) {
+int membersOfAllNeighbors(robj *zobj, GeoHashRadius n, double lon, double lat, double radius, geoArray *ga) {
GeoHashBits neighbors[9];
unsigned int i, count = 0;
@@ -316,7 +316,7 @@ int membersOfAllNeighbors(robj *zobj, GeoHashRadius n, double lat, double lon, d
for (i = 0; i < sizeof(neighbors) / sizeof(*neighbors); i++) {
if (HASHISZERO(neighbors[i]))
continue;
- count += membersOfGeoHashBox(zobj, neighbors[i], ga, lat, lon, radius);
+ count += membersOfGeoHashBox(zobj, neighbors[i], ga, lon, lat, radius);
}
return count;
}
@@ -342,9 +342,9 @@ static int sort_gp_desc(const void *a, const void *b) {
* Commands
* ==================================================================== */
void geoAddCommand(redisClient *c) {
- /* args 0-4: [cmd, key, lat, lng, val]; optional 5-6: [radius, units]
+ /* args 0-4: [cmd, key, lng, lat, val]; optional 5-6: [radius, units]
* - OR -
- * args 0-N: [cmd, key, lat, lng, val, lat2, lng2, val2, ...] */
+ * args 0-N: [cmd, key, lng, lat, val, lng2, lat2, val2, ...] */
/* Prepare for the three different forms of the add command. */
double radius_meters = 0;
@@ -358,8 +358,8 @@ void geoAddCommand(redisClient *c) {
return;
} else if ((c->argc - 2) % 3 != 0) {
/* Need an odd number of arguments if we got this far... */
- addReplyError(c, "format is: geoadd [key] [lat1] [long1] [member1] "
- "[lat2] [long2] [member2] ... ");
+ addReplyError(c, "format is: geoadd [key] [x1] [y1] [member1] "
+ "[x2] [y2] [member2] ... ");
return;
}
@@ -376,9 +376,9 @@ void geoAddCommand(redisClient *c) {
uint8_t step = geohashEstimateStepsByRadius(radius_meters,0);
int i;
for (i = 0; i < elements; i++) {
- double latlong[elements * 2];
+ double xy[2];
- if (extractLatLongOrReply(c, (c->argv+2)+(i*3),latlong) == REDIS_ERR) {
+ if (extractLongLatOrReply(c, (c->argv+2)+(i*3),xy) == REDIS_ERR) {
for (i = 0; i < argc; i++)
if (argv[i]) decrRefCount(argv[i]);
zfree(argv);
@@ -391,10 +391,7 @@ void geoAddCommand(redisClient *c) {
/* Turn the coordinates into the score of the element. */
GeoHashBits hash;
- double latitude = latlong[0];
- double longitude = latlong[1];
- geohashEncodeWGS84(latitude, longitude, step, &hash);
-
+ geohashEncodeWGS84(xy[0], xy[1], step, &hash);
GeoHashFix52Bits bits = geohashAlign52Bits(hash);
robj *score = createObject(REDIS_STRING, sdsfromlonglong(bits));
robj *val = c->argv[2 + i * 3 + 2];
@@ -416,7 +413,7 @@ void geoAddCommand(redisClient *c) {
#define RADIUS_MEMBER 2
static void geoRadiusGeneric(redisClient *c, int type) {
- /* type == cords: [cmd, key, lat, long, radius, units, [optionals]]
+ /* type == cords: [cmd, key, long, lat, radius, units, [optionals]]
* type == member: [cmd, key, member, radius, units, [optionals]] */
robj *key = c->argv[1];
@@ -427,17 +424,17 @@ static void geoRadiusGeneric(redisClient *c, int type) {
return;
}
- /* Find lat/long to use for radius search based on inquiry type */
+ /* Find long/lat to use for radius search based on inquiry type */
int base_args;
- double latlong[2] = { 0 };
+ double xy[2] = { 0 };
if (type == RADIUS_COORDS) {
base_args = 6;
- if (extractLatLongOrReply(c, c->argv + 2, latlong) == REDIS_ERR)
+ if (extractLongLatOrReply(c, c->argv + 2, xy) == REDIS_ERR)
return;
} else if (type == RADIUS_MEMBER) {
base_args = 5;
robj *member = c->argv[2];
- if (latLongFromMember(zobj, member, latlong) == REDIS_ERR) {
+ if (longLatFromMember(zobj, member, xy) == REDIS_ERR) {
addReplyError(c, "could not decode requested zset member");
return;
}
@@ -483,7 +480,7 @@ static void geoRadiusGeneric(redisClient *c, int type) {
/* Get all neighbor geohash boxes for our radius search */
GeoHashRadius georadius =
- geohashGetAreasByRadiusWGS84(latlong[0], latlong[1], radius_meters);
+ geohashGetAreasByRadiusWGS84(xy[0], xy[1], radius_meters);
#ifdef DEBUG
printf("Searching with step size: %d\n", georadius.hash.step);
@@ -491,7 +488,7 @@ static void geoRadiusGeneric(redisClient *c, int type) {
/* Search the zset for all matching points */
geoArray *ga = geoArrayCreate();
- membersOfAllNeighbors(zobj, georadius, latlong[0], latlong[1], radius_meters, ga);
+ membersOfAllNeighbors(zobj, georadius, xy[0], xy[1], radius_meters, ga);
/* If no matching results, the user gets an empty reply. */
if (ga->used == 0) {
@@ -549,15 +546,15 @@ static void geoRadiusGeneric(redisClient *c, int type) {
if (withcoords) {
addReplyMultiBulkLen(c, 2);
- addReplyDouble(c, gp->latitude);
addReplyDouble(c, gp->longitude);
+ addReplyDouble(c, gp->latitude);
}
}
geoArrayFree(ga);
}
void geoRadiusCommand(redisClient *c) {
- /* args 0-5: ["georadius", key, lat, long, radius, units];
+ /* args 0-5: ["georadius", key, long, lat, radius, units];
* optionals: [withdist, withcoords, asc|desc] */
geoRadiusGeneric(c, RADIUS_COORDS);
}
@@ -578,30 +575,30 @@ void geoDecodeCommand(redisClient *c) {
geohash.step = GEO_STEP_MAX;
geohashDecodeWGS84(geohash, &area);
- double lat = (area.latitude.min + area.latitude.max) / 2;
double lon = (area.longitude.min + area.longitude.max) / 2;
+ double lat = (area.latitude.min + area.latitude.max) / 2;
/* Returning three nested replies */
addReplyMultiBulkLen(c, 3);
/* First, the minimum corner */
addReplyMultiBulkLen(c, 2);
- addReplyDouble(c, area.latitude.min);
addReplyDouble(c, area.longitude.min);
+ addReplyDouble(c, area.latitude.min);
/* Next, the maximum corner */
addReplyMultiBulkLen(c, 2);
- addReplyDouble(c, area.latitude.max);
addReplyDouble(c, area.longitude.max);
+ addReplyDouble(c, area.latitude.max);
/* Last, the averaged center of this bounding box */
addReplyMultiBulkLen(c, 2);
- addReplyDouble(c, lat);
addReplyDouble(c, lon);
+ addReplyDouble(c, lat);
}
void geoEncodeCommand(redisClient *c) {
- /* args 0-2: ["geoencode", lat, long];
+ /* args 0-2: ["geoencode", long, lat];
* optionals: [radius, units] */
double radius_meters = 0;
@@ -613,13 +610,13 @@ void geoEncodeCommand(redisClient *c) {
return;
}
- double latlong[2];
- if (extractLatLongOrReply(c, c->argv + 1, latlong) == REDIS_ERR) return;
+ double xy[2];
+ if (extractLongLatOrReply(c, c->argv + 1, xy) == REDIS_ERR) return;
/* Encode lat/long into our geohash */
GeoHashBits geohash;
uint8_t step = geohashEstimateStepsByRadius(radius_meters,0);
- geohashEncodeWGS84(latlong[0], latlong[1], step, &geohash);
+ geohashEncodeWGS84(xy[0], xy[1], step, &geohash);
/* Align the hash to a valid 52-bit integer based on step size */
GeoHashFix52Bits bits = geohashAlign52Bits(geohash);
@@ -631,8 +628,8 @@ void geoEncodeCommand(redisClient *c) {
GeoHashArea area;
geohashDecodeWGS84(geohash, &area);
- double lat = (area.latitude.min + area.latitude.max) / 2;
double lon = (area.longitude.min + area.longitude.max) / 2;
+ double lat = (area.latitude.min + area.latitude.max) / 2;
/* Return four nested multibulk replies. */
addReplyMultiBulkLen(c, 4);
@@ -642,18 +639,18 @@ void geoEncodeCommand(redisClient *c) {
/* Return the minimum corner */
addReplyMultiBulkLen(c, 2);
- addReplyDouble(c, area.latitude.min);
addReplyDouble(c, area.longitude.min);
+ addReplyDouble(c, area.latitude.min);
/* Return the maximum corner */
addReplyMultiBulkLen(c, 2);
- addReplyDouble(c, area.latitude.max);
addReplyDouble(c, area.longitude.max);
+ addReplyDouble(c, area.latitude.max);
/* Return the averaged center */
addReplyMultiBulkLen(c, 2);
- addReplyDouble(c, lat);
addReplyDouble(c, lon);
+ addReplyDouble(c, lat);
}
/* GEOHASH key ele1 ele2 ... eleN
@@ -684,8 +681,8 @@ void geoHashCommand(redisClient *c) {
* standard ranges in order to output a valid geohash string. */
/* Decode... */
- double latlong[2];
- if (!decodeGeohash(score,latlong)) {
+ double xy[2];
+ if (!decodeGeohash(score,xy)) {
addReply(c,shared.nullbulk);
continue;
}
@@ -693,11 +690,11 @@ void geoHashCommand(redisClient *c) {
/* Re-encode */
GeoHashRange r[2];
GeoHashBits hash;
- r[0].min = -90;
- r[0].max = 90;
- r[1].min = -180;
- r[1].max = 180;
- geohashEncode(&r[0],&r[1],latlong[0],latlong[1],26,&hash);
+ r[0].min = -180;
+ r[0].max = 180;
+ r[1].min = -90;
+ r[1].max = 90;
+ geohashEncode(&r[0],&r[1],xy[0],xy[1],26,&hash);
char buf[12];
int i;
diff --git a/src/geo.h b/src/geo.h
index 9cd1f56b4..4f5c5e6fe 100644
--- a/src/geo.h
+++ b/src/geo.h
@@ -12,8 +12,8 @@ void geoAddCommand(redisClient *c);
/* Structures used inside geo.c in order to represent points and array of
* points on the earth. */
typedef struct geoPoint {
- double latitude;
double longitude;
+ double latitude;
double dist;
double score;
char *member;
diff --git a/tests/unit/geo.tcl b/tests/unit/geo.tcl
index eedc40c96..a049804ae 100644
--- a/tests/unit/geo.tcl
+++ b/tests/unit/geo.tcl
@@ -2,46 +2,46 @@
# verify the Redis implementation with a fuzzy test.
proc geo_degrad deg {expr {$deg*atan(1)*8/360}}
-proc geo_distance {lat1d lon1d lat2d lon2d} {
- set lat1r [geo_degrad $lat1d]
+proc geo_distance {lon1d lat1d lon2d lat2d} {
set lon1r [geo_degrad $lon1d]
- set lat2r [geo_degrad $lat2d]
+ set lat1r [geo_degrad $lat1d]
set lon2r [geo_degrad $lon2d]
- set u [expr {sin(($lat2r - $lat1r) / 2)}]
+ set lat2r [geo_degrad $lat2d]
set v [expr {sin(($lon2r - $lon1r) / 2)}]
+ set u [expr {sin(($lat2r - $lat1r) / 2)}]
expr {2.0 * 6372797.560856 * \
asin(sqrt($u * $u + cos($lat1r) * cos($lat2r) * $v * $v))}
}
-proc geo_random_point {latvar lonvar} {
- upvar 1 $latvar lat
+proc geo_random_point {lonvar latvar} {
upvar 1 $lonvar lon
+ upvar 1 $latvar lat
# Note that the actual latitude limit should be -85 to +85, we restrict
# the test to -70 to +70 since in this range the algorithm is more precise
# while outside this range occasionally some element may be missing.
- set lat [expr {-70 + rand()*140}]
set lon [expr {-180 + rand()*360}]
+ set lat [expr {-70 + rand()*140}]
}
start_server {tags {"geo"}} {
test {GEOADD create} {
- r geoadd nyc 40.747533 -73.9454966 "lic market"
+ r geoadd nyc -73.9454966 40.747533 "lic market"
} {1}
test {GEOADD update} {
- r geoadd nyc 40.747533 -73.9454966 "lic market"
+ r geoadd nyc -73.9454966 40.747533 "lic market"
} {0}
test {GEOADD invalid coordinates} {
catch {
- r geoadd nyc 40.747533 -73.9454966 "lic market" \
+ r geoadd nyc -73.9454966 40.747533 "lic market" \
foo bar "luck market"
} err
set err
} {*valid*}
test {GEOADD multi add} {
- r geoadd nyc 40.7648057 -73.9733487 "central park n/q/r" 40.7362513 -73.9903085 "union square" 40.7126674 -74.0131604 "wtc one" 40.6428986 -73.7858139 "jfk" 40.7498929 -73.9375699 "q4" 40.7480973 -73.9564142 4545
+ r geoadd nyc -73.9733487 40.7648057 "central park n/q/r" -73.9903085 40.7362513 "union square" -74.0131604 40.7126674 "wtc one" -73.7858139 40.6428986 "jfk" -73.9375699 40.7498929 "q4" -73.9564142 40.7480973 4545
} {6}
test {Check geoset values} {
@@ -49,11 +49,11 @@ start_server {tags {"geo"}} {
} {{wtc one} 1791873972053020 {union square} 1791875485187452 {central park n/q/r} 1791875761332224 4545 1791875796750882 {lic market} 1791875804419201 q4 1791875830079666 jfk 1791895905559723}
test {GEORADIUS simple (sorted)} {
- r georadius nyc 40.7598464 -73.9798091 3 km ascending
+ r georadius nyc -73.9798091 40.7598464 3 km ascending
} {{central park n/q/r} 4545 {union square}}
test {GEORADIUS withdistance (sorted)} {
- r georadius nyc 40.7598464 -73.9798091 3 km withdistance ascending
+ r georadius nyc -73.9798091 40.7598464 3 km withdistance ascending
} {{{central park n/q/r} 0.7750} {4545 2.3651} {{union square} 2.7697}}
test {GEORADIUSBYMEMBER simple (sorted)} {
@@ -65,21 +65,21 @@ start_server {tags {"geo"}} {
} {{{wtc one} 0.0000} {{union square} 3.2544} {{central park n/q/r} 6.7000} {4545 6.1975} {{lic market} 6.8969}}
test {GEOENCODE simple} {
- r geoencode 41.2358883 1.8063239
- } {3471579339700058 {41.235888125243704 1.8063229322433472}\
- {41.235890659964866 1.806328296661377}\
- {41.235889392604285 1.8063256144523621}}
+ r geoencode 1.8063239 41.2358883
+ } {3471579339700058 {1.8063229322433472 41.235888125243704}\
+ {1.806328296661377 41.235890659964866}\
+ {1.8063256144523621 41.235889392604285}}
test {GEODECODE simple} {
r geodecode 3471579339700058
- } {{41.235888125243704 1.8063229322433472}\
- {41.235890659964866 1.806328296661377}\
- {41.235889392604285 1.8063256144523621}}
+ } {{1.8063229322433472 41.235888125243704}\
+ {1.806328296661377 41.235890659964866}\
+ {1.8063256144523621 41.235889392604285}}
test {GEOHASH is able to return geohash strings} {
# Example from Wikipedia.
r del points
- r geoadd points 42.6 -5.6 test
+ r geoadd points -5.6 42.6 test
lindex [r geohash points test] 0
} {ezs42e44yx0}
@@ -93,20 +93,20 @@ start_server {tags {"geo"}} {
r del mypoints
set radius_km [expr {[randomInt 200]+10}]
set radius_m [expr {$radius_km*1000}]
- geo_random_point search_lat search_lon
- lappend debuginfo "Search area: $search_lat,$search_lon $radius_km km"
+ geo_random_point search_lon search_lat
+ lappend debuginfo "Search area: $search_lon,$search_lat $radius_km km"
set tcl_result {}
set argv {}
for {set j 0} {$j < 20000} {incr j} {
- geo_random_point lat lon
- lappend argv $lat $lon "place:$j"
- if {[geo_distance $lat $lon $search_lat $search_lon] < $radius_m} {
+ geo_random_point lon lat
+ lappend argv $lon $lat "place:$j"
+ if {[geo_distance $lon $lat $search_lon $search_lat] < $radius_m} {
lappend tcl_result "place:$j"
- lappend debuginfo "place:$j $lat $lon [expr {[geo_distance $lat $lon $search_lat $search_lon]/1000}] km"
+ lappend debuginfo "place:$j $lon $lat [expr {[geo_distance $lon $lat $search_lon $search_lat]/1000}] km"
}
}
r geoadd mypoints {*}$argv
- set res [lsort [r georadius mypoints $search_lat $search_lon $radius_km km]]
+ set res [lsort [r georadius mypoints $search_lon $search_lat $radius_km km]]
set res2 [lsort $tcl_result]
set test_result OK
if {$res != $res2} {