¿Generar puntos aleatorios distribuidos como ciudades?

Question

¿Cómo se puede generar, por ejemplo, 1000 puntos aleatorios con una distribución como la de ciudades y pueblos en, por ejemplo, Ohio?
Me temo que no puedo definir "ciudades similares distribuidas" con precisión; centros uniformemente distribuidos + pequeñas nubes Gaussianas son fáciles pero ad hoc.
Agregado: debe haber una familia de distribuciones 2d con un parámetro de agrupamiento que se puede variar para que coincida con un conjunto dado de puntos?

Answer 1

En java esto se proporciona a través de new Random().nextGaussian(). Dado que la fuente de Java está disponible, puede mire:

synchronized public double nextGaussian() { 
    // See Knuth, ACP, Section 3.4.1 Algorithm C. 
    if (haveNextNextGaussian) { 
     haveNextNextGaussian = false; 
     return nextNextGaussian; 
    } else { 
     double v1, v2, s; 
     do { 
      v1 = 2 * nextDouble() - 1; // between -1 and 1 
      v2 = 2 * nextDouble() - 1; // between -1 and 1 
      s = v1 * v1 + v2 * v2; 
     } while (s >= 1 || s == 0); 
     double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s); 
     nextNextGaussian = v2 * multiplier; 
     haveNextNextGaussian = true; 
     return v1 * multiplier; 
    } 
} 

Trazado 30000 casas utilizando

x = r.nextGaussian() * rad/4 + rad; 
y = r.nextGaussian() * rad/4 + rad; 

rendimientos de esta hermosa ciudad:

Answer 2

Tal vez usted puede tomar una mira Theory of Central Places de Walter Christaller. Supongo que debe haber algún generador en alguna parte, o puedes cocinar tu propio.

Answer 3

Comience con un modelo de las características del agua en su área objetivo (o invente una, si es para un lugar imaginario), luego agrupe las ciudades cerca de uniones fluviales, a lo largo de las orillas del lago, uniones lago-río. Luego haga autopistas imaginarias que conecten esas ciudades principales. Ahora salpique algunas ciudades intermedias a lo largo de esas carreteras a un espacio razonable, prefiriendo estar cerca de las intersecciones en las carreteras. Ahora salpique algunas ciudades pequeñas a través de los espacios vacíos.

Answer 4

Los clústeres gaussianos con tamaños de clúster de Poisson funcionan bastante bien.

Problema: genere puntos aleatorios que se agrupen aproximadamente como ciudades determinadas, por ejemplo, en los EE. UU.

subproblemas:
a) describen grupos con filas de números, de modo que "grupo A es como clúster B" se simplifica a "clusternumbers (A) es como "clusternumbers (B)"
Ejecución de N = 100. entonces 1000 puntos a través de fcluster a continuación, con nCluster = 25, da

N 100 ncluster 25: 22 + 3 r 117 
sizes: av 4  10 9 8 7 6 6 5 5 4 4 4 ... 
radii: av 117 202 198 140 134 64 62 28 197 144 148 132 ... 

N 1000 cluster 25: 22 + 3 r 197 
sizes: av 45 144 139 130 85 84 69 63 43 38 33 30 ... 
radii: av 197 213 279 118 146 282 154 245 212 243 226 235 ... 

b) encontrar un combiation de generadores aleatorios con 2 o 3 parámetros que se pueden variar para generar diferentes clusterings.
racimos gaussiana con clúster Poisson los tamaños pueden coincidir con la agrupación de ciudades bastante bien:

def randomclusters(N, ncluster=25, radius=1, box=box): 
    """ -> N 2d points: Gaussian clusters, Poisson cluster sizes """ 
    pts = [] 
    lam = eval(str(N // ncluster)) 
    clustersize = lambda: np.random.poisson(lam - 1) + 1 
     # poisson 2: 14 27 27 18 9 4 % 
     # poisson 3: 5 15 22 22 17 10 % 
    while len(pts) < N: 
     u = uniformrandom2(box) 
     csize = clustersize() 
     if csize == 1: 
      pts.append(u) 
     else: 
      pts.extend(inbox(gauss2(u, radius, csize))) 
    return pts[:N] 


    # Utility functions -- 

import scipy.cluster.hierarchy as hier 

def fcluster(pts, ncluster, method="average", criterion="maxclust"): 
    """ -> (pts, Y pdist, Z linkage, T fcluster, clusterlists) 
     ncluster = n1 + n2 + ... (including n1 singletons) 
     av cluster size = len(pts)/ncluster 
    """ 
     # Clustering is pretty fast: 
     # sort pdist, then like Kruskal's MST, O(N^2 ln N) 
     # Many metrics and parameters are possible; these satisfice. 
    pts = np.asarray(pts) 
    Y = scipy.spatial.distance.pdist(pts) # N*(N-1)/2 
    Z = hier.linkage(Y, method) # N-1, like mst 
    T = hier.fcluster(Z, ncluster, criterion=criterion) 
    clusters = clusterlists(T) 
    return (pts, Y, Z, T, clusters) 

def clusterlists(T): 
    """ T = hier.fcluster(Z, t) e.g. [a b a b c a] 
     -> [ [0 2 5] [1 3] ] sorted by len, no singletons [4] 
    """ 
    clists = [ [] for j in range(max(T) + 1)] 
    for j, c in enumerate(T): 
     clists[c].append(j) 
    clists.sort(key=len, reverse=True) 
    n1 = np.searchsorted( map(len, clists)[::-1], 2) 
    return clists[:-n1] 

def radius(x): 
    """ rms |x - xmid| """ 
    return np.sqrt(np.mean(np.var(x, axis=0))) 
     # * 100 # 1 degree lat/long ~ 70 .. 111 km