Diese Seite wurde von der Cloud Translation API übersetzt.

Kamera ITS

Die Camera Image Test Suite (ITS) ist ein Framework zum Ausführen von Tests an Bildern, die von einer Android-Kamera aufgenommen wurden. Das allgemeine Ziel jedes Tests im ITS besteht darin, die Kamera auf bestimmte Weise zu konfigurieren, eine oder mehrere Aufnahmen aufzunehmen und die Aufnahmen zu überprüfen, um zu sehen, ob sie die erwarteten Bilddaten enthalten. Bei vielen Tests muss die Kamera auf ein bestimmtes Zieldiagramm ausgerichtet oder mit einer bestimmten Intensität beleuchtet werden.

ITS befindet sich im CTS Verifier-Test-Harness in cts/apps/CameraITS. Geräte müssen die ITS-Tests bestehen, die den unterstützten Funktionen entsprechen, die vom Kamera-Framework für Drittanbieter-Apps als Teil von CTS beworben werden.

Einrichten

Für ITS-Tests müssen folgende Voraussetzungen erfüllt sein:

Ein zu testendes Gerät (Device Under Test, DUT)
Ein Hostcomputer (z. B. ein Linux-Computer oder ‐Laptop)
Eine Szene, die von der Kamera aufgenommen wird

Testgerät einrichten

So richten Sie ein DUT ein:

Verbinden Sie das DUT über USB mit einem Hostcomputer.
Gewähren Sie dem Host die Berechtigung, über ADB auf die DUT zuzugreifen.
Installieren Sie die CTS Verifier App (CtsVerifier.apk) auf dem Gerät. Weitere Informationen finden Sie unter CTS Verifier verwenden.
```
extract root/out/host/linux-x86/cts-verfier/android-cts-verifier.zip
cd android-cts-verifier
adb install -r -g CtsVerifier.apk
```
Hinweis :Wenn Sie die App aus einem CTS-Verifier-Bundle (android-cts-verifier.zip) und nicht aus einem vollständigen Android-Quellbaum installieren, finden Sie sowohl CtsVerifier.apk als auch das Verzeichnis CameraITS/ auf der obersten Ebene des gezippten Ordners android-cts-verifier.

Hosteinrichtung

Für ITS muss der Hostcomputer über USB mit der DUT verbunden sein, ADB für die Gerätesteuerung und ‑kommunikation verwenden können und die erforderliche Software installiert haben.

Achten Sie bei der Einrichtung Ihres Hostcomputers darauf, dass die folgende Software installiert ist.

Android SDK-Plattformtools

Die Android SDK-Plattformtools müssen installiert sein und ADB muss sich im ausführbaren Pfad der Shell oder des Terminals befinden, das auf dem Hostcomputer ausgeführt wird. Informationen zur öffentlich veröffentlichten Version der Android SDK-Plattformtools finden Sie in den Versionshinweisen zu SDK-Plattformtools.

Python

Python muss auf dem Hostcomputer installiert sein. Wir empfehlen die Verwendung einer gebündelten Python-Distribution, um Unterstützung für kompatible Versionen zu gewährleisten. Weitere Informationen dazu, welche Python- und Paketversionen für einen bestimmten Release installiert werden, finden Sie in den ITS-Versionshinweisen der jeweiligen Kamera.

Mobly

Für Android 12 und höher muss das Mobly-Test-Framework installiert sein. Mit Mobly können Sie ein DUT und ein Diagrammtablet in der its_base_test-Klasse einrichten. Führen Sie Folgendes aus, um das Mobly-Test-Framework zu installieren:

pip install mobly

Umgebung einrichten

Führen Sie zum Einrichten der Testumgebung Folgendes aus:

cd CameraITS
source build/envsetup.sh

Mit diesem Befehl wird die Python-Installation geprüft, die Umgebungsvariable PYTHONPATH eingerichtet und Einheitentests für die utils/*.py-Module ausgeführt. Wenn keine Fehler im Terminal ausgegeben werden, ist die Umgebung bereit, die ITS-Tests auszuführen.

Szeneneinrichtung

Für die Einrichtung der Szenen empfehlen wir die ITS-in-a-Box-Einrichtung für Kameras, da sie eine einfache Automatisierung, Zuverlässigkeit und Effizienz bei Tests bietet. Die ITS-in-a-Box-Teststände unterstützen alle Anforderungen an Beleuchtung, Zentrierung und Kartenwechsel für ITS. Außerdem ist ITS-in-a-Box für den Test von Kameraerweiterungen erforderlich.

Beachten Sie bei manuellen Tests Folgendes:

Das DUT befindet sich auf einem Stativ.
Die DUT zeigt für jeden Test auf die richtige Szene. Das ITS-Testskript enthält Aufforderungen, die Szenenkonfiguration zu ändern, bevor Tests in einer neuen Szene gestartet werden.
Das DUT ist über USB mit dem Hostcomputer verbunden.
Das DUT bewegt sich während des Testlaufs nicht.
Die Szene wird von einer konstanten, nicht schwankenden Lichtquelle beleuchtet. Verwenden Sie kein Leuchtstoff, da dies zum Flackern führt.

Im ITS-Testscript wird der Nutzer aufgefordert, die Szeneneinrichtung zu ändern, bevor er Tests in einer neuen Szene startet.

Die Ausrichtung des Smartphones muss so eingestellt sein, dass die Kamera Bilder ohne Drehung aufnimmt. Am einfachsten lässt sich das mit den Gesichtern in „scene2“ prüfen. Bei den meisten Smartphones ist das Smartphone im Querformat und für die Rückkamera gegen den Uhrzeigersinn und für die Frontkamera im Uhrzeigersinn gedreht.

Konfigurationsdateien

Mit dem Mobly-Framework müssen Sie eine config.yml-Konfigurationsdatei erstellen, um den Mobly-Testbed zu definieren. Die folgenden Beispiele zeigen verschiedene Anwendungsfälle.

config.yml-Datei für Tablet-basierte Szenen

Im Folgenden finden Sie ein Beispiel für eine config.yml-Datei für tabletbasierte Szenen. Bei tabletbasierten Tests muss das Keyword TABLET im Namen des Testbeds enthalten sein. Während der Initialisierung initialisiert der Mobly-Test-Runner die Parameter in der Datei und übergibt sie an die einzelnen Tests.

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

Führen Sie tools/run_all_tests.py aus, um die Testplattform aufzurufen. Wenn keine Befehlszeilenwerte vorhanden sind, die Kameras oder Szenen angeben, wird der Test mit den Dateiwerten config.yml ausgeführt. Wenn es Befehlszeilenwerte für Kameras oder Szenen gibt, werden die Werte im Abschnitt TestParams der Datei config.yml überschrieben. Beispiel:

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

config.yml-Datei der Szene „sensor_fusion“

Im Folgenden finden Sie eine Beispielconfig_yml-Datei für sensor_fusion-Tests. Für sensor_fusion-Tests muss das Keyword SENSOR_FUSION im Namen des Testbeds enthalten sein. Unter Android 13 und höher wird aufgrund von Tests für die Vorschau und Videostabilisierung nur der Arduino-Controller für die Sensorfusion unterstützt. Android 12 unterstützt Arduino- und Canakit-Controller.

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

Wenn Sie sensor_fusion-Tests mit dem Sensorfusions-Box ausführen möchten, führen Sie Folgendes aus:

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

config.yml-Datei für mehrere Testbeds

Das folgende Beispiel zeigt eine config.yml-Datei mit mehreren Testbeds, einem Tablet-Testbed und einem sensor_fusion-Testbed. Das richtige Testsystem wird anhand der getesteten Szenen bestimmt.

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

config.yml-Datei für manuelle Tests

Im Folgenden finden Sie eine Beispieldatei config.yml für manuelle Tests. Ab Android 14 werden manuelle Tests für alle Tests unterstützt, mit Ausnahme der scene_extensions-Tests. Für manuelle Tests muss das Schlüsselwort MANUAL im Namen des testbed-Felds enthalten sein. Außerdem darf der Abschnitt AndroidDevice keinen Abschnitt für Seriennummern oder Labels für ein Tablet enthalten.

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

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

ITS-Tests ausführen

In diesem Abschnitt wird beschrieben, wie Sie ITS-Tests ausführen.

Tests aufrufen

Nachdem das Gerät, der Hostcomputer (einschließlich der Umgebung) und die physische Szene eingerichtet sind, führen Sie die ITS-Tests mit dem folgenden Verfahren aus.

Öffnen Sie die CTS Verifer App. Wählen Sie im Testmenü die Option Camera ITS Test aus.
Führen Sie die ITS-Tests auf dem Hostcomputer aus dem Verzeichnis CameraITS/ aus. Führen Sie beispielsweise für ein Gerät mit Front- und Rückkamera den folgenden Befehl aus:
```
python tools/run_all_tests.py
```
Das Script durchläuft basierend auf der Datei config.yml Kameras und Testszenen. Für Debugging-Konfigurationen empfehlen wir, eine der scene2-Szenen mit einem einzigen Test auszuführen, um die Bearbeitungszeit zu verkürzen.

Bei manuellen Tests nimmt das Script vor dem Ausführen der ITS-Tests für jede Szene ein Foto der aktuellen Szene auf, speichert es als JPEG, druckt den Pfad zum JPEG in die Konsole und bittet den Nutzer, zu bestätigen, dass das Bild in Ordnung ist. Dieser Ablauf Aufnahme und Bestätigung wird wiederholt, bis der Nutzer bestätigt, dass das Bild in Ordnung ist. Im Folgenden sind die Meldungen in diesem Ablauf aufgeführt.
```
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)
```
Bei jeder Ausführung des Scripts wird ein Protokoll ausgegeben, das für jeden ITS-Test entweder PASS, FAIL, FAIL* oder SKIP enthält. FAIL* gibt an, dass der Test fehlgeschlagen ist. Da der Test jedoch noch nicht obligatorisch ist, wird er von CtsVerifier als PASS gemeldet. SKIP gibt an, dass der Test bestanden wurde, weil das Gerät die getestete zugrunde liegende Funktion nicht anbietet. Wenn ein Gerät beispielsweise nicht über die Kameraschnittstellen angibt, dass es DNG unterstützt, werden Tests zur DNG-Datenaufnahme übersprungen und als PASS gezählt.
Tippen Sie auf das grüne Häkchen, um zu bestätigen, dass die Tests die Testanforderungen erfüllt haben. Der Eintrag Camera ITS Test im Testmenü des CTS Verifier wird dann grün und zeigt an, dass das Smartphone den ITS-Test für die Kamera bestanden hat.

Parallele DUT-Tests

Geräte mit Android 14 oder höher unterstützen parallele DUT-Tests. So können Sie DUTs parallel mit mehreren RIGs testen, um die Gesamttestzeit zu verkürzen. Mit parallelen Tests können Sie beispielsweise Kamera 0 in einem Rig und Kamera 1 in einem anderen Rig gleichzeitig testen. Alle Tests für parallele Testsitzungen werden in der CTS-Verifier-Sitzung auf der Referenz-DUT zusammengefasst. Sie müssen parallele Tests mit der Arduino-Lampensteuerung ausführen, da die manuelle Lampensteuerung bei parallelen Tests nicht unterstützt wird. Achten Sie darauf, dass ein anderer Kanal auf demselben Arduino-Controller die Beleuchtung für jeden Rig steuert.

Im Folgenden finden Sie eine Beispiel-config.yml-Datei, in der drei Testbeds definiert sind, die parallel ausgeführt werden sollen.

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"

Verwenden Sie den folgenden Befehl, um die Testbeds parallel auszuführen:

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

DNG-Rauschmodell

Geräte, die für Aufnahmen im RAW- oder DNG-Format werben, müssen in den Metadaten der Erfassungsergebnisse jeder Rohaufnahme ein Rauschmodell bereitstellen. Dieses Geräuschmodell muss für jede Kamera (z. B. Front- und Rückkameras) auf dem Gerät, für das Unterstützung angegeben wird, in den HAL eingebettet werden.

Implementierung des Rauschmodells

So implementieren Sie ein Rauschmodell:

Führen Sie das dng_noise_model.py-Script im Verzeichnis tools aus, um ein Rauschmodell für jede Kamera zu generieren. Dadurch wird ein C-Code-Snippet ausgegeben. Weitere Informationen zum Einrichten der Kamera und der Aufnahmeumgebung finden Sie im Dokument DngNoiseModel.pdf im Verzeichnis tools.
Schneiden Sie das C-Code-Snippet aus und fügen Sie es in den Kamera-HAL ein, um das Rauschmodell für das Gerät zu implementieren.

Validierung des Geräuschmodells

Beim automatisierten ITS-Test tests/scene1_1/test_dng_noise_model.py wird das Rauschmodell validiert, indem überprüft wird, ob die Rauschwerte für die Belichtung und den Gewinn des Aufnahmen in den Kameradaten korrekt sind.