selezionando una percentuale (75%) di un gruppo di punti in base alla distanza da un punto separato in ArcGIS?

Questo è specifico di ArcGIS.

Ho 2 shapefile di punti Ae B, il primo ( A) è un singolo punto che contiene un lat long, il secondo ( B) è una moltitudine di punti (oltre 12k) che contengono ciascuno il loro lat e long. Quello che sto cercando di fare è automatizzare la selezione del 75% dei Bpunti dello shapefile in base alla distanza dallo shapefile A. In altre parole, voglio selezionare il 75% più vicino dei Bpunti del file di forma per Aun solo punto del file di forma.

È possibile creare un buffer ad anello multiplo sul file di forma A, quindi eseguire un'unione spaziale del buffer al file di forma B. Quando si esegue un'unione spaziale di poligoni e punti, si ottiene un conteggio del numero di punti in ciascun poligono nell'attributo tabella del join. Quindi, esaminando il numero totale di punti all'interno dei buffer, è possibile ottenere entro il 75% dei punti nel file di forma B.

Un approccio leggermente diverso sarebbe quello di scrivere questo script in Python e verificare il 75% in un ciclo, ma se si tratta di un calcolo una tantum potrebbe non essere necessario.

Per 1200 punti (o addirittura per dire 12 milioni di punti?), Li metterei semplicemente in memoria come una raccolta generica, in questo caso un elenco di elenchi ordinati . Ciò potrebbe essere semplificato semplicemente saltando i punti quando ci si imbatte in una situazione con più punti che si trovano alla stessa distanza dal punto di origine. Inoltre, per prestazioni, considera l'utilizzo di una tabella hash invece di una SortedList e l'ordinamento una volta dopo aver inserito tutte le distanze. Ciò richiederebbe qualche altra riga di codice (?).

Non ho avuto il tempo di testarlo, ma questo c # potrebbe farti iniziare:

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();
}

Uno script di geoprocessing di Python è una scelta ovvia:

1. Utilizzare lo strumento Distanza punto per calcolare la distanza dalle funzioni nella classe di caratteristiche B (il parametro "Funzioni di input" dello strumento) al punto nella classe di caratteristiche A (il parametro "Funzioni vicine" dello strumento).
2. Ordina la tabella per la distanza calcolata.
3. Seleziona il primo 75% degli objectids nella tabella di output (la colonna "Input_FID") e usali per effettuare la tua selezione dalle funzionalità originali nella classe di caratteristiche B.

Ho avuto questo problema qualche anno fa. Ho trovato più facile mantenere i dati come "dati piatti", scorrere tutti i dati e calcolare manualmente la distanza, quindi prendere il 75% (ho effettivamente mantenuto il 10%). Ho quindi fatto lo stesso in ArcIMS usando i loro calcoli della distanza e ci è voluto molto più tempo.

Il buffering è un enorme sovraccarico, ma i calcoli matematici sono un forte fattore. Se tamponi 12k punti, penso che avrai problemi di performace.