À partir du 27 mars 2025, nous vous recommandons d'utiliser android-latest-release au lieu de aosp-main pour créer et contribuer à AOSP. Pour en savoir plus, consultez la section Modifications apportées à AOSP.

Cette page a été traduite par l'API Cloud Translation.

Présentation de Camera ITS

La suite de tests ITS (Image Test Suite) de l'appareil photo est un framework permettant d'exécuter des tests sur les images produites par un appareil photo Android. L'objectif général de chaque test dans ITS est de configurer la caméra d'une manière spécifique, de prendre une ou plusieurs photos et de les examiner pour voir si elles contiennent les données d'image attendues. Pour de nombreux tests, l'appareil photo doit être pointé sur un tableau cible spécifique ou être éclairé à une intensité spécifique.

ITS se trouve dans le harnais de test CTS Verifier sous cts/apps/CameraITS. Les appareils doivent réussir les tests ITS correspondant aux fonctionnalités compatibles annoncées par le framework de l'appareil photo pour les applications tierces en tant que sous-ensemble de CTS.

Configuration

Pour exécuter les tests ITS, vous devez configurer les éléments suivants :

Un appareil testé (DUT, device under test)
Une machine hôte (par exemple, un ordinateur de bureau ou portable Linux)
Scène photographiée par la caméra

Configuration de l'appareil testé

Pour configurer un DUT, procédez comme suit :

Connectez le DUT à une machine hôte via USB.
Accordez à l'hôte les autorisations nécessaires pour accéder à l'appareil en test via ADB.
Installez l'application CTS Verifier (CtsVerifier.apk) sur l'appareil. Pour en savoir plus, consultez Utiliser CTS Verifier.
```
extract root/out/host/linux-x86/cts-verfier/android-cts-verifier.zip
cd android-cts-verifier
adb install -r -g CtsVerifier.apk
```
Remarque : Si vous installez l'application à partir d'un bundle CTS Verifier (android-cts-verifier.zip) plutôt que d'un arbre source Android complet, CtsVerifier.apk et le répertoire CameraITS/ se trouvent au niveau supérieur du dossier android-cts-verifier compressé.
Sur l'appareil en test, lancez l'application d'appareil photo par défaut et fermez toutes les fenêtres qui s'affichent au lancement pour éviter toute interférence pendant le test.

Configuration de l'hôte

ITS exige que la machine hôte soit connectée au DUT via USB, qu'elle puisse utiliser ADB pour le contrôle et la communication de l'appareil, et que le logiciel requis soit installé.

Pour configurer votre machine hôte, assurez-vous que les logiciels suivants sont installés.

Outils de plate-forme du SDK Android

Les outils de plate-forme du SDK Android doivent être installés et ADB doit se trouver dans le chemin d'exécution du shell ou du terminal qui s'exécute sur la machine hôte. Pour la version publique des outils de plate-forme du SDK Android, consultez les notes de version des outils de plate-forme du SDK.

Python

Python doit être installé sur la machine hôte. Nous vous recommandons d'utiliser une distribution Python groupée pour garantir la compatibilité avec les versions compatibles. Pour savoir quelles versions de Python et de packages installer pour une version spécifique, consultez les notes de version de Camera ITS pour la version correspondante.

Mobly

Pour Android 12 et versions ultérieures, le framework de test Mobly doit être installé. Mobly vous permet de configurer un DUT et une tablette graphique dans la classe its_base_test. Pour installer le framework de test Mobly, exécutez la commande suivante :

pip install mobly

Configuration de l'environnement

Pour configurer l'environnement de test, exécutez la commande suivante :

cd CameraITS
source build/envsetup.sh

Cette commande vérifie l'installation de Python, configure la variable d'environnement PYTHONPATH et exécute des tests unitaires sur les modules utils/*.py. Si aucune erreur n'est affichée dans le terminal, l'environnement est prêt à exécuter les tests ITS.

Configuration de la scène

Pour configurer les scènes, nous vous recommandons d'utiliser la configuration Camera ITS-in-a-box pour faciliter l'automatisation, la fiabilité et l'efficacité des tests. Les bancs d'essai ITS-in-a-box sont compatibles avec toutes les exigences de l'ITS en matière d'éclairage, de centrage et de changement de graphique. ITS-in-a-box est également requis pour tester les extensions de caméras.

Pour les tests manuels, assurez-vous de respecter les points suivants :

L'appareil à tester est placé sur un trépied.
Le DUT est pointé sur la scène appropriée pour chaque test. (Le script de test ITS fournit des invites pour modifier la configuration de la scène avant de commencer les tests dans une nouvelle scène.)
Le DUT est connecté à la machine hôte via USB.
Le DUT ne bouge pas pendant l'exécution du test.
La scène est éclairée par une source de lumière stable, sans fluctuation. (N'utilisez pas de lumière fluorescente, car elle provoque un scintillement.)

Le script de test ITS affiche une invite demandant à l'utilisateur de modifier la configuration de la scène avant de lancer des tests dans une nouvelle scène.

L'orientation du téléphone doit être définie de sorte que l'appareil photo prenne des images sans rotation. Le moyen le plus simple de vérifier cela est d'utiliser les scènes de visage dans la scène 2. Sur la plupart des téléphones, le téléphone est en orientation paysage et est tourné dans le sens inverse des aiguilles d'une montre pour la caméra arrière et dans le sens des aiguilles d'une montre pour la caméra avant.

Fichiers de configuration

À l'aide du framework Mobly, vous devez créer un fichier de configuration config.yml pour définir le banc d'essai Mobly. Vous trouverez ci-dessous des exemples pour différents cas d'utilisation.

Fichier config.yml des scènes sur tablette

Voici un exemple de fichier config.yml pour les scènes sur tablette. Pour les tests sur tablette, le mot clé TABLET doit figurer dans le nom du banc d'essai. Lors de l'initialisation, le test runner Mobly initialise les paramètres du fichier et les transmet aux tests individuels.

TestBeds:
  - Name: TEST_BED_TABLET_SCENES
    # Test configuration for scenes[0:4, 6, _change]
    Controllers:
        AndroidDevice:
          - serial: 8A9X0NS5Z
            label: dut
          - serial: 5B16001229
            label: tablet

    TestParams:
      brightness: 192
      chart_distance: 22.0
      debug_mode: "False"  # "True" or "False"; quotes needed
      lighting_cntl: <controller-type>  # "arduino" or "None"; quotes needed
      lighting_ch: <controller-channel>
      camera: 0
      foldable_device: "False". # set "True" if testing foldable
      scene: <scene-name>  # if <scene-name> runs all scenes

Pour appeler le banc d'essai, exécutez tools/run_all_tests.py. S'il n'existe aucune valeur de ligne de commande spécifiant des caméras ou des scènes, le test est exécuté avec les valeurs du fichier config.yml. S'il existe des valeurs de ligne de commande pour les caméras ou les scènes, elles remplacent les valeurs de la section TestParams du fichier config.yml. Exemple :

python tools/run_all_tests.py
python tools/run_all_tests.py camera=1
python tools/run_all_tests.py scenes=2,1,0
python tools/run_all_tests.py camera=0 scenes=scene_tele
python tools/run_all_tests.py camera=0.4 scenes=4,scene6_tele

Fichier sensor_fusion scene config.yml

Voici un exemple de fichier config_yml pour les tests sensor_fusion. Pour les tests sensor_fusion, le mot clé SENSOR_FUSION doit figurer dans le nom du banc d'essai. Android 13 et versions ultérieures ne prennent en charge que le contrôleur Arduino pour la fusion de capteurs en raison des tests de prévisualisation et de stabilisation vidéo. Android 12 est compatible avec les manettes Arduino et Canakit.

Testbeds
  - Name: TEST_BED_SENSOR_FUSION
    # Test configuration for sensor_fusion/test_sensor_fusion.py
    Controllers:
        AndroidDevice:
          - serial: 8A9X0NS5Z
            label: dut

    TestParams:
      fps: 30
      img_size: 640,480
      test_length: 7
      debug_mode: "False"
      chart_distance: 25
      rotator_cntl: arduino
      rotator_ch: 1
      camera: 0

Pour exécuter des tests sensor_fusion avec la boîte de fusion de capteurs, exécutez la commande suivante :

python tools/run_all_tests.py scenes=sensor_fusion
python tools/run_all_tests.py scenes=sensor_fusion camera=0
python tools/run_all_tests.py scenes=scene_flash,feature_combination
python tools/run_all_tests.py scenes=checkerboard camera=1

Fichier config.yml pour plusieurs bancs d'essai

Voici un exemple de fichier config.yml avec plusieurs bancs d'essai, un banc d'essai pour tablette et un banc d'essai sensor_fusion. Le banc d'essai approprié est déterminé par les scènes testées.

Testbeds
  - Name: TEST_BED_TABLET_SCENES
    # Test configuration for scenes[0:4, 6, _change]
    Controllers:
        AndroidDevice:
          - serial: 8A9X0NS5Z
            label: dut
          - serial: 5B16001229
            label: tablet

    TestParams:
      brightness: 192
      chart_distance: 22.0
      debug_mode: "False"
      chart_loc_arg: ""
      camera: 0
      scene: <scene-name>           # if <scene-name> runs all scenes

  - Name: TEST_BED_SENSOR_FUSION
    # Test configuration for sensor_fusion/test_sensor_fusion.py
    Controllers:
        AndroidDevice:
          - serial: 8A9X0NS5Z
            label: dut

    TestParams:
      fps: 30
      img_size: 640,480
      test_length: 7
      debug_mode: "False"
      chart_distance: 25
      rotator_cntl: arduino         # cntl can be arduino or canakit
      rotator_ch: 1
      camera: 0

Fichier config.yml pour les tests manuels

Voici un exemple de fichier config.yml pour les tests manuels. À partir d'Android 14, les tests manuels sont compatibles avec tous les tests, à l'exception des tests scene_extensions. Pour les tests manuels, le mot clé MANUAL doit figurer dans le nom du banc d'essai. De plus, la section AndroidDevice ne peut pas inclure de section de numéro de série ni de libellé pour une tablette.

TestBeds:
  - Name: TEST_BED_MANUAL
    Controllers:
        AndroidDevice:
          - serial: 8A9X0NS5Z
            label: dut

    TestParams:
      debug_mode: "False"
      camera: 0
      scene: 1

Fichier config.yml de test du rig Gen2

Voici un exemple de fichier config.yml d'un banc d'essai TEST_BED_GEN2. Ce banc d'essai est utilisé pour les tests scene_ip, qui utilisent un banc de test de deuxième génération](/docs/compatibility/cts/camera-its-box-gen2). L'exemple suivant montre les paramètres du banc d'essai lorsque le banc Gen2 est disponible et que les tests scene_ip ne sont pas ignorés.

Testbeds
  - Name: TEST_BED_GEN2
    # Test configuration for scene_ip/test_default_jca_ip.py
    Controllers:
        AndroidDevice:
          - serial: <device-id>  # quotes needed if serial id entirely numeric
            label: dut
    TestParams:
      debug_mode: "False"  # quotes are needed here
      chart_distance: 30
      rotator_cntl: gen2_rotator   # gen2 rig specific. "None" if gen2 rig not available
      rotator_ch: 0
      camera: <camera-id>
      foldable_device: "False"  # "True" if testing foldable device
      tablet_device: "False"  # "True" if testing tablet device
      lighting_cntl: gen2_lights  # gen2 rig specific. "None" if gen2 rig not available
      lighting_ch: 1
      scene: scene_ip

L'exemple suivant montre les paramètres du banc d'essai lorsque le banc Gen2 n'est pas disponible et que les tests scene_ip sont ignorés.

Testbeds
  - Name: TEST_BED_GEN2
    # Test configuration for scene_ip/test_default_jca_ip.py
    Controllers:
        AndroidDevice:
          - serial: <device-id>  # quotes needed if serial id entirely numeric
            label: dut
    TestParams:
      debug_mode: "False"  # quotes are needed here
      chart_distance: 30
      rotator_cntl: "None"   # gen2 rig specific. "None" if gen2 rig not available
      rotator_ch: <controller-channel>
      camera: <camera-id>
      foldable_device: "False"  # "True" if testing foldable device
      tablet_device: "False"  # "True" if testing tablet device
      lighting_cntl: "None"  # gen2 rig specific. "None" if gen2 rig not available
      lighting_ch: <controller-channel>
      scene: scene_ip

Pour exécuter le test scene_ip, utilisez l'une des commandes suivantes :

python tests/scene_ip/test_default_jca_ip.py -c config.yml
python tools/run_all_tests.py camera=<camera-id> scenes=scene_ip

Exécuter les tests ITS

Cette section explique comment exécuter les tests ITS.

Appeler des tests

Une fois l'appareil, la machine hôte (y compris l'environnement) et la scène physique configurés, exécutez les tests ITS en suivant la procédure ci-dessous.

Ouvrez l'application CTS Verifier. Dans le menu des tests, sélectionnez Camera ITS Test.
Sur la machine hôte, exécutez les tests ITS à partir du répertoire CameraITS/. Par exemple, pour un appareil équipé de caméras avant et arrière, exécutez la commande suivante :
```
python tools/run_all_tests.py
```
Le script parcourt les caméras et les scènes de test en fonction du fichier config.yml. Pour déboguer les configurations, nous vous recommandons d'exécuter l'une des scènes scene2 avec un seul test pour obtenir les résultats le plus rapidement possible.

Pour les tests manuels, avant de commencer à exécuter l'ensemble des tests ITS sur chaque scène, le script prend une photo de la scène actuelle, l'enregistre au format JPEG, imprime le chemin d'accès au fichier JPEG dans la console et demande à l'utilisateur de confirmer si l'image est correcte. Ce flux capture and confirm (capturer et confirmer) se répète jusqu'à ce que l'utilisateur confirme que l'image est correcte. Voici les messages de ce flux.
```
Preparing to run ITS on camera 0
Start running ITS on camera:  0
Press Enter after placing camera 0 to frame the test scene:
scene1_1
The scene setup should be: A grey card covering at least the   middle 30% of the scene
Running vendor 3A on device
Capture an image to check the test scene
Capturing 1 frame with 1 format [yuv]
Please check scene setup in /tmp/tmpwBOA7g/0/scene1_1.jpg
Is the image okay for ITS scene1_1? (Y/N)
```
Chaque exécution du script affiche un journal indiquant PASS, FAIL, FAIL* ou SKIP pour chaque test ITS. FAIL* indique que le test a échoué, mais comme il n'est pas encore obligatoire, il sera signalé comme PASS à CtsVerifier. SKIP indique que le test a été réussi, car l'appareil n'a pas annoncé la fonctionnalité sous-jacente testée. Par exemple, si un appareil n'indique pas via les interfaces de caméras qu'il est compatible avec le format DNG, les tests liés à la capture de fichiers DNG sont ignorés et comptabilisés comme PASS.
Pour confirmer que les tests répondent aux exigences, appuyez sur le bouton en forme de coche verte. L'entrée Test ITS de l'appareil photo du menu des tests CTS Verifier devient alors verte, ce qui signifie que le téléphone a réussi le test ITS de l'appareil photo.

Test parallèle de l'appareil à tester

Les appareils équipés d'Android 14 ou version ultérieure sont compatibles avec les tests DUT parallèles. Cela vous permet de tester les DUT en parallèle avec plusieurs plates-formes pour accélérer les tests globaux. Par exemple, les tests parallèles vous permettent de tester la caméra 0 dans un rig et la caméra 1 dans un autre rig en même temps. Tous les tests des sessions de test parallèles sont agrégés dans la session CTS Verifier sur le DUT de référence. Vous devez effectuer des tests parallèles avec le contrôle de l'éclairage Arduino, car le contrôle manuel de l'éclairage n'est pas compatible avec les tests parallèles. Assurez-vous qu'un canal différent sur le même contrôleur Arduino contrôle l'éclairage de chaque plate-forme.

Voici un exemple de fichier config.yml qui définit trois bancs d'essai à exécuter en parallèle.

TestBeds:
  - Name: TEST_BED_TABLET_SCENES_INDEX_0
    Controllers:
        AndroidDevice:
          - serial: <device-id-0>
            label: dut
          - serial: <tablet-id-0>
            label: tablet
    TestParams:
      brightness: 192
      chart_distance: 22.0
      debug_mode: "False"
      lighting_cntl: "arduino"
      lighting_ch: <controller-channel-0>
      camera: 0
      scene: <scene-name>  # if <scene-name> left as-is runs all scenes
      foldable_device: "False"

  - Name: TEST_BED_TABLET_SCENES_INDEX_1
    Controllers:
        AndroidDevice:
          - serial: <device-id-1>
            label: dut
          - serial: <tablet-id-1>
            label: tablet
    TestParams:
      brightness: 192
      chart_distance: 22.0
      debug_mode: "False"
      lighting_cntl: "arduino"
      lighting_ch: <controller-channel-1>
      camera: 1
      scene: <scene-name>  # if <scene-name> left as-is runs all scenes
      foldable_device: "False"

  # TEST_BED_SENSOR_FUSION represents testbed index 2
  # Parallel sensor_fusion is currently unsupported due to Arduino requirements
  - Name: TEST_BED_SENSOR_FUSION
    # Test configuration for sensor_fusion
    Controllers:
        AndroidDevice:
          - serial: <device-id>
            label: dut
    TestParams:
      fps: 30
      img_size: 640,480
      test_length: 7
      debug_mode: "False"
      chart_distance: 25
      rotator_cntl: "arduino"
      rotator_ch: <controller-channel-2>
      camera: <camera-id>
      foldable_device: "False"
      tablet_device: "False"
      lighting_cntl: "None"
      lighting_ch: <controller-channel>
      scene: "sensor_fusion"

Pour exécuter les bancs d'essai en parallèle, utilisez la commande suivante :

for i in 0 1 2; do python3 tools/run_all_tests.py testbed_index=$i num_testbeds=3 & done; wait

Modèle de bruit DNG

Les appareils qui annoncent la possibilité de capturer des images au format RAW ou DNG doivent fournir un modèle de bruit dans les métadonnées du résultat de capture de chaque prise de vue RAW. Ce modèle de bruit doit être intégré au HAL de l'appareil photo pour chaque appareil photo (par exemple, les caméras avant et arrière) sur l'appareil qui prétend être compatible.

Implémentation du modèle de bruit

Pour implémenter un modèle de bruit, suivez ces étapes pour générer un modèle de bruit et l'intégrer au HAL de l'appareil photo.

Pour générer un modèle de bruit pour chaque caméra, exécutez le script dng_noise_model.py dans le répertoire tools. Un extrait de code C est alors généré. Pour en savoir plus sur la configuration de la caméra et de l'environnement de capture, consultez le document DngNoiseModel.pdf dans le répertoire tools.
Pour implémenter le modèle de bruit pour l'appareil, coupez et collez l'extrait de code C dans le HAL de l'appareil photo.

Validation du modèle de bruit

Le test ITS automatisé tests/scene1_1/test_dng_noise_model.py valide le modèle de bruit en vérifiant que les valeurs de bruit pour l'exposition et le gain du cliché fournies dans les données de la caméra sont correctes.