Caméra ITS

Camera Image Test Suite (ITS) est un framework permettant d'exécuter des tests sur des images produites par une caméra Android. L'objectif général de chaque test dans ITS est de configurer la caméra d'une manière spécifique, de capturer une ou plusieurs prises de vue et d'examiner les prises de vue pour voir si elles contiennent les données d'image attendues. De nombreux tests nécessitent que la caméra soit pointée vers une carte cible spécifique ou soit éclairée à une intensité spécifique.

ITS se trouve dans le faisceau de tests CTS Verifier dans cts/apps/CameraITS . Les appareils doivent réussir les tests ITS correspondant aux fonctionnalités prises en charge annoncées par le framework de caméra pour les applications tierces en tant que sous-ensemble de CTS.

Installation

Pour exécuter des tests ITS, les éléments suivants doivent être configurés :

  • Un appareil en test (DUT)
  • Une machine hôte (par exemple, un ordinateur de bureau ou un ordinateur portable Linux)
  • Une scène que la caméra photographie

Configuration de l'appareil sous test (DUT)

Pour créer un DUT, suivez ces étapes :

  1. Connectez le DUT à une machine hôte via USB.
  2. Accordez à l’hôte les autorisations nécessaires pour accéder au DUT via ADB.
  3. Installez l'application CTS Verifier ( CtsVerifier.apk ) sur l'appareil. Pour plus d'informations, consultez Utilisation de CTS Verifier .

    extract root/out/host/linux-x86/cts-verfier/android-cts-verifier.zip
    cd android-cts-verifier
    adb install -r -g CtsVerifier.apk
    

Configuration de l'hôte

ITS nécessite que la machine hôte soit connectée au DUT via USB, puisse utiliser ADB pour le contrôle et la communication des appareils et que le logiciel requis soit installé.

Pour configurer votre machine hôte, assurez-vous que le logiciel suivant est installé.

Outils de la plateforme SDK Android

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

Python

Python doit être installé sur la machine hôte. Nous vous recommandons d'utiliser une distribution Python fournie pour garantir la prise en charge des versions compatibles. Pour plus de détails sur les versions de Python et des packages à installer pour une version spécifique, consultez les notes de version de Camera ITS pour la version correspondante.

mobile

Pour Android 12 et supérieur, 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 :

pip install mobly

Configuration de l'environnement

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

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 imprimée sur le terminal, l'environnement est prêt à exécuter les tests ITS.

Si vous voyez le message d'erreur libtinfo.so.6: no version information available (required by /bin/sh) au moment de l'exécution, exécutez la commande suivante pour renommer le fichier libtinfo.so.6 .

mv $ENV_DIRECTORY/lib/libtinfo.so.6 $ENV_DIRECTORY/lib/libtinfo.so.6.bak

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 prennent en charge toutes les exigences d'éclairage, de centrage et de modification des graphiques pour ITS. De plus, ITS-in-a-box est requis pour les tests d’extensions de caméra .

Pour les tests manuels, assurez-vous de ce qui suit :

  • Le DUT est sur un trépied
  • Le DUT est pointé vers la bonne scène pour chaque test. (Le script de test ITS fournit des invites pour modifier la configuration de la scène avant de démarrer les tests dans une nouvelle scène.)
  • Le DUT est connecté à la machine hôte via USB.
  • Le DUT ne bouge pas pendant le test.
  • La scène est éclairée par une source lumineuse constante et non fluctuante. (N'utilisez pas de lumière fluorescente car cela introduit du scintillement.)

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

L'orientation du téléphone doit être réglée de manière à ce que l'appareil photo prenne des images sans rotation. Le moyen le plus simple de vérifier cela consiste à utiliser les scènes de visage de la scène2. La plupart des téléphones sont orientés paysage, le téléphone étant 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 de test Mobly. Voici des exemples de différents cas d'utilisation.

Fichier config.yml de 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 de test. Lors de l'initialisation, le lanceur de tests 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 de test, exécutez tools/run_all_tests.py . S'il n'y a 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, celles-ci remplacent les valeurs de la section TestParams du fichier config.yml . Par 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=1 scenes=2,1,0

fichier config.yml de la scène sensor_fusion

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 de test. Android 13 et versions ultérieures prennent uniquement en charge le contrôleur Arduino pour la fusion de capteurs en raison des tests de prévisualisation et de stabilisation vidéo. Android 12 prend en charge les contrôleurs 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 Sensor Fusion Box , exécutez :

python tools/run_all_tests.py scenes=sensor_fusion
python tools/run_all_tests.py scenes=sensor_fusion camera=0

Fichier config.yml de plusieurs bancs d'essai

Ce qui suit est un exemple de fichier config.yml avec plusieurs bancs de test, un banc de test pour tablette et un banc de test sensor_fusion . Le banc d'essai correct 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 de test manuel

Ce qui suit est un exemple de fichier config.yml pour les tests manuels. À partir d'Android 14, les tests manuels sont pris en charge pour tous les tests, à l'exception des tests scene_extensions . Pour les tests manuels, le mot-clé MANUAL doit figurer dans le nom du banc de test. De plus, la section AndroidDevice ne peut pas inclure de section de série ou d'étiquette pour une tablette.

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

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

Exécution de tests ITS

Cette section décrit comment exécuter les tests ITS.

Appel de tests

Une fois le périphérique, la machine hôte (y compris l'environnement) et la scène physique configurés, exécutez les tests ITS en suivant le processus suivant.

  1. Ouvrez l'application CTS Verifer. Dans le menu des tests, sélectionnez Camera ITS Test .

  2. Depuis la machine hôte, exécutez les tests ITS depuis le répertoire CameraITS/ . Par exemple, pour un appareil doté 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 les configurations de débogage, nous vous recommandons d’exécuter l’une des scènes scene2 avec un seul test pour un délai d’exécution le plus rapide.

    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 JPEG sur la console et demande à l'utilisateur de confirmer si l'image est ok. Cela capture et confirme les boucles de flux 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 imprime un journal indiquant PASS, FAIL ou SKIP pour chaque test ITS, où 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'annonce pas via les interfaces de la caméra qu'il prend en charge le DNG, les tests liés à la capture de fichiers DNG sont ignorés et comptés comme des réussites.

  3. Pour reconnaître que les tests répondent aux exigences du test, appuyez sur le bouton de coche verte. L’entrée Camera ITS Test dans le menu des tests CTS Verifier devient alors verte et signifie que le téléphone a réussi Camera ITS.

Tests DUT en parallèle

Les appareils exécutant Android 14 ou version ultérieure prennent en charge 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 simultanément la caméra 0 dans une plate-forme et la caméra 1 dans une autre plate-forme. Tous les tests pour les sessions de tests parallèles sont regroupés sur la session CTS Verifier sur le DUT de référence. Vous devez exécuter des tests en parallèle avec le contrôle de l'éclairage Arduino, car le contrôle manuel de l'éclairage n'est pas pris en charge avec les tests en parallèle. Assurez-vous qu'un canal différent sur le même contrôleur Arduino contrôle l'éclairage de chaque plate-forme.

Ce qui suit est un exemple de fichier config.yml qui définit trois bancs de test à 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 de test 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 RAW ou DNG doivent fournir un modèle de bruit dans les métadonnées des résultats de capture de chaque prise de vue brute. Ce modèle de bruit doit être intégré dans le HAL de la caméra pour chaque caméra (par exemple, les caméras avant et arrière) sur l'appareil qui revendique la prise en charge.

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 intégrer le modèle dans le HAL de la caméra.

  1. 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 . Cela génère un extrait de code C. Pour plus d'informations sur la configuration de la caméra et de l'environnement de capture, consultez le document DngNoiseModel.pdf dans le répertoire tools .

  2. Pour implémenter le modèle de bruit pour l'appareil, coupez et collez l'extrait de code C dans le HAL de la caméra.

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 de la prise de vue fournies dans les données de la caméra sont correctes.