Questa pagina è stata tradotta dall'API Cloud Translation.

Videocamera ITS

Camera Image Test Suite (ITS) è un framework per l'esecuzione di test su immagini prodotte da una fotocamera Android. L'obiettivo generale di ogni test nell'ITS è configurare la fotocamera in modo specifico, acquisire uno o più scatti ed esaminarli per verificare se contengono i dati delle immagini previsti. Molti dei test richiedono che la fotocamera sia rivolta verso un grafico target specifico o sia illuminata con un'intensità specifica.

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

Configura

Per eseguire test ITS, è necessario configurare quanto segue:

Un dispositivo in prova (DUT)
Una macchina host (ad esempio un computer o un laptop Linux)
Una scena fotografata dalla fotocamera

Configurazione del dispositivo in test (DUT)

Per configurare un DUT:

Collega il DUT a una macchina host tramite USB.
Concedi all'host le autorizzazioni per accedere al DUT tramite ADB.
Installa l'app CTS Verifier (CtsVerifier.apk) sul dispositivo. Per ulteriori informazioni, consulta Utilizzare 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 installi l'app da un CTS Verifier bundle (android-cts-verifier.zip) anziché da un albero di origine Android completo, sia CtsVerifier.apk che la directory CameraITS/ si trovano al livello superiore della cartella android-cts-verifier compressa.

Configurazione dell'host

ITS richiede che la macchina host sia collegata al DUT tramite USB, sia in grado di utilizzare ADB per il controllo e la comunicazione con i dispositivi e che abbia installato il software richiesto.

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

Android SDK Platform Tools

Gli strumenti della piattaforma Android SDK devono essere installati e ADB deve trovarsi nel percorso dell'eseguibile della shell o del terminale in esecuzione sulla macchina host. Per la versione rilasciata pubblicamente degli strumenti della piattaforma SDK Android, consulta le note di rilascio degli strumenti della piattaforma SDK.

Python

Python deve essere installato sulla macchina host. Ti consigliamo di utilizzare una distribuzione Python inclusa per garantire il supporto delle versioni compatibili. Per informazioni dettagliate su quali versioni di Python e dei pacchetti installare per una release specifica, consulta le note di rilascio ITS della videocamera per la release corrispondente.

Mobil

Per Android 12 e versioni successive, è necessario installare il framework di test Mobly. Mobly ti consente di configurare un DUT e una tavoletta con grafici nel its_base_test corso. Per installare il framework di test Mobly, esegui:

pip install mobly

Configurazione dell'ambiente

Per configurare l'ambiente di test, esegui:

cd CameraITS
source build/envsetup.sh

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

Configurazione scena

Per l'allestimento delle scene, consigliamo di utilizzare la configurazione Camera ITS-in-a-box per semplificare l'automazione, l'affidabilità e l'efficienza dei test. Le piattaforme per i test ITS-in-a-box supportano tutti i requisiti di illuminazione, centratura e modifica del grafico per l'ITS. Inoltre, l'uso della tecnologia ITS-in-a-box è richiesto per i test delle estensioni della videocamera.

Per i test manuali, assicurati di quanto segue:

Il DUT è su un treppiede
Il DUT è rivolto alla scena corretta per ogni test. Lo script di test ITS fornisce prompt per modificare la configurazione della scena prima di avviare i test in una nuova scena.
Il DUT è connesso alla macchina host tramite USB.
Il DUT non si muove durante l'esecuzione del test.
La scena è illuminata con una fonte di luce fissa e non fluttuante. Non utilizzare una luce fluorescente perché introduce uno sfarfallio.

Lo script per il test ITS mostra un messaggio che chiede all'utente di cambiare la configurazione della scena prima di avviare i test in una nuova scena.

L'orientamento dello smartphone deve essere impostato in modo che la fotocamera scatti le immagini senza ruotare. Il modo più semplice per verificarlo è utilizzare le scene di volti in scene2. La maggior parte degli smartphone è in orientamento orizzontale con lo smartphone ruotato in senso antiorario per la fotocamera posteriore e in senso orario per la fotocamera anteriore.

File di configurazione

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

File config.yml delle scene basate su tablet

Di seguito è riportato un file config.yml di esempio per scene basate su tablet. Per i test basati su tablet, la parola chiave TABLET deve essere presente nel nome del testbed. Durante l'inizializzazione, l'esecutore del test di 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 letto di test, esegui tools/run_all_tests.py. Se non sono presenti valori di riga di comando che specificano fotocamere o scene, il test viene eseguito con i valori del file config.yml. Se esistono valori della riga di comando per le videocamere o le scene, questi sostituiscono i valori nella sezione TestParams del file config.yml. Ad 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 scena sensor_fusion

Di seguito è riportato un file config_yml di esempio per i test sensor_fusion. Per i test sensor_fusion, la parola chiave SENSOR_FUSION deve essere presente nel nome del testbed. Android 13 e versioni successive supportano solo il controller Arduino per la fusione dei sensori a causa dei test di anteprima e 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 sensor_fusion test con la sensor fusion box, esegui:

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

File config.yml con più banchi di prova

Di seguito è riportato un esempio di file config.yml con più testbed, un testbed per tablet e un testbed sensor_fusion. La piattaforma di test corretta viene determinata 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 per i test manuali

Di seguito è riportato un esempio di file config.yml per i test manuali. Da Android 14, i test manuali sono supportati per tutti i test, ad eccezione di quelli scene_extensions. Per i test manuali, la parola chiave MANUAL deve essere presente nel nome del testbed. Inoltre, la sezione AndroidDevice non può includere una sezione di numero di serie 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.

Invocazione dei test

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

Apri l'app CTS Verifer. Nel menu dei test, seleziona Test ITS della fotocamera.
Dalla macchina host, esegui i test ITS dalla directory CameraITS/. Ad esempio, per un dispositivo con fotocamere anteriore e posteriore, esegui il seguente comando:
```
python tools/run_all_tests.py
```
Lo script esegue l'iterazione delle videocamere e delle scene di test in base al config.yml file. Per il debug delle configurazioni, ti consigliamo di eseguire una delle scene scene2 con un singolo test per velocizzare il tempo di risposta.

Per i test manuali, prima di iniziare a eseguire l'insieme di test ITS su ogni scena, lo script acquisisce un'immagine della scena corrente, la salva come JPEG, stampa il percorso del file JPEG nella console e chiede all'utente di confermare se l'immagine è corretta. Questo flusso di acquisizione e conferma si ripete fino a quando l'utente conferma che l'immagine è corretta. Di seguito sono riportati i messaggi di 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 log che mostra PASS, FAIL, FAIL* o SKIP per ogni test ITS. FAIL* indica che il test non è riuscito, ma poiché non è ancora obbligatorio, il test verrà segnalato come PASS a CtsVerifier. SKIP indica che il test è stato superato perché il dispositivo non ha pubblicizzato la funzionalità sottostante in fase di test. Ad esempio, se un dispositivo non indica tramite le interfacce della fotocamera che supporta il formato DNG, i test relativi all'acquisizione di file DNG vengono ignorati e conteggiati come PASS.
Per confermare che i test hanno soddisfatto i requisiti, tocca il pulsante con il segno di spunta verde. La voce Test ITS della fotocamera nel menu dei test di verifica CTS diventa verde e indica che il telefono ha superato la funzionalità Fotocamera ITS.

Test DUT in parallelo

I dispositivi con Android 14 o versioni successive supportano i test DUT paralleli. In questo modo puoi testare i DUT in parallelo con più rig per accelerare il test complessivo. Ad esempio, i test in parallelo ti consentono di testare contemporaneamente la videocamera 0 in un rig e la videocamera 1 in un altro rig. Tutti i test per le sessioni di test paralleli vengono aggregati nella sessione di verifica CTS sul DUT di riferimento. Devi 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 di ogni rig.

Di seguito è riportato un file config.yml di esempio che definisce tre testbed 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, utilizza 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 l'acquisizione dei dati in formato RAW o DNG devono fornire un modello di rumore nei metadati dei risultati dell'acquisizione di ogni ripresa non elaborata. Questo modello di rumore deve essere incorporato nell'HAL della fotocamera per ogni fotocamera (ad esempio, anteriore e posteriore) sul dispositivo che dichiara il supporto.

Implementazione del modello di rumore

Per implementare un modello di rumore, segui questi passaggi per generare un modello di rumore e incorporarlo nell'HAL della videocamera.

Per generare un modello di rumore per ogni videocamera, esegui lo script dng_noise_model.py nella directory tools. Viene visualizzato uno snippet di codice C. Per maggiori informazioni su come configurare la fotocamera e l'ambiente di acquisizione, consulta 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 videocamera.

Convalida del modello di rumore

Il test ITS automatico 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 dell'inquadratura forniti nei dati della fotocamera siano corretti.