Reducir la resolución de una matriz en Python

He básico 2-D de los arrays de numpy y me gustaría «reducir la resolución a una más gruesa de la resolución. Hay una simple numpy o scipy módulo que puede hacer esto fácilmente? También debo señalar que esta matriz es la que se muestra geográficamente a través de los Mapas de referencia de los módulos.

EJEMPLO:
Reducir la resolución de una matriz en Python

InformationsquelleAutor wuffwuff | 2013-09-06

6 Kommentare

  1. 13

    scikit-image ha implementado una versión de trabajo de downsampling aquí, a pesar de que rehuir de llamar downsampling por no tratarse de una disminución de resolución en términos de la DSP, si he entendido bien:

    http://scikit-image.org/docs/dev/api/skimage.measure.html#skimage.measure.block_reduce

    pero funciona muy bien, y es la única downsampler que he encontrado en Python que se puede lidiar con np.nan en la imagen. He disminuirá la gigantesca imágenes con esto muy rápidamente.

  2. 10

    Cuando la reducción de tamaño, la interpolación es la cosa incorrecta a hacer. Utilice siempre un agregado enfoque.

    Yo uso el bloque de medios para hacer esto, el uso de un «factor» de reducir la resolución.

    import numpy as np
    from scipy import ndimage
    
    def block_mean(ar, fact):
        assert isinstance(fact, int), type(fact)
        sx, sy = ar.shape
        X, Y = np.ogrid[0:sx, 0:sy]
        regions = sy/fact * (X/fact) + Y/fact
        res = ndimage.mean(ar, labels=regions, index=np.arange(regions.max() + 1))
        res.shape = (sx/fact, sy/fact)
        return res

    E. g., un (100, 200) forma de matriz utilizando un factor de 5 (5×5 bloques) resultados en un (20, 40) resultado de la matriz:

    ar = np.random.rand(20000).reshape((100, 200))
    block_mean(ar, 5).shape  # (20, 40)
    • Gracias, Mike. Yo creo que tu solución es más de lo que yo estoy buscando. Al aplicar el código, estoy recibiendo un error debido a la falta de coincidencia de tamaño de la matriz: File "diffplot.py", line 38, in block_mean res.shape = (sx/fact, sy/fact) ValueError: total size of new array must be unchanged
    • El problema anterior se debió a la necesidad de que el factor de ser igualmente divisible en la matriz original forma. Sin embargo, esta función todavía proporciona la indebida de los resultados. Interesante. No parece ser ‘re-muestreo» como lo que estoy buscando. En su lugar, tomó el diff de la matriz y se trazan varias veces en el mapa base de la ventana. Creo que tengo algún tipo de agregación o disolución de la técnica. Gracias por tu aporte hasta ahora.
    • Hola Mike, ¿te importaría explicar por qué la interpolación es una mala manera de reducir la resolución? Si la interpolación es malo, ¿hay una buena manera de lidiar con los casos en que las dimensiones de la imagen no son divisibles por el tamaño de bloque deseado?
    • Esta es una alternativa de implementación de la misma cosa, creo: github.com/keflavich/image_registration/blob/master/…. No estoy seguro de cómo la velocidad se compara, pero yo apostaría scipy.ndimage es un poco más rápido.
    • no funciona: ValueError: tamaño total de la nueva matriz debe ser invariable
  3. 4

    imresize y ndimage.la interpolación.zoom ver como hacen lo que quieren

    No he probado imresize antes, pero aquí es cómo he utilizado ndimage.la interpolación.zoom

    a = np.array(64).reshape(8,8)
    a = ndimage.interpolation.zoom(a,.5) #decimate resolution

    una es entonces una matriz de 4×4 con valores interpolados en ella

    • Aquí es un fragmento de código: findiff = scipy.misc.imresize(diff, 30., interp='bilinear', mode=None) frefcobj = m.pcolormesh(x,y,findiff,shading='flat',vmin=-15,vmax=15,cmap=cmap,zorder=1) colbar = m.colorbar(frefcobj,"bottom",size="4%",pad="5%",extend='both',ticks=intervals) diff es una 699×699 matriz. No parece ser el logro de la tarea.
    • No he probado imresize antes, pero he añadido un fragmento de código que utiliza el zoom. Es que no es lo que usted está buscando? No puedo probar imresize en el momento porque tengo una versión anterior de scipy que no parece incluir
    • Interesante. No parece ser ‘re-muestreo» como lo que estoy buscando. En su lugar, tomó el diff de la matriz y se trazan varias veces en el mapa base de la ventana. Creo que tengo algún tipo de agregación o disolución de la técnica. Gracias por tu aporte hasta ahora.
    • Por reducir la resolución que significa que usted quiera menos muestras de que cuando usted comenzó a la derecha? O a qué te refieres desea desenfocar su matriz?
    • Me gustaría hacer la nueva matriz más «gruesa» por lo menos muestras.
    • La interpolación debe nunca se utiliza para reducir la resolución de cualquier cosa.
    • imresize es int8 precisión, y ndimage.la interpolación.zoom utiliza vecino más cercano de la disminución de resolución. Ambos no son muy útiles para datos numéricos.

  4. 2

    Porque el OP quiere es un cazador de resolución, pensé que iba a compartir mi manera de reducir el número de píxeles por la mitad en cada dimensión. Me toma de la media de los bloques de 2×2. Esto se puede aplicar varias veces para reducir por un factor de 2.

    from scipy.ndimage import convolve
    array_downsampled = convolve(array, 
                     np.array([[0.25,0.25],[0.25,0.25]]))[:array.shape[0]:2,:array.shape[1]:2]
  5. 1

    Esto podría no ser lo que usted está buscando, pero he pensado que me gustaría mencionar es la integridad.

    Podrías probar instalando scikits.samplerate (docs), que es un wrapper) de Python para libsamplerate. Se ofrece agradable, de alta calidad de los algoritmos de remuestreo, PERO lo que puedo decir, sólo funciona en 1D. Usted podría ser capaz de volver a muestrear su señal 2D primera a lo largo del eje y, a continuación, a lo largo de otro, pero me gustaría pensar que pueden contrarrestar los beneficios de la alta calidad de remuestreo para empezar.

    • Sí, que no trabajo para esta situación, pero gracias por el aporte. Necesito algo que puede agregado espacialmente.
  6. 0

    Manera más fácil:
    Usted puede utilizar el array[0::2] la notación, que sólo considera a cada segundo índice.
    E. g.

    array= np.array([[i+j for i in range(0,10)] for j in range(0,10)])
    down_sampled=array[0::2,0::2]
    
    print("array \n", array)
    print("array2 \n",down_sampled)

    tiene la salida:

    array 
    [[ 0  1  2  3  4  5  6  7  8  9]
     [ 1  2  3  4  5  6  7  8  9 10]
     [ 2  3  4  5  6  7  8  9 10 11]
     [ 3  4  5  6  7  8  9 10 11 12]
     [ 4  5  6  7  8  9 10 11 12 13]
     [ 5  6  7  8  9 10 11 12 13 14]
     [ 6  7  8  9 10 11 12 13 14 15]
     [ 7  8  9 10 11 12 13 14 15 16]
     [ 8  9 10 11 12 13 14 15 16 17]
     [ 9 10 11 12 13 14 15 16 17 18]]
    array2 
    [[ 0  2  4  6  8]
     [ 2  4  6  8 10]
     [ 4  6  8 10 12]
     [ 6  8 10 12 14]
     [ 8 10 12 14 16]]

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea