O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Esta página foi traduzida pela API Cloud Translation.

ITS-in-a-Box da câmera

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

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

Automação. Nenhuma intervenção humana é necessária durante a teste.
Solução de problemas simplificada. Consistência do ambiente de teste resulta em menos erros de configuração e aumenta a reprodutibilidade.
Eficiência. Capacidade de tentar novamente para câmera/cena individuais melhora a eficiência da execução dos testes.

Primeiros passos

O ITS-in-a-box consiste em uma caixa plástica que é cortada a laser com a ajuda do computador desenhos de design (CAD), um tablet de gráficos e um dispositivo em teste (DUT). A tabela a seguir descreve os recursos e especificações dos diferentes suportes ITS-in-a-box disponíveis.

Equipamento	Distância do gráfico	Intervalo de FoV da câmera DUT (aprox.)	Recursos
Rig de base modular	22cm	60° a 120°	Menor presença Corte de grande abertura frontal, que permite testes do sistema com várias câmeras sem corte bloqueando câmeras secundárias A alavanca pode ser girada em 90°
Rig de base modular e de extensão de tele	22cm - 100cm*	10° a 120°	Corte de abertura grande na frente Oferece suporte a testes de câmeras que têm uma distância mínima de foco maior (a maioria das telecâmeras)
ITS-in-a-box para WFoV (em inglês)	22cm	60° a 120°	Espaço amplo, permitindo muitas posições de montagem DUT Suporte a DUTs grandes, como tablets
RFoV ITS-in-a-box (em inglês)	31cm	60° a 90°	Tablet para gráficos Sistema de iluminação interno
*O comprimento do rig de extensão da telemetria pode ser ajustado para diferentes distâncias do gráfico.

desenhos de design (CAD), um tablet de gráficos e um dispositivo em teste (DUT). A tabela a seguir descreve os recursos e especificações dos diferentes suportes ITS-in-a-box disponíveis.

Equipamento	Distância do gráfico	Intervalo de FoV da câmera DUT (aprox.)	Recursos
Rig de base modular	22cm	60° a 120°	Menor presença Corte de grande abertura frontal, que permite testes do sistema com várias câmeras sem corte bloqueando câmeras secundárias A alavanca pode ser girada em 90°
Rig de base modular e de extensão de tele	22cm - 100cm*	10° a 120°	Corte de abertura grande na frente Oferece suporte a testes de câmeras que têm uma distância mínima de foco maior (a maioria das telecâmeras)
ITS-in-a-box para WFoV (em inglês)	22cm	60° a 120°	Espaço amplo, permitindo muitas posições de montagem DUT Suporte a DUTs grandes, como tablets
RFoV ITS-in-a-box (em inglês)	31cm	60° a 90°	Tablet para gráficos Sistema de iluminação interno
*O comprimento do rig de extensão da telemetria pode ser ajustado para diferentes distâncias do gráfico.

Para começar a usar o Camera ITS-in-a-box:

Compre ou crie um modular WFoV ou um href="/docs/compatibility/cts/camera-modular-rig-system">modular, WFoV ou um RFoV ITS-in-a-box.
Configurar um tablet com o Camera ITS de software.
Execute testes.
receber resultados do DUT.

Configurar o tablet

Esta seção fornece instruções detalhadas para configurar uma tablet para uso com o dos sensores ITS da câmera localizados no CameraITS. Estas instruções usam um Pixel C como um tablet. Para informações sobre o tablet requisitos e recomendações, consulte a documentação sobre .

Observação:os scripts Python do Camera ITS definir automaticamente as seguintes opções no tablet para você:
Configurações > Exibição > Sono > Após 30 minutos de inatividade
Brilho adaptável > DESATIVADO

Carregue e ligue o tablet. Ignore a solicitação para configurar uma conta (A Camera ITS não requer nenhuma conta pareada com o tablet).
Atualize o tablet para o Android 7.0 ou uma versão mais recente. Android 6.x e versões anteriores não oferecem suporte ao Camera ITS.
Ative o modo de desenvolvedor.

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, o tablet solicitará Permitir a 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

Determine os IDs do DUT e do gráfico executando $ adb devices para listar disponíveis. Para determinar device_id e chart_id, conecte e desconecte os dispositivos e observe os dispositivos que para conectar e desconectar.
Faça três execuções de teste para suprimir dicas e comandos do usuário que possam ocultar gráficos na tela do tablet.
1. Posicione o tablet com a tela para cima em uma mesa (não o encaixe na parte de trás) 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, então o tablet solicita Permitir que o Drive acesse fotos, mídia e arquivos no seu dispositivo?. Limpar essa solicitação (e evitar solicitações futuras) pressionando Permitir.
3. Execute o comando novamente. O tablet exibirá a mensagem Manter uma cópia deste arquivo? e sugere o Google Drive. Para limpar esse comando (e evitar outros) ao pressionar o ícone do Drive e clicar em Cancelar para fazer o upload para o 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 os testes falharem (já que a câmera não está apontada para o gráfico), verifique se o tablet percorre as cenas corretamente sem exibir solicitações ou outros pop-ups na tela.

Executar testes

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

Um (1) ITS-in-a-box
Uma (1) alta resolução de 10" tablet para exibir cenas, S/N: 5811000011
Um (1) DUT que tenha o verificador do CTS App 7.0_8+ instalado. Exemplo de DUT:
- Um (1) Pixel NOF26W para os testes da câmera traseira, S/N: FA6BM0305016. Para instale o aplicativo do CTS Verifier, descompacte o android-cts-verifier.zip e depois funcionam
```
adb -s FA6BM0305016 install -r -g android-cts-verifier/CtsVerifier.apk
```

Executar cenas no tablet

Para executar cenas 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:

**Figura 1**. Câmera 0 S/N: FA6BM0305016

Repetir cenas

Você pode repetir cenas para uma única câmera:

Para repetir cenas com uma única câmera:

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

Executar cena 5

A cena 5 requer configuração especial com iluminação específica (para mais detalhes, consulte CameraITS.pdf no CTS Verifier. Faça o download dele em Downloads do conjunto de teste de compatibilidade). Você precisa executar a cena 5 separadamente (fora da caixa).

cena da câmera 5 — **Figura 2**. Cena da câmera 5

Para executar o cenário 5 para as 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

Você pode visualizar os resultados durante o teste e salvar os resultados concluídos como um relatório.

Confira os resultados. Para salvar os resultados do Camera ITS como relatório:
1. Pressione Aprovado e salve o relatório.
  
  Figura 3. Relatório ITS da câmera
2. Receba relatórios no dispositivo:
```
adb -s FA6BM0305016 pull /sdcard/verifierReports
```
3. Descompacte o arquivo de relatório e confira o test_result.xml.
  
  Figura 4. Relatórios do Camera ITS

Requisitos para tablets

No Android 15 e versões mais recentes, os tablets usados como o gráfico de ITS são mostrados precisa estar na lista de permissões de tablets a seguir. Para uma lista de tablets que oferecem suporte a testes de cenas com pouca luz, veja Tablets compatíveis com cenas com pouca luz. Para Android 14 ou anterior, consulte Requisitos de tablets para o Android 14 e versões anteriores.

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

tamanho de tela de cerca de 10 polegadas com resolução de tela superior a 1920 x 1200 pixels.
Não pode ter nenhuma oscilação medida causada por uma tela controlada por modulação de largura de pulso (PWM, na sigla em inglês) escurecimento.
Capaz de executar comandos adb enviados por testes ITS e exibir imagens de gráficos com para o brilho da tela indicado.

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

Dispositivo	Tamanho de exibição (polegadas)	Tamanho da tela (pixels)	Dimensões do tablet (polegadas)	Brilho da tela	Nome do dispositivo (ro.product .device)	Versão do SO do tablet
Google Pixel C	10.2	2.560 x 1.800	9,53 x 7,05 x 0,28	96	dragão	Android 6 ou versão mais recente
Honra Pad 8	11	2.000 x 1.200	10,18 x 6,76 x 0,29	192	HNHEY-Q	Android 12
Lenovo Tab M10 Plus	10.3	1.920 x 1.200	9,61 x 6,03 x 0,32	192	X606F	Android 9 ou versão mais recente
Lenovo Tab P11	11	2.000 x 1.200	10,17 x 6,42 x 0,30	192	J606F	Android 11 ou versões mais recentes
Lenovo Tab P11 Geração 2	11,5	2.000 x 1.200	10,59 x 6,67 x 0,29	192	TB350FU	Android 13 ou mais recente
Nokia T21	10,4	2.000 x 1.200	9,74 x 6,19 x 0,30	192	AGTA	Android 12 ou versões mais recentes
Samsung Galaxy Tab A7	10,4	2.000 x 1.200	9,75 x 6,2 x 0,28	192	gta4lwifi	Android 10 ou mais recente
Samsung Galaxy Tab A8	10,5	1.920 x 1.200	9,72 x 6,73 x 0,27	192	gta8wifi	Android 11 ou versões mais recentes
Samsung Galaxy Tab A9+	11	1.920 x 1.200	10,12 x 6,64 x 0,27	192	gta9pwifi	Android 13 ou mais recente
Vivo Pad2	12.1	2.800 x 1.968	10,47 x 7,54 x 0,26	192	DPD2221	Android 13 ou mais recente
Xiaomi Pad 5	11	2.560 x 1.600	10,18 x 6,76 x 0,29	192	Nabu	Android 13 ou mais recente
Xiaomi Redmi Pad	10,61	2.000 x 1.200	9,86 x 6,22 x 0,28	192	Yuunluo	Android 14 ou mais recente
Xiaomi Redmi Pad SE	11	2.560 x 1.600	10,06 x 6,58 x 0,29	192	Xun	Android 13 ou mais recente

Tablets compatíveis com cenas com pouca luz

A tabela a seguir lista os tablets que oferecem suporte a testes de cenas com pouca luz: Esses tablets podem atingir o nível de brilho necessário para cenários com pouca luz, permitindo que o DUT expor corretamente o gráfico.

Dispositivo	Nome do dispositivo (ro.product.device)	Versão do SO do tablet
Samsung Galaxy Tab A8	gta8wifi	Android 11 ou versões mais recentes
Samsung Galaxy Tab A9+	gta9pwifi	Android 13 ou mais recente

Requisitos de tablets para o Android 14 e versões anteriores

Os tablets precisam ter um tamanho de tela de cerca de 10 polegadas com uma resolução de tela maior que 1.920 x 1.200 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 de ITS, além da versão do Android para o DUT com que os tablets funcionam.

Dispositivo	Tamanho de exibição (polegadas)	Tamanho da tela (pixels)	Dimensões do tablet (polegadas)	Brilho da tela	Exibir bits	DUT OS compatível	SO para tablets compatível
Samsung Galaxy Tab A8	10,5	1.920 x 1.200	9,72 x 6,37 x 0,27	192	8	Android 13 ou mais recente	Android 11 ou versões mais recentes
Xiaomi Pad 5	11	2.560 x 1.600	10,03 x 6,55 x 0,27	1024	11	Android 12 ou versões mais recentes	Apenas o Android 11
Lenovo Tab M10 Plus	10.3	1.920 x 1.200	9,61 x 6,03 x 0,32	192	8	Android 12 ou versões mais recentes	Android 9 ou versão mais recente
Samsung Galaxy Tab A7	10,4	2.000 x 1.200	9,75 x 6,2 x 0,28	192	8	Android 12 ou versões mais recentes	Android 10 ou mais recente
Chuwi Hi9 Air 10.1	10.1	2.560 x 1.600	9,52 x 6,77 x 0,31	192	8	Android 7 ou versão mais recente	Android 8 ou mais recente
Asus ZenPad 3	9.7	2.048 x 1.536	9,47 x 6,44 x 0,28	192	8	Android 7 ou versão mais recente	Android 6 ou versão mais recente
Huawei MediaPad m5	10,8	2.560 x 1.600	10,18 x 6,76 x 0,29	192	8	Android 7 ou versão mais recente	Android 8 ou mais recente
Google Pixel C	10.2	2.560 x 1.800	9,53 x 7,05 x 0,28	96	8	Android 7 ou versão mais recente	Android 6 ou versão mais recente
Sony Xperia Z4	10.1	2.560 x 1.600	10 x 6,57 x 0,24	192	8	Android 7 ou versão mais recente	Android 5 ou superior

Perguntas frequentes

P1: Como determino de quais equipamentos de teste preciso para meu dispositivo?

O A revisão 1 do RFoV ITS-in-a-box testa câmeras de RFoV para testes de cenas em tablets no CameraITS/tests. A RFoV é definida como 60° < Campo de visão < 90°. Em câmeras de campo de visão maiores, as luzes podem aparecer nas imagens ou nos gráficos pode cobrir uma área muito pequena no campo de visão, afetando os resultados do teste.

O WFoV ITS-in-a-box revisão 2 testa câmeras WFoV para testes de cenas em tablets no CameraITS/tests. WFoV é definido como FoV >= 90°. O equipamento de teste da revisão 2 é funcionalmente idêntico à 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 posteriores. Dada a abrangência maior, a revisão 2 é ideal se o DUT for um tablet

O suporte de base modular testa câmeras WFoV para testes de cenas em tablets no CameraITS/tests. WFoV é definido como FoV >= 90°. O suporte de base modular pode testar câmeras RFoV e WFoV para dispositivos com Android 9 e versões mais recentes. Ele também oferece suporte ao suporte de extensão de tele que pode ser conectado a câmeras de teste com um distância mínima do foco. O suporte de base modular é funcionalmente idêntico ao "ITS-in-a-box" da WFoV mas é menor.

O A caixa de fusão do sensor testa o tempo da câmera/giroscópio. sincronização de frames de sistemas com várias câmeras e deslocamento com testes scenes=sensor_fusion uma deslocamento de tempo da câmera/giroscópio menor é necessário mais de 1 ms para a sinalização 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 sensor, caso a câmera tenha o recurso REALTIME .

Um conjunto de exemplos de configurações é fornecido na tabela abaixo.

Exemplo	FoVs da câmera	EM TEMPO REAL?	Rigs recomendados	Observações
1	22°	Não	Rev1 ou 2	Android 7.0 ou versão mais recente
2	22°	Sim	Base modular, ou Rev 1 ou 2, e fusão do sensor	Android 9 ou versão mais recente
3	22° + 95°	Sim	Rev2 + fusão do sensor	Android 9 ou versão mais recente
4	20° + 95° + 20°	Sim	Base modular, extensão de tele e fusão de sensores	Android 9 ou versão mais recente
5	Tablet 75° + 95°	Não	Rev. 2	Android 9 ou versão mais recente

P2: Como posso designar qual equipamento 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 gráficos de 31 cm, e o equipamento rev2 (WFoV) tem uma distância de gráfico de 22 cm. Por padrão, o do gráfico é definida como 31 cm.

Android 10 ao Android 11

Para identificar o equipamento de teste correto no Android 10 até o 11. Adicione a flag dist à linha de comando. O padrão o valor de dist é 31. Execute o comando a seguir: para mudar o parâmetro chart_distance.

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

Android 12 e versões mais recentes

Para identificar o equipamento de teste correto no Android 12 e versões mais recentes, edite o config.yml para alterar o parâmetro chart_distance.

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, faça o seguinte: executar:

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

Para mudar o brilho em tablets com Android 10 a 11, a O valor pode ser alterado na linha de comando adicionando a sinalização 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: executar:

edit config.yml
brightness: 96 → brightness: 192

P4: Como depurar um único teste?

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

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

Carregue uma cena adicionando a sinalização scenes em tools/run_all_tests.py:
```
python tools/run_all_tests.py device=# camera=# chart=# scenes=#
```
Pressione Control+C para interromper os testes após a cena está registrado como carregado em stdout.

Se a cena correta já estiver tela, ative a tela:
```
python tools/wake_up_screen.py screen=#
```
Executar um teste individual.
```
python tests/scene#/test_*.py device=# camera=#
```
Os gráficos são gerados no diretório local e stdout e stderr são mostrados na tela.

Para mais informações sobre depuração, adicione print ao script. Para aumentar a saída do teste para depuração, adicione a sinalização 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 quando executando tools/run_all_tests.py.

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

Edite o arquivo config.yml.

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

Executar o teste individual.

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

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

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

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

O Camera ITS 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 em a câmera. Para detectar comportamentos não confiáveis, esses testes devem transmitir como um grupo para uma cena inteira. Por exemplo, embora uma única instância não confiável pode ser aprovada na reexecução de toda a cena, dificultando a execução não confiáveis para serem aprovados.

Como 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 individualmente, há uma grande chance de o operador colocar a câmera passarem pelo Camera ITS. No entanto, se os testes forem executados em conjunto como uma cena, há apenas 0,1% de chance de a cena passar.

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

Por padrão, o script tools/run_all_tests.py executa todas as cenas em ordem. Entretanto, as cenas podem ser executadas individualmente ou em uma ordem especificada, e ser denunciado para CtsVerifier.apk.

Para executar uma cena individual (por exemplo, cena 2) ou executar mais de uma cena em uma cena específica no Android 11 ou menor:

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 executar mais de uma cena em uma determinada 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 outros parâmetros são definidos no arquivo config.yml.

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

Verifique se o tablet e o ambiente de teste atendem aos seguintes especificações.

Especificações do tablet

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

Tamanho da tela (polegadas): 10 polegadas
Tamanho de exibição (pixels): maior que 1920 x 1200 pixels

Para mais detalhes, consulte Requisitos para tablets.

Brilho do tablet

Os testes podem não obter resultados corretos se o brilho da tela do tablet estiver muito alto baixa.

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

Nível de iluminação da caixa (exige um medidor de lux)

Certifique-se de que o valor de lux desejado na abertura do tablet esteja entre 100 e 300

Se o nível de lux estiver muito alto, scene1/test_param_flash_mode.py retorna 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 do sensor?

Verifique se você está em um grupo dialout.
```
groups | egrep ‘dialout'
```
Verifique se o controlador de fusão do sensor está conectado determinando se A tecnologia Microchip está conectada à porta USB.
```
lsusb
…
Bus 003 Device 004: ID 04d8:fc73 Microchip Technology, Inc.
…
```
Execute o teste várias vezes para receber uma distribuição das tentativas de teste com os comandos a seguir.

No Android 11 ou 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 outros parâmetros são definidos no arquivo config.yml.

As saídas de execução estão na pasta /tmp/tmp### criada em as pastas sensor_fusion_#, em que # é a execução número Motivos comuns para falhas são:
1. O smartphone não está centralizado corretamente.
2. Não foram encontrados recursos suficientes na imagem (geralmente um problema de campo de visão ou iluminação).
3. O FAIL retornado é válido, e o deslocamento de tempo entre a câmera e o giroscópio precisam ser corrigidos.

P9: Que informações devo incluir ao denunciar uma bug de teste?

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

Se você executou o teste por tools/run_all_tests.py, anexe um compactado o diretório /tmp/ no bug.
Se você executou o teste sozinho, anexe todas as saídas da tela e imagens geradas ao bug.

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

adb -s device_id bugreport

P10: Como faço para executar uma cena de teste sensor_fusion com uma câmera que tem um foco mínimo distância que cria imagens desfocadas 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 suporte do gráfico caixa de fusão do sensor. Colocar o gráfico a uma distância em que o DUT possa focar e mudar chart_distance em config.yml para a distância medida entre o DUT e no gráfico. A Figura 5 mostra um exemplo de como medir a distância do gráfico nessa situação.

Exemplo de teste TELE de sensor_fusion — **Figura 5**. Medir a distância do gráfico com o cenário do teste de fusão do sensor

  edit config.yml
chart_distance: 25 → chart_distance: DISTANCE_BETWEEN_DUT_AND_CHART

P11: Como executar cenas de teste em tablets para uma câmera com foco mínimo distância que cria imagens desfocadas a 31 cm de distância do gráfico?

Caso sua câmera não consiga produzir imagens nítidas a 31 cm (o profundidade do equipamento de teste de RFoV), monte a câmera na frente do equipamento a uma distância para permitir que no gráfico de cena para preencher aproximadamente 60% do campo de visão (FoV) da câmera com imagens mais nítidas. Essa distância pode ser menor que o foco mínimo distância da câmera. Saia de chart_distance em config.yml às 31 cm. O dimensionamento do gráfico no tablet é determinado pela câmera como mostrado na tabela a seguir:

FoV da câmera	Fator de escala do gráfico
60 > Campo de visão > 40,	0,67x
40 > Campo de visão > 25,00	0,5x
Campo de visão < 25,00	0,33x

P12: Com a API lógica de várias câmeras, 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 são executadas na câmera lógica de nível superior. Um subconjunto dos testes de ITS é executado subcâmeras, e esses testes estão listados em tools/run_all_tests.py na constante SUB_CAMERA_TESTS.