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.

ITS kamery

Pakiet testów obrazu z kamery (ITS) to platforma do testowania 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 1 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.

Skonfiguruj

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

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

Połącz urządzenie DUT z hostem przez 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 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
```
Uwaga: jeśli instalujesz aplikację z pakietu weryfikatora CTS (android-cts-verifier.zip), a nie z pełnego drzewa źródłowego Androida, zarówno katalog CtsVerifier.apk, jak i CameraITS/ znajdziesz na najwyższym poziomie spakowanego folderu android-cts-verifier.
Na urządzeniu testowanym otwórz domyślną aplikację aparatu i zamknij wszystkie okna, które pojawiają się po uruchomieniu, aby uniknąć zakłóceń podczas testowania.

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 do testowania rozszerzeń aparatu wymagane jest ITS-in-a-box.

W przypadku testowania ręcznego:

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 komunikat 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ł obrazu. Najłatwiej sprawdzić to za pomocą scen z twarzy w scenie2. Większość telefonów ma orientację poziomą, a telefon obraca się 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ć test bed, 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. 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ładowy plik config_yml do testów sensor_fusion. W przypadku testowania sensor_fusion słowo kluczowe SENSOR_FUSION musi znajdować się w nazwa testbed. 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 modułem sensorów, wykonaj te czynności:

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 testbedami

Poniżej znajdziesz przykładowy plik config.yml z kilkoma platformami testowymi, platformą testową tabletu 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ęcznej 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

Plik config.yml do testowania platformy Gen2

Poniżej znajduje się przykładowy plik config.yml z testami TEST_BED_GEN2. Ta platforma testowa jest używana do testów scene_ip, które wykorzystują platformę Gen2](/docs/compatibility/cts/camera-its-box-gen2). Ten przykład przedstawia parametry testowego środowiska, gdy dostępne jest urządzenie Gen2 i 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 testowego stanowiska, gdy platforma Gen2 jest niedostępna i 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 (w tym środowiska) i sceny fizycznej uruchom testy ITS, korzystając z tego procesu.

Otwórz aplikację CTS Verifer. W menu testów wybierz Camera ITS Test (Test ITS aparatu).
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 testów ręcznych, 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 w ramach 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* wskazuje, że test się nie powiódł, ale ponieważ nie jest on jeszcze wymagany, raport z niego będzie miał status PASS w CtsVerifier. 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.
Aby potwierdzić, że testy spełniają wymagania, kliknij zielony przycisk wyboru. Wpis Test ITS aparatu 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 DUT. Testy równoległe musisz przeprowadzać 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 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 dotyczących wyniku 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.

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.
Aby zaimplementować model szumu na urządzeniu, skopiuj i 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.