Numpy replace vecteur dans un tab 3 dimensions

Bonjour,

Je cherche un faire une manip avec numpy. (je pense que c'est réalisable).
J'ai un tableau 3 dimensions (une image), j'isole tout les couleurs de l'image avec

Code:

---

np.unique

---

.
Mon but est de sélectionner une couleur (vecteur de 3) et de mettre tour le tableau à 0 sauf les ligne de la couleur sélectionner.
J'ai déjà un résultat avec 2 boucles for mais c'est super long et je suis sur que numpy gère ce cas.

J'ai déjà fait plusieurs essais avec

Code:

---

np.where

---

combiné avec

Code:

---

np.all

---

mais je n'obtient pas le résultat voulu.

Avez des piste pour la méthode de numpy pour réaliser ça ?

Salut,

Je ne suis pas certain d'avoir bien saisi le problème. Un petit exemple serait le bienvenu. En 2D encore mieux.

Si je prends:

Code:

---

1 2 3 4

x = np.array([ [0, 1, 1, 0], [1, 0, 1, 0], ])

---

Je peux remplacer tous les 0 par des 2 :

Code:

---

x[x == 0] = 2

---

Puis remplacer tous ce qui n'est pas 2 par des 0 :

Code:

---

np.where(x !=2, x, 0)

---

L'une ou l'autre des méthodes permettent de remplacer des valeurs par d'autres. Mais si on parle de vecteur, pourvu que l'on obtienne l'indice de ce dernier, alors on peut aussi le remplacer. Dans cet exemple on remplace la colonne i (en comptant de zero) par des zéros :

Code:

---

x[:, i:i+1] = np.zeros((x.shape[0], 1))

---

J

Merci pour ta réponse.

Oui j'ai fait beaucoup d'essais sur les matrices et remplacer par un nombre. Mais moi c'est un peu plus pousser pour le coup :)

par exemple:

mon tableau :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

array([[[0, 55, 4], [0, 250, 10], [10,1 0, 0], ..., [0, 70, 90], [1, 10, 0], [0, 0, 0]],   [[100, 0, 85], [150, 0, 0], [0, 204, 0], ..., [100, 0, 85], [40, 50, 0], [0, 0, 0]]])

---

Je récupère toutes les couleur unique. Et par exemple si je sélectionne le vecteur [100, 0, 85], mon but est de mettre toutes les valeurs à 0 sauf les lignes qui sont égale à mon vecteur.
pour obtenir :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

array([[[0, 0, 0], [0, 0, 0], [0, 0, 0], ..., [0, 0, 0], [0 0, 0], [0, 0, 0]],   [[100, 0, 85], [0, 0, 0], [0, 0, 0], ..., [100, 0, 85], [0, 0, 0], [0, 0, 0]]])

---

Numpy a forcement prévu ce cas je pense (c'est plus précis ?)

J'appuie le message de Julien :
Si vous avez déjà un code qui fonctionne mais qui est long alors :
- Fournissez ce code, même s'il utilise des for- Donnez nous une matrice simple (nous balancer pas toute votre image, prenez en juste une petite sous partie, que l'on puisse tester)
- En principe j'aurais aussi dit la matrice d'arrivée souhaitée (le résultat attendu), mais si vous nous transmettez correctement les 2 premiers points on devrait être capable d'identifier le résultat que vous souhaitez obtenir, à moins que votre code avec les for soit lui même bugger, dans ce cas ce 3ieme est lui aussi nécessaire.

Tant qu'on n'a pas ca, difficile de vous aider correctement.

Salut,

Citation:

---

Envoyé par dentfree

Avez des piste pour la méthode de numpy pour réaliser ça ?

---

On peut faire çà avec all pour fabriquer un masque de booléen et s'en servir pour mettre à jour l'array initial.

On part d'une image de 4 pixels ou la diagonale est à [1,2,3]:

Code:

---

1 2 3

>>> import numpy as np >>> im = np.zeros((2,2,3)) >>> im[0,0] = im[1,1] = [1,2,3]

---

puis on fabrique un masque en sélectionnant ce qu'on veut:

Code:

---

>>> mask = (im == [1,2,3]).all(axis=2)

---

le masque est un tableau 2D de booléens.
Puis on assigne d'autres valeurs:

Code:

---

1 2 3 4 5 6 7

>>> im[mask] = [5,5,5] >>> im array([[[5., 5., 5.], [0., 0., 0.]],   [[0., 0., 0.], [5., 5., 5.]]])

---

très pratique pour faire des seuillages (avec >=...)

note: tout çà pour montrer qu'en levant un peu le nez du guidon, on peut reproduire le problème sans même image juste avec une matrices 2x2 de simulacres de pixels. L'important n'est pas tellement dans les dimensions du tableau mais dans sa structure et les opérations qu'on projette d'y faire.

- W

Voici le code (qui est fonctionnel):

Code:

---

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

def imshow_components(image): gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) ret, labels = cv2.connectedComponents(gray) label_hue = np.uint8(179*labels/np.max(labels)) blank_ch = 255*np.ones_like(label_hue) labeled_img = cv2.merge([label_hue, blank_ch, blank_ch])   labeled_img = cv2.cvtColor(labeled_img, cv2.COLOR_HSV2BGR) labeled_img[label_hue==0] = 0 return (labeled_img)   def mask_fct(img): img = imshow_components(img) coor = [] colors = [] for i in range(img.shape[0]): for j in range(img.shape[1]): if (img[i][j][2] != 0 or img[i][j][1] != 0 or img[i][j][0] != 0): coor.append((i, j)) color = (img[i][j][0], img[i][j][1], img[i][j][2]) if (color not in colors): colors.append(color) nb_spot = (len(colors))   mask = np.zeros((img.shape[0],img.shape[1],nb_spot), dtype=bool) for i in range(img.shape[0]): for j in range(img.shape[1]): color = (img[i][j][0], img[i][j][1], img[i][j][2]) if (color in colors): index = colors.index(color) mask[i][j][index] = True class_ids = np.zeros((nb_spot), dtype=np.int32) class_ids[:] = 1 return(mask, class_ids)

---

L'image est un fond noir avec plusieurs tache blanche dessus
La fonction

Code:

---

imshow_components()

---

prend mon image en noir et blanc et retourne cette image mais avec une couleur différente par tache.
un exemple d'image réduit a 10*10 pixels :

Code:

---

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 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110

array([[[ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]],   [[ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 255, 136], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]],   [[ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 255, 136], [ 0, 255, 136], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]],   [[ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 255, 136], [ 0, 255, 136], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]],   [[ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]],   [[ 0, 0, 0], [247, 255, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [255, 0, 119], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]],   [[ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [255, 0, 119], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]],   [[ 0, 0, 0], [ 0, 0, 0], [ 8, 0, 255], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]],   [[ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]],   [[ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0], [ 0, 0, 0]]], dtype=uint8)

---

Ma première double boucle for est remplacer par :

Code:

---

colors = np.unique(img.reshape(-1, img.shape[-1]), axis=0)

---

Ce qui me donne un tableau avec chaque couleur unique de l'image, ici :

Code:

---

1 2 3 4 5 6

(array([[ 0, 0, 0], [ 0, 255, 136], [ 8, 0, 255], [247, 255, 0], [255, 0, 119]], dtype=uint8))

---

Mon but final est de sélectionner une couleur, par exemple [247, 255, 0] (présente dans mon tableau). Et dans mon image de 10*10 mettre tout les points à 0 excepter ceux de la couleur sélectionnée et ainsi isoler cette partie de l'image.

Je pense qu'avec un code style

Code:

---

a = np.where(np.all(<mon image> != <ma couleur select>, axis=1), [0,0,0], <mon image>)

---

je dois pas être trop loin mais je n'ai pas le résultat voulu

Je ne peux pas plus détailler :)
Le code est parfaitement fonctionnel pour mon utilisation mais super lent.

@wiztricks, je vais essayer de creuser ta solution, merci

Félicitation pour la rédaction de votre premier vrai message.
Alors le masque que vous chercher à produire (10,10, nb_colors), alors qu'il serait plus facile d'avoir qqch comme un array de taille (nb_colors, 10,10) (modifier 10 par la taille de l'image bien sûr), voire même une liste de longueur nb_colors, dont chaque élément est un np.array booléen de taille (10,10).

Wiztricks vous a en effet déjà donné ce qu'il vous faut je pense.

Voici comment on peut construire un masque pour une couleur donnée :

Code:

---

1 2 3 4 5 6

colors = np.unique(img.reshape(-1, img.shape[-1]), axis=0) print(colors)   one_color = colors[3]   mask = (img == one_color).all(axis=2)

---

puis comment l'utiliser :

Code:

---

1 2 3

img[np.invert(mask)]=[0,0,0]   print(img)

---

Notez le np.invert, car vous ne voulez pas modifier là où vous avez trouvez la couleur, mais vous voulez modifier (mettre à 0) partout où vous n'avez pas la couleur. Vous auriez aussi pu faire sans ce np.invert en construisant directement le mask des pixels qui ne sont pas de la couleur voulue:

Code:

---

mask = (img != one_color).all(axis=2)

---

.

A vous de voir comment vous voulez rassemblez ensuite l'information pour l'ensemble des couleurs.

Merci de coup de main j'ai réussis l'optimisation voulu.

Voici le code des fois que ça intéresse des gens pour plus tard>

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

def mask_fct(img): img = imshow_components(img) colors = np.unique(img.reshape(-1, img.shape[-1]), axis=0) colors = colors[1:] masks = None save_img = img.copy() for index, color in enumerate(colors): img = save_img.copy() mask = (img == color).all(axis=2) img[np.invert(mask)]=[0,0,0] img = img.astype(bool) mask = np.logical_or.reduce(img, axis=2) if index == 0: masks = mask.copy() else: masks = np.dstack((masks, mask)) class_ids = np.zeros((len(colors)), dtype=np.int32) class_ids[:] = 1 return(masks, class_ids)

---

Pour la forme de mon masque final (hauteur*largeur*nombre de couleur), je dois le laisser sous cette forme pour l'algo qui l'exploite après.

Bonne journée et encore merci.