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
Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

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 kamery w określony sposób, zrobienie co najmniej jednego zdjęcia i sprawdzenie, czy zawiera ono oczekiwane dane obrazu. Wiele z tych wymagają, aby kamera była kierowana na określony wykres docelowy lub o określonej intensywności.

Zespół ITS znajduje się w urządzeniu testowym CTS Verifier cts/apps/CameraITS Urządzenia muszą przejść testy ITS dotyczące obsługiwanych funkcji reklamowane przez platformę 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, którą aparat robi

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 dostęp do urządzenia DUT przez ADB.
Zainstaluj aplikację CTS Verifier (CtsVerifier.apk) na urządzeniu. 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: w przypadku instalowania aplikacji z pakietu CTS Verifier (android-cts-verifier.zip), a nie z pełnego drzewa źródłowego Androida, Katalog CtsVerifier.apk i CameraITS/ znajdziesz na stronie najwyższego poziomu skompresowanego folderu android-cts-verifier.

Konfiguracja hosta

ITS wymaga, aby host był podłączony do DUT przez USB, używać ADB do sterowania urządzeniami i komunikacji oraz ma zainstalowane 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óra jest uruchamiana na maszynie hosta. W przypadku publicznie dostępnych wersji narzędzi Android SDK Platform: zobacz Informacje o wersji Narzędzi platformy SDK

Python

Na komputerze hosta musi być zainstalowany Python. Zalecamy korzystanie z pakietu Dystrybucja Pythona w celu zapewnienia obsługi zgodnych wersji. Więcej informacji: które wersje Pythona i pakietów warto zainstalować dla danej wersji, zapoznaj się z Informacje o wersji odpowiedniej wersji Camera ITS.

Mobly

W przypadku Androida 12 lub nowszego musisz zainstalować framework testowy Mobly. Mobly pozwala skonfigurować urządzenie DUT i tablet z listą wykresów its_base_test zajęcia. Aby zainstalować platformę testową Mobly, uruchom polecenie:

pip install mobly

Konfiguracja środowiska

Aby skonfigurować środowisko testowe, uruchom polecenie:

cd CameraITS
source build/envsetup.sh

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

Konfiguracja sceny

Do skonfigurowania scen zalecamy skorzystanie z Indywidualna konfiguracja kamery dla łatwość automatyzacji, niezawodność i wydajność 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 ITS-in-a-box jest wymagany do testowania rozszerzeń aparatu.

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

DUT jest na statywie
W przypadku każdego testu urządzenie DUT jest kierowane na właściwą scenę. (skrypt testu ITS zawiera prompty dotyczące zmiany konfiguracji sceny przed rozpoczęciem testów w nowej scenie).
Urządzenie DUT jest podłączone do hosta przez USB.
Urządzenie DUT nie porusza się podczas testu.
Scena jest oświetlona stałym, niezmieniającym się źródłem światła. (Nie należy użyj światła fluorescencyjnego, ponieważ powoduje to 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 mógł robić zdjęcia bez i rotacji. Najłatwiej sprawdzić to za pomocą scen z twarzy w scenie2. Większość telefonów ma orientację poziomą i a telefon obrócił się w lewo, a tylny aparat – w prawo. przednim aparatem.

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 scen tworzonych na tablecie. Dla: na tabletach, w nazwie miejsca testowego musi znajdować się słowo kluczowe TABLET. W trakcie program uruchamiający 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ć ś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. 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 dla testów sensor_fusion. W przypadku testowania sensor_fusion słowo kluczowe SENSOR_FUSION musi znajdować się w nazwach testowanych jednostek. Android 13 i nowsze obsługują tylko Arduino kontroler do czujnika fusion z powodu testowania wersji przedpremierowej 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 kilkoma platformami testowymi, platformą testową tabletu i platformą testową sensor_fusion. Ustalono właściwe łóżko testowe w trakcie testowania.

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

Test ręczny pliku config.yml

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. Aby można było przeprowadzić test ręczny, słowo kluczowe MANUAL musi znajdować się w nazwie pokoju testowego. Poza tym sekcja AndroidDevice nie może zawierać sekcji z serialem ani etykietą dla na tablecie.

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 następujące polecenie:
```
python tools/run_all_tests.py
```
Skrypt przechodzi przez kamery i testuje sceny na podstawie pliku config.yml. Do debugowania konfiguracji zalecamy uruchomienie jednej scene2 sceny w ramach jednego testu, który zapewnia jak najkrótszy czas realizacji.

Jeśli chcesz przeprowadzić testy ręczne, przed rozpoczęciem zestawu testów ITS na każdej scenie skrypt wykonuje zdjęcie bieżącej sceny, zapisuje ją jako plik JPEG, ścieżkę do pliku JPEG do konsoli i prosi użytkownika o potwierdzenie, jest w porządku. W ten sposób przechwyć i potwierdź pętlę przepływu do czasu, aż użytkownik potwierdza, że obraz jest prawidłowy. Poniżej znajdują się komunikaty 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 wydruk logowania, w którym dla każdego testu ITS występuje wartość PASS, FAIL, FAIL* lub SKIP. FAIL* oznacza niepowodzenie testu ale ponieważ test nie jest jeszcze wymagany, zostanie zgłoszony jako PASS do 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 Camera ITS Test (Test kamery ITS) w weryfikatorze CTS. menu testów zmienia kolor na zielony i oznacza, że telefon przeszła kontrolę ITS.

Testowanie równoległe DUT

Urządzenia z Androidem 14 lub nowszym obsługują tryb równoległy Testy DUT. Dzięki temu możesz testować urządzenia DUT równolegle z wieloma urządzeniami, aby osiągnąć odpowiednią szybkość do ogólnego testowania. Test równoległy pozwala np. przetestować kamerę 0 w jednym z zestawu 1 i kamery w innym zestawie. Wszystkie testy równoległe sesje testowe są agregowane z sesji CTS Verifiera w referencyjnym urządzeniu DUT. Musisz przeprowadzić testy równoległe za pomocą sterowania oświetleniem Arduino, korzystając z oświetlenia ręcznego wersja kontrolna nie jest obsługiwana 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 określa 3 pomieszczenia 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 reklamujące możliwość zapisywania plików RAW lub DNG muszą generować szum. model w metadanych wyników przechwytywania każdego nieprzetworzonego ujęcia. Ten model szumu musi być wbudowany w HAL każdej kamery (np. przedni czy tylny aparat) na urządzeniu, które ma odpowiednią 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. Dla: więcej informacji na temat konfigurowania aparatu i środowiska nagrywania, patrz dokument DngNoiseModel.pdf w katalogu tools.
Aby wdrożyć model szumu dla urządzenia, wytnij i wklej kod C do kodu HAL kamery.

Weryfikacja modelu szumu

tests/scene1_1/test_dng_noise_model.py automatyczny test ITS weryfikuje model szumu, sprawdzając, czy wartości szumu dla ekspozycji i wzmocnienia podanego w danych aparatu.