Algoritmo per la ricerca del centroide poligonale irregolare (punto dell'etichetta)

Devo trovare un centroide (o punto dell'etichetta) per i poligoni di forma irregolare su Google Maps. Sto mostrando InfoWindows per i pacchi e ho bisogno di un posto per ancorare l'InfoWindow che è garantito per essere in superficie. Vedi le immagini qui sotto.

In realtà non ho bisogno di nulla di specifico su Google Maps, sto solo cercando un'idea su come trovare automaticamente questo punto.

La mia prima idea è stata quella di trovare il centroide "falso" prendendo il lat medio e gli lng e il posizionamento casuale di punti da lì fino a quando non ne trovo uno che interseca il poligono. Ho già il codice point-in-poligono. Questo mi sembra terribilmente "confuso".

Dovrei notare che non ho accesso a nessuno dei codici lato server che emettono la geometria, quindi non posso fare nulla come ST_PointOnSurface (the_geom).

Veloce e sporco: se il centroide "falso" non è nel poligono, usa il vertice più vicino a quel punto.

Potresti voler guardare questo: http://github.com/tparkin/Google-Maps-Point-in-Polygon

Sembra utilizzare un algoritmo Ray Casting che dovrebbe corrispondere al caso presentato.

C'è un post sul blog qui. http://appdelegateinc.com/blog/2010/05/16/point-in-polygon-checking/

Un algoritmo ESRI (più vecchio) calcola il centro di massa e, dopo averlo testato per l'inclusione nel poligono, lo sposta orizzontalmente, se necessario, fino a quando si trova all'interno del poligono. (Ciò potrebbe essere fatto in molti modi a seconda delle operazioni fondamentali disponibili nel proprio ambiente di programmazione.) Questo tende a produrre punti etichetta abbastanza vicini al centro visivo del poligono: provalo sull'illustrazione.

Ho risolto il mio problema estendendo il popolare codice epoly da http://econym.org.uk/gmap . Fondamentalmente quello che ho finito per fare è stato:

• Crea una serie di raggi che iniziano dal "falso centroide" e si estendono ad ogni angolo e lato (8 in totale)
• Crea in modo incrementale un punto del 10,20,30 ... percento in giù di ogni raggio e vedi se questo punto è nel nostro poligono originale

Codice epoly esteso di seguito:

google.maps.Polygon.prototype.Centroid = function() {
var p = this;
var b = this.Bounds();
var c = new google.maps.LatLng((b.getSouthWest().lat()+b.getNorthEast().lat())/2,(b.getSouthWest().lng()+b.getNorthEast().lng())/2);
if (!p.Contains(c)){
    var fc = c; //False Centroid
    var percentages = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]; //We'll check every 10% down each ray and see if we're inside our polygon
    var rays = [
        new google.maps.Polyline({path:[fc,new google.maps.LatLng(b.getNorthEast().lat(),fc.lng())]}),
        new google.maps.Polyline({path:[fc,new google.maps.LatLng(fc.lat(),b.getNorthEast().lng())]}),
        new google.maps.Polyline({path:[fc,new google.maps.LatLng(b.getSouthWest().lat(),fc.lng())]}),
        new google.maps.Polyline({path:[fc,new google.maps.LatLng(fc.lat(),b.getSouthWest().lng())]}),
        new google.maps.Polyline({path:[fc,b.getNorthEast()]}),
        new google.maps.Polyline({path:[fc,new google.maps.LatLng(b.getSouthWest().lat(),b.getNorthEast().lng())]}),
        new google.maps.Polyline({path:[fc,b.getSouthWest()]}),
        new google.maps.Polyline({path:[fc,new google.maps.LatLng(b.getNorthEast().lat(),b.getSouthWest().lng())]})
    ];
    var lp;
    for (var i=0;i<percentages.length;i++){
        var percent = percentages[i];
        for (var j=0;j<rays.length;j++){
            var ray = rays[j];
            var tp = ray.GetPointAtDistance(percent*ray.Distance()); //Test Point i% down the ray
            if (p.Contains(tp)){
                lp = tp; //It worked, store it
                break;
            }
        }
        if (lp){
            c = lp;
            break;
        }
    }
}
return c;}

Ancora un po 'confuso ma sembra funzionare.

Un altro algoritmo 'sporco' per farlo:

• Prendi il rettangolo di selezione della geometria (Xmax, Ymax, Xmin, Ymin)

• Ripeti finché non ( Xmin+rand*(Xmax-Xmin), Ymin+rand*(Ymax-Ymin) ) viene trovato un punto casuale all'interno della geometria (utilizzando Google-Maps-Point-in-Polygon )

Alla luce del recente chiarimento che preferiresti un luogo strettamente interno, puoi selezionare qualsiasi punto della Trasformazione dell'asse mediale che non si trovi anche sul confine del poligono. (Se non hai un codice per un MAT, puoi approssimarlo tamponando negativamente il poligono. Una ricerca binaria o secante produrrà rapidamente un piccolo poligono interno che approssima una parte del MAT; usa qualsiasi punto sul suo confine.)

Perché non usare il centroide solo per la posizione verticale (latitudine)? Quindi, puoi posizionare l'etichetta in orizzontale selezionando la longitudine media a quella latitudine . (Per questo dovresti trovare il valore di longitudine per un bordo poligonale a una latitudine specifica, che non dovrebbe darti alcun problema).

Inoltre, fai attenzione alle forme a U e a quelle più complesse. :) Forse per quelli, scegli la media della coppia di longitudinali più a destra (ogni coppia corrisponderebbe a una porzione del poligono), poiché la finestra informativa è orientata in quel modo?

Questo ti dà anche un po 'più di controllo sul posizionamento; ad esempio, potrebbe essere utile posizionare la finestra informativa al 66 o al 75% in verticale, in modo da lasciare più parte del poligono visibile. (O forse no! Ma hai la manopola per modificare.)

Che ne dici di usare solo il punto su cui l'utente ha fatto clic per selezionarlo, se è selezionato dall'utente che lo è.

Sto cercando di risolvere anche questo. Ho imposto una condizione ai miei poligoni che non possono avere linee di incrocio che entrano in quello che descriverò.

Quindi, il mio approccio usa la triangolazione. Prendi un vertice casuale (eventualmente prendi un vertice all'estremo N, E, W o S può semplificare le cose).

Da questo vertice, traccia le linee al vertice a un vertice di distanza, ovvero se il tuo vertice è vertice 3, osserva il vertice 3 + 2.

Costruisci una linea dal tuo vertice originale a questo vertice. Se la linea costruita:

1. non incrocia altre linee e
2. il suo punto medio non è esterno al poligono

Quindi hai costruito un triangolo all'interno del poligono. Se il vertice di successo era n + 2, il triangolo è {n, n + 1, n + 2}, che chiameremo {v, v1, v2}. In caso contrario, prova il vertice successivo e continua fino a quando tutti i vertici sono stati provati.

Quando trovi un triangolo, trova il centro di quello prendendo una linea dal vertice v al punto medio di v1 e v2. Il punto medio di quella linea è garantito all'interno del triangolo e all'interno del poligono.

Non l'ho ancora codificato, ma vedo come penso che un poligono con linee incrociate causerà effettivamente alcune condizioni esotiche in cui ciò non funziona. Se questo è il tipo di poligoni che hai, dovresti testare ogni segmento di linea sul poligono e assicurarti che non sia stato attraversato. Salta i segmenti di linea che sono incrociati e penso che funzionerà.

https://github.com/mapbox/polylabel potrebbe essere utile (javascript e C ++). Implementazione C # qui: https://gist.github.com/dfaivre/acfef42cdbf411555956e9eba65dd30d .

Domanda SO originale qui: /programming//a/38522611/79113