sélectionner un pourcentage (75%) d'un groupe de points en fonction de la distance d'un point distinct dans ArcGIS?

Ceci est spécifique à ArcGIS.

J'ai 2 fichiers de formes de points Aet B, le premier ( A) est un seul point qui contient un lat long, le second ( B) est une multitude de points (plus de 12k) qui contiennent chacun leur lat et long. Ce que j'essaie de faire, c'est d'automatiser la sélection de 75% des Bpoints du fichier de formes en fonction de la distance par rapport au fichier de formes A. En d'autres termes, je veux sélectionner les 75% de Bpoints de shapefile les plus proches d'un point de shapefile A.

Vous pouvez créer un tampon en anneau multiple sur le fichier de formes A, puis faire une jointure spatiale du tampon vers le fichier de formes B. Lorsque vous effectuez une jointure spatiale de polygones et de points, vous obtenez un compte du nombre de points de chaque polygone de l'attribut table de la jointure. Ensuite, en examinant le nombre total de points dans les tampons, vous pouvez obtenir 75% des points dans le fichier de formes B.

Une approche légèrement différente serait de l'écrire en Python et de vérifier les 75% dans une boucle, mais s'il s'agit d'un calcul unique, vous n'en aurez peut-être pas besoin.

Pour 1200 points (ou même jusqu'à 12 millions de points?), Je les mettrais simplement en mémoire en tant que collection générique - dans ce cas, une liste triée de listes . Cela pourrait être simplifié en sautant simplement des points lorsque vous rencontrez une situation avec plusieurs points qui sont à la même distance du point d'origine. De plus, pour des performances, pensez à utiliser une table de hachage au lieu d'une SortedList et à trier une fois après avoir inséré toutes les distances. Cela prendrait encore quelques lignes de code (?).

Je n'ai pas eu le temps de tester cela, mais ce c # pourrait vous aider à démarrer:

private void SelectNTile(string layer1, string layer2, double nTile)
{
    var fLayer1 = FindLayer(ArcMap.Document.FocusMap, "LayerWithLotsofPoints");
    var fLayer2 = FindLayer(ArcMap.Document.FocusMap, "LayerWithOneSelectedPoint");
    IFeature feat = GetSingleFeature(fLayer2);
    var distList = MakeDistList(fLayer1.FeatureClass,(IPoint)feat.ShapeCopy);
    // assume not many points exactly same distance
    var nRecs = (int)(distList.Count * nTile); // nTile would be 0.75 for 75%
    var Oids = new List<int>();
    foreach (KeyValuePair<double, List<int>> kvp in distList)
    {
        Oids.AddRange(kvp.Value);
        if (Oids.Count > nRecs)
            break;
    }
    var fSel = fLayer1 as IFeatureSelection;
    var OidArray = Oids.ToArray();
    fSel.SelectionSet.AddList(Oids.Count, ref OidArray[0]);                
}

private SortedList<double, List<int>> MakeDistList(IFeatureClass fc, IPoint pnt)
{
    var outList = new SortedList<double, List<int>>();
    var proxOp = pnt as IProximityOperator;
    IFeatureCursor fCur = null;
    try
    {
        fCur = fc.Search(null, true); // recycling is faster, we just need OIDs
        IFeature feat;
        while ((feat = fCur.NextFeature()) != null)
        {
            double dist = proxOp.ReturnDistance(feat.Shape);
            if (!outList.ContainsKey(dist))
                outList.Add(dist, new List<int> { feat.OID });
            else
                outList[dist].Add(feat.OID);  // this should rarely happen
        }
    }
    catch
    {
        throw;
    }
    finally
    {
        if (fCur != null)
            System.Runtime.InteropServices.Marshal.FinalReleaseComObject(fCur);
    }
    return outList;
}
private IFeature GetSingleFeature(IFeatureLayer fLayer)
{
    var fSel = fLayer as IFeatureSelection;
    if (fSel.SelectionSet.Count != 1)
        throw new Exception("select one feature in " + fLayer.Name + " first");
    var enumIDs = fSel.SelectionSet.IDs;
    enumIDs.Reset();
    IFeature feat = fLayer.FeatureClass.GetFeature(enumIDs.Next());
    return feat;
}
private IFeatureLayer FindLayer(IMap map, string name)
{
    throw new NotImplementedException();
}

Un script de géotraitement Python est un choix évident:

1. Utilisez l' outil Point Distance pour calculer la distance entre vos entités dans la classe d'entités B (le paramètre "Entités en entrée" de l'outil) et le point dans la classe d'entités A (le paramètre "Entités proches" de l'outil).
2. Triez le tableau selon la distance calculée.
3. Sélectionnez les 75 premiers% des ID d'objet dans le tableau de sortie (la colonne "Input_FID") et utilisez-les pour effectuer votre sélection à partir des entités d'origine de la classe d'entités B.

J'ai eu ce problème il y a quelques années. J'ai trouvé plus facile de garder les données en tant que `` données plates '', de parcourir toutes les données et de calculer manuellement la distance, puis de prendre les 75% supérieurs (j'ai en fait conservé les 10% supérieurs). J'ai ensuite fait la même chose dans ArcIMS en utilisant leurs calculs de distance et cela a pris beaucoup plus de temps.

La mise en mémoire tampon est un énorme frais généraux, mais les calculs mathématiques sont un point fort. Si vous mettez en mémoire tampon 12k points, je pense que vous allez avoir des problèmes de performances.