Include app and source code

README.md

@@ -11,4 +11,29 @@ license: mit
 short_description: Generate procedural geographic maps from random fields
 ---
 
+# MapGenerator
+
+Generate procedural geographic maps from random fields.
+
+## Map generation
+
+The process of map generation is as follows:
+
+1. Generate a random field, choosing from the list of available random fields
+2. Normalize the field between 0 and 1
+3. Smooth the field with a gaussian filter
+4. Retain only the mainland above a certain threshold
+
+## Random fields
+
+The available random fields are:
+
+- `gauss`: Random gaussian field, with a given power spectrum, computed using the package [powerbox](https://powerbox.readthedocs.io/en/latest/index.html)
+- `perlin`: Perlin noise, computed using the package [noise](https://pypi.org/project/noise/)
+- `warped_perlin`: Perlin noise with domain warping, computed using the package [noise](https://pypi.org/project/noise/)
+- `cos`: Sinusoidal noise (to be improved)
+- `fbm`: Fractional Brownian Field
+
+**See complete source code [here](https://github.com/PabloVD/MapGenerator/tree/master)**
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,76 @@
+import gradio as gr
+from source.visualization_tools import single_map
+from PIL import Image
+import io
+import random
+
+# Threshold for the sea level
+threshold = 0.6
+# Sigma for the gaussian smoothing
+sigma = 5.
+
+def generate_maps(kind_noise,boxsize,index,scale,octaves,persistence,lacunarity,make_island,deterministic):
+
+    if kind_noise=="gauss":
+        params = index
+    else:
+        params = [scale,octaves,persistence,lacunarity,boxsize]
+    
+    if deterministic:
+        seeds = range(3)
+    else:
+        seeds = random.sample(range(1000),3)
+
+    images = []
+
+    for llavor in seeds:
+        fig = single_map(kind_noise,boxsize,llavor,params,sigma,threshold,make_island=make_island)
+        img_buf = io.BytesIO()
+        fig.savefig(img_buf, format='png')
+
+        img = Image.open(img_buf)
+        images.append(img)
+
+    return images
+
+md ="""
+    # Map generator
+
+    Generate procedural geographic maps from random fields.
+    """
+
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+
+    gr.Markdown(md)
+
+    with gr.Accordion("General settings", open=True):
+    
+        with gr.Row():
+            kind_noise = gr.Dropdown(["gauss", "perlin", "warped_perlin"], label="Random field", value="gauss")
+            boxsize = gr.Slider(100, 1000, value=500, label="Box size")#, info="Box size"),
+            make_island = gr.Checkbox(label="Island", info="Mark to ensure that boundaries are sea")
+            deterministic = gr.Checkbox(label="Deterministic", info="Mark to employ the same random seed")
+
+    with gr.Accordion("Gaussian field settings", open=False):
+        index = gr.Slider(-5, -1, value=-3, label="Spectral index")#, info="Spectral index"),
+        
+    with gr.Accordion("Perlin field settings", open=False):
+        with gr.Row():
+            scale = gr.Slider(100, 1000, value=500, label="Scale")
+            octaves = gr.Slider(1, 10, value=6, label="Octaves", step=1)
+            persistence = gr.Slider(0, 1, value=0.5, label="Persistence")
+            lacunarity = gr.Slider(0.1, 10, value=2, label="Lacunarity")
+    
+    
+    inputs = [kind_noise,boxsize,index,scale,octaves,persistence,lacunarity,make_island,deterministic]
+
+    btn = gr.Button("Generate maps", scale=1)
+
+    gallery = gr.Gallery(label="Generated maps", show_label=False, elem_id="gallery", columns=[3], rows=[1], height="20vw")
+
+    btn.click(generate_maps, inputs=inputs, outputs=gallery)
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+powerbox
+noise
+scipy

source/fields.py

@@ -0,0 +1,168 @@
+#---------------------------
+# Field generator module
+# PabloVD
+# Started: 11/5/20
+#---------------------------
+
+"""
+Collection of noise fields for generating maps.
+Noises included are:
+"gauss": Random gaussian field, with a given power spectrum, computed using the package powerbox
+"perlin": Perlin noise, computed using the package noise
+"warped_perlin": Perlin noise with domain warping, computed using the package noise
+"cos": Sinusoidal noise (to be improved)
+"fbm": Fractional Brownian Field
+"""
+
+import numpy as np
+import powerbox as pbox
+import noise
+
+# Define power spectrum as a power law with an spectral index indexlaw
+# With lower the spectral indexes (redder noise), small structures are removed
+def powerspec(k,indexlaw=-3.):
+    return k**indexlaw
+
+# Generate a Gaussian field with a power law power spectrum
+def gaussian_field(boxsize,seed,indexlaw=-3.):
+    field = pbox.PowerBox(boxsize, lambda k: powerspec(k,indexlaw), dim=2, boxlength=1.,seed=seed).delta_x()
+    return field
+
+# Generate a Perlin field
+def perlin_field(boxsizex,seed,scale,octaves,persistence,lacunarity,boxsizey=None):
+
+    if boxsizey==None: boxsizey=boxsizex
+    shape = (boxsizex,boxsizey)
+
+    field = np.zeros(shape)
+    for i in range(shape[0]):
+        for j in range(shape[1]):
+            field[i,j] = noise.pnoise2(i/scale,
+                                        j/scale,
+                                        octaves=octaves,
+                                        persistence=persistence,
+                                        lacunarity=lacunarity,
+                                        #repeatx=1024,
+                                        #repeaty=1024,
+                                        base=seed)
+    return field
+
+# 2D cosinus (see Hill noise for something similar but better https://blog.bruce-hill.com/hill-noise)
+def cos_noise(X,Y,amp,frecx,frecy,phase):
+    return amp*np.cos( frecx*X +frecy*Y + phase)
+    #return Amp*(np.cos( frecx*X) +np.cos(frecy*Y + phase))
+
+# Generate a noise using superposition of cosinus
+def cos_field(boxsizex,seed,scale,octaves,persistence,lacunarity,boxsizey=None):
+
+    if boxsizey==None: boxsizey=boxsizex
+    np.random.seed(seed=seed)
+
+    frec0 = 5.
+
+    x, y = np.linspace(0,boxsizex,num=boxsizex), np.linspace(0,boxsizey,num=boxsizey)
+    X, Y = np.meshgrid(x,y)
+
+    noise_tot = np.zeros((boxsizex,boxsizey))
+
+    for oct in range(octaves):
+        Amp, frecx, frecy, phase = np.random.random(), 2.*np.pi*frec0*random.uniform(-1.,1.), 2.*np.pi*frec0*random.uniform(-1.,1.), 2.*np.pi*np.random.random()
+        noise_tot += persistence**oct*cos_noise(X/scale,Y/scale,Amp,frecx*lacunarity**oct,frecy*lacunarity**oct,phase)
+
+    return noise_tot
+
+# Generate a Perlin field with warping domain (see e.g. https://iquilezles.org/www/articles/warp/warp.htm)
+def warped_perlin_field(boxsizex,seed,scale,octaves,persistence,lacunarity,amplitude=None,boxsizey=None):
+
+    if boxsizey==None: boxsizey=boxsizex
+    shape = (boxsizex,boxsizey)
+
+    if amplitude==None: amplitude = np.random.uniform(0.,30.)
+
+    field = np.zeros(shape)
+    for i in range(shape[0]):
+        for j in range(shape[1]):
+            vec = np.random.rand(2)
+            ii = noise.pnoise2(i/scale,j/scale,octaves=octaves,persistence=persistence,lacunarity=lacunarity,base=seed)
+            jj = noise.pnoise2(i/scale,j/scale,octaves=octaves,persistence=persistence,lacunarity=lacunarity,base=seed)
+            field[i,j] = noise.pnoise2(i/scale + amplitude*ii,j/scale + amplitude*jj,octaves=octaves,persistence=persistence,lacunarity=lacunarity,base=seed)
+    return field
+
+# Embedding of covariance function on a [0,R]^2 grid for fractional Brownian field
+# From https://gist.github.com/radarsat1/6f8b9b50d1ecd2546d8a765e8a144631
+def rho(x,y,R,alpha):
+
+    if alpha <= 1.5:
+        # alpha=2*H, where H is the Hurst parameter
+        beta = 0
+        c2 = alpha/2
+        c0 = 1-alpha/2
+    else:
+        # parameters ensure piecewise function twice differentiable
+        beta = alpha*(2-alpha)/(3*R*(R**2-1))
+        c2 = (alpha-beta*(R-1)**2*(R+2))/2
+        c0 = beta*(R-1)**3+1-c2
+
+    # create continuous isotropic function
+    r = np.sqrt((x[0]-y[0])**2+(x[1]-y[1])**2)
+    if r<=1:
+        out=c0-r**alpha+c2*r**2
+    elif r<=R:
+        out=beta*(R-r)**3/r
+    else:
+        out=0
+
+    return out, c0, c2
+
+# Fractional Brownian surface
+# The main control is the Hurst parameter: H should be between 0 and 1, where 0 is very noisy, and 1 is smoother.
+# From https://gist.github.com/radarsat1/6f8b9b50d1ecd2546d8a765e8a144631
+def brownian_surface(boxsizex, H=0.8):
+    N = 2*boxsizex
+    R = 2  # [0,R]^2 grid, may have to extract only [0,R/2]^2
+
+    # size of grid is m*n; covariance matrix is m^2*n^2
+    M = N
+
+    # create grid for field
+    tx = np.linspace(0, R, M)
+    ty = np.linspace(0, R, N)
+    rows = np.zeros((M,N))
+
+
+    for i in range(N):
+        for j in range(M):
+            # rows of blocks of cov matrix
+            rows[j,i] = rho([tx[i],ty[j]],
+                            [tx[0],ty[0]],
+                            R, 2*H)[0]
+
+    BlkCirc_row = np.vstack(
+        [np.hstack([rows, rows[:,-1:1:-1]]),
+         np.hstack([rows[-1:1:-1,:], rows[-1:1:-1, -1:1:-1]])])
+
+    # compute eigen-values
+    lam = np.real(np.fft.fft2(BlkCirc_row))/(4*(M-1)*(N-1))
+    lam = np.sqrt(lam)
+
+    # generate field with covariance given by block circular matrix
+    Z = np.vectorize(complex)(np.random.randn(2*(M-1), 2*(M-1)),
+                              np.random.randn(2*(M-1), 2*(M-1)))
+    F = np.fft.fft2(lam*Z)
+    F = F[:M, :N] # extract sub-block with desired covariance
+
+    out,c0,c2 = rho([0,0],[0,0],R,2*H)
+
+    field1 = np.real(F) # two independent fields
+    #field2 = np.imag(F)
+    #field1 = field1 - field1[0,0] # set field zero at origin
+    #field2 = field2 - field2[0,0] # set field zero at origin
+
+    # make correction for embedding with a term c2*r^2
+    field1 = field1 + np.kron(np.array([ty]).T * np.random.randn(), np.array([tx]) * np.random.randn())*np.sqrt(2*c2)
+    #field2 = field2 + np.kron(np.array([ty]).T * np.random.randn(), np.array([tx])   * np.random.randn())*np.sqrt(2*c2)
+    #X,Y = np.meshgrid(tx,ty)
+
+    field1 = field1[:N//2, :M//2]
+    #field2 = field2[:N//2, :M//2]
+    return field1

source/maps.py

@@ -0,0 +1,91 @@
+#---------------------------
+# Field generator module
+# PabloVD
+# Started: 11/5/20
+#---------------------------
+
+import numpy as np
+from scipy import interpolate, ndimage
+from source.fields import gaussian_field, perlin_field, warped_perlin_field, brownian_surface, cos_field
+
+# Filter the field with a gaussian window
+def smooth_field(field,sigmagauss,gridsize=None):
+
+    if gridsize==None: gridsize=field.shape[0]
+
+    x, y = np.linspace(0,field.shape[0],num=field.shape[0]), np.linspace(0,field.shape[1],num=field.shape[1])
+
+    # Interpolation
+    f = interpolate.interp2d(x,y,field,kind="linear")
+
+    qx = np.linspace(x[0],x[-1], num = gridsize)
+    qy = np.linspace(y[0],y[-1], num = gridsize)
+
+    # Filtering
+    smooth = ndimage.filters.gaussian_filter(f(qx,qy),sigmagauss)
+    return smooth
+
+# Remove regions below sea level
+def mainland(field,threshold):
+    for i, row in enumerate(field):
+        for j, el in enumerate(row):
+            if el<threshold:   field[i,j]=0.
+    return field
+
+# Normalize the values of the field between 0 and 1
+def normalize_field(field):
+    min, max = np.amin(field), np.amax(field)
+    newfield = (field-min)/(max-min)
+    return newfield
+
+# A gaussian function
+def central_gaussian(x,y,x_c,y_c,sig):
+    return np.exp(-((x-x_c)**2.+(y-y_c)**2.)/2./sig**2.)
+
+# Multiply the field by a gaussian mask to ensure an island in the center of the image
+def masked_field(field,sig=None):
+    a, b = field.shape[0], field.shape[1]
+    if sig==None: sig = a/2.
+    x, y = np.linspace(0,a-1,num=a), np.linspace(0,b-1,num=b)
+    X, Y = np.meshgrid(x,y)
+    mask = central_gaussian(X,Y,a/2,b/2,sig)
+    field = field*mask
+    return field
+
+# Generate a map of islands applying different processes:
+# 1. Generate a random field, either gaussian or perlin
+# 2. Normalize the field between 0 and 1
+# 3. Smooth the field with a gaussian filter
+# 4. Retain only the mainland above a certain threshold
+def generate_map(kind_noise,boxsize,llavor,params,sigma,threshold,boxsizey=None,make_island=0):
+
+    if boxsizey==None: boxsizey=boxsize
+    np.random.seed(seed=llavor)
+
+    if kind_noise=="gauss":
+        indexlaw = params
+        field = gaussian_field(boxsize,llavor,indexlaw)
+    elif kind_noise=="perlin":
+        scale,octaves,persistence,lacunarity,boxsizey = params
+        field = perlin_field(boxsize,llavor,scale,octaves,persistence,lacunarity,boxsizey=boxsizey)
+        #field = perlin_field(boxsize,llavor,*params)
+    elif kind_noise=="warped_perlin":
+        scale,octaves,persistence,lacunarity,boxsizey = params
+        field = warped_perlin_field(boxsize,llavor,scale,octaves,persistence,lacunarity,boxsizey=boxsizey)
+    elif kind_noise=="fbm":
+        hurst = params
+        field = brownian_surface(boxsize, H=hurst)
+    elif kind_noise=="cos":
+        scale,octaves,persistence,lacunarity,boxsizey = params
+        field = cos_field(boxsize,llavor,scale,octaves,persistence,lacunarity,boxsizey=boxsizey)
+    else:
+        print("Kind of noise not valid.")
+        return np.zeros((boxsize,boxsizey))
+
+    field = normalize_field(field)
+    if make_island:
+        field = masked_field(field)
+    field = smooth_field(field,sigma,gridsize=2*boxsize)
+    field = mainland(field,threshold)
+
+    return field

source/visualization_tools.py

@@ -0,0 +1,68 @@
+#---------------------------
+# Tools for visualization
+# PabloVD
+# Started: 11/5/20
+#---------------------------
+
+import matplotlib.pyplot as plt
+from source.maps import generate_map
+
+# Modify gist_earth color map to have a dark blue as the minimum value, instead of black
+def modified_gist_earth():
+
+    cmap = plt.get_cmap("gist_earth")
+    # Color maps defined for 256 values
+    num = 256
+    # Location of the color I want to be the lowest value
+    ind_blue = 5   #
+
+    blue_list = []
+    for i in range(ind_blue):
+        blue_list.append(cmap(ind_blue))
+
+    newcmap = cmap.from_list('modified_gist_earth',blue_list+list(map(cmap,range(ind_blue,num))), N=num)
+    return newcmap
+
+# Creates a random map
+def single_map(kind_noise,boxsize,llavor,params,sigma,threshold,make_island=0,cmap=modified_gist_earth(),axissize=6):
+
+    figsize = (axissize,axissize)
+    fig, ax = plt.subplots(figsize=figsize)
+    margins = {  #     vvv margin in inches
+    "left"   :     0.,
+    "bottom" :     0.,
+    "right"  :  1.,
+    "top"    :  1.}
+    fig.subplots_adjust(**margins)
+
+    field = generate_map(kind_noise,boxsize,llavor,params,sigma,threshold,make_island=make_island)
+    ax.imshow(field,vmin=0.,vmax=1.,cmap=cmap)
+
+    ax.set_axis_off()
+
+    return fig
+    
+
+# Create (num_plots)x(num_plots) different maps of random islands, with different random seeds
+def plot_grid(kind_noise,boxsize,params,sigma,threshold,num_plots=3,make_island=0,cmap=modified_gist_earth()):
+
+    fig, axes = plt.subplots(num_plots,num_plots, figsize=(9.,9.))
+    fig.subplots_adjust(wspace = 0.1, hspace = 0.1)
+
+    llavor = 0
+
+    for axx in axes:
+        for ax in axx:
+
+            field = generate_map(kind_noise,boxsize,llavor,params,sigma,threshold,make_island=make_island)
+            ax.imshow(field,vmin=0.,vmax=1.,cmap=cmap)
+
+            ax.set_xlim([0,field.shape[0]])
+            ax.set_ylim([field.shape[0],0])
+            ax.set_axis_off()
+            llavor+=1
+
+    plt.axis('off')
+    fig.savefig("images/gridmap_noise_{:}_threshold_{:.1f}_sigma_{:.1f}.png".format(kind_noise,threshold,sigma), bbox_inches='tight')
+    #plt.close(fig)
+