Merge pull request #5 from chintan369/feature_resolve_issues

Resolve Radius Issue

Author: chintan369

.idea/misc.xml

@@ -16,7 +16,7 @@ fun Query.whereNearToLocation(
     fieldName: String = DEFAULT_KEY_GEO_DEGREE_MATCH
 ): Query {
     val geoPointUtils = BoundingBoxUtils(distance.unit)
-    val boundingBox = geoPointUtils.getBoundingBox(queryAtLocation, distance.distance)
+    val boundingBox = geoPointUtils.getBoundingBoxForNew(queryAtLocation, distance.distance)
     return orderBy(fieldName)
         .whereGreaterThanOrEqualTo(fieldName, boundingBox.minimumMatch)
         .whereLessThanOrEqualTo(fieldName, boundingBox.maximumMatch)

.idea/sonarIssues.xml

@@ -2,7 +2,7 @@ package com.ckdroid.geofirequery.utils
 
 import com.ckdroid.geofirequery.model.BoundingBox
 import com.ckdroid.geofirequery.model.QueryLocation
-import com.google.firebase.firestore.FirebaseFirestore
+import com.google.firebase.firestore.GeoPoint
 import kotlin.math.*
 
 /**
@@ -60,11 +60,67 @@ class BoundingBoxUtils(private val distanceUnit: DistanceUnit) {
         return BoundingBox(minimumLatitude, minimumLongitude, maximumLatitude, maximumLongitude)
     }
 
+    fun getBoundingBoxForNew(queryLocation: QueryLocation, distance: Double): BoundingBox {
+        val nearByLocationList: MutableList<GeoPoint> = mutableListOf()
+
+        (1..200).forEach { _ ->
+            nearByLocationList.add(pointAtDistance(queryLocation, distance))
+        }
+
+        if (nearByLocationList.isNotEmpty()) {
+            val sortedBounds = nearByLocationList.sortedWith(compareBy({ it.latitude }, { it.longitude }))
+
+            val minimumGeoPoint = sortedBounds.first()
+
+            val maximumGeoPoint = sortedBounds.last()
+
+            return BoundingBox(
+                minimumGeoPoint.latitude,
+                minimumGeoPoint.longitude,
+                maximumGeoPoint.latitude,
+                maximumGeoPoint.longitude
+            )
+        }
+
+        return BoundingBox(
+            queryLocation.latitude,
+            queryLocation.longitude,
+            queryLocation.latitude,
+            queryLocation.longitude
+        )
+    }
+
+    private fun pointAtDistance(queryLocation: QueryLocation, distance: Double): GeoPoint {
+        val sinLat = Math.sin(queryLocation.latitude)
+        val cosLat = Math.cos(queryLocation.latitude)
+
+        val bearing = Math.random().times(TWO_PI)
+        val theta = when (distanceUnit) {
+            DistanceUnit.KILOMETERS -> distance.div(EARTH_RADIUS_KM)
+            DistanceUnit.MILES -> distance.div(EARTH_RADIUS_MILES)
+        }
+
+        val sinBearing = sin(bearing)
+        val cosBearing = cos(bearing)
+        val sinTheta = sin(theta)
+        val cosTheta = cos(theta)
+
+        val latitude = asin(sinLat * cosTheta + cosLat * sinTheta * cosBearing)
+        var longitude =
+            queryLocation.longitude + atan2(sinBearing * sinTheta * cosLat, cosTheta - sinLat * sin(latitude))
+        longitude = ((longitude + THREE_PI) % TWO_PI) - Math.PI
+
+        return GeoPoint(Math.toDegrees(latitude), Math.toDegrees(longitude))
+    }
+
     companion object {
 
-        private val EARTH_RADIUS_KM = 6371.001
+        private val EARTH_RADIUS_KM = 6371.000//6371.001
         private val EARTH_RADIUS_MILES = 3958.756
 
+        private val THREE_PI = Math.PI.times(3)
+        private val TWO_PI = Math.PI.times(2)
+
         private val MINIMUM_LATITUDE = Math.toRadians(-90.0)  // -PI/2
         private val MAXIMUM_LATITUDE = Math.toRadians(90.0)   //  PI/2
         private val MINIMUM_LONGITUDE = Math.toRadians(-180.0) // -PI