SQlite Obtenir le plus proche emplacements (latitude et longitude)

1) Au premier filtrer vos données SQLite avec une bonne approximation et de la diminution de la quantité de données que vous devez évaluer dans votre code java. Utilisez la procédure suivante pour cette fin:

D'avoir un déterministe seuil et plus précis filtre sur les données, Il est préférable de calculer 4 emplacements qui sont dans radius mètre du nord, de l'ouest à l'est et au sud de votre point central dans votre code java et puis vérifier facilement en moins et plus que les opérateurs SQL (>, <) pour déterminer si vos points dans la base de données sont dans un rectangle ou non.

La méthode calculateDerivedPosition(...) calcule ces points (p1, p2, p3, p4 dans l'image).

/**
* Calculates the end-point from a given source at a given range (meters)
* and bearing (degrees). This methods uses simple geometry equations to
* calculate the end-point.
* 
* @param point
*           Point of origin
* @param range
*           Range in meters
* @param bearing
*           Bearing in degrees
* @return End-point from the source given the desired range and bearing.
*/
public static PointF calculateDerivedPosition(PointF point,
            double range, double bearing)
    {
        double EarthRadius = 6371000; //m

        double latA = Math.toRadians(point.x);
        double lonA = Math.toRadians(point.y);
        double angularDistance = range / EarthRadius;
        double trueCourse = Math.toRadians(bearing);

        double lat = Math.asin(
                Math.sin(latA) * Math.cos(angularDistance) +
                        Math.cos(latA) * Math.sin(angularDistance)
                        * Math.cos(trueCourse));

        double dlon = Math.atan2(
                Math.sin(trueCourse) * Math.sin(angularDistance)
                        * Math.cos(latA),
                Math.cos(angularDistance) - Math.sin(latA) * Math.sin(lat));

        double lon = ((lonA + dlon + Math.PI) % (Math.PI * 2)) - Math.PI;

        lat = Math.toDegrees(lat);
        lon = Math.toDegrees(lon);

        PointF newPoint = new PointF((float) lat, (float) lon);

        return newPoint;

    }

Et maintenant créer votre requête:

PointF center = new PointF(x, y);
final double mult = 1; //mult = 1.1; is more reliable
PointF p1 = calculateDerivedPosition(center, mult * radius, 0);
PointF p2 = calculateDerivedPosition(center, mult * radius, 90);
PointF p3 = calculateDerivedPosition(center, mult * radius, 180);
PointF p4 = calculateDerivedPosition(center, mult * radius, 270);

strWhere =  " WHERE "
        + COL_X + " > " + String.valueOf(p3.x) + " AND "
        + COL_X + " < " + String.valueOf(p1.x) + " AND "
        + COL_Y + " < " + String.valueOf(p2.y) + " AND "
        + COL_Y + " > " + String.valueOf(p4.y);

COL_X est le nom de la colonne dans la base de données qui stocke les valeurs de latitude et de COL_Y est pour la longitude.

Si vous avez des données qui sont à proximité de votre point central avec une bonne approximation.

2) Maintenant, vous pouvez faire une boucle sur ces données filtrées et de déterminer si elles sont vraiment à proximité de votre lieu (dans le cercle) ou non en utilisant les méthodes suivantes:

public static boolean pointIsInCircle(PointF pointForCheck, PointF center,
            double radius) {
        if (getDistanceBetweenTwoPoints(pointForCheck, center) <= radius)
            return true;
        else
            return false;
    }

public static double getDistanceBetweenTwoPoints(PointF p1, PointF p2) {
        double R = 6371000; //m
        double dLat = Math.toRadians(p2.x - p1.x);
        double dLon = Math.toRadians(p2.y - p1.y);
        double lat1 = Math.toRadians(p1.x);
        double lat2 = Math.toRadians(p2.x);

        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.sin(dLon / 2)
                * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        double d = R * c;

        return d;
    }

Profitez-en!

Que j'ai utilisé et personnalisé cette référence et à la fin.

Je sais que cela a été répondu et accepté, mais j'ai pensé ajouter mon expérience et de leur solution.

Alors que j'ai été heureux de faire un haversine de la fonction sur l'appareil pour calculer la distance exacte entre l'utilisateur de la position actuelle et les objectifs endroit, il y avait un besoin de trier et de limiter les résultats de la requête dans l'ordre de la distance.

Moins que satisfaisants, la solution est de retour du lot et de tri et de filtre après le fait, mais il en résulterait un deuxième curseur et bien des résultats retournés et jetés.

Mon préféré de la solution a été de passer dans un ordre de tri des carrés des valeurs delta de long et lat:

((<lat> - LAT_COLUMN) * (<lat> - LAT_COLUMN) +
 (<lng> - LNG_COLUMN) * (<lng> - LNG_COLUMN))

Il n'y a pas besoin de faire le plein haversine juste pour un ordre de tri et il n'y a pas besoin de racine carrée par conséquent, les résultats SQLite peut gérer le calcul.

EDIT:

Cette réponse est encore recevoir l'amour. Il fonctionne bien dans la plupart des cas, mais si vous avez besoin d'un peu plus de précision, veuillez consulter la réponse par @Teasel ci-dessous qui ajoute un "fudge" facteur qui corrige les inexactitudes qu'augmenter à mesure que la latitude approches 90.

Afin d'accroître les performances, autant que possible, je suggère d'améliorer @Chris Simpson idée avec les éléments suivants ORDER BY clause:

ORDER BY (<L> - <A> * LAT_COL - <B> * LON_COL + LAT_LON_SQ_SUM)

Dans ce cas, vous devez transmettre les valeurs suivantes de code:

<L> = center_lat^2 + center_lon^2
<A> = 2 * center_lat
<B> = 2 * center_lon

Et vous devriez également stocker LAT_LON_SQ_SUM = LAT_COL^2 + LON_COL^2 comme colonne supplémentaire dans la base de données. Remplir l'insertion de vos entités dans la base de données. Cela améliore légèrement les performances lors de l'extraction de grandes quantités de données.

Essayer quelque chose comme cela:

    //locations to calculate difference with 
    Location me   = new Location(""); 
    Location dest = new Location(""); 

    //set lat and long of comparison obj 
    me.setLatitude(_mLat); 
    me.setLongitude(_mLong); 

    //init to circumference of the Earth 
    float smallest = 40008000.0f; //m 

    //var to hold id of db element we want 
    Integer id = 0; 

    //step through results 
    while(_myCursor.moveToNext()){ 

        //set lat and long of destination obj 
        dest.setLatitude(_myCursor.getFloat(_myCursor.getColumnIndexOrThrow(DataBaseHelper._FIELD_LATITUDE))); 
        dest.setLongitude(_myCursor.getFloat(_myCursor.getColumnIndexOrThrow(DataBaseHelper._FIELD_LONGITUDE))); 

        //grab distance between me and the destination 
        float dist = me.distanceTo(dest); 

        //if this is the smallest dist so far 
        if(dist < smallest){ 
            //store it 
            smallest = dist; 

            //grab it's id 
            id = _myCursor.getInt(_myCursor.getColumnIndexOrThrow(DataBaseHelper._FIELD_ID)); 
        } 
    } 

Après cela, l'id contient l'élément que vous voulez à partir de la base de données de sorte que vous pouvez le récupérer:

    //now we have traversed all the data, fetch the id of the closest event to us 
    _myCursor = _myDBHelper.fetchID(id); 
    _myCursor.moveToFirst(); 

    //get lat and long of nearest location to user, used to push out to map view 
    _mLatNearest  = _myCursor.getFloat(_myCursor.getColumnIndexOrThrow(DataBaseHelper._FIELD_LATITUDE)); 
    _mLongNearest = _myCursor.getFloat(_myCursor.getColumnIndexOrThrow(DataBaseHelper._FIELD_LONGITUDE)); 

Espère que ça aide!