Questa pagina è stata tradotta dall'API Cloud Translation.

Videocamera ITS

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 nel ITS è configurare la fotocamera in un modo specifico, acquisire uno o più scatti e esamina gli scatti per vedere se contengono i dati immagine previsti. Molti dei test richiedono che la fotocamera sia rivolta verso un grafico target specifico a un'intensità specifica.

L'ITS si trova nel cablaggio di test 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 test ITS, è necessario configurare quanto segue:

Un dispositivo in corso di test (DUT)
Un computer host (ad esempio un computer o un laptop Linux)
Una scena fotografata dalla fotocamera

Configurazione del dispositivo in fase di test (DUT)

Per configurare un DUT, segui questi passaggi:

Collega il dispositivo DUT a un computer host tramite USB.
Concedi all'host le autorizzazioni per accedere al DUT su ADB.
Installa l'app CTS Verifier (CtsVerifier.apk) sul dispositivo. Per ulteriori 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
```
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/ sono disponibili livello superiore della cartella android-cts-verifier compressa.

Configurazione dell'organizzatore

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 software seguente.

Strumenti della piattaforma SDK Android

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 pubblica degli strumenti Android SDK Platform, vedi Note di rilascio di SDK Platform Tools.

Python

Python deve essere installato sulla macchina host. Ti consigliamo di utilizzare un set Distribuzione in Python per assicurare il supporto delle versioni compatibili. Per maggiori dettagli su quali versioni Python e pacchetto installare per una release specifica, consulta le Note di rilascio ITS della fotocamera per la release corrispondente.

Mobil

Per Android 12 e versioni successive, il framework di test di Mobly è installata. 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. In caso contrario gli errori vengono stampati sul terminale, l'ambiente è pronto per eseguire ITS test.

Configurazione 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, l'ITS in a-box è obbligatorio per estensioni per videocamere test.

Per i test manuali, verifica quanto segue:

Il DUT è su un treppiede
Il DUT deve essere indirizzato 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 è collegato 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 utilizza una luce fluorescente perché introduce uno 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 verificarlo è usare le scene di volti in scena2. La maggior parte dei telefoni ha lo smartphone in orientamento orizzontale con smartphone ruotato in senso antiorario per la fotocamera posteriore e in senso orario per 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 esempi per diversi casi d'uso.

File config.yml di scene basate su tablet

Di seguito è riportato un file config.yml di esempio per scene basate su tablet. Per test basati su tablet, la parola chiave TABLET deve essere presente nel nome del piano di test. Durante l'inizializzazione, l'esecutore del test di Mobly inizializza i parametri nel file e le 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 vengono visualizzati comandi che specificano videocamere o scene, il test viene eseguito con config.yml i valori dei file. Se esistono valori della riga di comando per le videocamere o le scene, questi sostituisci 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 il test sensor_fusion, la parola chiave SENSOR_FUSION deve essere nel test . Android 13 e versioni successive supportano solo Arduino per la fusione dei sensori grazie ai 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 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 di più testbed

Di seguito è riportato un file config.yml di esempio con più testbed, un tablet e un banco di prova sensor_fusion. Viene determinato il banco di prova corretto 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

Test manuale del file config.yml

Di seguito è riportato un file config.yml di esempio per i test manuali. Da Android 14, manuale è supportato per tutti i test ad eccezione di scene_extensions test. Per i test manuali, la parola chiave MANUAL deve essere presente nel nome del banco di prova. Inoltre, la sezione AndroidDevice non può includere una sezione seriale o di etichette 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 test ITS.

Richiamo dei test

Dopo il dispositivo, la macchina host (incluso l'ambiente) e la scena fisica vengono ed esegui i test ITS seguendo la procedura riportata di seguito.

Apri l'app CTS Verifer. Nel menu dei test, seleziona Test ITS della fotocamera.
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 eseguire il debug delle configurazioni, ti consigliamo di eseguirne una di scene2 scene con un singolo test per tempi di esecuzione più rapidi.

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. Per Ad esempio, se un dispositivo non fa pubblicità attraverso le interfacce della fotocamera che supporta 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 l'icona pulsante con un segno di spunta verde. Voce Camera ITS Test nello strumento di verifica CTS dei test diventa verde e indica che lo smartphone ha superato Fotocamera ITS.

Test DUT in parallelo

I dispositivi con Android 14 o versioni successive sono supportati in parallelo Test DUT. Ciò consente di testare i DUT in parallelo con più apparecchiature per la velocità per eseguire il test in generale. Ad esempio, il test parallelo ti consente di verificare lo 0 della videocamera in una rig e fotocamera 1 in un altro dispositivo contemporaneamente. Tutti i test per il confronto le sessioni di test vengono aggregate nella sessione di verifica CTS sul DUT di riferimento. Devi eseguire test paralleli con il controllo dell'illuminazione Arduino, perché con l'illuminazione manuale 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 capacità di acquisire dati RAW o DNG devono emettere un rumore nei metadati del risultato dell'acquisizione di ogni scatto non elaborato. 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.

Per generare un modello di rumore per ogni videocamera, esegui Script dng_noise_model.py nel tools. Viene generato uno snippet di codice C. Per per ulteriori informazioni su come configurare la fotocamera e acquisire l'ambiente di acquisizione, consulta il documento DngNoiseModel.pdf nella directory tools.
Per implementare il modello di rumore per il dispositivo, taglia e incolla il codice C nell'HAL della fotocamera.

Convalida del modello di rumore

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