Refactored new geohash functions

Author: Lezh1k

C/include/Geohash.h

@@ -5,7 +5,7 @@
 
 static const int GEOHASH_MAX_PRECISION = 12;
 
-uint64_t GeohashEncodeU64(double lat, double lon);
+uint64_t GeohashEncodeU64(double lat, double lon, int prec);
 int GeohashComparePointsU64(double lon1, double lat1, double lon2, double lat2, int precision);
 
 void GeohashDecode(const char* str,

C/src/Coordinates.cpp

@@ -51,9 +51,7 @@ CoordFilterByGeoHash(std::vector<geopoint_t> &lstSrc,
 
   int idx = 0;
   for (auto ci = lstSrc.begin(); ci != lstSrc.end(); ++ci) {
-    uint64_t gh = GeohashEncodeU64(ci->Latitude, ci->Longitude);
-    gh >>= precision*5 + 4;
-
+    uint64_t gh = GeohashEncodeU64(ci->Latitude, ci->Longitude, precision);
     dctIter it = dctHashCount.find(gh);
     if (it == dctHashCount.end()) {
       AuxItem ni;

C/src/Geohash.cpp

@@ -28,7 +28,7 @@ static uint64_t interleave(uint64_t x, uint64_t y) {
 }
 ///////////////////////////////////////////////////////
 
-uint64_t GeohashEncodeU64(double lat, double lon) {
+uint64_t GeohashEncodeU64(double lat, double lon, int prec) {
   lat = lat/180.0 + 1.5;
   lon = lon/360.0 + 1.5;
   uint64_t ilat = *((uint64_t*)&lat);
@@ -37,17 +37,14 @@ uint64_t GeohashEncodeU64(double lat, double lon) {
   ilon >>= 20;
   ilat &= 0x00000000ffffffff;
   ilon &= 0x00000000ffffffff;
-
-  return interleave(ilat, ilon);
+  return interleave(ilat, ilon) >> (GEOHASH_MAX_PRECISION-prec)*5;
 }
 
 int GeohashComparePointsU64(double lon1, double lat1,
                             double lon2, double lat2,
                             int precision) {
   assert(precision >= 1 && precision <= GEOHASH_MAX_PRECISION);
-  uint64_t gh1 = GeohashEncodeU64(lat1, lon1);
-  uint64_t gh2 = GeohashEncodeU64(lat2, lon2);
-  gh1 >>= precision*5 + 4;
-  gh2 >>= precision*5 + 4;
+  uint64_t gh1 = GeohashEncodeU64(lat1, lon1, precision);
+  uint64_t gh2 = GeohashEncodeU64(lat2, lon2, precision);
   return gh1 - gh2;
 }

C/src/mainwindow.cpp

@@ -117,15 +117,13 @@ static double filterDistanceRealTime(const std::vector<geopoint_t> &lst,
 
   laGeo.Latitude = laGeo.Longitude = COORD_NOT_INITIALIZED;
 
-  *tgh0 = GeohashEncodeU64(pi->Latitude, pi->Longitude);
+  *tgh0 = GeohashEncodeU64(pi->Latitude, pi->Longitude, prec);
   tmpGeo.Latitude = pi->Latitude;
   tmpGeo.Longitude = pi->Longitude;
   count = 1;
 
-  *tgh >>= prec*5 + 4;
   for (++pi; pi != lst.end(); ++pi) {
-     *tgh = GeohashEncodeU64(pi->Latitude, pi->Longitude);
-     *tgh >>= prec*5 + 4;
+     *tgh = GeohashEncodeU64(pi->Latitude, pi->Longitude, prec);
 
     //if (ppCompGeohash != ppReadGeohash)
     if (*tgh - *tgh0) {

C/tests/src/GeohashTest.cpp

@@ -20,16 +20,16 @@ typedef struct TestEncodeItem {
   const char *expected;
 } TestEncodeItem_t;
 
-static const char *geohash_str(uint64_t geohash, int8_t prec) ;
+static const char *geohash_str(uint64_t geohash) ;
 
 static void tesnEncodeU64() {
   double lat = 27.988056;
   double lon = 86.925278;
   uint64_t exp = 0xceb7f254240fd612;
-  uint64_t act = GeohashEncodeU64(lat, lon);
+  uint64_t act = GeohashEncodeU64(lat, lon, GEOHASH_MAX_PRECISION);
   assert(exp == act);  
   //tuvz4p141zc1
-  std::cout << geohash_str(act, GEOHASH_MAX_PRECISION) << std::endl;  
+  std::cout << geohash_str(act) << std::endl;
 }
 ///////////////////////////////////////////////////////
 
@@ -39,15 +39,13 @@ static const char base32Table[BASE32_COUNT] = {'0', '1', '2', '3', '4', '5', '6'
                                                'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r',
                                                's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
 
-const char *geohash_str(uint64_t geohash, int8_t prec) {
+const char *geohash_str(uint64_t geohash) {
   static char buff[GEOHASH_MAX_PRECISION+1] = {0};
-  char *str = buff + prec + 1;
-  int idx;
+  char *str = buff + GEOHASH_MAX_PRECISION + 1;
   *str = 0;
-  geohash >>= ((GEOHASH_MAX_PRECISION-prec) * 5) + 4; //cause we don't need last 4 bits
-  while (prec--){
-    idx = geohash & 0x1f;
-    *--str = base32Table[idx];
+  geohash >>= 4; //cause we don't need last 4 bits. that's strange, I thought we don't need first 4 bits %)
+  while (geohash){
+    *--str = base32Table[geohash & 0x1f];
     geohash >>= 5;
   }
   return str;
@@ -86,14 +84,14 @@ static void testEncode() {
   TestEncodeItem_t *tmp;
 
   for (tmp = posTests; tmp->expected; ++tmp) {
-    uint64_t geohash = GeohashEncodeU64(tmp->lat, tmp->lon);
-    const char *geostr = geohash_str(geohash, tmp->precision);
+    uint64_t geohash = GeohashEncodeU64(tmp->lat, tmp->lon, tmp->precision);
+    const char *geostr = geohash_str(geohash);
     assert(strcmp(geostr, tmp->expected) == 0);
   }
 
   for (tmp = negTests; tmp->expected; ++tmp) {
-    uint64_t geohash = GeohashEncodeU64(tmp->lat, tmp->lon);
-    const char *geostr = geohash_str(geohash, tmp->precision);
+    uint64_t geohash = GeohashEncodeU64(tmp->lat, tmp->lon, tmp->precision);
+    const char *geostr = geohash_str(geohash);
     assert(strcmp(geostr, tmp->expected) != 0);
   }
 }