Várias alterações do Camera ITS estão incluídas na versão do Android 12. Esta página resume as mudanças que se enquadram em quatro grandes categorias:
Refatorar para Python 3
Devido à descontinuação do Python 2.7 em janeiro de 2020, toda a base de código do Camera ITS foi refatorada para Python 3. As seguintes versões e bibliotecas do Python são necessárias no Android 12:
- Python 3.7.9 ou Python 3.7.10
- OpenCV3.4.2
- Numpy 1.19.2
- Matplotlib3.3.2
- Scipy 1.5.2
- pySerial 3.5
- Travesseiro 8.1.0
- PyYAML 5.3.1
O inicializador de teste principal, tools/run_all_tests.py , permanece o mesmo das versões Android 11 ou inferiores e foi refatorado para Python 3.
Todos os testes individuais são refatorados e usam a nova classe de configuração de teste definida em tests/its_base_test.py . A maioria dos nomes e funcionalidades dos testes permanecem os mesmos. No Android 12, todos os testes individuais agora carregam suas cenas. Embora o carregamento de cena para cada teste aumente o tempo geral do teste, ele permite a depuração de testes individuais.
Para obter mais informações sobre alterações de testes individuais, consulte Alterações de testes .
Os seguintes módulos Python são refatorados com uma mudança de nome:
-
pymodules/its/caps.py→utils/camera_properties_utils.py -
pymodules/its/cv2image.py→utils/opencv_processing_utils.py -
pymodules/its/device.py→utils/its_session_utils.py -
pymodules/its/error.py→utils/error_util.py -
pymodules/its/image.py→utils/image_processing_utils.py -
pymodules/its/objects.py→utils/capture_request_utils.py -
pymodules/its/target.py→utils/target_exposure_utils.py -
tools/hw.py→utils/sensor_fusion_utils.py
Adoção da estrutura de teste Mobly
Mobly é uma estrutura de teste baseada em Python que oferece suporte a casos de teste que requerem vários dispositivos com configurações de hardware personalizadas. Camera ITS usa a infraestrutura de teste Mobly para permitir melhor controle e registro dos testes.
Camera ITS usa a infraestrutura de teste Mobly para permitir melhor controle e registro dos testes. Mobly é uma estrutura de teste baseada em Python que oferece suporte a casos de teste que requerem vários dispositivos com configurações de hardware personalizadas. Para obter mais informações sobre Mobly, consulte google/mobly .
arquivos config.yml
Com a estrutura Mobly, você pode configurar um dispositivo em teste (DUT) e um tablet gráfico na classe its_base_test . Um arquivo config.yml (YAML) é usado para criar um ambiente de teste Mobly. Vários testbeds podem ser configurados neste arquivo de configuração, por exemplo, um tablet e um testbed de fusão de sensores. Dentro da seção de controlador de cada ambiente de teste, você pode especificar device_ids para identificar os dispositivos Android apropriados para o executor de teste. Além dos IDs dos dispositivos, outros parâmetros como brightness do tablet, chart_distance , debug_mode , camera_id e scene_id são passados na classe de teste. Os valores de parâmetros de teste comuns são:
brightness: 192 (all tablets except Pixel C)
chart_distance: 31.0 (rev1/rev1a box for FoV < 90° cameras)
chart_distance: 22.0 (rev2 test rig for FoV > 90° cameras)
Teste baseado em tablet
Para testes baseados em tablet, a palavra-chave TABLET deve estar presente no nome do ambiente de teste. Durante a inicialização, o executor de testes Mobly inicializa TestParams e os passa para os testes individuais.
A seguir está um exemplo de arquivo config.yml para execuções baseadas em tablet.
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
O testbed pode ser invocado usando tools/run_all_tests.py . Se nenhum valor de linha de comando estiver presente, os testes serão executados com os valores do arquivo config.yml . Além disso, você pode substituir os valores do arquivo de configuração camera e scene na linha de comando usando comandos semelhantes ao Android 11 ou inferior.
Por 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
Teste de fusão de sensores
Para testes de fusão de sensores , o nome do ambiente de teste deve incluir a palavra-chave SENSOR_FUSION . O ambiente de teste correto é determinado pelas cenas testadas. O Android 12 oferece suporte a controladores Arduino e Canakit para fusão de sensores .
A seguir está um exemplo de arquivo config.yml para execuções de fusão de sensores.
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 # cntl can be arduino or canakit
rotator_ch: 1
camera: 0
Para executar testes de fusão de sensores com o equipamento de teste de fusão de sensores , use:
python tools/run_all_tests.py scenes=sensor_fusion
python tools/run_all_tests.py scenes=sensor_fusion camera=0
Vários bancos de testes
Vários testbeds podem ser incluídos no arquivo de configuração. A combinação mais comum é ter um banco de testes para tablets e um banco de testes para fusão de sensores.
A seguir está um exemplo de arquivo config.yml com plataformas de teste de fusão de tablets e sensores.
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
O teste manual continua a ser compatível com o Android 12. No entanto, o testbed deve identificar o teste como tal com a palavra-chave MANUAL no nome do testbed. Além disso, o testbed não pode incluir um ID de tablet.
A seguir está um exemplo de arquivo config.yml para teste manual.
TestBeds:
- Name: TEST_BED_MANUAL
Controllers:
AndroidDevice:
- serial: 8A9X0NS5Z
label: dut
TestParams:
debug_mode: "False"
chart_distance: 31.0
camera: 0
scene: scene1
Teste cenas sem tablets
O teste para a cena 0 e a cena 5 pode ser feito com TEST_BED_TABLET_SCENES ou com TEST_BED_MANUAL . No entanto, se o teste for feito com TEST_BED_TABLET_SCENES , o tablet deverá estar conectado e o ID de série do tablet deverá ser válido mesmo que o tablet não seja usado porque a configuração da classe de teste atribui o valor do ID de série ao tablet.
Execute testes individuais
Os testes individuais podem ser executados apenas para fins de depuração porque seus resultados não são relatados ao CTS Verifier . Como os arquivos config.yml não podem ser substituídos na linha de comando para camera e scene , esses parâmetros devem estar corretos no arquivo config.yml para o teste individual em questão. Além disso, se houver mais de um testbed no arquivo de configuração, você deverá especificar o testbed com o sinalizador --test_bed . Por exemplo:
python tests/scene1_1/test_black_white.py --config config.yml --test_bed TEST_BED_TABLET_SCENES
Artefatos de teste
No Android 12, os artefatos de teste do Camera ITS são armazenados de forma semelhante ao Android 11 ou inferior, mas com as seguintes alterações:
- O diretório do artefato de teste
/tmptemCameraITS_anexado à sequência aleatória de 8 caracteres para maior clareza. - A saída do teste e os erros são armazenados em
test_log.DEBUGpara cada teste em vez detest_name_stdout.txtetest_name_stderr.txt. - Os logcats do DUT e do tablet de cada teste individual são armazenados no diretório
/tmp/CameraITS_########simplificando a depuração, pois todas as informações necessárias para depurar problemas 3A são registradas.
Alterações de teste
No Android 12, as cenas do tablet são arquivos PNG em vez de arquivos PDF. O uso de arquivos PNG permite que mais modelos de tablets exibam as cenas corretamente.
cena0/test_jitter.py
O teste test_jitter é executado em câmeras físicas ocultas no Android 12.
cena1_1/test_black_white.py
Para Android 12, test_black_white tem a funcionalidade de test_black_white e test_channel_saturation .
A tabela a seguir descreve os dois testes individuais no Android 11.
| Nome de teste | Primeiro nível de API | Asserções |
|---|---|---|
| cena1_1/test_black_white.py | TODOS | Exposição curta, valores RGB de baixo ganho ~[0, 0, 0] Exposição longa, valores RGB de alto ganho ~[255, 255, 255] |
| cena1_1/test_channel_saturation.py | 29 | Tolerância reduzida em diferenças [255, 255, 255] para eliminar a tonalidade da cor em imagens brancas. |
A tabela a seguir descreve o teste mesclado, scene1_1/test_black_white.py, no Android 12.
| Nome de teste | Primeiro nível de API | Asserções |
|---|---|---|
| cena1_1/test_black_white.py | TODOS | Exposição curta, valores RGB de baixo ganho ~[0, 0, 0] Exposição longa, valores RGB de alto ganho ~[255, 255, 255] e tolerância reduzida entre valores para eliminar a tonalidade da cor em imagens brancas. |
cena1_1/test_burst_sameness_manual.py
O teste test_burst_sameness_manual é executado em câmeras físicas ocultas no Android 12.
cena1_2/test_tonemap_sequence.py
O teste test_tonemap_sequence é executado em câmeras LIMITADAS no Android 12.
cena1_2/test_yuv_plus_raw.py
O teste test_yuv_plus_raw é executado em câmeras físicas ocultas no Android 12.
cena2_a/test_format_combos.py
O teste test_format_combos é executado em câmeras LIMITADAS no Android 12.
cena3/test_flip_mirror.py
O teste test_flip_mirror é executado em câmeras LIMITADAS no Android 12.
cena4/test_aspect_ratio_and_crop.py
Encontrar círculos em scene4/test_aspect_ratio_and_crop.py foi refatorado no Android 12.
Versões anteriores do Android usavam um método que envolvia encontrar um contorno filho (o círculo) dentro do contorno pai (o quadrado) com filtros de tamanho e cor. O Android 12 usa um método que envolve encontrar todos os contornos e, em seguida, filtrar para encontrar os recursos mais circulares . Para filtrar círculos espúrios na tela, é necessária uma área de contorno mínima e o contorno do círculo deve ser preto.
Os contornos e seus critérios de seleção são mostrados na imagem a seguir.
Figura 1. Desenho conceitual de contornos e critérios de seleção
O método Android 12 é mais simples e funciona para resolver o problema de recorte da caixa delimitadora em alguns tablets de exibição. Todos os candidatos ao círculo são registrados para fins de depuração.
No Android 12, o teste de corte é executado para dispositivos FULL e LEVEL3 . Android 11 ou versões anteriores ignoram as declarações de teste de corte para dispositivos FULL .
A tabela a seguir lista as asserções para test_aspect_ratio_and_crop.py que correspondem a um determinado nível de dispositivo e primeiro nível de API.
| Nível do dispositivo | Primeiro nível de API | Asserções |
|---|---|---|
| LIMITADO | TODOS | Proporção da tela FoV para formatos 4:3, 16:9, 2:1 |
| COMPLETO | <31 | Proporção da tela FoV para formatos 4:3, 16:9, 2:1 |
| COMPLETO | ≥ 31 | Cortar Proporção da tela FoV para formatos 4:3, 16:9, 2:1 |
| NÍVEL 3 | TODOS | Cortar Proporção da tela FoV para formatos 4:3, 16:9, 2:1 |
cena4/test_multi_camera_alignment.py
O método undo_zoom() para capturas YUV em scene4/test_multi_camera_alignment.py foi refatorado para contabilizar com mais precisão o corte em sensores que não correspondem à proporção da captura.
Código Python 2 do Android 11
zoom_ratio = min(1.0 * yuv_w / cr_w, 1.0 * yuv_h / cr_h)
circle[i]['x'] = cr['left'] + circle[i]['x'] / zoom_ratio
circle[i]['y'] = cr['top'] + circle[i]['y'] / zoom_ratio
circle[i]['r'] = circle[i]['r'] / zoom_ratio
Código Python 3 do Android 12
yuv_aspect = yuv_w / yuv_h
relative_aspect = yuv_aspect / (cr_w/cr_h)
if relative_aspect > 1:
zoom_ratio = yuv_w / cr_w
yuv_x = 0
yuv_y = (cr_h - cr_w / yuv_aspect) / 2
else:
zoom_ratio = yuv_h / cr_h
yuv_x = (cr_w - cr_h * yuv_aspect) / 2
yuv_y = 0
circle['x'] = cr['left'] + yuv_x + circle['x'] / zoom_ratio
circle['y'] = cr['top'] + yuv_y + circle['y'] / zoom_ratio
circle['r'] = circle['r'] / zoom_ratio
sensor_fusion/test_sensor_fusion.py
No Android 12, um método para detectar recursos em imagens foi adicionado para o teste de fusão de sensores.
Em versões anteriores ao Android 12, a imagem inteira é usada para encontrar os melhores 240 recursos que são então mascarados no centro em 20% para evitar efeitos de obturador com o requisito mínimo de recursos sendo 30 recursos.
Se os recursos encontrados por esse método forem insuficientes, o Android 12 mascara primeiro a área de detecção de recursos para o centro em 20% e limita o máximo de recursos a duas vezes o requisito mínimo de recursos.
A imagem a seguir mostra a diferença entre a detecção de recursos do Android 11 e do Android 12. O aumento do limite mínimo de requisitos de recursos resulta na detecção de recursos de baixa qualidade e afeta negativamente as medições.
Figura 2. Diferença na detecção de recursos entre Android 11 e Android 12
Novos testes
cena0/test_solid_color_test_pattern.py
Um novo teste, test_solid_color_test_pattern , está habilitado para Android 12. Esse teste está habilitado para todas as câmeras e é descrito na tabela a seguir.
| Cena | Nome de teste | Primeiro nível de API | Descrição |
|---|---|---|---|
| 0 | teste_solid_color_test_pattern | 31 | Confirma a saída de imagem em cores sólidas e a programabilidade de cores da imagem. |
Os padrões de teste de cores sólidas devem estar ativados para suportar o modo de privacidade da câmera. O teste test_solid_color_test_pattern confirma a saída da imagem YUV em cor sólida com a cor definida pelo padrão selecionado e a cor da imagem muda de acordo com a especificação.
Parâmetros
-
cameraPrivacyModeSupport: determina se a câmera oferece suporte ao modo de privacidade. -
android.sensor.testPatternMode: Define o modo padrão de teste. Este teste usaSOLID_COLOR. -
android.sensor.testPatternData: define os valores do padrão de teste R, Gr, Gb, G para o modo de padrão de teste.
Para obter uma descrição do padrão de teste de cor sólida, consulte SENSOR_TEST_PATTERN_MODE_SOLID_COLOR .
Método
Os quadros YUV são capturados para os parâmetros definidos e o conteúdo da imagem é validado. O padrão de teste é emitido diretamente do sensor de imagem, portanto, nenhuma cena específica é necessária. Se PER_FRAME_CONTROL for compatível, um único quadro YUV será capturado para cada configuração testada. Se PER_FRAME_CONTROL não for compatível, quatro quadros serão capturados com apenas o último quadro analisado para maximizar a cobertura do teste em câmeras LIMITED .
As capturas YUV são definidas para padrões de teste BLACK , WHITE , RED , GREEN e BLUE totalmente saturados. Como a definição do padrão de teste é conforme o padrão Bayer do sensor, os canais de cores devem ser configurados para cada cor conforme mostrado na tabela a seguir.
| Cor | testPatternData (RGGB) |
|---|---|
| PRETO | (0, 0, 0, 0) |
| BRANCO | (1, 1, 1, 1) |
| VERMELHO | (1, 0, 0, 0) |
| VERDE | (0, 1, 1, 0) |
| AZUL | (0, 0, 0, 1) |
Tabela de asserções
A tabela a seguir descreve as asserções de teste para test_solid_color_test_pattern.py .
| Câmera Primeiro nível de API | Tipo de câmera | Cores afirmadas |
|---|---|---|
| 31 | Bayer | PRETO, BRANCO, VERMELHO, VERDE, AZUL |
| 31 | MONO | PRETO BRANCO |
| <31 | Bayer/MONO | PRETO |
Testes de classe de desempenho
scene2_c/test_camera_launch_perf_class.py
Verifica se a inicialização da câmera é inferior a 500 ms para as câmeras primárias frontal e traseira com a cena facial scene2_c.
scene2_c/test_jpeg_capture_perf_class.py
Verifica se a latência de captura JPEG 1080p é inferior a 1 segundo para as câmeras primárias frontal e traseira com a cena de rosto scene2_c.