Notas de lançamento do Android 12 Camera Image Test Suite

Várias alterações ITS da câmera 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 Camera ITS foi refatorada para o Python 3. As seguintes versões e bibliotecas do Python são necessárias no Android 12:

O iniciador de teste principal, tools/run_all_tests.py , permanece o mesmo das versões Android 11 ou inferior 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 de teste e funcionalidade 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 teste individuais, consulte Alterações de teste .

Os seguintes módulos Python são refatorados com uma mudança de nome:

  • pymodules/its/caps.pyutils/camera_properties_utils.py
  • pymodules/its/cv2image.pyutils/opencv_processing_utils.py
  • pymodules/its/device.pyutils/its_session_utils.py
  • pymodules/its/error.pyutils/error_util.py
  • pymodules/its/image.pyutils/image_processing_utils.py
  • pymodules/its/objects.pyutils/capture_request_utils.py
  • pymodules/its/target.pyutils/target_exposure_utils.py
  • tools/hw.pyutils/sensor_fusion_utils.py

Adoção da estrutura de teste do Mobly

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. O Camera ITS usa a infraestrutura de teste Mobly para permitir um melhor controle e registro dos testes.

O Camera ITS usa a infraestrutura de teste Mobly para permitir um melhor controle e registro dos testes. 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 obter mais informações sobre o Mobly, consulte google/mobly .

arquivos config.yml

Com a estrutura do 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 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. Dentro da seção do controlador de cada testbed, você pode especificar device_ids para identificar os dispositivos Android apropriados para o executor de teste. Além dos IDs do dispositivo, 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 comuns dos parâmetros de teste 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 testbed. Durante a inicialização, o executor de teste Mobly inicializa TestParams e os passa para os testes individuais.

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

Veja a seguir um exemplo de arquivo config.yml para execuções de fusão de sensor.

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 testbeds

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

Veja a seguir um exemplo de arquivo config.yml com testbeds de fusão de tablet e sensor.

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 suportado no 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 arquivo config.yml de amostra 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

Cenas de teste sem tablets

O teste da cena 0 e da 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 de ID de série para o tablet.

Executar 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 para Camera ITS são armazenados de forma semelhante ao Android 11 ou inferior, mas com as seguintes alterações:

  • O diretório /tmp do artefato de teste tem CameraITS_ anexado à string aleatória de 8 caracteres para maior clareza.
  • A saída de teste e os erros 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, 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 tablet exibam as cenas corretamente.

cena0/test_jitter.py

O teste test_jitter é executado em câmeras ocultas físicas 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 [255, 255, 255] diferenças para eliminar a tonalidade de 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]
Longa exposição, valores RGB de alto ganho ~[255, 255, 255] e tolerância reduzida entre os 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 ocultas físicas no Android 12.

cena1_2/test_tonemap_sequence.py

O teste test_tonemap_sequence é executado em câmeras LIMITED no Android 12.

cena1_2/test_yuv_plus_raw.py

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

cena2_a/test_format_combos.py

O teste test_format_combos é executado em câmeras LIMITED no Android 12.

cena3/test_flip_mirror.py

O teste test_flip_mirror é executado em câmeras LIMITED 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 por encontrar os recursos que são os mais circulares . Para filtrar círculos espúrios no visor, é 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.

Desenho conceitual de contornos e critérios de seleção

Figura 1. Desenho conceitual de contornos e critérios de seleção

O método do Android 12 é mais simples e funciona para resolver o problema com o recorte da caixa delimitadora 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 colheita é executado para dispositivos FULL e LEVEL3 . O Android 11 ou versões anteriores ignoram as afirmaçõ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 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 de detecção de recursos em imagens é adicionado para o teste de fusão de sensores.

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

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 de recursos.

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.

diferença na detecção de recursos entre detecção de recurso sensor_fusion do Android 11 e Android 12

Figura 2. Diferença na detecção de recursos entre o Android 11 e o Android 12

Novos testes

cena0/test_solid_color_test_pattern.py

Um novo teste, test_solid_color_test_pattern , está habilitado para o 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 test_solid_color_test_pattern 31 Confirma a saída de imagem de cor sólida e a programação de cor de imagem.

Os padrões de teste de cores sólidas devem ser ativados para suportar o 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 as alterações de cor da imagem 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 usa SOLID_COLOR .
  • android.sensor.testPatternData : define os valores padrão de teste R, Gr, Gb, G para o modo 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 suportado, um único quadro YUV é 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 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 é de acordo com o padrão Bayer do sensor, os canais de cores devem ser definidos 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 afirmaçõ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

cena2_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 de rosto scene2_c.

cena2_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 face scene2_c.