paquete - Remuestreo de datos espaciados irregularmente a una cuadrícula regular en Python

paquete re python

Question

Necesito volver a muestrear datos 2D a una cuadrícula regular.

Así es como se ve mi código:

import matplotlib.mlab as ml
import numpy as np
y = np.zeros((512,115))
x = np.zeros((512,115))
# Just random data for this test:
data = np.random.randn(512,115)
# filling the grid coordinates:
for i in range(512):
y[i,:]=np.arange(380,380+4*115,4)
for i in range(115):
x[:,i] = np.linspace(-8,8,512)
y[:,i] -= np.linspace(-0.1,0.2,512)
# Defining the regular grid
y_i = np.arange(380,380+4*115,4)
x_i = np.linspace(-8,8,512)
resampled_data = ml.griddata(x,y,data,x_i,y_i)

(512,115) es la forma de los datos 2D, y ya instalé mpl_toolkits.natgrid.

Mi problema es que recupero una matriz enmascarada, donde la mayoría de las entradas son nan, en lugar de una matriz que se compone principalmente de entradas regulares y solo nan en las fronteras.

¿Podría alguien señalarme lo que estoy haciendo mal?

¡Gracias!

Answer 1

Comparando su ejemplo de código con el título de su pregunta, creo que está un poco confundido ...

En su código de ejemplo, está creando datos aleatorios de cuadrícula con frecuencia y luego los vuelve a muestrear en otra cuadrícula regular . No tienes datos irregulares en tu ejemplo ...

(Además, el código no se ejecuta como está, y deberías buscar en meshgrid en lugar de hacer un meshgrid para generar tus cuadrículas de x e y).

Si desea volver a muestrear una cuadrícula ya muestreada regularmente, como lo hace en su ejemplo, hay métodos más eficientes que los datos de cuadrícula o cualquier cosa que esté a punto de describir a continuación. ( scipy.ndimage.map_coordinates se scipy.ndimage.map_coordinates bien a su problema, en ese caso).

Sin embargo, según su pregunta, parece que tiene datos espaciados irregularmente que desea interpolar en una cuadrícula regular.

En ese caso, podría tener algunos puntos como este:

import numpy as np
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt
# Bounds and number of the randomly generated data points
ndata = 20
xmin, xmax = -8, 8
ymin, ymax = 380, 2428
# Generate random data
x = np.random.randint(xmin, xmax, ndata)
y = np.random.randint(ymin, ymax, ndata)
z = np.random.random(ndata)
# Plot the random data points
plt.scatter(x,y,c=z)
plt.axis([xmin, xmax, ymin, ymax])
plt.colorbar()
plt.show()

Luego puede interpolar los datos como lo estaba haciendo antes ... (Continúa en el fragmento de código de arriba ...)

# Size of regular grid
ny, nx = 512, 115
# Generate a regular grid to interpolate the data.
xi = np.linspace(xmin, xmax, nx)
yi = np.linspace(ymin, ymax, ny)
xi, yi = np.meshgrid(xi, yi)
# Interpolate using delaunay triangularization
zi = mlab.griddata(x,y,z,xi,yi)
# Plot the results
plt.figure()
plt.pcolormesh(xi,yi,zi)
plt.scatter(x,y,c=z)
plt.colorbar()
plt.axis([xmin, xmax, ymin, ymax])
plt.show()

Sin embargo, notará que está recibiendo muchos artefactos en la cuadrícula. Esto se debe al hecho de que sus coordenadas x varían de -8 a 8, mientras que las coordenadas y varían de ~ 300 a ~ 2500. El algoritmo de interpolación intenta hacer que las cosas sean isotrópicas, mientras que es posible que desee una interpolación altamente anisotrópica (para que aparezca isotrópica cuando se traza la cuadrícula).

Para corregir esto, necesita crear un nuevo sistema de coordenadas para hacer su interpolación. No hay una forma correcta de hacerlo. Lo que estoy usando a continuación funcionará, pero la "mejor" forma depende en gran medida de lo que realmente representan sus datos.

(En otras palabras, use lo que sabe sobre el sistema que miden sus datos para decidir cómo hacerlo. ¡Esto siempre es así con la interpolación! No debe interpolar a menos que sepa cómo debe verse el resultado , y está lo suficientemente familiarizado con el algoritmo de interpolación para usar esa información a priori para su ventaja. También hay algoritmos de interpolación mucho más flexibles que la triangulación de Delaunay que los datos de cuadrícula utilizan de forma predeterminada, pero está bien para un ejemplo simple ...)

En cualquier caso, una forma de hacerlo es volver a escalar las coordenadas x e y para que se extiendan aproximadamente en las mismas magnitudes. En este caso. los reescalamos de 0 a 1 ... (perdona el código de la cadena de espaguetis ... Sólo pretendo que esto sea un ejemplo ...)

# (Continued from examples above...)
# Normalize coordinate system
def normalize_x(data):
data = data.astype(np.float)
return (data - xmin) / (xmax - xmin)
def normalize_y(data):
data = data.astype(np.float)
return (data - ymin) / (ymax - ymin)
x_new, xi_new = normalize_x(x), normalize_x(xi)
y_new, yi_new = normalize_y(y), normalize_y(yi)
# Interpolate using delaunay triangularization
zi = mlab.griddata(x_new, y_new, z, xi_new, yi_new)
# Plot the results
plt.figure()
plt.pcolormesh(xi,yi,zi)
plt.scatter(x,y,c=z)
plt.colorbar()
plt.axis([xmin, xmax, ymin, ymax])
plt.show()

Espero que eso ayude, al menos ... ¡Lo siento por la longitud de la respuesta!