Rapport de projet - Les Gammas Caméras

Adrien ANTHORE et Yuxin XUE

June 29, 2023

1
Contents

1 Introduction 3

2 Structure du modèle 3
2.1 Collimateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Scintillateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Photo-détecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Visualisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5 Données numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3 Simulation 9
3.1 Un rayon gamma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2 Chercher la position où les éléments radioactifs se désintègrent . . . . . . . . . . . . . . . . . 10

4 Application 11
4.1 Évènements aléatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.2 Chercher les cellules cancéreuses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.3 l’environnement des centrales nucléaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

5 Conclusion 16

2
1 Introduction
Une gamma-caméra (γ-caméra)[2], également appelée caméra à scintillation ou caméra d’Anger, est utilisé
pour imager les radionucléides qui émettent des rayons gamma.

De multiples applications dans le développement précoce de médicaments et l’imagerie médicale nucléaire

peuvent être utilisées pour analyser la distribution de marqueurs humains et radioactifs.

En médecine, elles reprennent le principe de scintigraphie. On commence par administrer au patient une pe-
tite quantité de molécules radioactives émettant des rayons gamma et qui se fixent sur les cellules tumorales.
Les rayons gamma vont se décomposer en lumière visible en traversant un scintillateur et en sortie on obtient
une image 2D de la zone en question avec les tumeurs misent en valeur sur l’image.

Figure 1: Schéma du dispositif médical

Notre but dans ce projet est de comprendre et de réussir à modéliser la gamma-caméra et de faire le chemin
inverse pour trouver où les rayons gamma sont émis, c’est-à-dire où les éléments radioactifs se désintègrent,
à partir de la matrice d’intensité lumineuse reçue par le capteur.

2 Structure du modèle
La gamma-caméra se compose de quatre éléments principaux :
- un collimateur composé de mire qui va permettre aux rayons gamma. d’arriver tous perpendiculairement
au système.
- un scintillateur où les rayons vont se décomposer en lumière visible.
- une matrice de photo-détecteur qui mesure l’intensité lumineuse reçu.
- un ordinateur qui traite les informations et les visualise à l’écran.

Figure 2: Schéma de la caméra gamma

3
 En bref, dans notre modèle, les rayons gamma sont d’abord sélectionnés par le collimateur, puis absorbés
par le scintillateur pour produire de la lumière visible, chaque faisceau visible provoque différentes lumi-
nosités à différents endroits du détecteur de photons, nous enregistrons ces luminosités à l’aide de la matrice
d’intensité de la lumière, et enfin nous la visualisons

Ensuite, nous allons détailler notre modèle en fonction de ses différentes composantes.

2.1 Collimateur
Le collimateur est composé de mire qui va permettre aux rayons gamma. d’arriver tous perpendiculairement
au système.

Figure 3: Schéma du collimateur

Si nous n’avons pas de collimateur, les rayons gamma qui atteignent le scintillateur ne seraient pas
perpendiculaire à l’horizontale. Donc nous ne saurions pas exactement où se trouve la source de rayonnement
dans le patient.

Figure 4: lumière tombant sur le même point provienne de différents endroits

Dans notre modèle, le collimateur contient une série de 11 × 11 mires qu’on va distribuer régulièrement
sur sa surface.

4
 Figure 5: collimateur contenant une série de 11 × 11 mires

Pour cela, on conservera les coordonnées des centres des mires dans des arrays numpy. Chaque mire a un
rayon de 1 mm.
Lorsque les rayons gamma sont tirés sur le collimateur, nous sélectionnons ensuite le trou couvert par les
rayons gamma et générer aléatoirement la position dans le trou.

Pour le simuler, on applique une variation aléatoire en coordonnée polaire de r compris entre 0 et 1 mm, et
de θ compris entre 0 et 2π rad.

Il a été codé de la manière suivante :

def choose(x_select, y_select, number, r):

"""Choisir une position alatoire dans le trou et
sortir les valeurs initiales x0, y0 de 1000 vnements."""
# Gnration alatoire d’angles polaires
theta = np.random.uniform(low=0, high=2*pi, size=number) # angle (rad)
# Gnration alatoire de rayon polaires
p_x = np.random.uniform(low=0, high=r, size=number)
p_y = np.random.uniform(low=0, high=r, size=number)
x = x_select + p_x*np.cos(theta)
y = y_select + p_y*np.sin(theta)
# sortie
return x, y

2.2 Scintillateur
Un scintillateur est l’endroit où les rayons gamma vont se décomposer en lumière visible.

Figure 6: Schéma du scintillateur

Notez qu’un rayon gamma peut convertir en plusieurs rayons visibles.

5
Dans notre modèle, nous supposons que chaque rayon gamma se décompose en lumière visible de luminosité
I.
La luminosité sera donnée par le produit du rendement lumineux rl et de l’énergie des rayons gamma Eγ .

I = rl × Eγ
Plus précisément, Les rayons gamma sont absorbés par le matériau du scintillateur. Les atomes ou molécules
du scintillateur sont excités et produisent de la lumière visible.
les matériaux donnés correspondent à des longueurs d’absorption différentes zm pour les rayons gamma de
différentes énergiesEγ .

Nous modélisons ce phénomène par une loi exponentielle paramétrée par la distance caractéristique zm =
2, 88 cm avant être absorbés.

Afin que le rayon ne dépasse pas effectivement la hauteur du scintillateur, nous prenons la valeur mini-
male entre la valeur de z0 trouvée à l’aide de notre loi et la hauteur du dispositif zmax = 5 mm.

Cette loi a été codé de la manière suivante :

def generator_z(zmax, zm):

"""sortir les valeurs initiales alatoire z0,
qui suit la distribution exponentielle"""
return min(np.random.exponential(scale=1/zm), zmax)

2.3 Photo-détecteurs
Une matrice de photo-détecteur est un tube photo-multiplicateur, permettant la détection de photons, qui
se présente sous la forme d’un tube électronique.

Dans un tube photo-multiplicateur, des électrons sont arrachés d’un métal par effet photoélectrique à une
photo-cathode, le faible courant électrique ainsi généré est amplifié par une série de diodes utilisant le
phénomène d’émission secondaire pour obtenir un gain important.

Figure 7: Schéma du photodétecteurs

La distribution de lumière dans le scintillateur est isotrope et l’on considérera que ses côtés sont recouvert
d’un revêtement absorbant tandis que sa face côté collimateur est recouverte d’un revêtement réfléchissant

6
induisant une distribution de la lumière au niveau du système de photo-détection pouvant être modélise
par la loi de Scrimger-Baker donnant la densité surfacique de lumière au point de coordonnées (x, y) du
photo-détecteur :

dI(x, y) I
= (x0 −x)2 +(y0 −y)2 3
(1)
dS 2
2πz0 (1 + ( )2 )
z2 0

Où I est l’intensité totale qu’on définit comme :

I = rl × Eγ (2)

Cette nous donne une intensité pour chaque coordonnée de la surface. Cependant, il faut faire la distribution
pour chaque pixel. On fait donc la distribution pour les pixels centrés sur les coordonnées (xi , yj ) :

dI(xi ,yj )
Ii,j = Sp × ed × (3)
dS
Ces fonctions ont été codé de la manière suivante :

def derivee_I(I, x, y, x0, y0, z0):

"""Calculer la drive de I"""
C1 = 2*pi*z0**2
C2 = (1+((x0-x)**2+(y0- y)**2)/z0**2)**(3/2)
return I/(C1*C2)

def fonc_I(I, x, y, x0, y0, z0, Sp, ed):

"""Calculer I"""
return Sp*ed*derivee_I(I, x, y, x0, y0, z0)

Dans un cas réaliste, le scintillateur recevra des rayons gamma arrivant par le collimateur à différents
endroits, et chaque rayon gamma produira une matrice d’intensité de lumière sur le détecteur de photons.

Nous supposons que la matrice d’intensité lumineuse de sortie finale est la somme de toutes les matrices
d’intensité lumineuse des rayons gamma.

Pour modéliser cette situation, nous supposons que les positions initiales de tous les rayons gamma traversant
le collimateur qui sont absorbés par le scintillateur sont stockées par un tenseur tridimensionnel, c’est-à-dire
que le collimateur possède un total de 11 × 11 trous, chacun d’entre eux stockant une liste des positions
initiales de tous les rayons gamma traversant ce trou qui sont absorbés par le scintillateur.

Par exemple, supposons que chaques trous reçoivent 1000 rayons gamma, alors la taille de notre tenseur
est (11, 11, 1000).

Ils ont été codé de la manière suivante :

def calcule_dim3(X, Y, Z, x, y, I, Sp, ed):

"""Si la matrice de X,Y,Z est tridimensionnelle,
calculez I pour chaque x0, y0, z0"""
Iu = 0
# boucle
for i in range(len(X)):
for j in range(len(X[i])):
Iu += np.sum(fonc_I(I, x, y, X[i][j], Y[i]
[j], Z[i][j], Sp, ed))
return Iu

def calcule(xp, n, I, x0, y0, z0, Sp, ed):

"""Si la matrice de X,Y,Z est tridimensionnelle,

7
 calculez I pour chaque x0, y0, z0 et faites la somme."""
Iu = np.zeros((n, n))
# Boucle
for i in range(n):
for j in range(n):
xi, yi = position(i, j, xp)
Iu[i][j] = calcule_dim3(x0, y0, z0, xi, yi, I, Sp, ed)
return Iu

2.4 Visualisation
Pour représenter la luminosité détectée par le détecteur de photons final.
Nous dessinons des carrés de n × n pixels selon les paramètres de la plaque de détection, la couleur de chaque
carré étant déterminée par la luminosité à cet endroit, de sombre à clair ou de noir à blanc.
Pour réaliser cet effet, nous utilisons le module colormap, qui nous aide à faire correspondre chaque entier à
une couleur, et la taille de l’entier est proportionnelle à la nuance de la couleur.

Tout d’abord, nous régularisons la matrice de luminosité obtenue ci-dessus à un nombre entier dans [0,cmax].

I − Imin
Inormal = · cmax
Imax − Imin

def normalize(cmax, I):

""" Rgulariser les paramtres pour
limiter les valeurs du tableau d’entre entre 0 et 1."""
return np.array((I-np.min(I))/(np.max(I)-np.min(I))*cmax, dtype=int)

Nous utilisons ensuite le module matplotlib.pyplot pour tracer n × n carrés de différentes couleurs comme
points de pixels.

def visualise(Iu, xp, n):

"""La visualisation, o la couleur est exprime comme
l’ intensit de la lumire , en passant du noir au blanc."""
fig, ax = plt.subplots(1, 1, figsize=(12, 12))
cmap = cm.get_cmap("binary")
cmax = 200
colornum = cmax-normalize(cmax, Iu)
for i in range(n):
for j in range(n):
xi, yi = position(i, j, xp)
rect = plt.Rectangle(
(xi-1/2*xp, yi-1/2*xp), xp, xp, color=cmap(colornum[i][j]))
ax.add_patch(rect)
plt.xticks(np.linspace(xp/2, xp*(n)-xp/2, n), np.arange(1, n+1))
plt.yticks(np.linspace(xp/2, xp*(n)-xp/2, n), np.arange(1, n+1))
plt.xlim(0, n*xp)
plt.ylim(0, n*xp)
plt.xlabel("x")
plt.ylabel("y")
plt.show()

2.5 Données numériques

On considère que les rayons gammas ont tous la même énergie Eγ = 140 keV .
Pour les photo-détecteurs, on a pris un carré de 16 × 16 pixels. Chaque pixel fait 3mm de côté. Il a chacun

8
une efficacité de détection ed = 35%.
Le scintillateur sera un pavé de dimension 48 × 48 × 5 mm3 dont on fixera le rendement lumineux à
rl = 60 photons/keV .
Le collimateur est un pavé de dimension 48 × 48 × 5 mm3 .
L’ensemble de la structure est donc un pavé de dimension 48 × 48 × 10 mm3 .

Maintenant que le modèle est bien définie, on peut commencer à s’intéresser à la simulation.

3 Simulation
3.1 Un rayon gamma
Nous allons commencer avec un faisceau de rayons gamma.

Lorsque la position initiale de l’événement, c’est-à-dire la position où les rayons gamma sont absorbés sur
le scintillateur, est une liste unidimensionnelle, nous ne pouvons pas calculer l’intensité lumineuse avec la
fonction ci-dessus, nous redéfinissons donc une fonction simple. Pour obtenir le résultat d’un unique rayon
gamma, on utilise la fonction suivante :

def calcule_1d(xp, n, I, x0, y0, z0, Sp, ed):

"""Si la matrice de X0,Y0,Z0 est uni-dimensionnelle,
calculez I pour chaque x0, y0, z0 et faites la somme."""
# Crer un tableau pour stocker la luminosit
Iu = np.zeros((n, n))
# Boucle
for i in range(n):
for j in range(n):
xi, yi = position(i, j, xp)
Iu[i][j] = np.sum(fonc_I(I, xi, yi, x0, y0, z0, Sp, ed))
return Iu

On peut par exemple représenter le résultat d’un unique rayon gamma au point de coordonnée (x0 = 24, y0 =
24, z0 = 5) mm c’est à dire au milieu du dispositif et à zmin :

Figure 8: Représentation d’une désintégration d’un rayon gamma centré sur le détecteur à zmax

On peut également la représenter pour zmax :

On voit que la quantité de photon détecter est distribué de façon relativement circulaire et uniforme autour
de la position (x, y). La distribution est simplement d’autant plus étendu que la absorption se fait loin par
rapport au détecteur.
On peut maintenant voir ce qu’on obtient lorsqu’un rayon qui passe aléatoirement par une mire et qui est
absorbée à une hauteur suivant une loi exponentielle :

9
 Figure 9: Représentation d’une désintégration d’un rayon gamma centré sur le détecteur à zmax

Figure 10: Représentation de 6 évènements aléatoires indépendants

3.2 Chercher la position où les éléments radioactifs se désintègrent

Après avoir réussis à simuler le passage d’un rayon gamma à travers le dispositif ainsi que la distribution de la
lumière produite. On se pose maintenant la question suivante : comment retrouver la position où les éléments
radioactifs se désintègrent, c’est-à-dire où les rayons gamma sont produits à partir d’une distribution sur le
détecteur ?

Pour se faire, on réalise une moyenne des coordonnées pondérées par la quantité de photon détecté sur
chaques pixels[1]. Pour simplifier le calcul, on considérera les pixels seulement par les coordonnées de leurs
centres. la formule utilisée est la suivante :
P
Ii x i
xc = Pi I
P i i (4)
Ij yj
yc = Pj Ij
i

où: X X
p p
Ii = Ii,j Ij = Ii,j
j i

Pour simplifier le problème, on a pris p = 1, on l’a donc codé de la manière suivante :

def position_interaction(I, xp, n):

""" Prdire la localisation des vnements partir de la luminosit"""
xc = np.sum([np.sum(I[i, :])*((i+1)*xp-xp/2) for i in range(n)])/np.sum(I)
yc = np.sum([np.sum(I[:, i])*((i+1)*xp-xp/2) for i in range(n)])/np.sum(I)

10
 return xc, yc

Pour tester cette fonction, prenons un exemple dont on connaı̂t déjà les coordonnée.

Figure 11: Évènement en (x = 13, y = 39)mm

En utilisant notre fonction, on obtient xc = 14 mm et yc = 37 mm. L’erreur absolue est d’environ 1-2mm,
et l’erreur relative est de 0,5%-1%. Ce qui est très proche et assez satisfaisant. Une source d’erreur sur ce
calcule est que la évènement se fait plus où moins entre deux pixels et aussi qu’il y a une distribution de
petites variations de luminosité tout autour du point de évènement. Pour remédier à ce problème, il aurait
fallu prendre une puissance de p supérieure à 1 pour diminuer le poids des plus petites valeurs de luminosités.

4 Application
Comme nous l’avons mentionné, De multiples applications dans le développement précoce de médicaments
et l’imagerie médicale nucléaire peuvent être utilisées pour analyser la distribution de marqueurs humains et
radioactifs.[3]. En outre, la gamma-caméra peut être utilisée dans les centrales nucléaires.

Figure 12: Application en imagerie médicale

Ensuite, nous utiliserons quelques exemples spécifiques pour illustrer son application.

11
4.1 Évènements aléatoire
Nous commençons par créer une source de rayonnement complètement aléatoire.
En supposant que le collimateur de la gamma-caméra corresponde à un matériau émetteur extrêmement
grand, nous ne savons pas où l’émission sera produite et toutes les ouvertures du collimateur ont le potentiel
de capter des rayons gamma. Nous utilisons une méthode de Monte Carlo pour modéliser cette situation.

Nous considérons que le nombre de rayons gamma incidents dans tous les intervalles est aléatoire, entre
100 et 2000. Nous utilisons donc les fonctions suivantes:

def generator():
""" Crer un nombre alatoire d’ vnements dans
chaque trou du verticalisateur, entre 100 et 2000 vnements."""
n = d["nt"]
# Coordonnes des centres de tous les trous du collimateur
coli = d["Cord_coli"] # m
# un nombre alatoire d’ vnements
number = np.random.randint(low=100, high=2000, size=(11, 11))
# Crer des tableau pour stocker les positions
X = [[[] for j in range(n)] for i in range(n)]
Y = [[[] for j in range(n)] for i in range(n)]
Z = [[[] for j in range(n)] for i in range(n)]
# boucle
for i in range(n):
for j in range(n):
X[i][j], Y[i][j] = choose(
coli[i], coli[j], number[i][j], d["r"])
Z[i][j] = np.array([generator_z(d["zmax"], d["zm"])
for k in range(number[i][j])])

return X, Y, Z

(a) Distribution aléatoire 1 (b) Distribution aléatoire 2 (c) Distribution aléatoire 3

Les coordonnées d’occurrence de l’événement obtenues à partir de la reconstruction sont respectivement :

(23.6, 23.9) mm
(24.2,24.3) mm
(24.2,23.9) mm

Nous pouvons trouver que bien que les événements soient aléatoires, le barycentre de cette distribution
correspond relativement au centre du détecteur.

12
4.2 Chercher les cellules cancéreuses
Nous allons maintenant essayer un cas plus réaliste.

En utilisant la propriété de la gamma-caméra de détecter la position du matériel radioactif, nous sommes en

mesure de découvrir où se trouvent les cellules cancéreuses, les cellules tumorales.

Si nous injectons de faibles niveaux de particules de traceur radioactif dans le patient, ces particules seront
absorbées par les cellules cancéreuses et apparaı̂tront sur les scans ultérieurs.

Nous utilisons un cercle pour simuler des cellules cancéreuses.

Figure 13: Simulation d’une cellule cancéreuse

Nous pouvons constater que les cellules cancéreuses sont visibles avec plus de précision aux endroits in-
diqués.

Ensuite, en réorganisant sur la base de la matrice de luminosité, nous pouvons connaı̂tre l’emplacement
des cellules cancéreuses.

Pour détecter l’écart entre la position mesurée de la cellule cancéreuse et la position réelle, nous définissons
un cercle dont le centre est connu, et l’écart est obtenu par la différence entre le centre connu et la position
mesurée.

13
 Figure 14: décalages des coordonnées horizontales et verticales

Nous pouvons voir que les décalages des coordonnées horizontales et verticales sont conformes à une
distribution gaussienne, et à partir de l’ajustement nous obtenons les paramètres de ce modèle gaussien.
Nous pouvons obtenir une erreur relative entre 0.5% et 4%, ce qui est une erreur acceptable.

4.3 l’environnement des centrales nucléaires

La gamma-caméra permet de localiser, d’identifier et de quantifier avec précision les points chauds de sources
radioactives éloignées.

Ses applications comprennent également la sécurité intérieure, la défense et les interventions d’urgence, ainsi
que la radioprotection du personnel travaillant dans le domaine nucléaire.

Nous pouvons également mesurer la localisation des matériaux radioactifs dans l’environnement des cen-
trales nucléaires.

En modifiant les paramètres du détecteur de photons et du collimateur pour qu’ils soient plus grands, nous
pouvons mesurer la distribution du matériel radioactif sur une grande surface.

Nous pouvons imaginer que nous disposons d’une gamma-caméra, montée sur un robot, et que tout en
se promenant dans un endroit connu de l’usine, les observateurs peuvent obtenir la position de la source
radioactive à partir de l’image renvoyée, évitant ainsi l’arrivée d’un humain, ou peuvent savoir si la matière
radioactive fuit.

(Nous avons simulé du matériel radioactif avec des cercles dans trois endroits différents)

14
 Figure 15: S’il y a de matériau radioactif dans le champ de la caméra

S’il n’y a pas de matériau radioactif dans le champ de la caméra, nous obtiendrons:

Figure 16: S’il n’y a pas de matériau radioactif dans le champ de la caméra

15
5 Conclusion
Dans ce projet, nous avons d’abord construit un modèle simple de la gamma-caméra, puis nous avons réalisé
des applications simples basées sur ce modèle.

Ce projet nous a permis de comprendre le fonctionnement de la gamma-caméra et d’acquérir une première

compréhension d’un méthode de reconstruction et la simulation Monte-Carlo.

Elle a également contribué à renforcer nos connaissances en physique médicale et nous a permis de découvrir
de nouveaux concepts et techniques (langage informatique, programmation).

Pour aller plus loin, on aurait pu s’intéresser à l’influence de certains paramètres sur notre modélisation.
Par exemple l’influence de la résolution (nombre de pixels et taille des pixels) où encore la puissance au
dénominateur du barycentre. On peut s’attendre qu’avec ces changements on obtiennent des données plus
précises.

References
[1] M.J. Cree and P.J. Bones. “Towards direct reconstruction from a gamma camera based on Compton
scattering”. In: IEEE Transactions on Medical Imaging 13.2 (1994), pp. 398–407. doi: 10.1109/42.
293932.
[2] M. Gmar et al. “GAMPIX: A new generation of gamma camera”. In: Nuclear Instruments and Methods
in Physics Research Section A: Accelerators, Spectrometers, Detectors and Associated Equipment 652.1
(2011). Symposium on Radiation Measurements and Applications (SORMA) XII 2010, pp. 638–640.
issn: 0168-9002. doi: https : / / doi . org / 10 . 1016 / j . nima . 2010 . 09 . 003. url: https : / / www .
sciencedirect.com/science/article/pii/S0168900210019169.
[3] Koichi Okada et al. “Development of a gamma camera to image radiation fields”. In: Prog. Nucl. Sci.
Tech 4 (2014), pp. 14–17.

16