Avez-vous déjà pris des photos avec votre smartphone ?
En réalité, en analysant le capteur d’image de l’iPhone, on peut bien comprendre l’évolution des caméras de smartphone.
Le Sony IMX503 est l’un des capteurs utilisés dans les caméras de l’iPhone.
Dans cet article, nous allons analyser le capteur d’image utilisé dans l’iPhone 12, en incluant des méthodes de mesure en chambre noire.
Pourquoi analyser le capteur d’image de l’iPhone ?
Les smartphones existent depuis un certain temps maintenant.
Cependant, la fonction caméra a évolué de manière surprenante.
D’un autre côté, il est encore vrai que, dans des environnements sombres, il existe une différence de performance par rapport aux appareils photo reflex numériques.
Cela dit, dans des conditions bien éclairées, les photos peuvent être si belles que l’on pourrait penser qu’un reflex n’est même pas nécessaire.
De plus, étant donné que l’iPhone est un appareil utilisé au quotidien, analyser le capteur d’image de l’iPhone a une grande importance.
Capteur d’image utilisé dans l’iPhone 12
Mon smartphone personnel est un iPhone 12 (modèle standard).
Ainsi, le capteur à analyser est celui utilisé dans l’iPhone 12. Après diverses recherches, il semble que le capteur utilisé pour la caméra grand angle soit le Sony IMX503.
Cependant, malgré toutes mes recherches, je n’ai pas pu trouver de fiche technique pour ce capteur.
Il est probable que ce soit un capteur spécialement développé pour Apple, donc non disponible dans le commerce.
Cependant, étant donné que de nombreuses personnes sont curieuses de connaître ses performances, il vaut la peine de tenter une analyse du capteur d’image de l’iPhone ici.
Méthode de mesure du capteur d’image
Pour cette analyse, nous allons vérifier la réponse en sortie du capteur et ses performances en matière de bruit.
Voici les éléments nécessaires à la préparation de la mesure :
- iPhone (avec une application caméra permettant de capturer en Raw)
- Filtre ND (Neutral Density) de 15 étapes
- Source lumineuse plate
- Espace sombre
- PC (Python)
Points clés pour les mesures
Mesure en chambre noire
Pour garantir la linéarité près de la zone sombre, il est essentiel d’éviter l’entrée de lumière supplémentaire, à l’exception de la source lumineuse.
Capture d’images Raw
L’application caméra standard de l’iPhone ne permet pas de capturer en Raw. Cependant, en utilisant des applications comme SimpleRaw Camera, il est possible de prendre des photos au format DNG (Raw).
Source lumineuse plate
Il est important d’utiliser une source lumineuse avec une luminosité aussi uniforme que possible. Si vous disposez d’une sphère intégrante, vous pouvez l’utiliser directement. Sinon, vous pouvez configurer un écran PC en blanc pur et le régler à la luminosité maximale.
Filtre ND
Le filtre ND est essentiel pour réduire l’intensité lumineuse. Si vous ne disposez pas de filtre, vous pouvez ajuster la vitesse d’obturation, mais cela pourrait affecter les caractéristiques de bruit.
Procédure de mesure
- Fixez la position de la source lumineuse et de la caméra.
(Assurez-vous d’avoir suffisamment d’espace de travail pour insérer tous les filtres ND possibles.) - Augmentez l’intensité de la source lumineuse jusqu’à ce que la caméra soit saturée, sans utiliser de filtre ND.
Si la source lumineuse ne provoque pas de saturation, ajustez la vitesse d’obturation pour obtenir une exposition plus longue. - Capturez une image de la source lumineuse.
Ensuite, réduisez progressivement l’intensité lumineuse par étapes de 1/2 en ajoutant un filtre ND à chaque fois ou en ajustant la vitesse d’obturation. Répétez cette étape pour chaque niveau de luminosité. - Une fois que vous avez capturé des images depuis l’état de saturation jusqu’à un état suffisamment sombre, les données sont prêtes à être collectées.
Attention : ne changez pas la distance entre la source lumineuse et la caméra.
Si la distance change, l’intensité lumineuse variera également, ce qui entraînera des résultats incorrects.
Image de configuration réelle
Préparez une chambre noire ou un espace sombre, puis placez un filtre ND entre la caméra (iPhone) et la source lumineuse.
Il est crucial de fixer fermement le filtre et la caméra, car tout mouvement pourrait modifier les conditions de mesure et fausser les résultats.
Analyse des données Raw
À partir de ce point, nous allons analyser les données Raw capturées.
Cependant, les formats DNG des iPhones et les RAW des appareils photo reflex numériques sont souvent dans des formats propriétaires.
Par conséquent, il est pratique de les convertir en formats Raw universels avant de les traiter avec Python.
Désolé pour cela. Voici la traduction :
Voici le code d’analyse réel. Il utilise Python, Numpy, Matplotlib et la bibliothèque Math.
import numpy as np
import matplotlib.pyplot as plt
import math
#***********************************
#1. Paramétrage de l'image
#***********************************
width=4032
height=3024
width_roi = 100
height_roi = 100
image_num = 15
bit = 12
dark = 528 #
half_width = int(width/2)
half_height = int(height/2)
half_width_roi = int(width_roi/2)
half_height_roi = int(height_roi/2)
#***********************************
#2. Création des tableaux
#***********************************
img_roi=np.empty((height_roi, width_roi),dtype = np.uint16)
img_s = np.empty((4,image_num),dtype = np.float32)
img_n = np.empty((4,image_num),dtype = np.float32)
img_sn = np.empty((4,image_num),dtype = np.float32)
rgb = np.array(range(4))
rgb_det = rgb.reshape((2,2))
img_roi_r=np.empty((half_height_roi, half_width_roi),dtype = np.uint16)
img_roi_gr=np.empty((half_height_roi, half_width_roi),dtype = np.uint16)
img_roi_gb=np.empty((half_height_roi, half_width_roi),dtype = np.uint16)
img_roi_b=np.empty((half_height_roi, half_width_roi),dtype = np.uint16)
x_axis = np.empty((1,image_num),dtype = np.uint16)
#***********************************
#3. Traitement de plusieurs images Raw
#***********************************
for i in range(image_num):
x_axis[0][i] = 2**i
rawpath = "DNG_4032x3024_dark=528_12bit_lin"+str(i)+".raw"
#***********************************
# Ouverture de l'image Raw
#***********************************
fd = open(rawpath, 'rb')
f = np.fromfile(fd, dtype=np.uint16, count=height*width)
img = f.reshape((height,width))
fd.close()
#***********************************
# Découpage de la ROI
#***********************************
width_roi_start = int((width-width_roi)/2)
height_roi_start = int((height-height_roi)/2)
for x in range(width_roi_start,width_roi_start+width_roi):
for y in range(height_roi_start,height_roi_start+height_roi):
img_roi[y-height_roi_start][x-width_roi_start] = img[y][x]
#***********************************
# Suppression du bruit (Dark Removal)
#***********************************
for x in range(width_roi):
for y in range(height_roi):
if img_roi[y][x] > dark:
img_roi[y][x] = img_roi[y][x]-dark
else:
img_roi[y][x] = 0
#***********************************
# Calcul du SNR
#***********************************
for x in range(width_roi):
for y in range(height_roi):
color = rgb_det[y % 2][x % 2]
if color == 0: #R
y_r = int(y/2)
x_r = int(x/2)
img_roi_r[y_r][x_r] = img_roi[y][x]
elif color == 1: #Gr
y_gr = int(y/2)
x_gr = int((x-1)/2)
img_roi_gr[y_gr][x_gr] = img_roi[y][x]
elif color == 2: #Gb
y_gb = int((y-1)/2)
x_gb = int(x/2)
img_roi_gb[y_gb][x_gb] = img_roi[y][x]
else: #B
y_gb = int((y-1)/2)
x_gb = int((x-1)/2)
img_roi_b[y_gb][x_gb] = img_roi[y][x]
img_s[0][i] = np.mean(img_roi_r)
img_s[1][i] = np.mean(img_roi_gr)
img_s[2][i] = np.mean(img_roi_gb)
img_s[3][i] = np.mean(img_roi_b)
img_n[0][i] = np.std(img_roi_r)
img_n[1][i] = np.std(img_roi_gr)
img_n[2][i] = np.std(img_roi_gb)
img_n[3][i] = np.std(img_roi_b)
img_sn[0][i] = 20*(math.log10(img_s[0][i]/img_n[0][i]))
img_sn[1][i] = 20*(math.log10(img_s[1][i]/img_n[1][i]))
img_sn[2][i] = 20*(math.log10(img_s[2][i]/img_n[2][i]))
img_sn[3][i] = 20*(math.log10(img_s[3][i]/img_n[3][i]))
#***********************************
# Affichage des résultats
#***********************************
fig1 = plt.figure()
ax1 = fig1.add_subplot(111)
ax1.plot(x_axis[0,:], img_sn[0,:],label = "R",color = "r")
ax1.plot(x_axis[0,:], img_sn[1,:],label = "Gr",color = "lightgreen")
ax1.plot(x_axis[0,:], img_sn[2,:],label = "Gb",color = "forestgreen")
ax1.plot(x_axis[0,:], img_sn[3,:],label = "B",color = "b")
ax1.set_xscale("log")
ax1.legend()
fig2 = plt.figure()
ax2 = fig2.add_subplot(111)
ax2.plot(x_axis[0,:], img_s[0,:],label = "R",color = "r")
ax2.plot(x_axis[0,:], img_s[1,:],label = "Gr",color = "lightgreen")
ax2.plot(x_axis[0,:], img_s[2,:],label = "Gb",color = "forestgreen")
ax2.plot(x_axis[0,:], img_s[3,:],label = "B",color = "b")
ax2.plot(x_axis[0,:], img_n[0,:],linestyle="--",label = "R_Noise",color = "r")
ax2.plot(x_axis[0,:], img_n[1,:],linestyle="--",label = "Gr_Noise",color = "lightgreen")
ax2.plot(x_axis[0,:], img_n[2,:],linestyle="--",label = "Gb_Noise",color = "forestgreen")
ax2.plot(x_axis[0,:], img_n[3,:],linestyle="--",label = "B_Noise",color = "b")
ax2.set_xscale("log")
ax2.set_yscale("log")
ax2.legend()
plt.show()
Graphiques générés après l’exécution du code. L’un montre les caractéristiques de réponse du signal et du bruit, l’autre montre les caractéristiques du rapport signal/bruit (SNR).
Résultats de l’analyse et réflexion
- Le signal est proportionnel à la quantité de lumière
Comme on peut s’y attendre, plus la quantité de lumière augmente, plus la sortie du capteur augmente. - Le bruit est presque proportionnel à la racine carrée du signal
Il s’agit d’une caractéristique typique du bruit de photon (bruit de scintillation). - Le rapport signal sur bruit (SNR) atteint environ 35dB maximum
De plus, la plage dynamique est d’environ 70dB.
En résumé, les principales caractéristiques du capteur IMX503 intégré à l’iPhone 12 peuvent être extraites de ces résultats.
De plus, cette méthode est applicable non seulement aux iPhones, mais à tous les appareils photo.
N’hésitez pas à essayer avec le capteur d’un appareil photo à portée de main.
Résumé : L’attrait de l’analyse du capteur d’image de l’iPhone
Cet article a présenté des méthodes concrètes pour analyser le capteur d’image de l’iPhone. En effectuant des prises de vue en chambre noire, en utilisant des filtres ND et en analysant les données Raw avec Python, vous pouvez explorer les caractéristiques du capteur Sony IMX503. De plus, il est fascinant de pouvoir vérifier de manière numérique jusqu’où la performance des caméras de smartphone a évolué.
Si vous souhaitez approfondir la puissance de la caméra de votre smartphone quotidien, essayez d’acquérir vos propres données et de les analyser de la même manière. Comparer avec des appareils photo reflex numériques ou sans miroir rendra encore plus frappante la différence de performance, ce qui est très intéressant.
Attention : Nous ne pouvons être tenus responsables des phénomènes ou dommages survenus lors de l’utilisation de ce code. Veuillez l’utiliser uniquement à titre informatif.
コメント