Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Se usó la API de Cloud Translation para traducir esta página.

ITS de la cámara

El Paquete de prueba de imagen de la cámara (ITS) es un framework para ejecutar pruebas en imágenes que produce una cámara Android. El objetivo general de cada prueba en ITS es configurar la cámara de una manera específica, capturar una o más tomas y examinarlas para ver si contienen los datos de imagen esperados. Muchas de las pruebas requieren que la cámara apunte a un gráfico de destino específico o que se ilumine con una intensidad específica.

El ITS se encuentra en el kit de prueba del verificador de CTS en cts/apps/CameraITS. Los dispositivos deben aprobar las pruebas de ITS correspondientes a las funciones compatibles que anuncia el framework de la cámara para apps de terceros como un subconjunto de CTS.

Configuración

Para ejecutar pruebas de ITS, se debe configurar lo siguiente:

Un dispositivo en prueba (DUT)
Una máquina host (por ejemplo, una computadora de escritorio o laptop con Linux)
Una escena que fotografía la cámara

Configuración del dispositivo en prueba (DUT)

Para configurar un DUT, sigue estos pasos:

Conecta el DUT a una máquina host a través de USB.
Otorga permisos para que el host acceda al DUT a través de ADB.
Instala la app de CTS Verifier (CtsVerifier.apk) en el dispositivo. Para obtener más información, consulta Cómo usar el verificador del CTS.
```
extract root/out/host/linux-x86/cts-verfier/android-cts-verifier.zip
cd android-cts-verifier
adb install -r -g CtsVerifier.apk
```
Nota: Si instalas la app desde un paquete del verificador de CTS (android-cts-verifier.zip) en lugar de desde un árbol de fuentes de Android completo, puedes encontrar CtsVerifier.apk y el directorio CameraITS/ en el nivel superior de la carpeta android-cts-verifier comprimida.

Configuración del host

ITS requiere que la máquina anfitrión esté conectada al DUT a través de USB, que se pueda usar ADB para el control y la comunicación del dispositivo, y que se tenga instalado el software necesario.

Para configurar la máquina host, asegúrate de que el siguiente software esté instalado.

Herramientas de la plataforma del SDK de Android

Se deben instalar las herramientas de la plataforma del SDK de Android, y ADB debe estar en la ruta de acceso ejecutable de la shell o la terminal que se ejecuta en la máquina host. Para obtener la versión pública de las herramientas de la plataforma del SDK de Android, consulta las notas de la versión de las herramientas de la plataforma del SDK.

Python

Python debe estar instalado en la máquina host. Te recomendamos que uses una distribución de Python empaquetada para garantizar la compatibilidad con las versiones compatibles. Para obtener detalles sobre las versiones de Python y de paquetes que se deben instalar para una versión específica, consulta las notas de la versión de ITS de la cámara de la versión correspondiente.

Mobly

Para Android 12 y versiones posteriores, se debe instalar el framework de pruebas de Mobly. Mobly te permite configurar un DUT y una tablet de gráficos en la clase its_base_test. Para instalar el framework de pruebas de Mobly, ejecuta lo siguiente:

pip install mobly

Configuración del entorno

Para configurar el entorno de pruebas, ejecuta el siguiente comando:

cd CameraITS
source build/envsetup.sh

Este comando verifica la instalación de Python, configura la variable de entorno PYTHONPATH y ejecuta pruebas de unidades en los módulos utils/*.py. Si no se imprimen errores en la terminal, el entorno está listo para ejecutar las pruebas de ITS.

Configuración de la escena

Para configurar las escenas, te recomendamos que uses la configuración de ITS en una caja para cámaras para facilitar la automatización, la confiabilidad y la eficiencia en las pruebas. Los equipos de prueba integrados en la caja de ITS admiten todos los requisitos de iluminación, centrado y cambio de gráficos para ITS. Además, se requiere el ITS integrado en la caja para probar las extensiones de la cámara.

Para las pruebas manuales, asegúrate de lo siguiente:

El DUT está en un trípode
El DUT se apunta a la escena correcta para cada prueba. (La secuencia de comandos de la prueba de ITS proporciona instrucciones para cambiar la configuración de la escena antes de iniciar pruebas en una escena nueva).
El DUT está conectado a la máquina anfitrión a través de USB.
El DUT no se mueve durante la ejecución de prueba.
La escena se ilumina con una fuente de luz estable que no fluctúa. (No uses una luz fluorescente, ya que esto genera parpadeos).

La secuencia de comandos de prueba de ITS muestra un mensaje que le solicita al usuario que cambie la configuración de la escena antes de iniciar pruebas en una nueva.

La orientación del teléfono debe establecerse de modo que la cámara tome imágenes sin rotación. La forma más fácil de verificar esto es con las escenas de rostros en escena2. La mayoría de los teléfonos tienen el teléfono en orientación horizontal con el teléfono rotado en sentido contrario a las manecillas del reloj para la cámara posterior y en el sentido de las manecillas del reloj para la cámara frontal.

Archivos de configuración

Con el framework de Mobly, debes crear un archivo de configuración config.yml para definir el entorno de pruebas de Mobly. Los siguientes son ejemplos de diferentes casos de uso.

Archivo config.yml de escenas basadas en tablets

El siguiente es un ejemplo de archivo config.yml para escenas basadas en tablets. Para las pruebas basadas en tablets, la palabra clave TABLET debe estar en el nombre del entorno de pruebas. Durante la inicialización, el ejecutor de pruebas de Mobly inicializa los parámetros del archivo y los pasa a las pruebas individuales.

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 la plataforma de pruebas, ejecuta tools/run_all_tests.py. Si no hay valores de línea de comandos que especifiquen cámaras o escenas, la prueba se ejecutará con los valores del archivo config.yml. Si hay valores de línea de comandos para cámaras o escenas, estos anulan los valores de la sección TestParams del archivo config.yml. Por ejemplo:

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

Archivo config.yml de la escena de sensor_fusion

El siguiente es un ejemplo de archivo config_yml para pruebas de sensor_fusion. Para las pruebas de sensor_fusion, la palabra clave SENSOR_FUSION debe estar en el nombre del campo de pruebas. Android 13 y versiones posteriores solo admiten el controlador Arduino para la fusión de sensores debido a las pruebas de vista previa y estabilización de video. Android 12 admite controles Arduino y 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 ejecutar pruebas de sensor_fusion con la caja de fusión de sensores, ejecuta lo siguiente:

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

Archivo config.yml de varios bancos de pruebas

El siguiente es un archivo config.yml de ejemplo con varios testbeds, un testbed de tablet y un testbed de sensor_fusion. El testbed correcto se determina con las escenas probadas.

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

Archivo config.yml de pruebas manuales

El siguiente es un ejemplo de archivo config.yml para pruebas manuales. A partir de Android 14, las pruebas manuales son compatibles con todas las pruebas, excepto las de scene_extensions. Para las pruebas manuales, la palabra clave MANUAL debe estar en el nombre del entorno de pruebas. Además, la sección AndroidDevice no puede incluir una sección de número de serie o etiqueta para una tablet.

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

    TestParams:
      debug_mode: "False"
      camera: 0
      scene: 1

Ejecución de pruebas de ITS

En esta sección, se describe cómo ejecutar pruebas de ITS.

Cómo invocar pruebas

Después de configurar el dispositivo, la máquina host (incluido el entorno) y la escena física, ejecuta las pruebas de ITS con el siguiente proceso.

Abre la app de CTS Verifier. En el menú de pruebas, selecciona Camera ITS Test.
En la máquina anfitrión, ejecuta las pruebas de ITS desde el directorio CameraITS/. Por ejemplo, para un dispositivo con cámaras frontal y posterior, ejecuta el siguiente comando:
```
python tools/run_all_tests.py
```
La secuencia de comandos itera a través de cámaras y escenas de prueba en función del archivo config.yml. Para depurar configuraciones, te recomendamos que ejecutes una de las escenas de scene2 con una sola prueba para obtener el tiempo de respuesta más rápido.

Para las pruebas manuales, antes de comenzar a ejecutar el conjunto de pruebas de ITS en cada escena, la secuencia de comandos toma una foto de la escena actual, la guarda como JPEG, imprime la ruta de acceso al JPEG en la consola y le pide al usuario que confirme si la imagen está bien. Este flujo de captura y confirmación se repite hasta que el usuario confirma que la imagen está bien. Los siguientes son los mensajes de este flujo.
```
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 ejecución de la secuencia de comandos imprime un registro que muestra PASS, FAIL, FAIL* o SKIP para cada prueba de ITS. FAIL* indica que la prueba falló, pero como aún no es obligatoria, se informará como PASS a CtsVerifier. SKIP indica que la prueba se aprobó porque el dispositivo no promocionó la capability subyacente que se estaba probando. Por ejemplo, si un dispositivo no anuncia a través de las interfaces de la cámara que admite DNG, se omiten las pruebas relacionadas con la captura de archivos DNG y se cuentan como PASS.
Para confirmar que las pruebas cumplieron con los requisitos, presiona el botón de marca de verificación verde. La entrada Camera ITS Test en el menú de pruebas de CTS Verifier se vuelve verde y significa que el teléfono aprobó la prueba de ITS de la cámara.

Pruebas paralelas DUT

Los dispositivos que ejecutan Android 14 o versiones posteriores admiten pruebas de DUT en paralelo. Esto te permite probar los DUT en paralelo con varios rigs para acelerar las pruebas generales. Por ejemplo, las pruebas en paralelo te permiten probar la cámara 0 en una rig y la cámara 1 en otra rig al mismo tiempo. Todas las pruebas de sesiones de prueba en paralelo se agregan en la sesión del verificador de CTS en el DUT de referencia. Debes ejecutar pruebas en paralelo con el control de iluminación de Arduino, ya que el control de iluminación manual no es compatible con las pruebas en paralelo. Asegúrate de que un canal diferente en el mismo control de Arduino controle la iluminación de cada equipo.

El siguiente es un archivo config.yml de muestra que define tres plataformas de pruebas para ejecutar en 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 ejecutar las plataformas de pruebas en paralelo, usa el siguiente comando:

for i in 0 1 2; do python3 tools/run_all_tests.py testbed_index=$i num_testbeds=3 & done; wait

Modelo de ruido DNG

Los dispositivos que anuncian la capacidad de capturar imágenes en formato RAW o DNG deben proporcionar un modelo de ruido en los metadatos del resultado de la captura de cada foto en formato RAW. Este modelo de ruido debe estar incorporado en la HAL de la cámara para cada cámara (por ejemplo, cámaras frontal y posterior) en el dispositivo que afirma ser compatible.

Implementación del modelo de ruido

Para implementar un modelo de ruido, sigue estos pasos para generarlo y, luego, incorporarlo en el sistema HAL de la cámara.

Para generar un modelo de ruido para cada cámara, ejecuta la secuencia de comandos dng_noise_model.py en el directorio tools. Esto genera un fragmento de código C. Para obtener más información sobre cómo configurar la cámara y capturar el entorno, consulta el documento DngNoiseModel.pdf en el directorio tools.
Para implementar el modelo de ruido del dispositivo, corta y pega el fragmento de código C en el HAL de la cámara.

Validación del modelo de ruido

La prueba de ITS automatizada tests/scene1_1/test_dng_noise_model.py valida el modelo de ruido verificando que los valores de ruido para la exposición y la ganancia de la toma proporcionados en los datos de la cámara sean correctos.