Strumenti modello Gravity / Huff

Sto cercando un modo per simulare un modello di gravità usando uno strato basato su punti.

A tutti i miei punti viene assegnato un valore z e maggiore è questo valore, maggiore è la loro "sfera di influenza". Questa influenza è inversamente proporzionale alla distanza dal centro.

È un tipico modello di Huff, ogni punto è un massimo locale e le valli tra loro indicano i limiti della zona di influenza tra di loro.

Ho provato diversi algoritmi di Arcgis (IDW, allocazione dei costi, interpolazione polinomiale) e QGIS (plug-in Heatmap), ma non ho trovato nulla che potesse aiutarmi. Ho anche trovato questo thread , ma non è molto utile per me.

In alternativa, potrei anche essere soddisfatto di un modo per generare diagrammi Voronoi se c'è un modo per influenzare la dimensione di ciascuna cella dal valore z del punto corrispondente.

Ecco una piccola funzione Python QGIS che implementa questo. Richiede il plug-in rasterlang (il repository deve essere aggiunto manualmente a QGIS).

Prevede tre parametri obbligatori: il livello punti, un livello raster (per determinare le dimensioni e la risoluzione dell'output) e un nome file per il livello output. È inoltre possibile fornire un argomento facoltativo per determinare l'esponente della funzione di decadimento della distanza.

I pesi per i punti devono trovarsi nella prima colonna degli attributi del livello punti.

Il raster risultante viene automaticamente aggiunto all'area di disegno.

Ecco un esempio di come eseguire lo script. I punti hanno pesi compresi tra 20 e 90 e la griglia ha dimensioni di 60 per 50 unità della mappa.

points = qgis.utils.iface.mapCanvas().layer(0)
raster = qgis.utils.iface.mapCanvas().layer(1)
huff(points,raster,"output.tiff",2)

from rasterlang.layers import layerAsArray
from rasterlang.layers import writeGeoTiff
import numpy as np

def huff(points, raster, outputfile, decay=1):
    if points.type() != QgsMapLayer.VectorLayer:
        print "Error: First argument is not a vector layer (but it has to be)"
        return
    if raster.type() != QgsMapLayer.RasterLayer:
        print "Error: Second argument is not a raster layer (but it has to be)"
        return
    b = layerAsArray(raster)
    e = raster.extent()
    provider = points.dataProvider()
    extent = [e.xMinimum(),e.yMinimum(),e.xMaximum(),e.yMaximum()]
    xcols = np.size(layerAsArray(raster),1)
    ycols = np.size(layerAsArray(raster),0)
    xvec = np.linspace(extent[0], extent[2], xcols, endpoint=False)
    xvec = xvec + (xvec[1]-xvec[0])/2
    yvec = np.linspace(extent[3], extent[1], ycols, endpoint=False)
    yvec = yvec + (yvec[1]-yvec[0])/2
    coordArray = np.meshgrid(xvec,yvec)
    gravity = b
    point = QgsFeature()
    provider.select( provider.attributeIndexes() )
    while provider.nextFeature(point):
      coord = point.geometry().asPoint()
      weight = point.attributeMap()[0].toFloat()[0]
      curGravity = weight * ( (coordArray[0]-coord[0])**2 + (coordArray[1]-coord[1])**2)**(-decay/2)
      gravity = np.dstack((gravity, curGravity))
    gravitySum = np.sum(gravity,2)
    huff = np.max(gravity,2)/gravitySum
    np.shape(huff) 
    writeGeoTiff(huff,extent,outputfile)
    rlayer = QgsRasterLayer(outputfile)
    QgsMapLayerRegistry.instance().addMapLayer(rlayer)