Notas da versão do pacote de testes de imagens da câmera do Android 12

Várias mudanças na ITS da câmera foram incluídas na versão do Android 12. Esta página resume as mudanças que se enquadram em quatro categorias amplas:

• Refactoring para Python 3
• Adoção do framework de teste do Mobly
• Testar mudanças
• Novos testes

Refactorizar para o Python 3

Devido à descontinuação do Python 2.7 em janeiro de 2020, toda a base de código ITS da Camera foi refatorada para o 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
• OpenCV 3.4.2
• Numpy 1.19.2
• Matplotlib 3.3.2
• Scipy versão 1.5.2
• pySerial 3.5
• Pillow 8.1.0 (link em inglês)
• PyYAML 5.3.1 (link em inglês)

O iniciador de teste principal, tools/run_all_tests.py, permanece o mesmo das versões Android 11 ou anteriores e é reestruturado para o 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 das funcionalidades dos testes permanecem os mesmos. No Android 12, todos os testes individuais agora carregam as cenas. Embora o carregamento de cena para cada teste aumente o tempo geral do teste, ele permite a depuração de testes individuais.

Para mais informações sobre mudanças de teste individuais, consulte Mudanças de teste.

Os seguintes módulos Python foram 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 do Mobly

O Mobly é um framework de teste baseado em Python que oferece suporte a casos de teste que exigem vários dispositivos com configurações de hardware personalizadas. O Camera ITS usa a infraestrutura de teste do Mobly para permitir um melhor controle e registro dos testes.

O Camera ITS usa a infraestrutura de testes do Mobly para permitir melhor controle e registro de testes. O Mobly é uma estrutura de teste baseada em Python que oferece suporte a casos de teste que exigem vários dispositivos com configurações de hardware personalizadas. Para mais informações sobre o Mobly, consulte google/mobly.

Arquivos config.yml

Com o framework do Mobly, você pode configurar um dispositivo em teste (DUT, na sigla em inglês) e um bloco de gráficos na classe its_base_test. Um arquivo config.yml (YAML) é usado para criar um ambiente de teste do Mobly. Vários testbeds podem ser configurados neste arquivo de configuração, por exemplo, um tablet e um testbed de fusão de sensores. Na seção do controlador de cada ambiente de teste, é possível especificar device_ids para identificar os dispositivos Android adequados para o executor de teste. Além dos IDs de dispositivo, outros parâmetros, como brightness, chart_distance, debug_mode, camera_id e scene_id do tablet, são transmitidos na classe de teste. Os valores de parâmetro de teste mais 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)

Testes em tablets

Para testes em tablets, a palavra-chave TABLET precisa estar presente no nome do ambiente de teste. Durante a inicialização, o executor de teste do Mobly inicializa TestParams e as transmite aos testes individuais.

Confira a seguir 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 ambiente de teste 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, é possível substituir os valores do arquivo de configuração camera e scene na linha de comando usando comandos semelhantes ao Android 11 ou versões anteriores.

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 precisa incluir a palavra-chave SENSOR_FUSION. O testbed correto é determinado pelas cenas testadas. O Android 12 oferece suporte a Arduino e Canakit controladores para fusão de sensores.

Confira a seguir 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 sensor test rig, use:

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

Vários ambientes de teste

Vários testbeds podem ser incluídos no arquivo de configuração. A combinação mais comum é ter um ambiente de teste de tablet e um ambiente de teste de fusão de sensores.

Confira a seguir um exemplo de arquivo config.yml com testes 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

Os testes manuais continuam disponíveis no Android 12. No entanto, o testbed precisa identificar testes como tal com a palavra-chave MANUAL no nome do testbed. Além disso, o testbed não pode incluir um ID de tablet.

Confira a seguir um exemplo de arquivo config.yml para testes manuais.

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

    TestParams:
      debug_mode: "False"
      chart_distance: 31.0
      camera: 0
      scene: scene1

Testar cenas sem tablets

Os testes para a cena 0 e a cena 5 podem ser feitos com TEST_BED_TABLET_SCENES ou com TEST_BED_MANUAL. No entanto, se o teste for feito com TEST_BED_TABLET_SCENES, o tablet precisa estar conectado e o ID de série do tablet precisa 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.

Executar testes individuais

Os testes individuais só podem ser executados para fins de depuração, porque os resultados não são informados 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 precisam estar corretos no arquivo config.yml para o teste individual em questão. Além disso, se houver mais de um ambiente de teste no arquivo de configuração, especifique o ambiente de teste com a flag --test_bed. Exemplo:

python tests/scene1_1/test_black_white.py --config config.yml --test_bed TEST_BED_TABLET_SCENES

Testar artefatos

No Android 12, os artefatos de teste para o ITS da câmera são armazenados de maneira semelhante ao Android 11 ou versões anteriores, mas com as seguintes mudanças:

• O diretório do artefato de teste /tmp tem CameraITS_ precedido pela string aleatória de 8 caracteres para maior clareza.
• A saída e os erros do teste são armazenados em test_log.DEBUG para cada teste, em vez de test_name_stdout.txt e test_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, já que todas as informações necessárias para depurar problemas de 3A são registradas.

Testar mudanças

No Android 12, as cenas do tablet são arquivos PNG em vez de PDF. O uso de arquivos PNG permite que mais modelos de tablet exibam as cenas corretamente.

scene0/test_jitter.py

O teste test_jitter é executado em câmeras ocultas físicas no Android 12.

scene1_1/test_black_white.py

No Android 12, o 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.

A tabela a seguir descreve o teste combinado, scene1_1/test_black_white.py, no Android 12.

cenário1_1/teste_de_igualdade_manual.py

O teste test_burst_sameness_manual é executado em câmeras ocultas físicas no Android 12.

scene1_2/test_tonemap_sequence.py

O teste test_tonemap_sequence é executado em CÂMERAS LIMITADAS no Android 12.

scene1_2/test_yuv_plus_raw.py

O teste test_yuv_plus_raw é executado em câmeras ocultas físicas no Android 12.

cena2_a/formato_de_teste_combos.py

O teste test_format_combos é executado em CÂMERAS LIMITADAS no Android 12.

scene3/test_flip_mirror.py

O teste test_flip_mirror é executado em CÂMERAS LIMITADAS no Android 12.

scene4/test_aspect_ratio_and_crop.py

A descoberta de círculos em scene4/test_aspect_ratio_and_crop.py foi refatorizada no Android 12.

As 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 encontrando os recursos mais circunscritos. Para filtrar círculos falsos na tela, é necessária uma área mínima de contorno, e o contorno do círculo precisa ser preto.

Os contornos e os 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 do Android 12 é mais simples e resolve o problema com o recorte da caixa de limite em alguns tablets de exibição. Todos os candidatos do círculo são registrados para fins de depuração.

No Android 12, o teste de corte é executado para dispositivos FULL e LEVEL3. O Android 11 ou versões anteriores pulam as declarações de teste de corte para dispositivos FULL.

A tabela abaixo lista as declarações para test_aspect_ratio_and_crop.py que correspondem a um determinado nível de dispositivo e primeiro nível de API.

scene4/test_multi_camera_alignment.py

O método undo_zoom() para capturas YUV em scene4/test_multi_camera_alignment.py foi reestruturado para considerar 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 ao teste de fusão de sensores.

Em versões anteriores ao Android 12, toda a imagem é usada para encontrar os 240 melhores elementos, que são mascarados para o centro 20% para evitar efeitos de obturador com o requisito mínimo de 30 elementos.

Se os recursos encontrados por esse método forem insuficientes, o Android 12 mascara a área de detecção de recursos para o centro 20% primeiro e limita os recursos máximos a duas vezes o requisito mínimo.

A imagem a seguir mostra a diferença entre a detecção de recursos do Android 11 e do Android 12. Aumentar o 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 o Android 11 e o Android 12

Novos testes

scene0/test_solid_color_test_pattern.py

Um novo teste, test_solid_color_test_pattern, foi ativado para o Android 12. Esse teste é ativado para todas as câmeras e é descrito na tabela a seguir.

Os padrões de teste de cores sólidas precisam estar ativados para oferecer suporte ao modo de privacidade da câmera. O teste test_solid_color_test_pattern confirma a saída de imagem YUV de 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 de padrão de teste. Este teste usa SOLID_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 uma descrição do padrão de teste de cor sólida, consulte SENSOR_TEST_PATTERN_MODE_SOLID_COLOR.

Método

Os frames YUV são capturados para o conjunto de parâmetros, e o conteúdo da imagem é validado. O padrão de teste é gerado diretamente do sensor de imagem. Portanto, nenhuma cena específica é necessária. Se PER_FRAME_CONTROL tiver suporte, um único frame YUV será capturado para cada configuração testada. Se PER_FRAME_CONTROL não tiver suporte, quatro frames serão capturados com apenas o último frame analisado para maximizar a cobertura de 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 é por padrão de Bayer do sensor, os canais de cor precisam ser definidos para cada cor, conforme mostrado na tabela a seguir.

Tabela de declarações

A tabela abaixo descreve as declarações de teste para test_solid_color_test_pattern.py.

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 principais frontal e traseira com a cena de rosto scene2_c.

scene2_c/test_jpeg_capture_perf_class.py

Verifica se a latência de captura JPEG de 1080p é inferior a 1 segundo para as câmeras principais frontais e traseiras com a cena do rosto de stage2_c.