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

Kamera IT

Camera Image Test Suite (ITS) to platforma do testowania zdjęć utworzonych przez aparat z Androidem. Ogólnym celem każdego testu w ITS jest skonfigurowanie kamery 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 w trakcie testowania

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 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/, znajdziesz na najwyższym poziomie skompresowanego folderu android-cts-verifier.

Konfiguracja hosta

ITS wymaga, aby host był podłączony do urządzenia DUT przez USB, mógł używać ADB do sterowania urządzeniami i komunikacji oraz musi mieć zainstalowane 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 mieć pewność, że będzie on obsługiwał 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 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ć platformę testową Mobly, uruchom polecenie:

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 konfiguracji ITS-in-a-box dla kamery, która ułatwia automatyzację, zwiększa niezawodność i efektywność testów. Testowe zestawy ITS-in-a-box obsługują wszystkie wymagania dotyczące oświetlenia, wyśrodkowania i zmiany wykresów w ITS. Ponadto do testowania rozszerzeń kamery wymagany jest pakiet ITS.

W przypadku testowania ręcznego:

DUT 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.
Urządzenie DUT 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ł 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

Korzystając z platformy Mobly, musisz utworzyć plik konfiguracji config.yml, aby zdefiniować środowisko testowe 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ć łóżko testowe, uruchom polecenie 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 wierszu poleceń są 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=1 scenes=2,1,0

Plik sensor_fusion scene config.yml

Poniżej znajdziesz przykładowy plik config_yml do testów sensor_fusion. Aby przeprowadzić test sensor_fusion, słowo kluczowe SENSOR_FUSION musi się znajdować 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 config.yml dla wielu testówbeds

Poniżej znajdziesz przykładowy plik config.yml z wieloma łóżkami testowymi, zestawem do testowania na tablecie i miejscem do testowania 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 config.yml do testowania ręcznego

Poniżej znajdziesz przykładowy plik config.yml do testowania ręcznego. 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 słowo kluczowe MANUAL musi znajdować się w nazwie urządzenia testowego. Poza tym sekcja AndroidDevice nie może zawierać sekcji numeru seryjnego ani etykiety tabletu.

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

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

Przeprowadzanie testów ITS

W 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 jednym testem, aby uzyskać najszybszy czas realizacji.

Aby przeprowadzić testy ręczne, przed rozpoczęciem zestawu testów ITS każdej sceny skrypt wykonuje zdjęcie bieżącej sceny, zapisuje ją jako plik JPEG, drukuje w konsoli ścieżkę do pliku JPEG i pyta użytkownika o potwierdzenie, czy obraz jest prawidłowy. Proces rejestrowania i potwierdzania procesu zapętla się, dopóki użytkownik nie potwierdzi, że obraz jest prawidłowy. Poniżej znajdziesz komunikaty wyświetlane w ramach 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 powoduje wydruk logowania, w którym dla każdego testu ITS występuje wartość PASS, FAIL, FAIL* lub SKIP. FAIL* wskazuje na niepowodzenie, ale ponieważ test nie jest jeszcze wymagany, test zostanie zgłoszony 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.
Aby potwierdzić, że testy spełniają wymagania, kliknij zielony przycisk wyboru. Wpis Test ITS aparatu w menu testów narzędzia CTS Verifier stanie się 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. 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 reklamujące możliwość zapisywania plików RAW lub DNG muszą zawierać model szumu w metadanych wyniku przechwytywania każdego nieprzetworzonego ujęcia. Ten model szumu musi być umieszczony w panelu HAL każdej kamery urządzenia (np. przedniego i tylnego) urządzenia, które obsługuje dane.

Implementacja modelu szumu

Aby wdrożyć model szumu, wykonaj te czynności, aby wygenerować model szumu i umieścić go w HAL aparatu.

Aby wygenerować model szumu dla każdej kamery, uruchom skrypt dng_noise_model.py w katalogu tools. Powoduje to wyświetlenie fragmentu 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, 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ętych w danych z aparatu są prawidłowe.