A partir de 27 de março de 2025, recomendamos usar android-latest-release em vez de aosp-main para criar e contribuir com o AOSP. Para mais informações, consulte Mudanças no AOSP.

Esta página foi traduzida pela API Cloud Translation.

Visão geral do Camera ITS

O pacote de testes de imagens da câmera (ITS) é um framework para executar testes em imagens produzidas por uma câmera Android. O objetivo geral de cada teste no ITS é configurar a câmera de uma maneira específica, capturar uma ou mais fotos e examinar as fotos para ver se elas contêm os dados de imagem esperados. Muitos dos testes exigem que a câmera seja apontada para um gráfico de destino específico ou seja iluminada em uma intensidade específica.

O ITS está localizado no conjunto de testes do CTS Verifier em cts/apps/CameraITS. Os dispositivos precisam passar nos testes do ITS correspondentes aos recursos compatíveis anunciados pela estrutura da câmera para apps de terceiros como um subconjunto do CTS.

Configuração

Para executar os testes do ITS, é necessário configurar o seguinte:

Um dispositivo em teste (DUT)
Uma máquina host (por exemplo, um desktop ou laptop Linux)
Uma cena que a câmera fotografa

Configuração do dispositivo em teste (DUT)

Para configurar um DUT, siga estas etapas:

Conecte o DUT a uma máquina host por USB.
Conceda permissões para que o host acesse o DUT por ADB.
Instale o app CTS Verifier (CtsVerifier.apk) no dispositivo. Para mais informações, consulte Como usar o CTS Verifier.
```
extract root/out/host/linux-x86/cts-verfier/android-cts-verifier.zip
cd android-cts-verifier
adb install -r -g CtsVerifier.apk
```
Observação: se você estiver instalando o app de um pacote do CTS Verifier (android-cts-verifier.zip) em vez de uma árvore de origem completa do Android, CtsVerifier.apk e o diretório CameraITS/ podem ser encontrados no nível superior da pasta android-cts-verifier compactada.
No DUT, inicie o app de câmera padrão e limpe todas as janelas que aparecem na inicialização para evitar interferências durante o teste.

Configuração do organizador

O ITS exige que a máquina host esteja conectada ao DUT por USB, possa usar o ADB para controle e comunicação do dispositivo e tenha o software necessário instalado.

Para configurar a máquina host, verifique se o software a seguir está instalado.

Android SDK Platform Tools

As ferramentas de plataforma do SDK Android precisam estar instaladas, e o ADB precisa estar no caminho executável do shell ou terminal em execução na máquina host. Para conferir a versão pública das ferramentas da plataforma do SDK do Android, consulte notas da versão das ferramentas da plataforma do SDK.

Python

O Python precisa estar instalado na máquina host. Recomendamos usar uma distribuição Python agrupada para garantir a compatibilidade com as versões. Para detalhes sobre quais versões do Python e do pacote instalar para um lançamento específico, consulte as notas da versão do Camera ITS correspondente.

Mobly

No Android 12 e em versões mais recentes, é necessário instalar a estrutura de teste do Mobly. O Mobly permite configurar um DUT e um tablet de gráficos na classe its_base_test. Para instalar a estrutura de teste do Mobly, execute:

pip install mobly

Configuração do ambiente

Para configurar o ambiente de teste, execute:

cd CameraITS
source build/envsetup.sh

Esse comando verifica a instalação do Python, configura a variável de ambiente PYTHONPATH e executa testes de unidade nos módulos utils/*.py. Se nenhum erro for impresso no terminal, o ambiente estará pronto para executar os testes ITS.

Configuração de cena

Para configurar as cenas, recomendamos usar a configuração Camera ITS-in-a-box para facilitar a automação, a confiabilidade e a eficiência nos testes. Os equipamentos de teste do ITS-in-a-box atendem a todos os requisitos de iluminação, centralização e mudança de gráfico do ITS. Além disso, o ITS-in-a-box é necessário para testes de extensões de câmera.

Para testes manuais, verifique o seguinte:

O DUT está em um tripé
O DUT é apontado para a cena correta em cada teste. O script de teste do ITS fornece comandos para mudar a configuração da cena antes de iniciar os testes em uma nova cena.
O DUT está conectado à máquina host via USB.
O DUT não se move durante a execução do teste.
A cena é iluminada com uma fonte de luz constante e não flutuante. Não use uma luz fluorescente, porque ela causa oscilação.

O script de teste do ITS mostra um aviso pedindo que o usuário mude a configuração da cena antes de iniciar os testes em uma nova cena.

A orientação do smartphone precisa ser definida para que a câmera tire fotos sem rotação. A maneira mais fácil de verificar isso é com as cenas de rosto em scene2. A maioria dos smartphones fica na orientação paisagem, girada no sentido anti-horário para a câmera traseira e no sentido horário para a câmera frontal.

Arquivos de configuração

Usando o framework Mobly, crie um arquivo de configuração config.yml para definir o ambiente de teste do Mobly. Confira exemplos para diferentes casos de uso.

Arquivo config.yml de cenas baseadas em tablet

Confira abaixo um exemplo de arquivo config.yml para cenas baseadas em tablets. Para testes baseados em tablets, a palavra-chave TABLET precisa estar no nome do ambiente de teste. Durante a inicialização, o executor de testes do Mobly inicializa os parâmetros no arquivo e os transmite aos testes individuais.

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

Para invocar o ambiente de teste, execute tools/run_all_tests.py. Se não houver valores de linha de comando especificando câmeras ou cenas, o teste será executado com os valores do arquivo config.yml. Se houver valores de linha de comando para câmeras ou cenas, eles vão substituir os valores na seção TestParams do arquivo config.yml. Exemplo:

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

Arquivo sensor_fusion scene config.yml

Confira abaixo um exemplo de arquivo config_yml para testes de sensor_fusion. Para testes de sensor_fusion, a palavra-chave SENSOR_FUSION precisa estar no nome do ambiente de teste. O Android 13 e versões mais recentes são compatíveis apenas com o controlador Arduino para fusão de sensores devido aos testes de estabilização de vídeo e visualização. O Android 12 é compatível com os controles 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

Para executar testes de sensor_fusion com a caixa de fusão de sensores, execute:

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

Arquivo config.yml de vários testbeds

Confira a seguir um exemplo de arquivo config.yml com várias plataformas de teste, uma plataforma de teste de tablet e uma plataforma de teste sensor_fusion. O testbed correto é determinado pelas cenas testadas.

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

Arquivo config.yml de teste manual

Confira abaixo um exemplo de arquivo config.yml para testes manuais. No Android 14, o teste manual é compatível com todos os testes, exceto os scene_extensions. Para testes manuais, a palavra-chave MANUAL precisa estar no nome do ambiente de teste. Além disso, a seção AndroidDevice não pode incluir uma seção de número de série ou rótulo para um tablet.

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

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

Arquivo config.yml de teste de plataforma Gen2

Confira abaixo um exemplo de arquivo config.yml de um ambiente de teste TEST_BED_GEN2. Esse ambiente de teste é usado para testes scene_ip, que usam um equipamento Gen2](/docs/compatibility/cts/camera-its-box-gen2). O exemplo a seguir mostra os parâmetros do ambiente de teste quando o equipamento Gen2 está disponível e os testes scene_ip não são ignorados.

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

O exemplo a seguir mostra os parâmetros do ambiente de teste quando o equipamento Gen2 não está disponível e os testes scene_ip são ignorados.

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

Para executar o teste scene_ip, use um dos seguintes comandos:

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

Executar testes do ITS

Nesta seção, descrevemos como executar testes do ITS.

Como invocar testes

Depois que o dispositivo, a máquina host (incluindo o ambiente) e a cena física forem configurados, execute os testes do ITS usando o processo a seguir.

Abra o app CTS Verifier. No menu de testes, selecione Teste ITS da câmera.
Na máquina host, execute os testes do ITS no diretório CameraITS/. Por exemplo, para um dispositivo com câmeras frontal e traseira, execute o seguinte comando:
```
python tools/run_all_tests.py
```
O script itera pelas câmeras e cenas de teste com base no arquivo config.yml. Para configurações de depuração, recomendamos executar uma das cenas scene2 com um único teste para uma resposta mais rápida.

Para testes manuais, antes de começar a executar o conjunto de testes do ITS em cada cena, o script tira uma foto da cena atual, salva como JPEG, imprime o caminho para o JPEG no console e pede que o usuário confirme se a imagem está correta. Esse fluxo de captura e confirmação fica em loop até que o usuário confirme que a imagem está correta. Estas são as mensagens nesse fluxo.
```
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)
```
Cada execução do script imprime um registro mostrando PASS, FAIL, FAIL* ou SKIP para cada teste do ITS. FAIL* indica que o teste falhou, mas, como ele ainda não é obrigatório, o teste será informado como um PASS para o CtsVerifier. SKIP indica que o teste foi aprovado porque o dispositivo não anunciou a capacidade subjacente que estava sendo testada. Por exemplo, se um dispositivo não anunciar pelas interfaces de câmera que é compatível com DNG, os testes relacionados à captura de arquivos DNG serão ignorados e contados como um PASS.
Para confirmar que os testes atenderam aos requisitos, toque no botão de marca de seleção verde. A entrada Teste ITS da câmera no menu de testes do CTS Verifier fica verde, indicando que o smartphone passou no teste ITS da câmera.

Teste paralelo de DUTs

Dispositivos com o Android 14 ou versões mais recentes oferecem suporte a testes paralelos de DUT. Isso permite testar DUTs em paralelo com várias plataformas para acelerar o teste geral. Por exemplo, o teste paralelo permite testar a câmera 0 em um suporte e a câmera 1 em outro suporte ao mesmo tempo. Todos os testes de sessões de teste paralelas são agregados na sessão do Verificador do CTS no DUT de referência. Você precisa executar testes paralelos com o controle de iluminação do Arduino, já que o controle manual não é compatível com esse tipo de teste. Verifique se um canal diferente no mesmo controlador Arduino controla a iluminação de cada equipamento.

Confira a seguir um exemplo de arquivo config.yml que define três ambientes de teste para serem executados em paralelo.

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"

Para executar os testbeds em paralelo, use o seguinte comando:

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

Modelo de ruído DNG

Os dispositivos que anunciam a capacidade de capturar RAW ou DNG precisam fornecer um modelo de ruído nos metadados de resultado de captura de cada foto RAW. Esse modelo de ruído precisa ser incorporado à HAL da câmera para cada câmera (por exemplo, frontal e traseira) no dispositivo que declara suporte.

Implementação do modelo de ruído

Para implementar um modelo de ruído, siga estas etapas para gerar e incorporar o modelo ao HAL da câmera.

Para gerar um modelo de ruído para cada câmera, execute o script dng_noise_model.py no diretório tools. Isso gera um snippet de código em C. Para mais informações sobre como configurar a câmera e o ambiente de captura, consulte o documento DngNoiseModel.pdf no diretório tools.
Para implementar o modelo de ruído no dispositivo, corte e cole o snippet de código C na HAL da câmera.

Validação do modelo de ruído

O teste ITS automatizado tests/scene1_1/test_dng_noise_model.py valida o modelo de ruído verificando se os valores de ruído para a exposição e o ganho do disparo fornecidos nos dados da câmera estão corretos.