Intensität Normalisierung des Bildes mit Python+PIL - Speed Probleme

Ich bin auf ein kleines problem in meinem sparetime Einbeziehung der Analyse von einigen Bildern, die durch ein Mikroskop. Es ist ein wafer mit ein paar Sachen hier und da, und letztendlich möchte ich ein Programm um zu erkennen, Wann bestimmte Materialien zu zeigen.

Sowieso, der erste Schritt ist die Normalisierung der Intensität über das Bild, da die Linse nicht geben einheitlichen Blitz. Derzeit verwende ich ein Bild, mit keine Sachen auf, nur der Untergrund, als hintergrund, oder als Referenz, Bild. Ich finde das maximum von drei (Intensitäts -) Werte für RGB.

from PIL import Image
from PIL import ImageDraw

rmax = 0;gmax = 0;bmax = 0;rmin = 300;gmin = 300;bmin = 300

im_old = Image.open("test_image.png")
im_back = Image.open("background.png")

maxx = im_old.size[0] #Import the size of the image
maxy = im_old.size[1]
im_new = Image.new("RGB", (maxx,maxy))


pixback = im_back.load()
for x in range(maxx):
    for y in range(maxy):
        if pixback[x,y][0] > rmax:
            rmax = pixback[x,y][0]
        if pixback[x,y][1] > gmax:
            gmax = pixback[x,y][1]
        if pixback[x,y][2] > bmax:
            bmax = pixback[x,y][2]


pixnew = im_new.load()
pixold = im_old.load()
for x in range(maxx):
    for y in range(maxy):
        r = float(pixold[x,y][0]) / ( float(pixback[x,y][0])*rmax )
        g = float(pixold[x,y][1]) / ( float(pixback[x,y][1])*gmax )
        b = float(pixold[x,y][2]) / ( float(pixback[x,y][2])*bmax )
        pixnew[x,y] = (r,g,b)

Den ersten Teil des Codes legt die maximale Intensität der ROT -, GRÜN-und BLAU-Kanäle, pixel für pixel, der hintergrund-Bild, aber muss nur einmal gemacht werden.

Den zweiten Teil übernimmt das "echte" Bild (mit Sachen drauf), und normalisiert die ROT -, GRÜN-und BLAU-Kanäle, pixel für pixel, nach dem hintergrund. Dies dauert einige Zeit, 5-10 Sekunden für einen 1280x960-Bild, das ist viel zu langsam, wenn ich brauche, um dies zu tun, um mehrere Bilder.

Was kann ich tun um die Geschwindigkeit zu verbessern? Ich dachte, der Umzug alle Bilder in numpy-arrays, aber ich kann nicht scheinen zu finden, eine schnelle Möglichkeit, dass Sie für RGB-Bilder.
Ich möchte lieber nicht Weg von python, da mein C++ ist ziemlich low-level, und immer eine funktionierende FORTRAN-code würde wahrscheinlich länger dauern, als ich jemals sparen in Bezug auf die Geschwindigkeit 😛

Dies ist wahrscheinlich gehört zur codereview.stackexchange.com mehr als hier.
Ich denke, es ist eine Grauzone. Die Frage ist in Bezug auf eine bestimmte Technologie, nachdem alle.
Lösegeld: Wie funktioniert die "spezielle Technologie" machen Sie Grau? Es ist code. Überprüft werden.
vielleicht hast du Recht, es ist nicht Grau, nachdem alle. Ich habe gerade wieder-die FAQ gelesen und ich sehe nicht ein einziges problem mit dieser Frage.
haben Sie sich Gedanken über OpenCV? Es ist ein leistungsfähiges Bildverarbeitungs-Bibliothek mit Python bindings. Es ist schnell mit Lesen und schreiben, und hat, zum Beispiel, eine adaptiveThreshold Algorithmus.

InformationsquelleAutor Happy | 2011-09-14

9
```
import numpy as np
from PIL import Image

def normalize(arr):
    """
    Linear normalization
    http://en.wikipedia.org/wiki/Normalization_%28image_processing%29
    """
    arr = arr.astype('float')
    # Do not touch the alpha channel
    for i in range(3):
        minval = arr[...,i].min()
        maxval = arr[...,i].max()
        if minval != maxval:
            arr[...,i] -= minval
            arr[...,i] *= (255.0/(maxval-minval))
    return arr

def demo_normalize():
    img = Image.open(FILENAME).convert('RGBA')
    arr = np.array(img)
    new_img = Image.fromarray(normalize(arr).astype('uint8'),'RGBA')
    new_img.save('/tmp/normalized.png')
```
- wenn ich Sie auf Graustufen-Bild (geändert konvertieren und speichern Sie auf 'L') ich kann nicht sagen, keinen Unterschied im Vergleich zu knapp der Konvertierung in Graustufen (außer, dass es etwa 3 mal größere Dateigröße). mit Farbe ist auch größer, aber ich kann visuell erzählen Unterschied. wo kommt die filesize erhöhen kommen? sollte ich in der Lage sein, um zu bemerken, ein diff in Graustufen Normalisierung, und wenn ja, was muss ich hier ändern, wenn irgendetwas? mir ist aufgefallen das wiki gibt das Beispiel der gleichen Formel für die Graustufen.
- Wenn Sie ein Graustufen-Bild, dann arr haben Form (H, W) statt (H, W, 4). Deshalb, Sie brauchen nicht zu normalisieren jeden Kanal arr[..., i]. Stattdessen würden Sie normalisieren arr selbst. So entfernen Sie die for-loop und ändern arr[..., i] zu arr.
InformationsquelleAutor unutbu
2

Sehen http://docs.scipy.org/doc/scipy/reference/generated/scipy.misc.fromimage.html#scipy.misc.fromimage

Kann man sagen,
```
databack = scipy.misc.fromimage(pixback)
rmax = numpy.max(databack[:,:,0])
gmax = numpy.max(databack[:,:,1])
bmax = numpy.max(databack[:,:,2])
```
denen sollte viel schneller sein als die Schleife über alle (r,g,b) Drillinge von Ihrem Bild.
Dann können Sie tun,
```
dataold = scip.misc.fromimage(pixold)
r = dataold[:,:,0] / (pixback[:,:,0] * rmax )
g = dataold[:,:,1] / (pixback[:,:,1] * gmax )
b = dataold[:,:,2] / (pixback[:,:,2] * bmax )

datanew = numpy.array((r,g,b))
imnew = scipy.misc.toimage(datanew)
```
Der code ist nicht getestet, aber es sollte doch irgendwie funktionieren mit geringfügigen änderungen.
- Dies ist zwar in der Tat durchaus(!) schnell im Vergleich zu meinem (w)hack, etwas zu sein scheint, aus mit der scipy-Funktion. E. g. mit einem Bild wie farm1.static.flickr.com/58/165782919_38f15d585a.jpg sollte der folgende code zeigt den rot-Kanal des Bildes, aber das scheint nicht der Fall zu sein: scipy.misc.toimage(databack[:,:,0]).show()
- Unutbu gab eine andere Lösung, welche nicht mit scipy zum konvertieren von Bildern und numpy Daten in beide Richtungen. Vielleicht sollten Sie versuchen, so etwas wie arr=np.array(np.asarray(img).astype('float')) new_img = Bild.fromarray(normalize(arr).astype('uint8'),'RGBA')
InformationsquelleAutor rocksportrocker

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.