Questa pagina è stata tradotta dall'API Cloud Translation.

Fotocamera ITS

Camera Image Test Suite (ITS) è un framework per l'esecuzione di test sulle immagini prodotte da una fotocamera Android. L'obiettivo generale di ogni test in ITS è configurare la fotocamera in un modo specifico, catturare uno o più scatti ed esaminare gli scatti per vedere se contengono i dati immagine attesi. Molti test richiedono che la fotocamera sia puntata verso uno specifico diagramma di destinazione o sia illuminata con un'intensità specifica.

ITS si trova nel cablaggio di test CTS Verifier in cts/apps/CameraITS . I dispositivi devono superare i test ITS corrispondenti alle funzionalità supportate pubblicizzate dal framework della fotocamera per app di terze parti come sottoinsieme di CTS.

Impostare

Per eseguire i test ITS è necessario impostare quanto segue:

Un dispositivo sotto test (DUT)
Una macchina host (ad esempio, un desktop o un laptop Linux)
Una scena che la macchina fotografica fotografa

Configurazione del dispositivo sotto test (DUT).

Per impostare un DUT, attenersi alla seguente procedura:

Collegare il DUT a una macchina host tramite USB.
Concedere all'host le autorizzazioni per accedere al DUT su ADB.
Installa l'app CTS Verifier ( CtsVerifier.apk ) sul dispositivo. Per ulteriori informazioni, vedere Utilizzo di CTS Verifier .
```
extract root/out/host/linux-x86/cts-verfier/android-cts-verifier.zip
cd android-cts-verifier
adb install -r -g CtsVerifier.apk
```
Nota: se si installa l'app da un bundle CTS Verifier ( android-cts-verifier.zip ) anziché da un albero sorgente Android completo, sia CtsVerifier.apk che la directory CameraITS/ possono essere trovati al livello superiore del file zippato android-cts-verifier cartella android-cts-verifier .

Configurazione dell'ospite

ITS richiede che la macchina host sia connessa al DUT tramite USB, sia in grado di utilizzare ADB per il controllo e la comunicazione del dispositivo e abbia il software richiesto installato.

Per configurare il computer host, assicurati che sia installato il seguente software.

Strumenti della piattaforma SDK Android

Gli strumenti della piattaforma Android SDK devono essere installati e ADB deve trovarsi nel percorso eseguibile della shell o del terminale in esecuzione sul computer host. Per la versione rilasciata al pubblico degli strumenti della piattaforma Android SDK, consulta le note sulla versione degli strumenti della piattaforma SDK .

Pitone

Python deve essere installato sul computer host. Ti consigliamo di utilizzare una distribuzione Python in bundle per garantire il supporto per le versioni compatibili. Per dettagli su quali versioni di Python e pacchetti installare per una versione specifica, vedere le note sulla versione di Camera ITS per la versione corrispondente.

Mobilmente

Per Android 12 e versioni successive è necessario installare il framework di test Mobly. Mobly ti consente di configurare un DUT e una tavoletta cartografica nella classe its_base_test . Per installare il framework di test Mobly, eseguire:

pip install mobly

Configurazione dell'ambiente

Per configurare l'ambiente di test, eseguire:

cd CameraITS
source build/envsetup.sh

Questo comando controlla l'installazione di Python, imposta la variabile di ambiente PYTHONPATH ed esegue unit test sui moduli utils/*.py . Se non vengono stampati errori sul terminale, l'ambiente è pronto per eseguire i test ITS.

Se viene visualizzato il messaggio di errore libtinfo.so.6: no version information available (required by /bin/sh) in fase di runtime, esegui il comando seguente per rinominare il file libtinfo.so.6 .

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

Impostazione della scena

Per impostare le scene, si consiglia di utilizzare la configurazione ITS-in-a-box della fotocamera per facilitare l'automazione, l'affidabilità e l'efficienza nei test. I banchi di prova ITS-in-a-box supportano tutti i requisiti di illuminazione, centratura e modifica dei grafici per ITS. Inoltre, è necessario ITS-in-a-box per testare le estensioni della fotocamera .

Per i test manuali, verificare quanto segue:

Il DUT è su un treppiede
Il DUT viene puntato sulla scena corretta per ciascun test. (Lo script del test ITS fornisce istruzioni per modificare l'impostazione della scena prima di iniziare i test in una nuova scena.)
Il DUT è collegato alla macchina host tramite USB.
Il DUT non si muove durante la prova.
La scena è illuminata da una fonte di luce fissa e non fluttuante. (Non utilizzare una luce fluorescente perché ciò introduce sfarfallio.)

Lo script del test ITS visualizza un messaggio che chiede all'utente di modificare l'impostazione della scena prima di iniziare i test in una nuova scena.

L'orientamento del telefono deve essere impostato in modo che la fotocamera scatti immagini senza rotazione. Il modo più semplice per verificarlo è con le scene dei volti nella scena2. La maggior parte dei telefoni ha il telefono in orientamento orizzontale con il telefono ruotato in senso antiorario per la fotocamera posteriore e ruotato in senso orario per la fotocamera anteriore.

File di configurazione

Utilizzando il framework Mobly, è necessario creare un file di configurazione config.yml per definire il banco di prova Mobly. Di seguito sono riportati esempi per diversi casi d'uso.

File config.yml delle scene basate su tablet

Quello che segue è un esempio di file config.yml per scene basate su tablet. Per i test basati su tablet, la parola chiave TABLET deve essere presente nel nome del banco di prova. Durante l'inizializzazione, il test runner Mobly inizializza i parametri nel file e li passa ai singoli test.

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

Per richiamare il banco di prova, esegui tools/run_all_tests.py . Se non sono presenti valori della riga di comando che specificano telecamere o scene, il test viene eseguito con i valori del file config.yml . Se sono presenti valori della riga di comando per telecamere o scene, questi sovrascrivono i valori nella sezione TestParams del file config.yml . Per esempio:

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

File config.yml della scena sensor_fusion

Di seguito è riportato un esempio di file config_yml per i test sensor_fusion . Per i test sensor_fusion , la parola chiave SENSOR_FUSION deve essere nel nome del banco di prova. Android 13 e versioni successive supportano solo il controller Arduino per la fusione dei sensori a causa dei test di anteprima e di stabilizzazione video. Android 12 supporta i controller Arduino e 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

Per eseguire i test sensor_fusion con la sensor fusion box , eseguire:

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

File config.yml di più banchi di prova

Quello che segue è un esempio di file config.yml con più testbed, un testbed per tablet e un testbed sensor_fusion . Il banco di prova corretto è determinato dalle scene testate.

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

File config.yml di test manuale

Quello che segue è un file config.yml di esempio per il test manuale. A partire da Android 14, i test manuali sono supportati per tutti i test ad eccezione dei test scene_extensions . Per i test manuali, la parola chiave MANUAL deve essere nel nome del banco di prova. Inoltre, la sezione AndroidDevice non può includere una sezione seriale o etichetta per un tablet.

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

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

Esecuzione di test ITS

Questa sezione descrive come eseguire i test ITS.

Invocare i test

Dopo aver configurato il dispositivo, la macchina host (incluso l'ambiente) e la scena fisica, eseguire i test ITS utilizzando la seguente procedura.

Apri l'app CTS Verifer. Nel menu dei test, seleziona Test ITS della fotocamera .
Dal computer host, eseguire i test ITS dalla directory CameraITS/ . Ad esempio, per un dispositivo con fotocamere anteriore e posteriore, esegui il comando seguente:
```
python tools/run_all_tests.py
```
Lo script scorre le telecamere e testa le scene in base al file config.yml . Per le configurazioni di debug, consigliamo di eseguire una delle scene scene2 con un singolo test per un completamento più rapido.
Per i test manuali, prima di iniziare a eseguire la serie di test ITS su ciascuna scena, lo script scatta un'immagine della scena corrente, la salva come JPEG, stampa il percorso del JPEG sulla console e chiede all'utente di confermare se l'immagine va bene. Questo cattura e conferma i cicli di flusso finché l'utente non conferma che l'immagine è a posto. Di seguito sono riportati i messaggi in questo flusso.
```
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)
```
Ogni esecuzione dello script stampa un registro che mostra PASS, FAIL o SKIP per ciascun test ITS, dove SKIP indica che il test è stato superato perché il dispositivo non ha pubblicizzato la funzionalità sottostante sottoposta a test. Ad esempio, se un dispositivo non pubblicizza tramite le interfacce della fotocamera il supporto DNG, i test relativi all'acquisizione di file DNG vengono saltati e conteggiati come superati.
Per confermare che i test hanno soddisfatto i requisiti del test, toccare il pulsante del segno di spunta verde. La voce Camera ITS Test nel menu dei test di CTS Verifier diventa verde e indica che il telefono ha superato Camera ITS.

Test DUT parallelo

I dispositivi con Android 14 o versioni successive supportano i test DUT paralleli. Ciò consente di testare i DUT in parallelo con più impianti per accelerare i test complessivi. Ad esempio, il test parallelo consente di testare contemporaneamente la fotocamera 0 su un impianto e la fotocamera 1 su un altro impianto. Tutti i test per le sessioni di test paralleli vengono aggregati nella sessione CTS Verifier sul DUT di riferimento. È necessario eseguire test paralleli con il controllo dell'illuminazione Arduino, poiché il controllo manuale dell'illuminazione non è supportato con i test paralleli. Assicurati che un canale diverso sullo stesso controller Arduino controlli l'illuminazione per ciascun rig.

Quello che segue è un file config.yml di esempio che definisce tre banchi di prova da eseguire in parallelo.

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"

Per eseguire i testbed in parallelo, utilizzare il seguente comando:

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

Modello di rumore DNG

I dispositivi che pubblicizzano la possibilità di acquisire RAW o DNG devono fornire un modello di rumore nei metadati dei risultati di acquisizione di ogni scatto raw. Questo modello di rumore deve essere incorporato nell'HAL della fotocamera per ogni fotocamera (ad esempio, fotocamere anteriore e posteriore) sul dispositivo che richiede il supporto.

Implementazione del modello di rumore

Per implementare un modello di rumore, attenersi alla seguente procedura per generare un modello di rumore e incorporare il modello nell'HAL della fotocamera.

Per generare un modello di rumore per ciascuna telecamera, esegui lo script dng_noise_model.py nella directory tools . Questo restituisce uno snippet di codice C. Per ulteriori informazioni su come configurare la fotocamera e l'ambiente di acquisizione, consultare il documento DngNoiseModel.pdf nella directory tools .
Per implementare il modello di rumore per il dispositivo, taglia e incolla lo snippet di codice C nell'HAL della fotocamera.

Validazione del modello di rumore

Il test ITS automatizzato tests/scene1_1/test_dng_noise_model.py convalida il modello di rumore verificando che i valori di rumore per l'esposizione e il guadagno dello scatto forniti nei dati della fotocamera siano corretti.