ITS-in-a-Box da câmera

O pacote de testes de imagem da câmera do Android (ITS) faz parte do verificador do conjunto de teste de compatibilidade (CTS) do Android e inclui testes que verificam o conteúdo da imagem. O CTS Verifier oferece suporte à automação de testes ITS com o Camera ITS-in-a-box; o suporte para testes manuais abrange todos os formatos de dispositivos Android.

O ITS-in-a-box oferece os seguintes benefícios:

• Automação. Nenhuma intervenção humana é necessária durante o teste.
• Solução de problemas fácil. A consistência do ambiente de teste leva a menos erros de configuração e aumenta a capacidade de reprodução.
• Eficiência. A capacidade de tentar novamente para uma câmera/cena individual melhora a eficiência da execução do teste.

Seleção de equipamento

O ITS-in-a-box consiste em uma caixa de plástico cortada a laser de desenhos de design assistido por computador (CAD), um tablet de gráficos e um dispositivo em teste (DUT). A tabela a seguir descreve os recursos e as especificações dos diferentes equipamentos ITS-in-a-box disponíveis. Para selecionar o suporte adequado, considere o campo de visão específico e a distância mínima de foco do DUT. Para sistemas de câmera com um campo de visão de 60 a 110 graus e uma distância mínima de foco de 22 a 31 cm, recomendamos um suporte modular pela adaptabilidade. Se o sistema de câmera incluir uma lente telefoto com uma distância mínima de foco entre 31 cm e 110 cm, recomendamos um suporte modular com uma extensão telescópica que corresponda à distância de foco da lente. As extensões telescópicas estão disponíveis em comprimentos de 50 cm a 90 cm.

Rig	Distância do gráfico	Intervalo do campo de visão da câmera do DUT (aprox.)	Recursos
Rig de base modular	22 cm	60° a 120°	Pegada menor Corte de grande abertura na frente para permitir testes do sistema de várias câmeras sem bloquear as câmeras secundárias O suporte pode ser girado em 90°
Base modular e extensão telescópica	22 cm a 110 cm*	10° a 120°	Abertura grande na frente Suporta testes de câmeras com uma distância mínima de foco maior (a maioria das telecâmeras) O comprimento do suporte de extensão pode ser ajustado para diferentes distâncias do gráfico.
WFoV ITS-in-a-box	22 cm	60° a 120°	Grande área de contato que permite muitas posições de montagem do DUT Suporte para DUTs grandes, como tablets
RFoV ITS-in-a-box	31 cm	60° a 90°	Tablet de gráficos Sistema de iluminação interna
ITS-in-a-box de segunda geração	31 cm	60° a 90°	Gráfico em papel Sistema de iluminação interna

Distância do gráfico	Porcentagem de escalonamento da cena	Imagem
31 cm	33%
50 cm	50%
80 cm	100%

Para começar a usar o ITS-in-a-box da câmera:

1. Compre ou crie um ITS-in-a-box modular, WFoV ou RFoV e sensor Fusion.
2. Configure um tablet com o software Camera ITS.
3. Executar testes.
4. Receba os resultados do DUT.

Configurar o tablet

Nesta seção, fornecemos instruções detalhadas para configurar um tablet para uso com os testes ITS da câmera localizados no diretório CameraITS. Estas instruções usam um Pixel C como exemplo de tablet. Para informações sobre requisitos e recomendações de tablet, consulte Requisitos de tablet.

Observação:os scripts Python do Camera ITS definem automaticamente as seguintes opções no tablet:
Configurações > Tela > Suspender > Após 30 minutos de inatividade
Brilho adaptável > DESATIVADO

1. Carregue e ligue o tablet. Se for solicitado que você configure uma conta, pule essa etapa. O Camera ITS não exige que uma conta seja pareada com o tablet.
2. Atualize o tablet para o Android 7.0 ou mais recente. O Android 6.x e versões anteriores não são compatíveis com o Camera ITS.
3. Ative o modo de desenvolvedor.
4. Volte para Configurações e selecione Opções do desenvolvedor.

   Ativar opções	Ativado Permanecer ativo Depuração USB: permite que o host execute o tablet no modo de depuração. Quando você conectar o tablet ao host pela primeira vez, ele vai perguntar Permitir depuração USB? Se o tablet não mostrar o comando de depuração, desconecte e reconecte o tablet.)
   Desativar opções	Atualizações automáticas do sistema Verificar apps por USB

5. Para determinar os IDs do DUT e do gráfico, execute $ adb devices para listar os dispositivos disponíveis. Para determinar device_id e chart_id, conecte e desconecte os dispositivos e observe quais deles se conectam e desconectam.
6. Faça três execuções de teste para suprimir dicas e solicitações do usuário que podem ocultar gráficos na tela do tablet.
   1. Coloque o tablet com a tela para cima em uma mesa (não prenda o tablet ao painel traseiro da caixa).
   2. Execute este comando:

      python tools/run_all_tests.py device=$device_id camera=0 chart=$chart_id scenes=2,3
      

      As cenas 2 e 3 exigem que o tablet mostre uma imagem. Por isso, o tablet solicita Permitir que o Drive acesse fotos, mídia e arquivos no seu dispositivo?. Para dispensar essa solicitação (e evitar futuras), pressione Permitir.
   3. Execute o comando novamente. O tablet pergunta Manter uma cópia deste arquivo? e sugere o Google Drive. Para limpar essa solicitação (e evitar futuras), pressione o ícone do Drive e Cancelar para fazer o upload no Drive.
   4. Por fim, execute tools/run_all_tests.py e confirme se as cenas mudam automaticamente à medida que o script passa por diferentes cenas. Embora a maioria dos testes falhe (já que a câmera não está apontada para o gráfico), você pode verificar se o tablet passa pelas cenas corretamente sem mostrar solicitações ou outros pop-ups na tela.

Executar testes

Antes de executar o ITS-in-a-box, verifique se a configuração de teste inclui o seguinte hardware e software:

• Um (1) ITS-in-a-box
• Um (1) tablet de 10 polegadas de alta resolução para exibir cenas, S/N: 5811000011
• Um (1) DUT com o app CTS Verifier 7.0_8+ instalado. Exemplo de DUT:
  • Um (1) Pixel NOF26W para o teste da câmera traseira(0), S/N: FA6BM0305016. Para instalar o app CTS Verifier, descompacte android-cts-verifier.zip e execute

    adb -s FA6BM0305016 install -r -g android-cts-verifier/CtsVerifier.apk
    

Executar cenas baseadas em tablets

Para executar as cenas de 0 a 4, 6 e scene_change na câmera traseira:

cd android-cts-verifier/CameraITS
. build/envsetup.sh
python tools/run_all_tests.py camera=0

Exemplo:

Tentar gerar cenas de novo

Você pode tentar novamente as cenas de uma única câmera:

• Para tentar novamente as cenas em uma única câmera:

  python tools/run_all_tests.py device=FA6BM0305016 camera=0 scenes=3,4
  

Executar a cena 5

A cena 5 exige uma configuração especial com iluminação específica. Para mais detalhes, consulte CameraITS.pdf no CTS Verifier, que pode ser baixado em Downloads do conjunto de teste de compatibilidade. Execute a cena 5 separadamente (fora da caixa) e com o ambiente de teste TEST_BED_MANUAL.

Para executar a cena 5 nas câmeras frontal e traseira em um único dispositivo:

python tools/run_all_tests.py device=FA6BM0305016 camera=0 scenes=5
python tools/run_all_tests.py device=FA6BM0305016 camera=1 scenes=5

Conferir resultados

É possível conferir os resultados durante o teste e salvar os resultados concluídos como um relatório.

• Confira os resultados. Para salvar os resultados do ITS da câmera como um relatório:
  1. Pressione Aprovar e salve o relatório.
     
     Figura 3. Relatório do Camera ITS
  2. Extrair relatórios do dispositivo:

     adb -s FA6BM0305016 pull /sdcard/verifierReports
     

  3. Descompacte o arquivo de relatório e confira test_result.xml.
     
     Figura 4. Relatórios do Camera ITS
     

Requisitos do tablet

Para o Android 15 e versões mais recentes, os tablets usados como tela de gráficos do ITS precisam estar na seguinte lista de permissões. Para conferir uma lista de tablets que oferecem suporte a testes de cenas com pouca luz, consulte Tablets compatíveis com cenas com pouca luz. Para Android 14 ou versões anteriores, consulte Requisitos de tablet para Android 14 e versões anteriores.

Os tablets na lista de permissões são escolhidos com base nos seguintes critérios:

• Tamanho da tela de aproximadamente 10 polegadas com resolução maior que 1920 x 1200 pixels.
• Não pode ter oscilações medidas causadas pelo escurecimento da tela controlado por modulação por largura de pulso (PWM).
• Capaz de executar comandos adb enviados por testes do ITS e mostrar imagens de gráficos com brilho da tela instruído.

O valor brightness precisa ser definido em config.yml de acordo com o modelo do tablet. Para determinar se o modelo do tablet corresponde a um nome de dispositivo na lista de permissões, imprima o valor ro.product.device executando o comando adb adb shell getprop | grep 'ro.product.device'.

Tablets compatíveis com cenas em ambientes com pouca luz

Requisitos de tablet para Android 14 e versões anteriores

Os tablets precisam ter um tamanho de tela de cerca de 10 polegadas com uma resolução maior que 1920 x 1200 pixels. O tablet não pode usar modulação por largura de pulso (PWM) para definir o nível de brilho. O valor brightness precisa ser definido em config.yml de acordo com o modelo do tablet. A tabela abaixo lista os tablets recomendados para testes do ITS e as versões do Android para o DUT com que os tablets funcionam.

Perguntas frequentes

P1: Como faço para determinar quais plataformas de teste preciso para meu dispositivo?

A revisão 1 do RFoV ITS-in-a-box testa câmeras RFoV para testes de cenas de tablet no diretório CameraITS/tests. O RFoV é definido como 60° < FoV < 90°. Para câmeras com FoV maior, as luzes podem aparecer nas imagens ou os gráficos podem cobrir uma área muito pequena no FoV, afetando os resultados do teste.

A revisão 2 do WFoV ITS-in-a-box testa câmeras WFoV para testes de cenas de tablet no diretório CameraITS/tests. O WFoV é definido como FoV >= 90°. O equipamento de teste da revisão 2 é funcionalmente idêntico ao da revisão 1, mas maior. O equipamento de teste da revisão 2 pode testar câmeras RFoV e WFoV no Android 9 e versões mais recentes. Devido à área maior, a revisão 2 é ideal se o DUT for um tablet.

O equipamento de base modular testa câmeras WFoV para testes de cenas de tablet no diretório CameraITS/tests. O WFoV é definido como FoV >= 90°. A plataforma de base modular pode testar câmeras RFoV e WFoV em dispositivos com Android 9 e versões mais recentes. Ele também é compatível com o suporte de extensão tele, que pode ser conectado para testar câmeras tele com uma distância mínima de foco maior. A base modular é funcionalmente idêntica ao ITS-in-a-box WFoV, mas é menor.

A caixa de fusão do sensor testa o desvio de tempo da câmera/giroscópio e a sincronização de frames de sistemas multicâmera com testes em scenes=sensor_fusion. É necessário um ajuste de tempo de câmera/giroscópio de menos de 1 ms para a flag de recurso REALTIME.

Dispositivos com várias câmeras podem ser testados com um único suporte para testes ITS estáticos e um suporte de fusão de sensores se a câmera tiver a flag de recurso REALTIME.

Confira na tabela abaixo um conjunto de exemplos de configurações.

P2: Como designo qual plataforma de teste está em uso?

Para designar o equipamento de teste correto, verifique se o parâmetro de distância do gráfico está correto. O equipamento de teste rev1 (RFoV) tem uma distância de 31 cm, e o equipamento rev2 (WFoV) tem uma distância de 22 cm. Por padrão, a distância do gráfico é definida como 31 cm.

Android 10 para Android 11

python tools/run_all_tests.py ... chart=# dist=22

Android 12 e versões mais recentes

edit config.yml
chart_distance: 31.0 → chart_distance: 22.0

P3: Como faço para controlar o brilho do tablet?

Por padrão, o brilho do tablet é definido como 96.

Para mudar o brilho em tablets com Android 7.0 a 9, execute:

edit tools/wake_up_screen.py
DISPLAY_LEVEL=96 → DISPLAY_LEVEL=192

Para mudar o brilho em tablets com Android 10 a 11, o valor pode ser alterado na linha de comando adicionando a flag brightness:

python tools/run_all_tests.py device=# camera=# chart=# brightness=192

Para mudar o brilho em tablets com o Android 12 e versões mais recentes, execute:

edit config.yml
brightness: 96 → brightness: 192

4ª pergunta: como depurar um único teste?

Os testes podem ser executados individualmente para fins de depuração, mas os resultados não são informados ao CtsVerifier.apk, a menos que toda a cena seja executada.

Para executar uma cena individual no Android 11 e versões anteriores:

1. Carregue uma cena adicionando a flag scenes em tools/run_all_tests.py:

   python tools/run_all_tests.py device=# camera=# chart=# scenes=#
   

2. Pressione Control+C para interromper os testes depois que a cena for registrada como carregada em stdout.

   Se a cena correta já estiver na tela, ative-a:

   python tools/wake_up_screen.py screen=#
   

3. Execute um teste individual.

   python tests/scene#/test_*.py device=# camera=#

   Em seguida, os gráficos são gerados no diretório local, e stdout e stderr são impressos na tela.

   Para mais informações sobre depuração, adicione instruções print ao script. Para aumentar a saída de teste para depuração, adicione a flag debug=True.

   python tests/scene#/test_*.py device=# camera=# debug=True

Os resultados são impressos na tela local, e as imagens são salvas no diretório local em vez do diretório /tmp/tmp### gerado ao executar tools/run_all_tests.py.

Para executar uma cena individual no Android 12 e versões mais recentes:

1. Edite o arquivo config.yml.

   edit config.yml
   camera: <camera-id> → camera:  0
   scene: <scene-name> → scene: scene1_1

2. Execute o teste individual.

   python tools/run_all_tests.py -c config.yml --test_bed TEST_BED_TABLET_SCENES
   

Os resultados são impressos no diretório /tmp/logs/mobly/TEST_BED_TABLET_SCENES/ classificados por tempo de execução.

P5: Por que preciso executar testes com falha como uma cena inteira em vez de executar testes individualmente?

Os testes podem ser executados individualmente para fins de depuração, mas os resultados não são informados ao CtsVerifier.apk, a menos que toda a cena seja executada.

O ITS da câmera garante que apps de terceiros tenham uma interface de câmera compatível. Semelhante a um teste de unidade, cada teste enfatiza uma única especificação na câmera. Para detectar comportamentos não confiáveis, espera-se que esses testes sejam aprovados como um grupo em uma cena inteira. Por exemplo, embora um único teste não confiável possa passar em uma nova execução de uma cena inteira, é difícil que vários testes não confiáveis sejam aprovados.

Como um exemplo extremo, considere o caso em que há 10 testes em uma cena, cada um com 50% de probabilidade de retornar PASS. Ao executar cada teste individualmente, há uma grande chance de um operador conseguir fazer com que a câmera passe no ITS. No entanto, se os testes forem executados no agregado como uma cena, haverá apenas 0,1% de chance de aprovação.

P6: Como faço para executar uma única cena ou reordenar as cenas de uma execução?

Por padrão, o script tools/run_all_tests.py executa todas as cenas em ordem. No entanto, as cenas podem ser executadas individualmente ou em uma ordem especificada e serem informadas ao CtsVerifier.apk.

Para executar uma cena individual (por exemplo, a cena 2) ou mais de uma cena em uma ordem específica no Android 11 ou versões anteriores:

python tools/run_all_tests.py device=# camera=# chart=# scenes=2

python tools/run_all_tests.py device=# camera=# chart=# scenes=3,2

Para executar uma cena individual ou mais de uma em uma ordem específica no Android 12 e versões mais recentes:

python tools/run_all_tests.py scenes=2

python tools/run_all_tests.py scenes=3,2

Os parâmetros adicionais são definidos no arquivo config.yml.

P7: Vários testes da cena 1 falham com a configuração do tablet, mas são aprovados com um gráfico em papel. Qual é o problema?

Confira se o tablet e o ambiente de teste atendem às seguintes especificações.

Especificações do tablet

Confira se o tablet atende às seguintes especificações:

• Tamanho da tela (polegadas): 10 polegadas
• Tamanho da tela (pixels): maior que 1920 x 1200 pixels

Para mais detalhes, consulte Requisitos para tablets.

Brilho do tablet

Os testes podem não gerar resultados corretos se o brilho da tela do tablet estiver muito baixo.

Para mais detalhes, consulte Como controlar o brilho do tablet?

Nível de iluminação da caixa (requer um luxímetro)

Verifique se o valor de lux desejado na abertura do tablet está entre 100 e 300.

Se o nível de lux for muito alto, scene1/test_param_flash_mode.py vai retornar FAIL. Se o nível de lux for muito baixo, vários testes vão falhar.

P8: Como faço para depurar testes de fusão de sensores?

1. Verifique se você está em um grupo dialout.

   groups | egrep ‘dialout'

2. Confira se o controlador de fusão de sensores está conectado. Para isso, verifique se a Microchip Technology está conectada à porta USB.

   lsusb
   …
   Bus 003 Device 004: ID 04d8:fc73 Microchip Technology, Inc.
   …
   

3. Execute o teste várias vezes para ter uma distribuição de tentativas com os seguintes comandos.

   No Android 11 ou em versões anteriores:

   python tools/run_sensor_fusion_box.py device=A camera=0 num_runs=10 rotator=default
   

   No Android 12 e versões mais recentes:

   python tools/run_sensor_fusion_box.py num_runs=10
   

   Os parâmetros adicionais são definidos no arquivo config.yml.

   As saídas de execução estão na pasta /tmp/tmp### criada em sensor_fusion_#, em que # é o número da execução. Os motivos comuns para falha são:

   1. O smartphone não está centralizado corretamente.
   2. Não há recursos suficientes na imagem (geralmente um problema de campo de visão ou iluminação).
   3. O FAIL retornado é válido, e o ajuste de tempo entre a câmera e o giroscópio precisa ser corrigido.

P9: Quais informações devo incluir ao relatar um bug de teste?

Ao informar um bug de teste, inclua os arquivos e imagens gerados para o teste.

1. Se você executou o teste usando tools/run_all_tests.py, anexe um diretório /tmp/ compactado ao bug.
2. Se você executou o teste por conta própria, anexe todas as saídas de tela e imagens geradas ao bug.

Inclua também um relatório do bug. Depois que o teste em questão falhar, use o comando a seguir para gerar um relatório de bug e anexe o arquivo ZIP gerado ao bug.

adb -s device_id bugreport

P10: Como executar uma cena de teste de sensor_fusion com uma câmera que tem uma distância mínima de foco que cria imagens borradas a 25 cm de distância do gráfico?

Se a câmera não conseguir focar a uma distância de 25 cm, remova o painel de fixação do gráfico da caixa de fusão de sensores. Coloque o gráfico a uma distância em que o DUT possa focar e mude chart_distance em config.yml para a distância medida entre o DUT e o gráfico. A Figura 5 mostra um exemplo de como medir a distância do gráfico nessa situação.

  edit config.yml
chart_distance: 25 → chart_distance: DISTANCE_BETWEEN_DUT_AND_CHART

P11: Como faço para executar cenas de teste de tablet para uma câmera com uma distância mínima de foco que cria imagens desfocadas a 31 cm de distância do gráfico?

Se a câmera não produzir imagens nítidas o suficiente ao testar a 31 cm (a profundidade do equipamento de teste de RFoV), coloque a câmera na frente do equipamento a uma distância que permita que a cena do gráfico preencha aproximadamente 60% do campo de visão (FoV) da câmera com imagens mais nítidas. Essa distância pode ser menor do que a distância mínima de foco da câmera. Deixe o chart_distance em config.yml a 31 cm. O dimensionamento do gráfico no tablet é determinado pelo campo de visão da câmera, conforme mostrado na tabela a seguir:

P12: Com a API lógica multicâmera, quais testes são executados em quais câmeras?

Se a câmera usar REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA, todos os testes ITS compatíveis serão executados na câmera lógica de nível superior. Um subconjunto dos testes ITS é executado nas subcâmeras físicas, e esses testes estão listados em tools/run_all_tests.py na constante SUB_CAMERA_TESTS.