Od 27 marca 2025 r. zalecamy używanie android-latest-release zamiast aosp-main do kompilowania i wspołtworzenia AOSP. Więcej informacji znajdziesz w artykule o zmianach w AOSP.

Ta strona została przetłumaczona przez Cloud Translation API.

Omówienie ITS aparatu

Zestaw testów obrazów z kamery (ITS) to platforma do przeprowadzania testów obrazów generowanych 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 weryfikatora CTS 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 fotografowana przez aparat

Konfiguracja testowanego urządzenia

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

Połącz DUT z maszyną hosta za pomocą kabla USB.
Przyznaj hostowi uprawnienia dostępu do DUT przez ADB.
Zainstaluj na urządzeniu aplikację CTS Verifier (CtsVerifier.apk). Więcej informacji znajdziesz w artykule Korzystanie z weryfikatora CTS.
```
extract root/out/host/linux-x86/cts-verfier/android-cts-verifier.zip
cd android-cts-verifier
adb install -r -g CtsVerifier.apk
```
Uwaga: jeśli instalujesz aplikację z pakietu CTS Verifier (android-cts-verifier.zip), a nie z pełnego drzewa źródłowego Androida, zarówno CtsVerifier.apk, jak i katalog CameraITS/ znajdują się na najwyższym poziomie spakowanego folderu android-cts-verifier.
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 komputer hosta był połączony z DUT przez USB, mógł używać ADB do sterowania urządzeniem i komunikacji z nim oraz miał 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. Aby zapewnić obsługę zgodnych wersji, zalecamy używanie pakietu dystrybucyjnego Pythona. 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 i nowszych musi być zainstalowany framework testowy 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 skonfigurowania scen zalecamy użycie konfiguracji Camera ITS-in-a-box, która ułatwia automatyzację, zapewnia niezawodność i wydajność testów. 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).
DUT jest połączony z maszyną hosta za pomocą kabla USB.
Urządzenie DUT nie porusza się podczas testu.
Scena jest oświetlona stałym, nie migoczącym źródłem światła. (Nie używaj świetlówki, ponieważ powoduje ona migotanie).

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

Telefon musi być ustawiony tak, aby aparat robił zdjęcia bez obracania. Najłatwiej sprawdzić to na scenach z twarzami w scenie 2. Większość telefonów jest w orientacji poziomej, a aparat tylny jest skierowany w stronę przeciwną do ruchu wskazówek zegara, a aparat przedni – w stronę zgodną 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 narzędzie 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 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 w nazwie platformy testowej musi występować słowo kluczowe SENSOR_FUSION. 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. Od Androida 14 testowanie ręczne jest obsługiwane w przypadku 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.

Otwórz aplikację CTS Verifier. W menu testów wybierz Camera ITS Test (Test ITS aparatu).
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 testów ręcznych przed rozpoczęciem wykonywania zestawu testów ITS w każdej scenie skrypt robi zdjęcie bieżącej sceny, zapisuje je jako plik JPEG, wyświetla ścieżkę do pliku JPEG w konsoli i prosi użytkownika o potwierdzenie, czy obraz jest prawidłowy. Ten proces robienia i potwierdzania zdjęć jest powtarzany, dopóki użytkownik nie potwierdzi, że obraz jest prawidłowy. 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.
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ł test 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ń w wielu stanowiskach równolegle, 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 weryfikatora CTS 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ównoległego.

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 zdjęć 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 wdrożyć model szumu, wykonaj te czynności, aby wygenerować model szumu i osadzić go w warstwie HAL aparatu.

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 aparatu i środowiska przechwytywania znajdziesz w dokumencie DngNoiseModel.pdf w katalogu tools.
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 ujęcia podane w danych z aparatu są prawidłowe.