L'intensité de normalisation de l'image à l'aide de Python+PIL - des problèmes de Vitesse de

Je suis en train de travailler sur un petit problème dans mon sparetime, comprenant l'analyse de certaines images obtenues à l'aide d'un microscope. C'est une gaufre avec quelques trucs ici et là, et, finalement, je veux faire un programme pour détecter lorsque certains matériaux.

De toute façon, la première étape consiste à normaliser l'intensité dans l'image, étant donné que la lentille ne donne pas l'uniforme de la foudre. Actuellement, je utiliser une image, avec un pas de trucs, seul le substrat, comme un arrière-plan ou de référence, de l'image. J'ai trouver le maximum de trois (intensité) les valeurs de RVB.

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)

La première partie du code qui détermine le maximum d'intensité de ROUGE, de VERT et de BLEU, pixel par pixel, de l'image d'arrière-plan, mais il doit être fait une seule fois.

La deuxième partie prend les images "réelles" (avec des trucs sur elle), et normalise le ROUGE, le VERT et le BLEU, pixel par pixel, en fonction de l'arrière-plan. Cela prend un certain temps, de 5 à 10 secondes pour une 1280x960 image, qui est trop lent si j'en ai besoin pour ce faire de plusieurs images.

Que puis-je faire pour améliorer la vitesse? J'ai pensé à déplacer toutes les images de tableaux numpy, mais je n'arrive pas à trouver un moyen rapide de le faire pour les images RVB.
Je préfère ne pas l'éloigner de python, depuis mon C++ est assez bas niveau, et d'obtenir un travail code FORTRAN serait probablement prendre plus de temps que je ne pourrais jamais enregistrer en termes de vitesse 😛

C'est probablement ce qui appartient à codereview.stackexchange.com plus qu'ici.
Je pense que c'est une zone grise. La question est au sujet d'une technologie spécifique, après tout.
Rançon: Comment "technologie spécifique" gris? C'est le code. Pour être examiné.
peut-être que vous avez raison, il n'est pas gris, après tout. Je viens de re-lire la FAQ et je ne vois pas un seul problème avec cette question.
avez-vous pensé à OpenCV? C'est un puissant traitement de l'image de la bibliothèque avec des bindings Python. Il est rapide avec la lecture et l'écriture, et a, par exemple, un adaptiveThreshold algorithme.

OriginalL'auteur Happy | 2011-09-14

  1. 8
    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')
    quand je fais cela sur une image en niveaux de gris (modifié convertir et enregistrer à 'L') je ne peux pas dire toute différence par rapport à seulement convertir en niveaux de gris (sauf que c'est environ 3 fois plus grande taille de fichier). avec la couleur de ses aussi des grandes mais je peux visuellement dire la différence. d'où l'augmentation de la taille des fichiers à partir de? dois-je être capable de remarquer les différences dans les niveaux de gris de la normalisation, et si oui, quoi d'autre ai-je besoin de changer ici si quelque chose? j'ai remarqué que le wiki donne l'exemple de la même formule pour les niveaux de gris.
    Si vous avez une image en niveaux de gris, puis arr aura la forme (H, W) au lieu de (H, W, 4). Par conséquent, vous n'avez pas besoin de normaliser chaque canal, arr[..., i]. Au lieu de cela, vous auriez normaliser arr lui-même. Donc, supprimer le for-loop et changement arr[..., i] à arr.

    OriginalL'auteur unutbu

  2. 2

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

    Vous pouvez dire

    databack = scipy.misc.fromimage(pixback)
rmax = numpy.max(databack[:,:,0])
gmax = numpy.max(databack[:,:,1])
bmax = numpy.max(databack[:,:,2])

    qui devrait être beaucoup plus rapide en boucle sur toutes les (r,g,b) les triplets de votre image.
    Ensuite, vous pouvez faire

    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)

    Le code n'est pas testé, mais devrait fonctionner d'une certaine manière avec des modifications mineures.

    Tout cela est en effet très(!) rapide par rapport à mon (w)hack, quelque chose qui semble être désactivé avec la fonction scipy. E. g. l'utilisation d'une image comme farm1.static.flickr.com/58/165782919_38f15d585a.jpg le code suivant devrait montrer le canal rouge de l'image, mais cela ne semble pas être le cas: scipy.misc.toimage(databack[:,:,0]).show()
    Unutbu a donné une autre solution qui n'utilise pas de scipy pour convertir les images et numpy données dans les deux directions. Peut être devrais tu essayer quelque chose comme arr=np.array(np.asarray(img).astype('float')) new_img = Image.fromarray(normalize(arr).astype('uint8'),'RGBA')

    OriginalL'auteur rocksportrocker