ITS kamery

Pakiet testów obrazu z kamery (ITS) to platforma do przeprowadzania testów obrazów tworzonych przez kamerę Androida. Ogólnym celem każdego testu w ITS jest skonfigurowanie aparatu w określony sposób, zrobienie co najmniej jednego zdjęcia i sprawdzenie, czy zawiera ono oczekiwane dane obrazu. Wiele testów wymaga skierowania kamery na określony wykres docelowy lub oświetlenia go z określoną intensywnością.

ITS znajduje się w komponencie testowym CTS Verifier w cts/apps/CameraITS. Urządzenia muszą przejść testy ITS odpowiadające obsługiwanym funkcjom reklamowanym przez framework aparatu w aplikacjach innych firm jako podzbiór CTS.

Konfiguracja

Aby przeprowadzić testy ITS, musisz skonfigurować te elementy:

  • Urządzenie testowe (DUT)
  • Urządzenie hosta (np. komputer stacjonarny lub laptop z systemem Linux)
  • Scena fotografowana przez aparat

Konfiguracja urządzenia testowego (DUT)

Aby skonfigurować urządzenie DUT, wykonaj te czynności:

  1. Połącz urządzenie DUT z hostem przez USB.
  2. Przyznaj hostowi uprawnienia dostępu do DUT przez ADB.

  3. Zainstaluj na urządzeniu aplikację CTS Verifier (CtsVerifier.apk). Więcej informacji znajdziesz w artykule Używanie narzędzia CTS Verifier.

    extract root/out/host/linux-x86/cts-verfier/android-cts-verifier.zip
cd android-cts-verifier
adb install -r -g CtsVerifier.apk

Konfiguracja hosta

ITS wymaga, aby maszyna hosta była połączona z badanym urządzeniem przez USB, aby można było używać ADB do sterowania urządzeniem i komunikacji oraz aby zainstalowane było wymagane oprogramowanie.

Aby skonfigurować komputer hosta, upewnij się, że masz zainstalowane podane niżej oprogramowanie.

Android SDK Platform Tools

Musisz zainstalować narzędzia platformy Android SDK, a ADB musi znajdować się na ścieżce wykonywalnej powłoki lub terminala, który działa na maszynie hosta. Informacje o publicznie udostępnionej wersji narzędzi platformy Android SDK znajdziesz w informacjach o wersji narzędzi platformy SDK.

Python

Na komputerze hosta musi być zainstalowany Python. Zalecamy korzystanie z pakietu dystrybucji Pythona, aby zapewnić obsługę zgodnych wersji. Szczegółowe informacje o tym, które wersje Pythona i pakietów należy zainstalować w przypadku konkretnej wersji, znajdziesz w informacjach o wersji ITS aparatu odpowiadającej wersji.

Mobly

W przypadku Androida 12 lub nowszego musisz zainstalować framework testowy Mobly. Mobly umożliwia skonfigurowanie tabletu z testowanym urządzeniem i wykresem w klasie its_base_test. Aby zainstalować framework testowy Mobly, uruchom:

pip install mobly

Konfiguracja środowiska

Aby skonfigurować środowisko testowe, uruchom:

cd CameraITS
source build/envsetup.sh

To polecenie sprawdza instalację Pythona, konfiguruje zmienną środowiskową PYTHONPATH i uruchamia testy jednostkowe modułów utils/*.py. Jeśli w terminalu nie pojawią się żadne błędy, środowisko jest gotowe do przeprowadzania testów ITS.

Konfiguracja sceny

Do konfigurowania scen zalecamy użycie ustawienia ITS-in-a-box dla kamery, które ułatwia automatyzację, zwiększa niezawodność i efektywność testów. Testowe urządzenia ITS-in-a-box obsługują wszystkie wymagania dotyczące oświetlenia, wyśrodkowania i zmiany wykresów dla ITS. Ponadto ITS-in-a-box jest wymagany do testowania rozszerzeń aparatu.

W przypadku testów ręcznych:

  • Testowane urządzenie jest na statywie
  • Urządzenie testowe jest skierowane na odpowiednią scenę w przypadku każdego testu. (skrypt testu ITS zawiera prompty dotyczące zmiany konfiguracji sceny przed rozpoczęciem testów w nowej scenie).
  • Urządzenie DUT jest połączone z hostem przez USB.
  • Testowany obiekt nie porusza się podczas testu.
  • Scena jest oświetlona za pomocą stałego, niepulsującego źródła światła. (Nie używaj światła fluorescencyjnego, ponieważ powoduje ono migotanie).

Skrypt testu ITS wyświetla prompt z prośbą o zmianę konfiguracji sceny przed rozpoczęciem testów w nowej scenie.

Orientacja telefonu musi być ustawiona tak, aby aparat nie obracał zdjęć. Najłatwiej sprawdzić to za pomocą scen z twarzy w scenie2. Większość telefonów ma orientację poziomą, a telefon jest obracany w przeciwnym kierunku od ruchu wskazówek zegara, aby użyć tylnego aparatu, i w kierunku ruchu wskazówek zegara, aby użyć przedniego aparatu.

Pliki konfiguracji

Aby zdefiniować środowisko testowe Mobly, musisz utworzyć plik konfiguracji config.yml za pomocą platformy Mobly. Poniżej znajdziesz przykłady różnych zastosowań.

Plik config.yml dla scen na tablety

Poniżej znajdziesz przykładowy plik config.yml do scen na tablety. W przypadku testów na tablecie nazwa testu musi zawierać słowo kluczowe TABLET. Podczas inicjowania uruchamiacz testów Mobly inicjalizuje parametry w pliku i przekazuje je do poszczególnych testów.

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

Aby wywołać środowisko testowe, uruchom tools/run_all_tests.py. Jeśli nie ma wartości wiersza poleceń określających kamery lub sceny, test jest uruchamiany z wartościami z pliku config.yml. Jeśli w przypadku kamer lub scen są określone wartości w wierszu poleceń, zastąpią one wartości w sekcji TestParams w pliku config.yml. Przykład:

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

Plik sensor_fusion scene config.yml

Poniżej znajdziesz przykładowy plik config_yml do testów sensor_fusion. W przypadku testowania sensor_fusion słowo kluczowe SENSOR_FUSION musi znajdować się w nazwach testów. Android 13 i nowsze wersje obsługują tylko kontroler Arduino do fuzji sensorów ze względu na testowanie podglądu i stabilizacji wideo. Android 12 obsługuje kontrolery Arduino i 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

Aby przeprowadzić testy sensor_fusion z użyciem modułu sensora fusion, wykonaj te czynności:

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

Plik konfiguracji config.yml z wieloma testbedami

Poniżej znajdziesz przykładowy plik config.yml z kilkoma platformami testowymi, platformą testową dla tabletów i platformą testową sensor_fusion. Odpowiednią platformę testową określają testowane sceny.

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

Plik konfiguracji ręcznego testowania config.yml

Poniżej znajdziesz przykładowy plik config.yml do ręcznego testowania. Od Androida 14 ręczne testowanie jest obsługiwane we wszystkich testach z wyjątkiem testów scene_extensions. W przypadku testów ręcznych nazwa testu musi zawierać słowo kluczowe MANUAL. Sekcja AndroidDevice nie może też zawierać sekcji numeru seryjnego ani etykiety dla tabletu.

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

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

Przeprowadzanie testów ITS

Z tej sekcji dowiesz się, jak przeprowadzać testy ITS.

Wywoływanie testów

Po skonfigurowaniu urządzenia, hosta (w tym środowiska) i sceny fizycznej uruchom testy ITS, korzystając z tego procesu.

  1. Otwórz aplikację CTS Verifer. W menu testów wybierz Camera ITS Test (Test ITS aparatu).

  2. Na komputerze-hoście uruchom testy ITS z katalogu CameraITS/. Na przykład w przypadku urządzenia z przednim i tylnym aparatem uruchom to polecenie:

    python tools/run_all_tests.py

    Skrypt przechodzi przez kamery i testuje sceny na podstawie pliku config.yml. Aby debugować konfiguracje, zalecamy uruchomienie jednej sceny scene2 z pojedynczym testem, aby uzyskać najszybszy czas realizacji.

    W przypadku testowania ręcznego, zanim rozpocznie się wykonywanie zestawu testów ITS w każdej scenie, skrypt robi zdjęcie bieżącej sceny, zapisuje je w formacie JPEG, drukuje ścieżkę do pliku JPEG w konsoli i prosi użytkownika o potwierdzenie, czy obraz jest odpowiedni. Ten proces przechwytywania i potwierdzania powtarza się, dopóki użytkownik nie potwierdzi, że obraz jest odpowiedni. Poniżej znajdują się komunikaty z tego procesu.

    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)

    Każde uruchomienie skryptu wypisuje log, w którym dla każdego testu ITS występuje wartość PASS, FAIL, FAIL* lub SKIP. FAIL* oznacza, że test się nie powiódł, ale ponieważ nie jest on jeszcze wymagany, raport zostanie wysłany do CtsVerifier jako PASS. SKIP wskazuje, że test został zaliczony, ponieważ urządzenie nie reklamowało testowanej funkcji. Jeśli na przykład urządzenie nie reklamuje się za pomocą interfejsów aparatu, że obsługuje format DNG, testy związane z przechwytywaniem plików DNG są pomijane i liczone jako PASS.

  3. Aby potwierdzić, że testy spełniają wymagania, kliknij zielony przycisk wyboru. Wpis Camera ITS Test w menu testów CTS Verifier zmieni kolor na zielony, co oznacza, że telefon przeszedł test ITS aparatu.

Testowanie równoległe DUT

Urządzenia z Androidem 14 lub nowszym obsługują równoległe testowanie DUT. Umożliwia to testowanie DUT równolegle na wielu platformach, co przyspiesza ogólne testowanie. Na przykład równoległe testowanie umożliwia jednoczesne testowanie kamery 0 w jednym układzie i kamery 1 w innym układzie. Wszystkie testy równoległych sesji testowych są agregowane w sesji weryfikatora CTS na referencyjnym urządzeniu testowym. Testowanie równoległe musisz przeprowadzać z użyciem sterowania oświetleniem Arduino, ponieważ ręczne sterowanie oświetleniem nie jest obsługiwane w przypadku testowania równoległego. Upewnij się, że oświetlenie każdego urządzenia steruje innym kanałem tego samego kontrolera Arduino.

Poniżej znajduje się przykładowy plik config.yml, który definiuje 3 platformy testowe do uruchamiania równolegle.

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"

Aby uruchomić platformy testowe równolegle, użyj tego polecenia:

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

Model szumu DNG

Urządzenia, które reklamują możliwość robienia zdjęć w formacie RAW lub DNG, muszą podawać model szumów w metadanych każdego zdjęcia w formacie RAW. Ten model szumów musi być wbudowany w bibliotece HAL aparatu dla każdego aparatu (np. przedniego i tylnego) na urządzeniu, które twierdzi, że obsługuje tę funkcję.

Implementacja modelu szumu

Aby zaimplementować model szumu, wykonaj te czynności, aby wygenerować model szumu i osadzać go w bibliotece HAL aparatu.

  1. Aby wygenerować model szumu dla każdej kamery, uruchom skrypt dng_noise_model.py w katalogu tools. Wyświetli to fragment kodu C. Więcej informacji o konfigurowaniu aparatu i środowiska do wykonywania zdjęć znajdziesz w dokumentach DngNoiseModel.pdf w katalogu tools.

  2. Aby zaimplementować model szumu na urządzeniu, wklej fragment kodu C do interfejsu HAL aparatu.

Weryfikacja modelu szumu

Automatyczny test ITS tests/scene1_1/test_dng_noise_model.py sprawdza model szumu, weryfikując, czy wartości szumu dla ekspozycji i wzmocnienia ujęte w danych z aparatu są prawidłowe.