O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Esta página foi traduzida pela API Cloud Translation.

ITS da câmera

O Camera Image Test Suite (ITS) é um framework para executar testes em imagens produzido 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 imagens e examine as imagens para ver se elas contêm os dados de imagem esperados. Muitas das Os testes exigem que a câmera esteja apontada para um gráfico de destino específico ou com uma intensidade específica.

O ITS fica localizado no arcabouço de testes do CTS Verifier em cts/apps/CameraITS Os dispositivos precisam ser aprovados nos testes de ITS correspondentes aos recursos com suporte anunciada pelo framework da câmera para apps de terceiros como um subconjunto do CTS.

Configurar

Para executar testes ITS, é preciso configurar o seguinte:

Um dispositivo em teste (DUT, na sigla em inglês)
Uma máquina host (por exemplo, um computador desktop ou laptop Linux)
Uma cena fotografada pela câmera

Configuração do dispositivo em teste (DUT, na sigla em inglês)

Para configurar um DUT, siga estas etapas:

Conecte o DUT a uma máquina host via USB.
Conceda permissões ao host para acessar o DUT pelo adb.
Instale o app CTS Verifier (CtsVerifier.apk) no dispositivo. Para mais mais informações, consulte Como usar o Verificador do CTS.
```
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, os diretórios CtsVerifier.apk e CameraITS/ podem ser encontrados na nível superior da pasta android-cts-verifier compactada.

Configuração do host

O ITS exige que a máquina host esteja conectada ao DUT por USB, possam usar o adb para controle e comunicação de dispositivos e ter as e o software instalado.

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

Android SDK Platform Tools

As ferramentas da plataforma Android SDK precisam estar instaladas e o adb precisa estar no o caminho executável do shell ou terminal em execução no host máquina virtual. Para a versão pública das ferramentas da plataforma SDK do Android, ver Notas da versão do SDK Platform Tools.

Python

O Python precisa estar instalado na máquina host. Recomendamos o uso de um pacote Distribuição Python para garantir suporte para versões compatíveis. Para detalhes sobre quais versões de Python e de pacote instalar para uma versão específica, consulte o Notas da versão do Camera ITS para a versão correspondente.

Mobly

Para o Android 12 e versões mais recentes, o framework de teste do Mobly precisam ser instalados. O Mobly permite configurar um DUT e um tablet de gráficos its_base_test. Para instalar o framework 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 e configura o PYTHONPATH variável de ambiente e executa testes de unidade nos módulos utils/*.py. Em caso negativo erros são impressos no terminal, o ambiente está pronto para executar o ITS provas.

Configuração da cena

Para montar os cenários, recomendamos o uso do Configuração do Camera ITS-in-a-box para facilidade em automação, confiabilidade e eficiência em testes. O ITS-in-a-box os equipamentos de teste atendem a todos os requisitos de iluminação, centralização e mudança de gráficos para o ITS. Além disso, o ITS-in-a-box é necessário para extensões de câmera testes.

Para testes manuais, verifique o seguinte:

O DUT está em um tripé
O DUT é direcionado para a cena correta em cada teste. (O script de teste de ITS dê instruções para mudar a configuração do cenário antes de iniciar os testes em um novo cena.)
O DUT está conectado à máquina host por 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 isso causa oscilação.)

O script de teste de ITS mostra uma solicitação para o usuário mudar o cenário antes de iniciar testes em uma nova cena.

A orientação do telefone deve ser definida de forma que a câmera tire fotos sem a rotação de chaves. A maneira mais fácil de verificar isso é com as cenas de rosto cenário2. A maioria dos smartphones usa o modo paisagem telefone girado em sentido anti-horário para a câmera traseira e girado no sentido horário por a câmera frontal.

Arquivos de configuração

Com o framework do Mobly, você precisa criar um arquivo de configuração config.yml para definem o testbed do Mobly. Confira a seguir exemplos de diferentes casos de uso.

Arquivo config.yml de cenas baseadas em tablet

Confira a seguir um exemplo de arquivo config.yml para cenas baseadas em tablet. Para em tablets, a palavra-chave TABLET precisa estar no nome do testbed. Durante inicial, o executor de testes do Mobly inicializa os parâmetros no arquivo e passa para os 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 banco de testes, execute tools/run_all_tests.py. Se não houver comandos valores de linha especificando câmeras ou cenas, o teste vai ser executado com o método config.yml valores de arquivo. Se houver valores de linha de comando para câmeras ou cenas, 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=1 scenes=2,1,0

Arquivo config.yml do cenário sensor_fusion

Confira abaixo um exemplo de arquivo config_yml para testes sensor_fusion. Para testes de sensor_fusion, a palavra-chave SENSOR_FUSION precisa estar no testbed nome. O Android 13 e versões mais recentes oferecem suporte apenas ao Arduino para fusão de sensores devido aos testes de visualização e estabilização de vídeo. O Android 12 oferece suporte a controladores 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 sensor_fusion com o caixa de fusão do sensor, execute:

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

Arquivo config.yml de vários testbeds

Confira a seguir um exemplo de arquivo config.yml com vários testbeds, uma um testbed do tablet e um testbed 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

Teste manual do arquivo config.yml

Confira a seguir um exemplo de arquivo config.yml para testes manuais. De Android 14, manual tem suporte para todos os testes, exceto para scene_extensions provas. Para testes manuais, a palavra-chave MANUAL precisa estar no nome do testbed. Além disso, a seção AndroidDevice não pode incluir uma seção de número ou rótulo para em um tablet.

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

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

Como executar testes de ITS

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

Como invocar testes

Depois do dispositivo, a máquina host (incluindo o ambiente) e o cenário físico são configuração, execute os testes ITS usando o processo a seguir.

Abra o app CTS Verifer. No menu de testes, selecione Teste ITS da câmera.
Na máquina host, execute os testes ITS no CameraITS/. diretório. 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 na config.yml. Para configurações de depuração, recomendamos executar uma dos cenários scene2 com um único teste para o retorno mais rápido.

Para testes manuais, antes de começar a executar o conjunto de testes ITS em cada cena, o script tira uma foto da cena atual, salva como JPEG, imprime o caminho para o JPEG para o console e pede que o usuário confirme se a imagem está bem. Esse fluxo de captura e confirmação se repete até que o usuário confirma que a imagem está correta. Veja a seguir 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 ITS. FAIL* indica que o teste falhou No entanto, como o teste ainda não foi obrigatório, ele será registrado como PASS ao CtsVerifier. SKIP indica que o teste foi aprovado porque o dispositivo não anunciou o recurso que está sendo testado. Para por exemplo, se um dispositivo não anuncia pelas interfaces de câmera que oferece suporte a DNG, os testes relacionados à captura de arquivos DNG sã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 Camera ITS Test no CTS Verifier O menu de testes fica verde, indicando que o smartphone passou pelo ITS da câmera.

Teste paralelo do DUT

Dispositivos com o Android 14 ou versões mais recentes têm suporte ao Teste DUT. Isso permite testar DUTs em paralelo com vários rigs para acelerar o teste geral. Por exemplo, o teste paralelo permite testar a câmera 0 em uma e a câmera 1 em outro ao mesmo tempo. Todos os testes de paralelismo são agregadas à sessão do verificador do CTS no DUT de referência. Faça testes paralelos com o controle de iluminação do Arduino, já que a iluminação manual não é compatível com testes paralelos. Certifique-se de que um endereço canal no mesmo controle do Arduino controla a iluminação de cada equipamento.

Confira a seguir um exemplo de arquivo config.yml que define três testbeds para execução. 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 gerar ruído nos metadados do resultado de cada imagem bruta. Esse modelo de ruído precisam ser incorporados à HAL da câmera para cada câmera (por exemplo, e câmeras traseiras) no dispositivo que afirma ser compatível.

Implementação do modelo de ruído

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

Para gerar um modelo de ruído para cada câmera, execute o dng_noise_model.py no script tools. Isso gera um snippet de código 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, recorte e cole o código C na HAL da câmera.

Validação do modelo de ruído

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