Omówienie ITS aparatu

Camera Image Test Suite (ITS) to platforma do przeprowadzania testów na obrazach wygenerowanych przez aparat 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 zawierają one oczekiwane dane obrazu. Wiele testów wymaga skierowania kamery na konkretną kartę testową lub oświetlenia jej z określoną intensywnością.

ITS znajduje się w platformie testowej CTS Verifier w cts/apps/CameraITS. Urządzenia muszą przejść testy ITS odpowiadające obsługiwanym funkcjom reklamowanym przez platformę aparatu dla aplikacji innych firm jako podzbiór CTS.

Konfiguracja

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

• Urządzenie testowe
• maszyna hosta (np. komputer stacjonarny lub laptop z systemem Linux);
• scena, którą fotografuje aparat;

Konfiguracja testowanego urządzenia

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

1. Połącz DUT z maszyną hosta za pomocą kabla 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 Korzystanie z CTS Verifier.

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

4. Na testowanym urządzeniu uruchom domyślną aplikację aparatu i zamknij wszystkie okna, które pojawią się po uruchomieniu, aby uniknąć zakłóceń podczas testowania.

Konfiguracja hosta

ITS wymaga, aby urządzenie hosta było połączone z DUT przez USB, mogło używać ADB do sterowania urządzeniem i komunikacji z nim oraz miało zainstalowane wymagane oprogramowanie.

Aby skonfigurować komputer hosta, upewnij się, że zainstalowane jest na nim to oprogramowanie.

Android SDK Platform Tools

Narzędzia platformy Android SDK muszą być zainstalowane, a ADB musi znajdować się w ścieżce wykonywalnej powłoki lub terminala działającego na komputerze hosta. Informacje o wersji narzędzi platformy Android SDK udostępnionej publicznie znajdziesz w informacjach o wersji narzędzi platformy SDK.

Python

Na komputerze hosta musi być zainstalowany język Python. Zalecamy używanie pakietu dystrybucyjnego Pythona, aby mieć pewność, że obsługiwane są zgodne wersje. Szczegółowe informacje o tym, które wersje Pythona i pakietów należy zainstalować w przypadku konkretnej wersji, znajdziesz w informacjach o wersji Camera ITS.

Mobly

W przypadku Androida 12 lub nowszego zainstaluj platformę testową Mobly. Mobly umożliwia skonfigurowanie DUT i tabletu z wykresem w its_base_test. Aby zainstalować platformę testową Mobly, uruchom to polecenie:

pip install mobly

Konfigurowanie ś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 uruchomienia testów ITS.

Konfiguracja sceny

Do konfigurowania scen zalecamy używanie konfiguracji Camera ITS-in-a-box, która zapewnia łatwość automatyzacji, niezawodność i wydajność testowania. Stanowiska testowe ITS-in-a-box spełniają wszystkie wymagania ITS dotyczące oświetlenia, centrowania i zmiany wykresów. Do testowania rozszerzeń aparatu wymagany jest też zestaw ITS-in-a-box.

W przypadku testowania ręcznego upewnij się, że:

• Urządzenie jest umieszczone na statywie.
• Urządzenie jest skierowane na odpowiednią scenę w przypadku każdego testu. Skrypt testu ITS zawiera instrukcje dotyczące zmiany konfiguracji sceny przed rozpoczęciem testów w nowej scenie.
• Urządzenie jest połączone z komputerem hosta za pomocą kabla USB.
• Urządzenie nie porusza się podczas testu.
• Scena jest oświetlona stałym, nie migającym źródłem światła. (Nie używaj świetlówki, ponieważ powoduje ona migotanie).

Scenariusz testowania ITS wyświetla prośbę o zmianę konfiguracji sceny przed rozpoczęciem testów w nowej scenie.

Orientacja telefonu musi być ustawiona tak, aby aparat robił zdjęcia bez obracania. Najłatwiej sprawdzić to na scenach z twarzami w scenie 2. W większości telefonów urządzenie jest w orientacji poziomej, a tylny aparat jest obrócony w kierunku przeciwnym do ruchu wskazówek zegara, a przedni – w kierunku zgodnym z ruchem wskazówek zegara.

Pliki konfiguracji

Za pomocą platformy Mobly musisz utworzyć plik konfiguracji config.yml, aby zdefiniować platformę testową Mobly. Poniżej znajdziesz przykłady różnych przypadków użycia.

Plik Tablet-based scenes config.yml

Poniżej znajdziesz przykład pliku config.yml dla scen na tabletach. W przypadku testów na tabletach w nazwie platformy testowej musi się znajdować słowo kluczowe TABLET. Podczas inicjowania program do uruchamiania testów Mobly inicjuje 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ć platformę testową, uruchom polecenie tools/run_all_tests.py. Jeśli nie ma wartości wiersza poleceń określających kamery lub sceny, test jest przeprowadzany z wartościami pliku config.yml. Jeśli w wierszu poleceń znajdują się wartości dotyczące kamer lub scen, zastępują one wartości w sekcji TestParams pliku config.yml. Na 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=0 scenes=scene_tele
python tools/run_all_tests.py camera=0.4 scenes=4,scene6_tele

plik sensor_fusion scene config.yml

Poniżej znajdziesz przykład pliku config_yml do testów sensor_fusion. W przypadku testów sensor_fusion słowo kluczowe SENSOR_FUSION musi znajdować się w nazwie platformy testowej. Android 13 i nowsze wersje obsługują tylko kontroler Arduino do fuzji czujnikó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 uruchomić testy sensor_fusion za pomocą urządzenia do fuzji czujników, wykonaj to polecenie:

python tools/run_all_tests.py scenes=sensor_fusion
python tools/run_all_tests.py scenes=sensor_fusion camera=0
python tools/run_all_tests.py scenes=scene_flash,feature_combination
python tools/run_all_tests.py scenes=checkerboard camera=1

Plik config.yml z wieloma platformami testowymi

Poniżej znajdziesz przykład pliku config.yml z kilkoma platformami testowymi, platformą testową na tablecie i platformą testową sensor_fusion. Odpowiednie środowisko testowe jest określane na podstawie testowanych scen.

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 config.yml testów ręcznych

Poniżej znajdziesz przykładowy plik config.yml do testowania ręcznego. Android 14 i nowsze wersje obsługują testowanie ręczne wszystkich testów z wyjątkiem testów scene_extensions. W przypadku testów ręcznych nazwa platformy testowej musi zawierać słowo kluczowe MANUAL. Sekcja AndroidDevice nie może też zawierać sekcji z numerem seryjnym ani etykietą w przypadku tabletu.

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

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

Plik Gen2 rig testing config.yml

Poniżej znajdziesz przykładowy plik config.yml platformy testowej TEST_BED_GEN2. To stanowisko testowe jest używane do scene_ip testów, które wykorzystują platformę Gen2](/docs/compatibility/cts/camera-its-box-gen2). Poniższy przykład pokazuje parametry stanowiska testowego, gdy platforma Gen2 jest dostępna, a testy scene_ip nie są pomijane.

Testbeds
  - Name: TEST_BED_GEN2
    # Test configuration for scene_ip/test_default_jca_ip.py
    Controllers:
        AndroidDevice:
          - serial: <device-id>  # quotes needed if serial id entirely numeric
            label: dut
    TestParams:
      debug_mode: "False"  # quotes are needed here
      chart_distance: 30
      rotator_cntl: gen2_rotator   # gen2 rig specific. "None" if gen2 rig not available
      rotator_ch: 0
      camera: <camera-id>
      foldable_device: "False"  # "True" if testing foldable device
      tablet_device: "False"  # "True" if testing tablet device
      lighting_cntl: gen2_lights  # gen2 rig specific. "None" if gen2 rig not available
      lighting_ch: 1
      scene: scene_ip

Ten przykład pokazuje parametry platformy testowej, gdy platforma Gen2 jest niedostępna, a testy scene_ip są pomijane.

Testbeds
  - Name: TEST_BED_GEN2
    # Test configuration for scene_ip/test_default_jca_ip.py
    Controllers:
        AndroidDevice:
          - serial: <device-id>  # quotes needed if serial id entirely numeric
            label: dut
    TestParams:
      debug_mode: "False"  # quotes are needed here
      chart_distance: 30
      rotator_cntl: "None"   # gen2 rig specific. "None" if gen2 rig not available
      rotator_ch: <controller-channel>
      camera: <camera-id>
      foldable_device: "False"  # "True" if testing foldable device
      tablet_device: "False"  # "True" if testing tablet device
      lighting_cntl: "None"  # gen2 rig specific. "None" if gen2 rig not available
      lighting_ch: <controller-channel>
      scene: scene_ip

Aby uruchomić test scene_ip, użyj jednego z tych poleceń:

python tests/scene_ip/test_default_jca_ip.py -c config.yml
python tools/run_all_tests.py camera=<camera-id> scenes=scene_ip

Przeprowadzanie testów ITS

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

Wywoływanie testów

Po skonfigurowaniu urządzenia, hosta (wraz ze środowiskiem) i sceny fizycznej uruchom testy ITS, wykonując te czynności.

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

2. Na komputerze hosta 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 iteruje kamery i sceny testowe na podstawie pliku config.yml. W przypadku konfiguracji debugowania zalecamy uruchomienie jednej ze scen scene2 z pojedynczym testem, aby uzyskać najszybsze wyniki.

   W przypadku testowania ręcznego przed rozpoczęciem wykonywania zestawu testów ITS w każdej scenie skrypt robi zdjęcie bieżącej sceny, zapisuje je jako plik JPEG, drukuje ścieżkę do pliku JPEG w konsoli i prosi użytkownika o potwierdzenie, czy obraz jest w porządku. Ten proces robienia i potwierdzania zdjęć jest powtarzany, dopóki użytkownik nie potwierdzi, że obraz jest w porządku. Poniżej znajdziesz komunikaty wyświetlane w tym procesie.

   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 powoduje wydrukowanie logu z informacją PASS, FAIL, FAIL* lub SKIP dla każdego testu ITS. FAIL* oznacza, że test się nie powiódł, ale ponieważ nie jest on jeszcze wymagany, CtsVerifier zgłosi go jako PASS. Symbol SKIP oznacza, że test został zaliczony, ponieważ urządzenie nie reklamowało testowanej funkcji. Jeśli na przykład urządzenie nie reklamuje za pomocą interfejsów aparatu, że obsługuje format DNG, testy związane z rejestrowaniem plików DNG są pomijane i liczone jako PASS.

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

Równoległe testowanie urządzeń

Urządzenia z Androidem 14 lub nowszym obsługują równoległe testowanie DUT. Umożliwia to testowanie urządzeń równolegle na wielu stanowiskach, co przyspiesza ogólny proces testowania. Na przykład testowanie równoległe umożliwia jednoczesne testowanie kamery 0 na jednym stanowisku i kamery 1 na innym. Wszystkie testy w sesjach testów równoległych są agregowane w sesji CTS Verifier na referencyjnym urządzeniu DUT. Musisz przeprowadzić testy równoległe z użyciem sterowania oświetleniem Arduino, ponieważ ręczne sterowanie oświetleniem nie jest obsługiwane w przypadku testów równoległych. Upewnij się, że oświetlenie każdego stanowiska jest sterowane przez inny kanał na tym samym kontrolerze Arduino.

Poniżej znajdziesz przykładowy plik config.yml, który definiuje 3 platformy testowe do uruchomienia 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ść rejestrowania obrazów w formacie RAW lub DNG, muszą podawać model szumu w metadanych wyniku rejestrowania każdego zdjęcia w formacie RAW. Ten model szumu musi być wbudowany w HAL aparatu dla każdego aparatu (np. przedniego i tylnego) na urządzeniu, które deklaruje obsługę.

Implementacja modelu szumu

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

1. Aby wygenerować model szumu dla każdego aparatu, uruchom skrypt dng_noise_model.py w katalogu tools. Wygeneruje to fragment kodu w języku C. Więcej informacji o konfigurowaniu kamery i środowiska do rejestrowania znajdziesz w dokumencie DngNoiseModel.pdf w katalogu tools.

2. Aby wdrożyć model szumu na urządzeniu, wytnij i wklej fragment kodu C do 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 podane w danych aparatu są prawidłowe.