Diese Seite wurde von der Cloud Translation API übersetzt.

Kamera ITS

Die Camera Image Test Suite (ITS) ist ein Framework zum Testen von 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 der unterstützten Funktionen bestehen für Drittanbieter-Apps als Teil von CTS beworben.

Einrichten

Zum Ausführen von ITS-Tests müssen folgende Voraussetzungen erfüllt sein:

Ein zu testendes Gerät (DUT)
Ein Hostcomputer (z. B. ein Linux-Computer 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 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: Installation der App aus einem CTS Verifier-Bundle (android-cts-verifier.zip) anstatt aus einer vollständigen Android-Quellstruktur, sowohl das Verzeichnis CtsVerifier.apk als auch das Verzeichnis CameraITS/ finden Sie im der obersten Ebene des ZIP-Ordners android-cts-verifier.

Hosteinrichtung

ITS verlangt, dass der Hostcomputer über USB mit dem DUT verbunden ist. können ADB für die Gerätesteuerung und -kommunikation verwenden und haben die erforderlichen Software installiert werden.

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

Android SDK-Plattformtools

Die Android SDK Platform-Tools müssen installiert sein und ADB muss sich im Der ausführbare Pfad der Shell oder des Terminals, die auf dem Host ausgeführt wird Maschine. 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 eines gebündelten Python-Distribution, um die Unterstützung kompatibler Versionen sicherzustellen. Weitere Informationen zu welche Python- und Paketversionen für einen bestimmten Release installiert werden sollen, finden Sie in der ITS-Versionshinweise der Kamera für die entsprechende Version.

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 folgenden Befehl aus, um das Mobly-Test-Framework zu installieren:

pip install mobly

Umgebung einrichten

Führen Sie folgenden Befehl aus, um die Testumgebung einzurichten:

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.

Wenn Sie die Fehlermeldung libtinfo.so.6: no version information available (required by /bin/sh) mit Laufzeit verwenden, führen Sie den folgenden Befehl aus, um die Datei libtinfo.so.6 umzubenennen.

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

Ambienteeinrichtung

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. ITS-in-a-box Prüfstände erfüllen alle Anforderungen an Beleuchtung, Zentrierung und Tabelle. für ITS. Außerdem ist ITS-in-a-box erforderlich für Kameraerweiterungen Tests durchführen.

Achten Sie bei manuellen Tests auf Folgendes:

Die DUT ist 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)
Der 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-Testskript wird eine Aufforderung angezeigt, in der der Nutzer aufgefordert wird, das Ambiente zu ändern. bevor Sie Tests in einer neuen Szene starten.

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 Handys ist das Telefon im Querformat mit der Smartphone für die Rückkamera gegen den Uhrzeigersinn und für der Frontkamera.

Konfigurationsdateien

Mit dem Mobly-Framework müssen Sie eine config.yml-Konfigurationsdatei erstellen, um Mobly testbed zu definieren. Im Folgenden finden Sie Beispiele für verschiedene Anwendungsfälle.

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

Das folgende Beispiel zeigt eine config.yml-Datei für Tablet-Szenen. Für Tablet-basierten Tests muss das Keyword TABLET im Namen der Testbedienelemente enthalten sein. Währenddessen -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 kein Befehl vorhanden ist Zeilenwerte für Kameras oder Szenen enthält, wird der Test mit der config.yml durchgeführt. Dateiwerte. Wenn es Befehlszeilenwerte für Kameras oder Szenen gibt, die Werte im Abschnitt TestParams der Datei config.yml überschreiben. 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

Das folgende Beispiel zeigt eine config_yml-Datei für sensor_fusion-Tests. Für sensor_fusion-Tests muss sich das Keyword SENSOR_FUSION im testbed befinden Namen. 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

Zum Ausführen von sensor_fusion-Tests mit der Sensor Fusion Box, 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

Hier sehen Sie eine config.yml-Beispieldatei mit mehreren testbeds, einem -Tablet und ein sensor_fusion-Testbed. Das richtige Prüffeld wurde ermittelt die von den Szenen getestet wurden.

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

Datei „config.yml“ manuell testen

Hier sehen Sie eine config.yml-Beispieldatei für manuelle Tests. Von Android 14 (manuell) Testing wird für alle Tests unterstützt, mit Ausnahme der scene_extensions Tests durchführen. 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 Umgebung) und der physische Standort führen Sie die ITS-Tests wie im Folgenden beschrieben 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 Debugging-Konfigurationen empfehlen wir, eine der scene2 Szenen mit einem einzigen Test für eine schnellstmögliche Bearbeitungszeit.

Bevor Sie die ITS-Tests für jede Szene ausführen, nimmt das Skript ein Bild der aktuellen Szene auf, speichert es als JPEG-Datei, druckt Pfad zur JPEG-Datei zur Konsole und bittet den Nutzer, zu bestätigen, ob das Image ist in Ordnung. Dieser Erfassungs- und Bestätigungsvorgang wird wiederholt, bis der Nutzer bestätigt, dass das Bild in Ordnung ist. Im Folgenden sind die Nachrichten 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 jeden ITS-Test, wobei ÜBERSPRINGEN anzeigt, dass der Test bestanden wurde, weil das Gerät die zu testende Funktion nicht beworben wurde. Wenn zum Beispiel ein Gerät wirbt nicht über die unterstützten Kameraschnittstellen DNG: Tests im Zusammenhang mit der DNG-Dateierfassung werden übersprungen und als bestanden gezählt.
Um zu bestätigen, dass die Tests die Testanforderungen erfüllt haben, tippen Sie auf das Schaltfläche mit grünem 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 Geschwindigkeit zu erhöhen. Tests durchführen. Mit parallelen Tests können Sie z. B. Kamera 0 in einem Rig und Kamera 1 an einem anderen Rig aus. 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 config.yml-Beispieldatei, in der drei auszuführende Testbetten definiert sind. .

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 für Aufnahmen im RAW- oder DNG-Format werben, muss ein Rauschen ausgegeben werden. in den Metadaten der Aufnahmeergebnisse jeder RAW-Aufnahme. Dieses Rauschmodell muss für jede Kamera in den Kamera-HAL eingebettet sein (z. B. und Rückkameras).

Implementierung des Rauschmodells

Um ein Rauschmodell zu implementieren, führen Sie die folgenden Schritte aus, um ein Rauschmodell zu generieren und das Modell in den Kamera-HAL einzubetten.

Führen Sie den Befehl dng_noise_model.py-Script im tools-Verzeichnis. Dadurch wird ein C-Code-Snippet ausgegeben. Für Weitere Informationen zum Einrichten der Kamera und der Aufnahmeumgebung findest du unter Das 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, die in den Kameradaten angegeben sind, korrekt sind.