Ab dem 27. März 2025 empfehlen wir, android-latest-release anstelle von aosp-main zu verwenden, um AOSP zu erstellen und Beiträge dazu zu leisten. Weitere Informationen finden Sie unter Änderungen am AOSP.

Diese Seite wurde von der Cloud Translation API übersetzt.

Kamera-ITS
Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

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 konfigurieren, eine oder mehrere Aufnahmen machen und die Aufnahmen überprüfen, um zu sehen, ob sie die erwarteten Bilddaten enthalten. Viele der Tests erfordern, dass die Kamera auf ein bestimmtes Zieldiagramm ausgerichtet oder mit einer bestimmten Intensität leuchten.

ITS ist in der Testumgebung von CTS Verifier in cts/apps/CameraITS Geräte müssen die ITS-Tests bestehen, die den vom Kamera-Framework für Drittanbieter-Apps beworbenen unterstützten Funktionen entsprechen, als Teil der CTS.

Einrichten

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

Ein zu testendes Gerät (Device Under Test, DUT)
Einen Hostcomputer (z. B. einen Linux-Desktop oder -Laptop)
Eine Szene, die mit der Kamera aufgenommen wird

Einrichtung des Testgeräts (DUT)

So richten Sie einen DUT ein:

Verbinden Sie den DUT über USB mit einem Hostcomputer.
Gewähren Sie dem Host Berechtigungen für den Zugriff auf den DUT über ADB.
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 gezipten 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. Bei der öffentlichen Version der Android SDK Platform-Tools Siehe Versionshinweise zu SDK Platform Tools

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. Informationen dazu, welche Python- und Paketversionen für eine bestimmte Version installiert werden müssen, finden Sie in den entsprechenden Versionshinweisen für die Kamera-ITS.

Mobly

Mobly-Test-Framework für Android 12 und höher installiert werden. Mit Mobly können Sie ein DUT und ein Diagramm-Tablet in der Klasse its_base_test. 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 und PYTHONPATH eingerichtet und führt Einheitentests für die utils/*.py-Module aus. Falls nein Fehler an das Terminal zurückgegeben, kann der ITS in der Umgebung ausgeführt werden. Tests durchführen.

Szeneneinrichtung

Für die Einrichtung der Szenen empfehlen wir die Verwendung des Kamera-ITS-in-a-Box-Einrichtung für einfache Automatisierung, Zuverlässigkeit und Effizienz beim Testen. 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. (ITS-Testskript Aufforderungen zum Ändern der Szenerie bereitstellen, bevor Tests in einem neuen Szene)
Das DUT ist über USB mit dem Hostcomputer verbunden.
Der DUT verschiebt sich während des Testlaufs nicht.
Die Umgebung wird mit einer konstanten, nicht fluktuierenden Lichtquelle beleuchtet. (Achten Sie darauf, eine Leuchtstofflampe, da dies Flackern verursacht.)

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 Rotation. Am einfachsten lässt sich das anhand der Gesichtsszenen in Szene 2. 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-Testbereich zu definieren. Im Folgenden finden Sie Beispiele für verschiedene Anwendungsfälle.

config.yml-Datei für tabletbasierte Szenen

Das folgende Beispiel zeigt eine config.yml-Datei für Tablet-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 für Kameras oder Szenen angegeben sind, wird der Test mit den Dateiwerten von 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

Datei „sensor_fusion“ in config.yml

Im Folgenden finden Sie eine Beispiel-config_yml-Datei für sensor_fusion-Tests. Für sensor_fusion-Tests muss das Keyword SENSOR_FUSION im Namen des Testbeds enthalten sein. Android 13 und höher unterstützen nur Arduino. Controller für die Sensorfusion aufgrund von Vorschau- und Videostabilisierungstests. 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

Das folgende Beispiel zeigt eine config.yml-Datei 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 Seriennummern- oder Labelabschnitt für Tablet.

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 ITS-Tests ausgeführt werden.

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ü ITS-Test der Kamera.
Führen Sie auf dem Hostcomputer die ITS-Tests im CameraITS/ aus -Verzeichnis. Führen Sie bei einem Gerät mit Front- und Rückkamera folgenden Befehl:
```
python tools/run_all_tests.py
```
Das Skript iteriert über Kameras und testet Szenen basierend auf den config.yml-Datei. Für die Fehlerbehebung empfehlen wir, eine der scene2-Szenen mit einem einzelnen Test auszuführen, um möglichst schnell Ergebnisse zu erhalten.

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 Skripts wird ein Protokoll mit PASS, FAIL, FAIL* oder SKIP für jeden ITS-Test. 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.
Um zu bestätigen, dass die Tests die Testanforderungen erfüllt haben, tippen Sie auf das Schaltfläche mit einem grünen Häkchen. Eintrag Camera ITS Test im CTS Verifier wird dann grün und bedeutet, dass das Smartphone die Kamera-ITS bestanden hat.

Parallele DUT-Tests

Geräte mit Android 14 oder höher unterstützen parallel DUT-Test. 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 Tests Testsitzungen werden in der CTS-Verifier-Sitzung auf der Referenz-DUT zusammengefasst. Sie müssen parallele Tests mit der Arduino-Beleuchtungssteuerung durchführen, da manuelle Beleuchtung wird die Kontrollgruppe bei parallelen Tests nicht unterstützt. Stellen Sie sicher, dass ein anderes auf demselben Arduino-Controller die Beleuchtung für jeden Rig gesteuert.

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

Bei Geräten, die die Aufnahme von RAW- oder DNG-Dateien versprechen, muss in den Metadaten der Aufnahmeergebnisse jeder RAW-Aufnahme ein Rauschmodell angegeben werden. Dieses Rauschmodell muss in die HAL der Kamera für jede Kamera (z. B. Front- und Rückkamera) auf dem Gerät eingebettet sein, für das die Unterstützung beansprucht wird.

Implementierung des Rauschmodells

So implementieren Sie ein Rauschmodell:

Führen Sie den Befehl dng_noise_model.py-Script im tools-Verzeichnis. 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.
Schneide den C-Code aus und füge ihn ein, um das Rauschmodell für das Gerät zu implementieren in den Kamera-HAL ein.

Validierung des Rauschmodells

Die tests/scene1_1/test_dng_noise_model.py automatisierte ITS-Tests validieren das Rauschmodell, indem überprüft wird, ob die Rauschwerte für die Belichtungseinstellung und die Verstärkung in den Kameradaten sind korrekt.