Esta página se ha traducido con Cloud Translation API.

Cámara SU

Camera Image Test Suite (ITS) es un marco para ejecutar pruebas en imágenes producidas por 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 examinar las tomas para ver si contienen los datos de imagen esperados. Muchas de las pruebas requieren que la cámara apunte a un gráfico objetivo específico o que se ilumine con una intensidad específica.

ITS está ubicado en el arnés de prueba CTS Verifier en cts/apps/CameraITS . Los dispositivos deben pasar las pruebas ITS correspondientes a las funciones admitidas anunciadas por el marco de la cámara para aplicaciones de terceros como un subconjunto de CTS.

Configuración

Para ejecutar pruebas ITS, se debe configurar lo siguiente:

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

Configuración del dispositivo bajo prueba (DUT)

Para configurar un DUT, siga estos pasos:

Conecte el DUT a una máquina host a través de USB.
Otorgue permisos para que el host acceda al DUT a través de ADB.
Instale la aplicación CTS Verifier ( CtsVerifier.apk ) en el dispositivo. Para obtener más información, consulte Uso del Verificador 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 instala la aplicación desde un paquete CTS Verifier ( android-cts-verifier.zip ) en lugar de desde un árbol fuente completo de Android, tanto CtsVerifier.apk como el directorio CameraITS/ se pueden encontrar en el nivel superior del archivo comprimido de android-cts-verifier carpeta android-cts-verifier .

Configuración del anfitrión

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

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

Herramientas de la plataforma SDK de Android

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

Pitón

Python debe estar instalado en la máquina host. Recomendamos utilizar una distribución de Python incluida para garantizar la compatibilidad con versiones compatibles. Para obtener detalles sobre qué versiones de Python y paquetes instalar para una versión específica, consulte las notas de la versión de Camera ITS para la versión correspondiente.

Movilmente

Para Android 12 y superior, se debe instalar el marco de prueba Mobly. Mobly le permite configurar un DUT y una tableta gráfica en la clase its_base_test . Para instalar el marco de prueba Mobly, ejecute:

pip install mobly

Configuración del entorno

Para configurar el entorno de prueba, ejecute:

cd CameraITS
source build/envsetup.sh

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

Si ve el mensaje de error libtinfo.so.6: no version information available (required by /bin/sh) en tiempo de ejecución, ejecute el siguiente comando para cambiar el nombre del archivo libtinfo.so.6 .

mv $ENV_DIRECTORY/lib/libtinfo.so.6 $ENV_DIRECTORY/lib/libtinfo.so.6.bak

Configuración de escena

Para configurar las escenas, recomendamos utilizar la configuración Camera ITS-in-a-box para facilitar la automatización, la confiabilidad y la eficiencia en las pruebas. Los bancos de pruebas ITS-in-a-box admiten todos los requisitos de iluminación, centrado y cambio de gráficos para ITS. Además, se requiere ITS-in-a-box para probar extensiones de cámara .

Para pruebas manuales, asegúrese de lo siguiente:

El DUT está sobre un trípode.
El DUT apunta a la escena correcta para cada prueba. (El script de prueba ITS proporciona indicaciones para cambiar la configuración de la escena antes de comenzar las pruebas en una nueva escena).
El DUT está conectado a la máquina host a través de USB.
El DUT no se mueve durante la ejecución de la prueba.
La escena se ilumina con una fuente de luz fija y no fluctuante. (No utilice una luz fluorescente porque esto produce parpadeo).

El script de prueba ITS muestra un mensaje que solicita al usuario que cambie la configuración de la escena antes de comenzar las pruebas en una nueva escena.

La orientación del teléfono debe configurarse para que la cámara tome imágenes sin rotación. La forma más sencilla de comprobarlo es con las escenas de rostros en la escena 2. La mayoría de los teléfonos tienen el teléfono en orientación horizontal con el teléfono girado en el sentido contrario a las agujas del reloj para la cámara trasera y girado en el sentido de las agujas del reloj para la cámara frontal.

Archivos de configuración

Al utilizar el marco de Mobly, debe crear un archivo de configuración config.yml para definir el banco de pruebas de Mobly. Los siguientes son ejemplos de diferentes casos de uso.

Archivo config.yml de escenas basadas en tabletas

El siguiente es un archivo config.yml de ejemplo para escenas basadas en tabletas. Para pruebas basadas en tabletas, la palabra clave TABLET debe estar en el nombre del banco de pruebas. Durante la inicialización, el ejecutor de pruebas de Mobly inicializa los parámetros en el 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 el banco de pruebas, ejecute tools/run_all_tests.py . Si no hay valores de línea de comando que especifiquen cámaras o escenas, la prueba se ejecuta con los valores del archivo config.yml . Si hay valores de línea de comando para cámaras o escenas, estos anulan los valores en 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 escena sensor_fusion

El siguiente es un archivo config_yml de ejemplo para pruebas sensor_fusion . Para las pruebas sensor_fusion , la palabra clave SENSOR_FUSION debe estar en el nombre del banco 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 es compatible con controladores 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 sensor_fusion con la caja de fusión del sensor , ejecute:

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 bancos de pruebas, un banco de pruebas de tableta y un banco de pruebas sensor_fusion . El banco de pruebas correcto está determinado por 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 prueba manual

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

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

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

Ejecución de pruebas ITS

Esta sección describe cómo ejecutar pruebas ITS.

Invocar pruebas

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

Abra la aplicación CTS Verifer. En el menú de pruebas, seleccione Cámara ITS Test .
Desde la máquina host, ejecute las pruebas ITS desde el directorio CameraITS/ . Por ejemplo, para un dispositivo con cámaras frontal y trasera, ejecute el siguiente comando:
```
python tools/run_all_tests.py
```
El script recorre en iteración cámaras y escenas de prueba según el archivo config.yml . Para configuraciones de depuración, recomendamos ejecutar una de las escenas scene2 con una única prueba para obtener una respuesta más rápida.
Para las pruebas manuales, antes de comenzar a ejecutar el conjunto de pruebas ITS en cada escena, el script toma una fotografía de la escena actual, la guarda como JPEG, imprime la ruta 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 del script imprime un registro que muestra PASA, FALLA o SALTAR para cada prueba ITS, donde SALTAR indica que la prueba se pasó porque el dispositivo no anunció la capacidad 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, las pruebas relacionadas con la captura de archivos DNG se omiten y se cuentan como aprobadas.
Para reconocer que las pruebas cumplieron con los requisitos de la prueba, toque el botón de marca de verificación verde. La entrada Prueba ITS de la cámara en el menú de pruebas del Verificador CTS se vuelve verde y significa que el teléfono pasó la ITS de la cámara.

Pruebas DUT en paralelo

Los dispositivos que ejecutan Android 14 o superior admiten pruebas DUT paralelas. Esto le permite probar DUT en paralelo con múltiples equipos para acelerar las pruebas generales. Por ejemplo, las pruebas en paralelo le permiten probar la cámara 0 en un equipo y la cámara 1 en otro equipo al mismo tiempo. Todas las pruebas para sesiones de prueba paralelas se agregan en la sesión del Verificador CTS en el DUT de referencia. Debe ejecutar pruebas en paralelo con el control de iluminación Arduino, ya que el control de iluminación manual no es compatible con las pruebas en paralelo. Asegúrese de que un canal diferente en el mismo controlador Arduino controle la iluminación de cada equipo.

El siguiente es un archivo config.yml de muestra que define tres bancos 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 los bancos de pruebas en paralelo, utilice 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 RAW o DNG deben proporcionar un modelo de ruido en los metadatos del resultado de la captura de cada toma sin procesar. Este modelo de ruido debe estar integrado en la cámara HAL para cada cámara (por ejemplo, cámaras frontal y trasera) en el dispositivo que afirma ser compatible.

Implementación del modelo de ruido.

Para implementar un modelo de ruido, siga estos pasos para generar un modelo de ruido e incrustarlo en la cámara HAL.

Para generar un modelo de ruido para cada cámara, ejecute el script 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 el entorno de captura, consulte el documento DngNoiseModel.pdf en el directorio tools .
Para implementar el modelo de ruido para el dispositivo, corte y pegue el fragmento de código C en la cámara HAL.

Validación del modelo de ruido.

La prueba 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 proporcionados en los datos de la cámara sean correctos.