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 saber 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 que seja iluminada com uma intensidade específica.
O ITS está localizado no conjunto de teste do Verificador do CTS em
cts/apps/CameraITS
.
Os dispositivos precisam passar nos testes ITS correspondentes aos recursos com suporte
anunciados pelo framework da câmera para apps de terceiros como um subconjunto do CTS.
Configurar
Para executar testes de ITS, é necessário configurar o seguinte:
- Um dispositivo em teste (DUT)
- Uma máquina host (por exemplo, um computador 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 o host acessar o DUT pelo ADB.
Instale o app CTS Verifier (
CtsVerifier.apk
) no dispositivo. Para 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
Configuração do host
O ITS exige que a máquina host esteja conectada ao DUT por USB, que use o ADB para controle e comunicação do dispositivo e que tenha o software necessário instalado.
Para configurar a máquina host, verifique se o software abaixo 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 lançada publicamente das ferramentas da plataforma do SDK do Android, consulte as 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 do Python para garantir o suporte a versões compatíveis. Para saber quais versões do Python e do pacote instalar para uma versão específica, consulte as notas da versão da ITS da câmera para a versão correspondente.
Mobly
Para o Android 12 e versões mais recentes, o framework de teste do Mobly
precisa ser instalado. O Mobly permite configurar um DUT e um tablet de gráfico na
classe 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, 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 do cenário
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 conjuntos de testes ITS-in-a-box são compatíveis com todos os requisitos de iluminação, centralização e mudança de gráfico para ISTS. Além disso, o ITS-in-a-box é necessário para testar as extensões de câmera.
Para testes manuais, siga estas instruções:
- O DUT está em um tripé
- O DUT é apontado para a cena correta para cada teste. O script de teste do ITS oferece instruções para mudar a configuração do cenário antes de iniciar os testes em um novo cenário.
- 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 estável e sem flutuações. Não use uma luz fluorescente, porque ela causa cintilaçã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 tem a orientação paisagem com o smartphone girado no sentido anti-horário para a câmera traseira e girado no sentido horário para a câmera frontal.
Arquivos de configuração
Ao usar o framework Mobly, é necessário criar um arquivo de configuração config.yml
para
definir o ambiente de teste do Mobly. Confira abaixo 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
testes baseados em tablet, a palavra-chave TABLET
precisa estar no nome do ambiente de teste. Durante
a inicialização, o executor de teste do Mobly inicializa os parâmetros no arquivo
e os transmite 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 ambiente de teste, execute tools/run_all_tests.py
. Se não houver valores de linha
de comando que especifiquem câmeras ou cenas, o teste será executado com os valores de arquivo
config.yml
. Se houver valores de linha de comando para câmeras ou cenas, eles
substituirão 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 sensor_fusion scene config.yml
Confira a seguir um exemplo de arquivo config_yml
para testes sensor_fusion
.
Para testes sensor_fusion
, a palavra-chave SENSOR_FUSION
precisa estar no nome do ambiente
de teste. O Android 13 e versões mais recentes oferecem suporte apenas ao controlador
Arduino para fusão de sensores devido aos testes de visualização e estabilização de vídeo.
O Android 12 oferece suporte a 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 sensor_fusion
com a
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 ambientes de teste
Confira a seguir um exemplo de arquivo config.yml
com vários ambientes de teste, um
ambiente de teste de tablet e um ambiente de teste sensor_fusion
. O ambiente de teste 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 a seguir um exemplo de arquivo config.yml
para testes manuais. No
Android 14, o teste
manual é aceito em 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 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
Como executar testes de ITS
Esta seção descreve como executar testes de ITS.
Como invocar testes
Depois que o dispositivo, a máquina host (incluindo o ambiente) e a cena física estiverem configurados, 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 do 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 por câmeras e cenas de teste com base no arquivo
config.yml
. Para configurações de depuração, recomendamos executar uma das cenasscene2
com um único teste para uma resposta mais rápida.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 no console e pede ao usuário para confirmar se a imagem está correta. Esse fluxo de captura e confirmação faz loops até que o usuário confirme que a imagem está correta. As mensagens neste fluxo são as seguintes.
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*
ouSKIP
para cada teste ITS.FAIL*
indica que o teste falhou, mas, como ele ainda não é obrigatório, o teste será informado comoPASS
para o CtsVerifier.SKIP
indica que o teste foi aprovado porque o dispositivo não anunciou o recurso em questão. Por exemplo, se um dispositivo não anunciar pelas interfaces de câmera que oferece suporte a DNG, os testes relacionados à captura de arquivos DNG serão ignorados e contados comoPASS
.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 verificador do CTS fica verde e indica que o smartphone passou no teste ITS da câmera.
Teste de DUT paralelo
Dispositivos com o Android 14 ou versões mais recentes oferecem suporte a testes DUT paralelos. 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 uma plataforma e a câmera 1 em outra ao mesmo tempo. Todos os testes para sessões de teste em paralelo são agregados na sessão do Verificador do CTS no DUT de referência. É necessário executar o teste paralelo com o controle de iluminação do Arduino, já que o controle manual de iluminação não é compatível com o teste paralelo. 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 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 fornecer um modelo de ruído nos metadados do resultado da captura de cada foto RAW. Esse modelo de ruído precisa ser incorporado à HAL da câmera para cada câmera (por exemplo, câmeras 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 um modelo de ruído 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óriotools
. 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 documentoDngNoiseModel.pdf
no diretóriotools
.Para implementar o modelo de ruído do dispositivo, corte e cole o snippet de código C no 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 da foto fornecidos nos dados da câmera estão corretos.