A partire dal 27 marzo 2025, ti consigliamo di utilizzare android-latest-release anziché aosp-main per compilare e contribuire ad AOSP. Per ulteriori informazioni, vedi Modifiche ad AOSP.

Questa pagina è stata tradotta dall'API Cloud Translation.

Panoramica di ITS della videocamera

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 videocamera in un modo specifico, acquisire uno o più scatti ed esaminare gli scatti per verificare se contengono i dati immagine previsti. Molti test richiedono che la videocamera sia puntata su un grafico target specifico o che sia illuminata a un'intensità specifica.

ITS si trova nell'ambiente di test di 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 di CTS.

Configura

Per eseguire i test ITS, è necessario configurare quanto segue:

Un dispositivo in fase di test (DUT)
Una macchina host (ad esempio, un computer fisso o portatile Linux)
Una scena fotografata dalla videocamera

Configurazione del dispositivo in fase di test (DUT)

Per configurare un DUT:

Collega il DUT a una macchina host tramite USB.
Concedi le autorizzazioni all'host per accedere al DUT tramite ADB.
Installa l'app CTS Verifier (CtsVerifier.apk) sul dispositivo. Per maggiori informazioni, consulta 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 installi l'app da un bundle CTS Verifier (android-cts-verifier.zip) anziché da un albero di origine Android completo, sia CtsVerifier.apk sia la directory CameraITS/ si trovano al livello superiore della cartella android-cts-verifier compressa.
Sul DUT, avvia l'app Fotocamera predefinita e chiudi tutte le finestre che vengono visualizzate all'avvio per evitare interferenze durante il test.

Configurazione dell'host

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 la macchina 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 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 in bundle per garantire il supporto delle versioni compatibili. Per informazioni dettagliate sulle versioni di Python e dei pacchetti da installare per una release specifica, consulta le note di rilascio di Camera ITS per la release corrispondente.

Mobly

Per Android 12 e versioni successive, deve essere installato il framework di test Mobly. Mobly ti consente di configurare un DUT e un tablet grafico nella classe its_base_test. 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, imposta la variabile di ambiente PYTHONPATH e esegue test delle unità sui moduli utils/*.py. Se non vengono stampati errori nel terminale, l'ambiente è pronto per eseguire i test ITS.

Configurazione della scena

Per configurare le scene, ti consigliamo di utilizzare la configurazione Camera ITS-in-a-box per semplificare l'automazione, l'affidabilità e l'efficienza dei test. I banchi di prova ITS-in-a-box supportano tutti i requisiti di illuminazione, centratura e cambio grafico per ITS. Inoltre, ITS-in-a-box è necessario per i test delle estensioni della videocamera.

Per i test manuali, assicurati che:

Il DUT è su un treppiede
Il DUT è puntato sulla scena corretta per ogni test. (Lo script di test ITS fornisce prompt per modificare 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 fonte di luce costante e non fluttuante. Non utilizzare una luce fluorescente perché introduce sfarfallio.

Lo script di test ITS mostra un prompt che chiede all'utente di modificare la configurazione della scena prima di iniziare i test in una nuova scena.

L'orientamento dello smartphone deve essere impostato in modo che la fotocamera scatti immagini senza rotazione. Il modo più semplice per verificarlo è con 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 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 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 test bed, 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 le videocamere o le scene, questi sovrascrivono 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=0 scenes=scene_tele
python tools/run_all_tests.py camera=0.4 scenes=4,scene6_tele

File sensor_fusion scene config.yml

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 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 i test sensor_fusion con la scatola di fusione dei sensori, esegui:

python tools/run_all_tests.py scenes=sensor_fusion
python tools/run_all_tests.py scenes=sensor_fusion camera=0
python tools/run_all_tests.py scenes=scene_flash,feature_combination
python tools/run_all_tests.py scenes=checkerboard camera=1

File config.yml di più testbed

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

Di seguito è riportato un esempio di file config.yml per i test manuali. 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 presente nel nome del testbed. Inoltre, la sezione AndroidDevice non può includere una sezione con 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

File config.yml di test del rig Gen2

Di seguito è riportato un esempio di file config.yml di un testbed TEST_BED_GEN2. Questo banco di prova viene utilizzato per i test scene_ip, che utilizzano un rig Gen2](/docs/compatibility/cts/camera-its-box-gen2). L'esempio seguente mostra i parametri del banco di prova quando il banco di prova Gen2 è disponibile e i test scene_ip non vengono ignorati.

Testbeds
  - Name: TEST_BED_GEN2
    # Test configuration for scene_ip/test_default_jca_ip.py
    Controllers:
        AndroidDevice:
          - serial: <device-id>  # quotes needed if serial id entirely numeric
            label: dut
    TestParams:
      debug_mode: "False"  # quotes are needed here
      chart_distance: 30
      rotator_cntl: gen2_rotator   # gen2 rig specific. "None" if gen2 rig not available
      rotator_ch: 0
      camera: <camera-id>
      foldable_device: "False"  # "True" if testing foldable device
      tablet_device: "False"  # "True" if testing tablet device
      lighting_cntl: gen2_lights  # gen2 rig specific. "None" if gen2 rig not available
      lighting_ch: 1
      scene: scene_ip

L'esempio seguente mostra i parametri del banco di prova quando il rig Gen2 non è disponibile e i test scene_ip vengono ignorati.

Testbeds
  - Name: TEST_BED_GEN2
    # Test configuration for scene_ip/test_default_jca_ip.py
    Controllers:
        AndroidDevice:
          - serial: <device-id>  # quotes needed if serial id entirely numeric
            label: dut
    TestParams:
      debug_mode: "False"  # quotes are needed here
      chart_distance: 30
      rotator_cntl: "None"   # gen2 rig specific. "None" if gen2 rig not available
      rotator_ch: <controller-channel>
      camera: <camera-id>
      foldable_device: "False"  # "True" if testing foldable device
      tablet_device: "False"  # "True" if testing tablet device
      lighting_cntl: "None"  # gen2 rig specific. "None" if gen2 rig not available
      lighting_ch: <controller-channel>
      scene: scene_ip

Per eseguire il test scene_ip, utilizza uno dei seguenti comandi:

python tests/scene_ip/test_default_jca_ip.py -c config.yml
python tools/run_all_tests.py camera=<camera-id> scenes=scene_ip

Esecuzione dei test ITS

Questa sezione descrive come eseguire i test ITS.

Richiamare 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 Verifier. Nel menu dei test, seleziona Camera ITS Test.
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 scorre le videocamere e le scene di test in base al file config.yml. Per il debug delle configurazioni, ti consigliamo di eseguire uno dei test delle scene scene2 per ottenere risultati più rapidi.

Per i test manuali, prima di iniziare a eseguire il set di test ITS su ogni scena, lo script scatta una foto della scena corrente, la salva come JPEG, stampa il percorso del JPEG nella console e chiede all'utente di confermare se l'immagine è corretta. Questo flusso di acquisizione e conferma si ripete finché l'utente non conferma che l'immagine è corretta. 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 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à 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 annuncia tramite le interfacce della videocamera che supporta il formato DNG, i test relativi all'acquisizione di file DNG vengono ignorati e conteggiati come PASS.
Per confermare che i test soddisfano i requisiti, tocca il pulsante con il segno di spunta verde. La voce Camera ITS Test nel menu dei test di CTS Verifier diventa verde e indica che lo smartphone ha superato il test ITS della fotocamera.

Test parallelo del dispositivo in prova

I dispositivi con Android 14 o versioni successive supportano i test DUT paralleli. In questo modo puoi testare i DUT in parallelo con più configurazioni per velocizzare i test complessivi. Ad esempio, i test paralleli ti consentono di testare la videocamera 0 in un rig e la videocamera 1 in un altro rig contemporaneamente. Tutti i test per le sessioni di test paralleli 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 canale diverso sullo stesso controller Arduino controlli 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 comando seguente:

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 immagini 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 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 restituito uno snippet di codice C. Per maggiori informazioni su come configurare la videocamera 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 fotocamera.

Convalida 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 videocamera siano corretti.