Merge pull request #4 from flitsmeister/feature/GEOHASH_hashes_for_region

MaartenZonneveld · web-flow · commit ba643ebd93ca · 2025-05-05T15:41:37.000+02:00
Geohashes for region in C
diff --git a/Sources/FlitsGeohashC/flitsgeohash.c b/Sources/FlitsGeohashC/flitsgeohash.c
@@ -6,6 +6,7 @@
 #include <stdbool.h>
 
 #define MAX_HASH_LENGTH 22
+#define MAX_ITERATIONS 100000
 
 #define SET_BIT(bits, mid, range, val, bit) \
     mid = (range->min + range->max) / 2.0; \
@@ -122,7 +123,7 @@
 char*
 GEOHASH_get_adjacent(const char* hash, GEOHASH_direction dir)
 {
-    int len, idx;
+    size_t len, idx;
     const char *border_table, *neighbor_table;
     char *base, *refined_base, *ptr, last;
 
@@ -161,3 +162,122 @@
     base[len] = BASE32_ENCODE_TABLE[idx];
     return base;
 }
+
+void add_hash(GeohashArray* array, char* hash) {
+    if (array->count >= array->capacity) {
+        int new_capacity = array->capacity * 2;
+        char** new_hashes = realloc(array->hashes, new_capacity * sizeof(char*));
+        if (!new_hashes) {
+            // Allocation failed
+            GEOHASH_free_array(array);
+            free(hash);
+            exit(EXIT_FAILURE);
+        }
+        array->hashes = new_hashes;
+        array->capacity = new_capacity;
+    }
+    array->hashes[array->count++] = hash;
+}
+
+int geohash_equals(const char* a, const char* b) {
+    return strcmp(a, b) == 0;
+}
+
+char* GEOHASH_clone(const char* hash) {
+    if (!hash) {
+        exit(EXIT_FAILURE);
+        return NULL;
+    }
+    
+    char* clone = strdup(hash);
+    if (!clone) {
+        exit(EXIT_FAILURE);
+        return NULL;
+    }
+    return clone;
+}
+
+GeohashArray
+GEOHASH_hashes_for_region(double centerLat, double centerLon, double latDelta, double lonDelta, unsigned int len) {
+    
+    double north = centerLat + latDelta / 2.0;
+    double south = centerLat - latDelta / 2.0;
+    double west  = centerLon - lonDelta / 2.0;
+    double east  = centerLon + lonDelta / 2.0;
+    
+    char* nw = GEOHASH_encode(north, west, len);
+    char* ne = GEOHASH_encode(north, east, len);
+    char* se = GEOHASH_encode(south, east, len);
+    
+    char* current = GEOHASH_clone(nw);
+    char* eastLimit = GEOHASH_clone(ne);
+    char* westStart = GEOHASH_clone(nw);
+    
+    GeohashArray result = {
+        .hashes = malloc(128 * sizeof(char*)),
+        .count = 0,
+        .capacity = 128
+    };
+    if (!result.hashes) {
+        // Allocation failed
+        exit(EXIT_FAILURE);
+    }
+    
+    add_hash(&result, GEOHASH_clone(current));
+    
+    int maxIterations = MAX_ITERATIONS; // Prevent infinite loops
+    while (!geohash_equals(current, se) && maxIterations-- > 0) {
+        if (geohash_equals(nw, ne)) {
+            // Single column case
+            char* nextSouth = GEOHASH_get_adjacent(westStart, GEOHASH_SOUTH);
+            free(westStart);
+            westStart = nextSouth;
+            free(current);
+            current = GEOHASH_clone(westStart);
+            add_hash(&result, GEOHASH_clone(current));
+            continue;
+        }
+        
+        // Move east
+        char* next = GEOHASH_get_adjacent(current, GEOHASH_EAST);
+        free(current);
+        current = next;
+        add_hash(&result, GEOHASH_clone(current));
+
+        if (geohash_equals(current, eastLimit) && !geohash_equals(current, se)) {
+            char* tmp;
+            
+            tmp = GEOHASH_get_adjacent(eastLimit, GEOHASH_SOUTH);
+            free(eastLimit);
+            eastLimit = tmp;
+            
+            tmp = GEOHASH_get_adjacent(westStart, GEOHASH_SOUTH);
+            free(westStart);
+            westStart = tmp;
+            
+            free(current);
+            current = GEOHASH_clone(westStart);
+            add_hash(&result, GEOHASH_clone(current));
+        }
+    }
+    
+    // Cleanup
+    free(nw);
+    free(ne);
+    free(se);
+    free(current);
+    free(eastLimit);
+    free(westStart);
+    
+    return result;
+}
+
+void GEOHASH_free_array(GeohashArray* array) {
+    for (int i = 0; i < array->count; i++) {
+        free(array->hashes[i]);
+    }
+    free(array->hashes);
+    array->hashes = NULL;
+    array->count = 0;
+    array->capacity = 0;
+}
diff --git a/Sources/FlitsGeohashC/include/flitsgeohash.h b/Sources/FlitsGeohashC/include/flitsgeohash.h
@@ -22,8 +22,17 @@ typedef struct {
     char* south_west;
 } GEOHASH_neighbors;
 
+typedef struct {
+    char** hashes;
+    int count;
+    int capacity;
+} GeohashArray;
+
 char* GEOHASH_encode(double latitude, double longitude, unsigned int hash_length);
 GEOHASH_neighbors* GEOHASH_get_neighbors(const char *hash);
 void GEOHASH_free_neighbors(GEOHASH_neighbors *neighbors);
 
 char* GEOHASH_get_adjacent(const char* hash, GEOHASH_direction dir);
+
+GeohashArray GEOHASH_hashes_for_region(double centerLatitude, double centerLongitude, double latitudeDelta, double longitudeDelta, unsigned int len);
+void GEOHASH_free_array(GeohashArray* array);
diff --git a/Sources/FlitsGeohashSwift/GeoHash.swift b/Sources/FlitsGeohashSwift/GeoHash.swift
@@ -20,18 +20,6 @@ public enum Geohash {
         }
     }
 
-    public struct Region: Sendable {
-        public let center: CLLocationCoordinate2D
-        public let latitudeDelta: CLLocationDegrees
-        public let longitudeDelta: CLLocationDegrees
-        
-        public init(center: CLLocationCoordinate2D, latitudeDelta: CLLocationDegrees, longitudeDelta: CLLocationDegrees) {
-            self.center = center
-            self.latitudeDelta = latitudeDelta
-            self.longitudeDelta = longitudeDelta
-        }
-    }
-
     public struct Neighbors: Hashable, Sendable {
         public let north: String
         public let south: String
@@ -96,6 +84,21 @@ public enum Geohash {
         GEOHASH_free_neighbors(pointer)
         return neighbors
     }
+    
+    public static func hashesForRegion(
+        centerCoordinate: CLLocationCoordinate2D,
+        latitudeDelta: CLLocationDegrees,
+        longitudeDelta: CLLocationDegrees,
+        length: UInt32
+    ) -> [String] {
+        var cArray = GEOHASH_hashes_for_region(centerCoordinate.latitude, centerCoordinate.longitude, latitudeDelta, longitudeDelta, length)
+        let buffer = UnsafeBufferPointer(start: cArray.hashes, count: Int(cArray.count))
+        let result = buffer.compactMap {
+            string(from: $0!)
+        }
+        GEOHASH_free_array(&cArray)
+        return result
+    }
 }
 
 extension Geohash {
diff --git a/Sources/FlitsGeohashSwift/LengthedGeohash.swift b/Sources/FlitsGeohashSwift/LengthedGeohash.swift
@@ -83,58 +83,6 @@ public struct LengthedGeohash<Length: GeohashLengthed>: Hashable, Sendable {
         )
     }
     
-    public static func hashes(for region: Geohash.Region) -> Set<Self> {
-        let northWest = CLLocationCoordinate2D(
-            latitude: region.center.latitude + region.latitudeDelta / 2,
-            longitude: region.center.longitude - region.longitudeDelta / 2
-        )
-        let northEast = CLLocationCoordinate2D(
-            latitude: region.center.latitude + region.latitudeDelta / 2,
-            longitude: region.center.longitude + region.longitudeDelta / 2
-        )
-        let southEast = CLLocationCoordinate2D(
-            latitude: region.center.latitude - region.latitudeDelta / 2,
-            longitude: region.center.longitude + region.longitudeDelta / 2
-        )
-        
-        let hashNorthWest = Self.init(northWest)
-        let hashNorthEast = Self.init(northEast)
-        let hashSouthEast = Self.init(southEast)
-        
-        var currentHash = hashNorthWest
-        var mostEastHash = hashNorthEast
-        var mostWestHash = hashNorthWest
-        
-        var hashes: Set<Self> = [currentHash]
-        while currentHash != hashSouthEast {
-            
-            guard hashNorthEast != hashNorthWest else {
-                // Our region fits inside a single geohash (width)
-                // This will produce 1 or more rows of a single column
-                // Only look in the southern direction, if you start looking east you will immediately go past the mostEastHash
-                // Immediately move to the next row until we find the hashSouthEast
-                mostEastHash = mostEastHash.adjacent(direction: .south)
-                mostWestHash = mostWestHash.adjacent(direction: .south)
-                currentHash = mostWestHash
-                hashes.insert(currentHash)
-                continue
-            }
-            
-            // Look for the next column by moving east
-            currentHash = currentHash.adjacent(direction: .east)
-            hashes.insert(currentHash)
-            
-            if currentHash == mostEastHash && currentHash != hashSouthEast {
-                // We are now at the most east row. Start again with a new row.
-                mostEastHash = mostEastHash.adjacent(direction: .south)
-                mostWestHash = mostWestHash.adjacent(direction: .south)
-                currentHash = mostWestHash
-                hashes.insert(currentHash)
-            }
-        }
-        return hashes
-    }
-
     public func adjacent(direction: Geohash.Direction) -> LengthedGeohash {
         .init(string: Geohash.adjacent(hash: string, direction: direction))
     }
@@ -149,6 +97,16 @@ public struct LengthedGeohash<Length: GeohashLengthed>: Hashable, Sendable {
         }
         return .init(string: String(string.prefix(Int(otherLength))))
     }
+    
+    public static func hashesForRegion(centerCoordinate: CLLocationCoordinate2D, latitudeDelta: CLLocationDegrees, longitudeDelta: CLLocationDegrees) -> [LengthedGeohash] {
+        Geohash.hashesForRegion(
+            centerCoordinate: centerCoordinate,
+            latitudeDelta: latitudeDelta,
+            longitudeDelta: longitudeDelta,
+            length: Length.length
+        )
+        .map { .init(string: $0) }
+    }
 }
 
 extension LengthedGeohash {
diff --git a/Tests/FlitsGeohashSwiftTests/LengthTests.swift b/Tests/FlitsGeohashSwiftTests/LengthTests.swift
@@ -1,7 +1,7 @@
 
 import XCTest
 import CoreLocation
-@testable import FlitsGeohash
+import FlitsGeohash
 
 final class GeohashTests: XCTestCase {
 
@@ -48,6 +48,16 @@ final class GeohashTests: XCTestCase {
         )
         XCTAssertEqual(neighbors, expectedNeighbors)
     }
+    
+    func testRegion() {
+        let hashes = Geohash3.hashesForRegion(
+            centerCoordinate: .init(latitude: 57.64911063015461, longitude: 10.40743969380855),
+            latitudeDelta: 2,
+            longitudeDelta: 2
+        )
+        let hashesString = hashes.map(\.string).sorted().joined(separator: ",")
+        XCTAssertEqual(hashesString, "u4n,u4p,u4q,u4r,u60,u62")
+    }
 
     func testLowerLength() {
         let (lat, lon) = (57.64911063015461, 10.40743969380855)
@@ -69,13 +79,4 @@ final class GeohashTests: XCTestCase {
         let geohashFromSame: Geohash11? = geohash11.toLowerLength()
         XCTAssertEqual(geohashFromSame, geohash11)
     }
-    
-    func testRegion() {
-        let expectedHashes: Set<String> = ["u14zr","u14yd","u16bj","u14yg","u16b4","u14zd","u16bc","u14yf","u16bd","u14zb","u14xn","u14zh","u14zp","u16b6","u16bz","u14xq","u14wy","u14xy","u14wx","u14zq","u16bh","u14zc","u16b3","u16bv","u14xp","u14zv","u14zf","u14wz","u14xz","u14ww","u16b2","u168w","u16bq","u16bb","u16bk","u14zs","u14yx","u16b1","u14ye","u14zm","u14zy","u14yv","u16bg","u16bn","u16bt","u14zu","u16b7","u14yc","u14xx","u16bx","u14z3","u14y9","u14z9","u14zn","u16br","u16be","u16bf","u14yu","u16b9","u14xr","u16b8","u16b5","u14z8","u14yy","u14zg","u168n","u14zx","u14z5","u14y8","u14zt","u168x","u14zz","u14z0","u16bm","u14zj","u14yt","u168q","u168z","u14xw","u16b0","u14z2","u14yz","u14ze","u16bs","u14z6","u14z7","u14ys","u14zw","u14z1","u14yb","u16bw","u16bp","u14zk","u14z4","u16by","u168r","u14yw","u168p","u168y","u16bu"]
-        measure {
-            let region = Geohash.Region(center: .init(latitude: 52, longitude: 4), latitudeDelta: 0.4, longitudeDelta: 0.4)
-            let hashesInRegion = Geohash5.hashes(for: region).reduce(into: Set(), { $0.insert($1.string) })
-            XCTAssertEqual(hashesInRegion, expectedHashes)
-        }
-    }
 }
diff --git a/Tests/FlitsGeohashSwiftTests/PerformanceTests.swift b/Tests/FlitsGeohashSwiftTests/PerformanceTests.swift
@@ -7,7 +7,7 @@
 
 import XCTest
 import CoreLocation
-@testable import FlitsGeohash
+import FlitsGeohash
 
 final class PerformanceTests: XCTestCase {
 
@@ -24,13 +24,21 @@ final class PerformanceTests: XCTestCase {
     }
 
     func testMakeGeohashes() {
+        var geohashes: [String] = []
+        geohashes.reserveCapacity(Self.size)
+        for coordinate in Self.array {
+            geohashes.append(Geohash.hash(coordinate, length: 5))
+        }
+        XCTAssertEqual(geohashes.count, Self.size)
+        XCTAssertEqual(geohashes.first, "u15d1")
+        XCTAssertEqual(geohashes.last, "u1hrb")
+    }
+    
+    func testMakeGeohashesPerformance() {
         measure {
-            let geohashes = Self.array.map {
-                Geohash.hash($0, length: 5)
+            for coordinate in Self.array {
+                _ = Geohash.hash(coordinate, length: 5)
             }
-            XCTAssertEqual(geohashes.count, Self.size)
-            XCTAssertEqual(geohashes.first, "u15d1")
-            XCTAssertEqual(geohashes.last, "u1hrb")
         }
     }
 
@@ -55,6 +63,42 @@ final class PerformanceTests: XCTestCase {
             XCTAssertEqual(adjacentHashes.last, "u1k20")
         }
     }
+    
+    func testRegion() {
+        let expectedHashes: [String] = ["u14zr","u14yd","u16bj","u14yg","u16b4","u14zd","u16bc","u14yf","u16bd","u14zb","u14xn","u14zh","u14zp","u16b6","u16bz","u14xq","u14wy","u14xy","u14wx","u14zq","u16bh","u14zc","u16b3","u16bv","u14xp","u14zv","u14zf","u14wz","u14xz","u14ww","u16b2","u168w","u16bq","u16bb","u16bk","u14zs","u14yx","u16b1","u14ye","u14zm","u14zy","u14yv","u16bg","u16bn","u16bt","u14zu","u16b7","u14yc","u14xx","u16bx","u14z3","u14y9","u14z9","u14zn","u16br","u16be","u16bf","u14yu","u16b9","u14xr","u16b8","u16b5","u14z8","u14yy","u14zg","u168n","u14zx","u14z5","u14y8","u14zt","u168x","u14zz","u14z0","u16bm","u14zj","u14yt","u168q","u168z","u14xw","u16b0","u14z2","u14yz","u14ze","u16bs","u14z6","u14z7","u14ys","u14zw","u14z1","u14yb","u16bw","u16bp","u14zk","u14z4","u16by","u168r","u14yw","u168p","u168y","u16bu"].sorted()
+        let center = CLLocationCoordinate2D(latitude: 52, longitude: 4)
+        var hashes: [String] = []
+        measure {
+            hashes = Geohash.hashesForRegion(centerCoordinate: center, latitudeDelta: 0.4, longitudeDelta: 0.4, length: 5)
+        }
+        XCTAssertEqual(hashes.sorted(), expectedHashes)
+    }
+    
+    func testSmallRegionReturnsNonEmptyArray() {
+        let hashes = Geohash.hashesForRegion(centerCoordinate: .init(latitude: 52, longitude: 5), latitudeDelta: 0.001, longitudeDelta: 0.001, length: 6)
+        XCTAssertGreaterThan(hashes.count, 0)
+    }
+    
+    func testLargeRegionReturnsManyHashes() {
+        let hashes = Geohash.hashesForRegion(centerCoordinate: .init(latitude: 52, longitude: 5), latitudeDelta: 0.5, longitudeDelta: 0.5, length: 6)
+        XCTAssertGreaterThan(hashes.count, 1000)
+    }
+    
+    func testFreeingHashArrayWorks() {
+        var array = GEOHASH_hashes_for_region(52, 5, 0.02, 0.02, 6)
+        GEOHASH_free_array(&array)
+        
+        XCTAssertEqual(array.count, 0, "After free, count should be zero")
+        XCTAssertNil(array.hashes, "After free, hashes should be nil")
+        XCTAssertEqual(array.capacity, 0, "After free, capacity should be zero")
+    }
+    
+    func testEdgeAlignedRegion() {
+        let hashes = Geohash.hashesForRegion(centerCoordinate: .init(latitude: 0, longitude: 0), latitudeDelta: 0.01, longitudeDelta: 0.01, length: 6)
+            .sorted()
+            .joined(separator: ",")
+        XCTAssertEqual(hashes, "7zzzzz,ebpbpb,kpbpbp,s00000")
+    }
 }
 
 private extension CLLocationCoordinate2D {
