Gibt es eine bequeme Möglichkeit, eine Nachschlagetabelle auf ein großes Array in numpy anzuwenden?

Question

Ich habe ein Bild in numpy mit einigen Pixeln in meinem resultierenden Array gelesen.

ich eine Lookup-Tabelle mit 256 Werten berechnet. Jetzt möchte ich folgendes tun:

for i in image.rows: 
    for j in image.cols: 
     mapped_image[i,j] = lut[image[i,j]] 

Ja, das ist im Grunde, was ein lut tut.
Nur Problem ist: Ich möchte es effizient zu tun und rufen Sie diese Schleife in Python wird mich warten, für einige Sekunden, bis es zu beenden.

ich von numpy.vectorize() wissen, es ist einfach eine Komfortfunktion, die den gleichen Python-Code aufruft.

Answer 1

Sie können nur image indizieren in lut verwenden, wenn lut ist 1D.
Hier ist ein Starter auf Indizierung in NumPy:
http://www.scipy.org/Tentative_NumPy_Tutorial#head-864862d3f2bb4c32f04260fac61eb4ef34788c4c

In [54]: lut = np.arange(10) * 10 

In [55]: img = np.random.randint(0,9,size=(3,3)) 

In [56]: lut 
Out[56]: array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90]) 

In [57]: img 
Out[57]: 
array([[2, 2, 4], 
     [1, 3, 0], 
     [4, 3, 1]]) 

In [58]: lut[img] 
Out[58]: 
array([[20, 20, 40], 
     [10, 30, 0], 
     [40, 30, 10]]) 

Geist auch die Indizierung beginnt bei 0

Answer 2

in der richtigen TheodrosZelleke Antwort, aber ich wollte nur ein wenig undokumentierte Weisheit, um es hinzuzufügen. Numpy stellt eine Funktion zur Verfügung, np.take, die laut der Dokumentation "macht das gleiche Ding wie Phantasie Indizierung."

Naja, fast, aber das gleiche nicht ganz:

>>> import numpy as np 
>>> lut = np.arange(256) 
>>> image = np.random.randint(256, size=(5000, 5000)) 
>>> np.all(lut[image] == np.take(lut, image)) 
True 
>>> import timeit 
>>> timeit.timeit('lut[image]', 
...    'from __main__ import lut, image', number=10) 
4.369504285407089 
>>> timeit.timeit('np.take(lut, image)', 
...    'from __main__ import np, lut, image', number=10) 
1.3678052776554637 

np.take über 3x schneller ist! Meiner Erfahrung nach ermöglicht die Verwendung von 3D-Luts zum Konvertieren von Bildern von RGB in andere Farbräume das Hinzufügen einer Logik zum Konvertieren des 3D-Look-Ups in ein 1D-Flat-Up-Look-Up, um eine X10-Beschleunigung zu erzielen.