Discussion :

[Luke spywoker]

Salut les pythons scientifiques.

j'ai quelques notions de numpy: quelques chapitres dédier et paragraphe par ci et par là sur le sujet.

Mais en ce moment je bosse avec OpenCV et donc aussi avec numpy.

Et j'ai comme par exemple pour extraire la liste des pixels canal par canal de couleurs ont peut employer la méthode suivante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
import cv2 # OpenCV
 
image=cv2.imread(filepath)
 
b, r, g = cv2.split(image) ; # blue, green, red color channels or pixel components list.
                             # or 
                             # >>> channels=cv2.split(image) ;

Puis par exemple de multiplier chaque canal (Qui est un numpy.array que je met en dtype=numpy.uint8 (un byte non-signé) ) par un facteur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
def scale_image(image, factor=1.0) :
  b, r, g = cv2.split(image) ;
 
  b = ( b * factor).astype(numpy.uint8)  # The problem is wenn the result from the multiplication is
  g = ( g * factor).astype(numpy.uint8)  # greater than 255 it overflow and rebound to 0 instead  
  r = ( r * factor).astype(numpy.uint8)  # of stopping at 255. And the same wenn littler than zero.
 
  cv2.merge((b,g,r), image) ;

De me pas être en mesure de mettre une valeur maximale | minimale.

Si l'on pourrait itérer sur les canaux de cette manière:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
def scale_per_canal(channel, factor=1.0) :
 
  for values in channel :
    for value in values :
      if int(value * factor) > 255 :
	value=255
      elif int(value * factor) < 0 :
	value=0
      else :
	value = int(value * factor)

Sans perdre la vitesse de numpy. Et bien ça serai parfait.

Vous avez sans nul doutes tous compris mon problème: si la multiplication produit un résultat hors des limites d'un uint8 et bien ça crée des erreurs dans les frames et si l'on itère sans numpy et bien l'on perd beaucoup de vitesse d'exécution et si l'on traite de la vidéo ou des images trop grandes ça se remarque.

En espérant que vous avez compris mon problème, je vous remercie pour vos réponses éclairées et votre aide précieuse.

PS: Le programme de démo du problème:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
import cv2
import numpy
 
from sys import argv, exit
 
from os.path import isfile
 
if len(argv) != 2 :
  print "usage %s filepath" %argv[0] 
  exit() 
 
if not isfile(argv[1]) :
  print "usage %s filepath" %argv[0] 
  exit()
 
image=cv2.imread(argv[1])
 
def scale_per_canal(channel, factor=1.0) :
 
  for values in channel :
    for value in values :
      if int(value * factor) > 255 :
	value=255
      elif int(value * factor) < 0 :
	value=0
      else :
	value = int(value * factor)  
 
 
def scale_image(image, factor=1.0) :
  b, r, g = cv2.split(image) ;
 
  # Uncomment following code to sea the speed difference.
  #scale_per_canal(b, factor) 
  #scale_per_canal(g, factor)
  #scale_per_canal(r, factor)
 
  # And comment folllowing lines to the sea the image result difference with relevant factors. 
  b = ( b * factor).astype(numpy.uint8)  # The problem is wenn the result from the multiplication is
  g = ( g * factor).astype(numpy.uint8)  # greater than 255 it overflow and rebound to 0 instead  
  r = ( r * factor).astype(numpy.uint8)  # of stopping at 255. And the same wenn littler than zero.
 
  cv2.merge((b,g,r), image) ;
 
 
 
 
scale_image(image, 1.5) 
 
cv2.namedWindow("MyWin",1);
 
print "Press 'q' to quit."
 
while True :
 
  keycode = cv2.waitKey(1)
 
  if (keycode & 0xFF == ord('q') ) :
    break ; 
 
  cv2.imshow("MyWin",image) ;

[he2lo]

Salut,

Tu peux créer une fonction qui fait ton traitement sur un nombre (fonction "universelle" ou ufunc) puis la vectoriser via la fonction vectorize() de numpy.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np
 
def scale_per_value(value, factor):
    if int(value * factor) > 255:
        return 255
    elif int(value * factor) < 0:
        return 0
    else:
        return int(value * factor)
 
scale_per_channel = np.vectorize(scale_per_value)
 
scale_per_channel(my_image[:, :, 0], .5)
scale_per_channel(my_image[:, :, 1], .5)
scale_per_channel(my_image[:, :, 2], .5)

Il y a aussi moyen d'utiliser des masques booléens:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
inf_to_zero = (channel * factor) < 0
channel[inf_to_zero] = 0

[Luke spywoker]

J'ai aussi penser a utiliser la primitive map() comme ufunc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
import numpy as np
my_map_ufunc=np.frompyfunc(map, 2, 1)

ou alors j'ai perquisitionner le secteur nditer de la documentation.

Rien ne vaut une simple multiplication qui agit sur tout le tableau.

Comme tout est bien qui finit bien:

il existe des fonctions permettant les opérations de base (+, -, *, /) dans cv2 (OpenCV) qui sont "safe" en terme de uint8 overflow...

PS: je regarderai la solution avec vectorize() quand même.