ITS della fotocamera

Camera Image Test Suite (ITS) è un framework per l'esecuzione di test sulle immagini prodotto 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 pubblicizzato dal framework della fotocamera per le app di terze parti come sottoinsieme di CTS.

Configura

Per eseguire i 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 prova (DUT)

Per configurare un DUT, segui questi passaggi:

  1. Collega il DUT a una macchina host tramite USB.
  2. Concedi all'host le autorizzazioni per accedere al DUT tramite ADB.

  3. Installa l'app CTS Verifier (CtsVerifier.apk) sul dispositivo. Per maggiori informazioni consulta la pagina 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

Configurazione dell'host

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

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

Android SDK Platform-Tools

Gli strumenti Android SDK Platform devono essere installati e ADB deve essere il percorso eseguibile della shell o del terminale in esecuzione sull'host in una macchina virtuale. Per la versione rilasciata pubblicamente degli SDK Platform Tools per Android, consulta le note di rilascio di SDK Platform Tools.

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.

Mobly

Per Android 12 e versioni successive, è necessario installare il framework di test Mobly. Mobly consente di impostare un DUT e un tablet per grafici its_base_test corso. Per installare il framework di test di 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 PYTHONPATH ed esegue i test delle unità sui moduli utils/*.py. Se non vengono stampati errori sul terminale, l'ambiente è pronto per eseguire i test ITS.

Configurazione della scena

Per impostare le scene, consigliamo di usare il Configurazione della fotocamera ITS-in-a-box per facilità nell'automazione, affidabilità ed efficienza dei test. L'ITS in una scatola le piattaforme di test supportano tutti i requisiti di illuminazione, centratura e modifica del grafico per ITS. Inoltre, ITS-in-a-box è necessario per il 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. (Script per il test ITS) fornire prompt per cambiare la configurazione della scena prima di iniziare 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 da una sorgente di luce stabile e non fluttuante. Non usare una lampada fluorescente perché introduce sfarfallio.

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

L'orientamento del telefono deve essere impostato in modo che la fotocamera acquisisca immagini senza la rotazione. Il modo più semplice per controllare è 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 il banco di prova Mobly. Di seguito sono riportati alcuni esempi per casi d'uso diversi.

File config.yml delle scene basate su tablet

Di seguito è riportato un esempio di file config.yml per le scene basate su tablet. Per i test basati su tablet, la parola chiave TABLET deve essere presente nel nome del testbed. Durante l'inizializzazione, il programma di test 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 test bed, esegui tools/run_all_tests.py. Se non vengono visualizzati comandi che specificano videocamere o scene, il test viene eseguito con config.yml i valori dei file. Se sono presenti valori della riga di comando per le videocamere o le scene, questi valori override 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 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 file config.yml di esempio con più testbed, un banco di prova per tablet e un banco di prova 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 dei 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 procedura riportata di seguito.

  1. Apri l'app CTS Verifer. Nel menu dei test, seleziona Test ITS della fotocamera.

  2. Dal computer host, esegui i test ITS dal CameraITS/ . Ad esempio, per un dispositivo con fotocamere anteriore e posteriore, esegui il seguente comando:

    python tools/run_all_tests.py

    Lo script viene ripetuto attraverso le videocamere e le scene di test in base ai config.yml. 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 la serie di test ITS su ogni scena, lo script scatta una foto della scena corrente, la salva in formato JPEG, stampa il percorso del file JPEG verso la console e chiede all'utente di confermare se l'immagine va bene. Il flusso di acquisizione e conferma si ripete finché l'utente conferma che l'immagine è a posto. 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é il test non è ancora obbligatorio, verrà registrato 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.

  3. 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 CTS Verifier diventa verde e indica che lo smartphone ha superato il test ITS della fotocamera.

Test DUT in parallelo

I dispositivi con Android 14 o versioni successive sono supportati in parallelo Test DUT. In questo modo puoi testare i DUT in parallelo con più rig per velocizzare i test complessivi. 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 parallele vengono aggregati nella sessione CTS Verifier 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 altro sullo stesso controller Arduino controlla l'illuminazione di ogni impianto.

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 la possibilità di acquisire file RAW o DNG devono fornire un modello di rumore nei metadati del risultato di acquisizione di ogni foto RAW. Questo modello di rumore devono essere incorporati nell'HAL per ciascuna videocamera (ad esempio, e le fotocamere posteriori) sul dispositivo che richiede supporto.

Implementazione del modello di rumore

Per implementare un modello di rumore, segui questi passaggi per generarlo e incorporare il modello nell'HAL della fotocamera.

  1. Per generare un modello di rumore per ogni videocamera, esegui Script dng_noise_model.py nel tools. Viene visualizzato uno snippet di codice C. Per per ulteriori informazioni su come configurare la fotocamera e acquisire l'ambiente, consulta il documento DngNoiseModel.pdf nella directory tools.

  2. Per implementare il modello di rumore per il dispositivo, taglia e incolla il codice C nell'HAL della fotocamera.

Convalida del modello di rumore

Il test ITS automatico di 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.