Afficher un vecteur comme morcellement d'images

[gmoaltos]

Salut tout le monde,

(Je post rarement car j'ai l'habitude de chercher longtemps mais là je ne sais même pas comment chercher ... donc excusez-moi si le post est mal placé.)

J'utilise actuellement imshow pour afficher temporellement l'activité dans des aires cérébrales en image. (Exemple ici : 10_0P.png)
Ce que je fait actuellement :
- créer 67 images (66 aires (A) et 1 contour (C)) au temps t_0
- calculer le vecteur des 66 activites v
- créer mon image comme : img = C + sum([ v[i] * A[i] , for i in range(66) ])
- affichage de l'image via imshow(img)

Le problème est le coût en temps de calcul.
Quelqu'un connaîtrait-il un moyen d'afficher mon vecteur sur une grille qui prendrait la forme de mon contour ? Une idée de mot clé pour chercher plus loin ?

J'ai pensé à créer plusieurs objets imshow pour chaque aires et faire varier les alphas en fonction du vecteur ce qui eviterait de recalculer l'image à chaque fois mais je n'ai pas encore essayé. Je pense que j'aurai un problème pour mon colorbar.

Merci pour votre temps.

[dividee]

Salut,

je ne suis pas sûr d'avoir bien compris; chaque image A représente un seule zone du cerveau, colorée, avec tout le reste de l'image en ... noir ? blanc ?, et tu multiplies par l'activité pour faire varier la couleur, c'est ça ?

Dans ce cas mon idée serait d'utiliser une seule image de base, en mode palette, avec chaque région dans un couleur différente de la palette. Il suffira ensuite d'assigner les couleurs aux entrées de la palette en fonction des activités, ce serait très rapide. La principale difficulté serait pour afficher la colorbar; le plus simple serait de convertir l'image en 24 bits et d'ajouter ensuite la colobar.

[gmoaltos]

L'idée est pas mal je la met de côté merci, mais le code couleur m'est important pour voir si deux zones ont la même intensité.
Et oui chaque image A[i] représente une zone i du cerveau constitué de 1 dans la zone et de 0 en dehors.
J'ai trouvé une solution (jouer sur la transparence des objets imshow) mais je pense que c'est plus du bricolage qu'autre chose :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
# Au temps t_0 :
from pylab import cm
from matplotlib import colors, imshow
 
cmap = cm.Reds
cmap.set_under(color='w', alpha=0)   # Pour mettre le blanc transparent
norm = colors.Normalize(vmin=0.5, clip=False)
 
imC  =   imshow(Contour, cmap=cmap, norm=norm)
imA  = [ imshow(A[i],    cmap=cmap, norm=norm) for i in range(len(A)) ]
cbar = colorbar(imC)
 
# Au temps t :
[ imA[i].set_alpha(v[i]) ]

Cela me permet d'éviter de recalculer l'image à chaque itération donc le gain de temps est là mais il y a un effet crénelage qui apparaît au niveau des contours du à la transparence donc ce n'est pas aussi beau qu'avant.

[__dardanos__]

Bonjour.
Je ne suis pas sûr d'avoir tout compris.
Le problème me semble plus simple si on traite l'image comme un tableau de nombres.
Chaque zone est associée à une valeur de clef d'un dictionnaire, qui sert à stocker les indices de la zone dans l'image.
Ma solution doit être proche de celle de Dividee.

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
# -*- coding:Utf-8 -*-
import matplotlib.pyplot as plt
import numpy as np
import time
 
def definir_zone(i_1, i_2, j_1, j_2):
    """ Calcule les indices équivalents à tab[i_1:i_2,j_1,j_2] """
    ind_y = [ (i)//(j_2 - j_1) + i_1 for i in range( (i_2 - i_1) * (j_2 - j_1) ) ]
    ind_x = range( j_1, j_2) * (i_2 - i_1)
    return np.array(ind_y), np.array(ind_x)
 
if __name__ == '__main__':
    n = 100     # Taille de l'image [n x n]
    plt.ion()   # utilise pyplot en interactif
 
    # Déclaration de l'image
    A = np.zeros( (n,n), dtype=np.int)
 
    # Création des zones
    zones = {}
    for i, ind in enumerate( ( (10,40,10,50), (50,100,10,70), (10,100,80,100) ) ):
        i1, i2, j1, j2 = ind
        zones[i] = definir_zone( i1, i2, j1, j2)
    nb_z = zones.__len__()
 
    while True:
        # Modification des valeurs quelque part dans le programme
        valeurs = { i: int(np.random.uniform(high=100)) for i in np.arange(nb_z) }
 
        # Mise à jour de l'image
        for k, v in zones.items():
            A[v] = valeurs[k]
 
        # Affichage
        plt.imshow(A)
        plt.axis('off')
        plt.colorbar()
        plt.draw()
        time.sleep(0.1)
        plt.clf()

Ou alors j'ai raté quelque chose ?