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

Caméra ITS

La suite de tests d'images de caméra (ITS) est un framework qui permet d'exécuter des tests sur des images. produit par un appareil photo Android. L'objectif général de chaque test dans ITS est de configurer l'appareil photo de façon spécifique, prendre une ou plusieurs prises de vue ; Examinez les prises de vue pour voir si elles contiennent les données d'image attendues. Bon nombre des les tests exigent que l'appareil photo soit dirigé vers un graphique cible spécifique s'illumine à une intensité spécifique.

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

Configuration

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

Un appareil soumis aux tests (DUT)
Un ordinateur hôte (par exemple, un ordinateur de bureau ou portable Linux)
Une scène photographiée par l'appareil photo

Configuration de l'appareil soumis aux tests (DUT)

Pour configurer un appareil testé, procédez comme suit:

Connectez l'appareil testé à une machine hôte via USB.
Accordez des autorisations à l'hôte pour qu'il puisse accéder à l'appareil testé via ADB.
Installez l'application CTS Verifier (CtsVerifier.apk) sur l'appareil. Pour plus consultez Utiliser l'outil de vérification CTS.
```
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 qu'à partir d'une arborescence source Android complète, les répertoires CtsVerifier.apk et CameraITS/ se trouvent dans la section premier niveau du dossier android-cts-verifier compressé.

Configuration de l'hôte

Le service ITS exige que la machine hôte soit connectée à l'appareil à l'aide d'un câble USB, soit utiliser ADB pour le contrôle des appareils et la communication, et disposer des d'installer le logiciel.

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 la plate-forme du SDK Android doivent être installés et ADB doit être dans Chemin d'accès exécutable de l'interface système ou du terminal qui s'exécute sur l'hôte machine. Pour la version publique d'Android SDK Platform Tools, voir Notes de version de SDK Platform Tools

Python

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

Mobilité

Pour Android 12 et versions ultérieures, le framework de test Mobly doit être installé. Mobly vous permet de configurer un appareil testé et une tablette pour cartographier 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 PYTHONPATH variable d'environnement et exécute des tests unitaires sur les modules utils/*.py. Si non sont affichées sur le terminal, l'environnement est prêt à exécuter tests.

Si le message d'erreur s'affiche libtinfo.so.6: no version information available (required by /bin/sh) à 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 Configuration de la caméra ITS incluse dans la boîte pour d'automatisation, de fiabilité et d'efficacité des tests. L'outil ITS prêt à l'emploi Les plates-formes d'évaluation prennent en charge l'éclairage, le centrage et l'évolution des graphiques. pour ITS. En outre, ITS-in-a-box est requis pour extensions pour appareil photo tests.

Pour les tests manuels, vérifiez les points suivants:

L'appareil testé est posé sur un trépied
L'appareil testé est dirigé vers la bonne scène pour chaque test. (Le script de test ITS fournir des invites pour modifier la configuration de la scène avant de lancer les tests dans une nouvelle .)
L'appareil testé est connecté à la machine hôte via USB.
L'appareil testé ne bouge pas pendant le test.
La scène est éclairée par une source de lumière régulière et non fluctuante. (À éviter utilisez une lumière fluorescente, car cela provoque un scintillement.)

Le script de test ITS affiche une invite demandant à l'utilisateur de changer de 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 la rotation des clés. Le moyen le plus simple de vérifier est de créer des portraits scène 2. La plupart des téléphones sont en mode paysage, avec téléphone a 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

Avec le framework Mobly, vous devez créer un fichier de configuration config.yml pour pour définir Mobly testbed. Vous trouverez ci-dessous des exemples pour différents cas d'utilisation.

Fichier config.yml de scènes basées sur une tablette

Voici un exemple de fichier config.yml pour des scènes sur tablette. Pour les tests sur tablette, le mot clé TABLET doit figurer dans le nom du test. Pendant Initialisation, le lanceur de test 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. Si aucune commande des valeurs de ligne spécifiant les caméras ou les scènes, le test est exécuté avec l'config.yml valeurs de fichier. S'il existe des valeurs de ligne de commande pour les caméras ou les scènes, ces remplacez 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=1 scenes=2,1,0

Fichier de configuration.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 se trouver dans le testbed. son nom. Android 13 et versions ultérieures ne sont compatibles qu'avec Arduino pour la fusion des capteurs, grâce aux tests d'aperçu 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 méthode boîte de fusion des 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

Plusieurs fichiers config.yml

Voici un exemple de fichier config.yml avec plusieurs testbeds, un sur une tablette et un autre sur sensor_fusion. Le testbed 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

Test manuel du fichier config.yml

Voici un exemple de fichier config.yml pour un test manuel. De Android 14, manuel sont acceptés pour tous les tests, à l'exception de scene_extensions tests. Pour les tests manuels, le mot clé MANUAL doit figurer dans le nom de la campagne test. De plus, la section AndroidDevice ne peut pas inclure de section concernant les séries ou les étiquettes pour une tablette.

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

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

Exécution des tests ITS

Cette section explique comment exécuter des tests ITS.

Appeler des tests

Après l'appareil, la machine hôte (y compris l'environnement) et la scène physique sont exécutez les tests ITS en procédant comme suit.

Ouvrez l'application CTS Verifer. Dans le menu des tests, sélectionnez Test ITS de la caméra
À partir de la machine hôte, exécutez les tests ITS à partir de CameraITS/. . Par exemple, pour un appareil équipé d'une caméra avant et arrière, exécutez la commande suivante : la commande suivante:
```
python tools/run_all_tests.py
```
Le script parcourt les caméras et les scènes de test en fonction config.yml. Pour les configurations de débogage, nous vous recommandons d'en exécuter une des scènes scene2 avec un seul test pour une durée d'exécution plus rapide.

Pour les tests manuels, avant de commencer à exécuter l'ensemble de tests ITS sur chaque scène, le script prend une photo de la scène actuelle, l'enregistre au format JPEG, le chemin d'accès au fichier JPEG sur la console, et demande à l'utilisateur de confirmer si l'image n'est pas un problème. Ce flux de capture et confirmation est répété 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 ITS test, où SKIP indique que le test a été réussi parce que l'appareil n'analysait pas les fonctionnalités sous-jacentes testées. Par exemple, si un l'appareil ne diffuse pas d'annonces via les interfaces de caméra compatibles DNG, les tests liés à la capture de fichiers DNG sont ignorés et comptabilisés comme réussis.
Pour confirmer que les tests ont satisfait aux exigences de test, appuyez sur l'icône une coche verte. L'entrée Camera ITS Test (Appareil photo ITS Test) dans l'outil de vérification CTS le menu tests devient vert et signifie que le téléphone a réussi les tests de l'appareil photo.

Tests des appareils testés en parallèle

Les appareils équipés d'Android 14 ou version ultérieure sont compatibles avec Tests de l'appareil testé. Cela vous permet de tester les appareils testés en parallèle avec plusieurs supports afin de gagner en rapidité. les tests globaux. Par exemple, les tests en parallèle vous permettent de tester la caméra 0 le support et la caméra 1 sur un autre support en même temps. Tous les tests en parallèle les sessions de test sont agrégées sur la session CTS Verifier dans l'appareil testé de référence. Vous devez effectuer des tests en parallèle avec la commande d'éclairage Arduino, car l'éclairage manuel n'est pas compatible avec les tests en parallèle. Assurez-vous qu'un autre sur le même contrôleur Arduino contrôle l'éclairage de chaque support.

Voici un exemple de fichier config.yml qui définit trois tables 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 testsbeds 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é d'enregistrer des images au format RAW ou DNG doivent fournir un bruit dans les métadonnées de résultat de la capture de chaque plan brut. Ce modèle de bruit doit être intégré au HAL de chaque caméra (par exemple, avant et les caméras arrière) sur l'appareil qui en revendique la prise en charge.

Implémentation d'un modèle de bruit

Pour implémenter un modèle de bruit, procédez comme suit afin de générer un modèle de bruit et intégrer le modèle dans le HAL de la caméra.

Pour générer un modèle de bruit pour chaque caméra, exécutez la Script dng_noise_model.py dans Répertoire tools. Cela génère un extrait de code C. Pour plus d'informations sur la configuration de l'appareil photo et 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 le code C. dans le HAL de la caméra.

Validation du modèle de bruit

tests/scene1_1/test_dng_noise_model.py un test ITS automatisé valide le modèle de bruit en vérifiant que les valeurs de bruit pour l'exposition et le gain du plan fournis dans les données de l'appareil photo sont corrects.