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

Kamera IT

Camera Image Test Suite (ITS) to platforma do przeprowadzania testów zdjęć. generowany przez aparat Androida. Ogólnym celem każdego testu w ITS jest skonfigurować kamerę w określony sposób, nagrać jedno lub kilka ujęć, sprawdzić, czy zawierają one właściwe dane. 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 w trakcie testowania (DUT)
hosta (np. komputer stacjonarny lub laptop z systemem Linux).
Scena fotografowana przez aparat

Konfiguracja urządzenia w fazie testów (DUT)

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

Podłącz DUT do hosta przez USB.
Przyznaj hostowi dostęp do urządzenia DUT przez ADB.
Zainstaluj aplikację CTS Verifier (CtsVerifier.apk) na urządzeniu. Więcej Więcej informacji znajdziesz w artykule Using CTS Verifier (Używanie 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: w przypadku instalowania aplikacji z pakietu CTS Verifier (android-cts-verifier.zip), a nie z pełnego drzewa źródłowego Androida, zarówno katalog CtsVerifier.apk, jak i katalog CameraITS/ znajdziesz w 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ć hosta, upewnij się, że masz zainstalowane następujące oprogramowanie.

Narzędzia platformy Android SDK

Narzędzia platformy Android SDK muszą być zainstalowane i interfejs ADB musi być w interfejsie ścieżka pliku wykonywalnego powłoki lub terminala uruchomionego na hoście na komputerze. W przypadku opublikowanych publicznie wersji narzędzi Android SDK Platform: zobacz Informacje o wersji Narzędzi platformy SDK

Python

Na hoście 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.

Moble

W przypadku Androida 12 i nowszych platform testowych Mobly musi być zainstalowana. Mobly pozwala skonfigurować urządzenie DUT i tablet do wykresu 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 nie gdy w terminalu zostaną wyświetlone błędy, środowisko jest gotowe do uruchomienia ITS testów.

Konfiguracja sceny

Do skonfigurowania scen zalecamy skorzystanie z Indywidualna konfiguracja kamery dla łatwość automatyzacji, niezawodność i wydajność testów. Infrastruktura ITS w pudełku sprzęty testowe obsługują wszystkie wymagania dotyczące zmiany oświetlenia, wycentrowania i wykresów dla ITS. Dodatkowo do rozszerzenia do aparatu i testowania.

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 testowy ITS wyświetlić monity o zmianę konfiguracji sceny przed rozpoczęciem testów na nowym scena).
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 testowy ITS wyświetla prośbę o zmianę sceny konfiguracji 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 to sprawdzić, używając sceny z twarzami w scen2. Większość telefonów ma orientację poziomą i a telefon obrócił się w lewo, a tylny aparat – w prawo. przednim aparatem.

Pliki konfiguracji

Korzystając z platformy Mobly, musisz utworzyć plik konfiguracji config.yml, aby: i określić platformę Mobly. Poniżej znajdziesz przykłady różnych zastosowań.

Plik config.yml scen dla tabletów

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ć łóżko testowe, uruchom polecenie tools/run_all_tests.py. Jeśli nie ma polecenia wartości wierszy określające kamery lub sceny, test jest przeprowadzany za pomocą parametru config.yml wartości plików. Jeśli w wierszu poleceń są wartości przypisane do kamer lub scen, zastąp 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 config.yml sceny sensor_fusion

Poniżej znajdziesz przykładowy plik config_yml dla testów sensor_fusion. Aby można było przeprowadzić testy sensor_fusion, słowo kluczowe SENSOR_FUSION musi znajdować się w pomieszczeniu testowym imię i nazwisko. 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 uruchomić sensor_fusion testów za pomocą sensor fusion box, uruchom:

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 znajduje się przykładowy plik config.yml z wieloma łóżkami testowymi, na tablecie i 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 Android 14, instrukcja jest obsługiwane we wszystkich testach oprócz scene_extensions testów. 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łuję testy

Po urządzeniu hostujący komputer (w tym środowisko) oraz scena fizyczna przeprowadź testy ITS, korzystając z poniższego procesu.

Otwórz aplikację CTS Verifer. W menu testów wybierz Test kamery IT.
Na hoście uruchom testy ITS w: CameraITS/ katalogu. Na przykład w przypadku urządzenia z przednim i tylnym aparatem uruchom następujące polecenie:
```
python tools/run_all_tests.py
```
Scenariusz jest powtarzany przez kamery i sceny testowe na podstawie 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)
```
Po każdym uruchomieniu skryptu generowany jest dziennik zawierający elementy PASS, FAIL, FAIL* lub SKIP dla każdego testu ITS. FAIL* oznacza niepowodzenie testu ale ponieważ test nie jest jeszcze wymagany, zostanie zgłoszony jako PASS do CtsVerifier. SKIP oznacza, że test został zaliczony, ponieważ urządzenie nie reklamowało podstawowych funkcji, które są testowane. Dla: Jeśli na przykład urządzenie nie reklamuje się za pomocą interfejsów aparatu, obsługuje DNG, testy związane z przechwytywaniem tych plików są pomijane i zliczane. jako PASS.
Aby potwierdzić, że testy spełniają wymagania, kliknij zielony przycisk znacznika 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.

Równoległe testowanie 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 inny adres na tym samym kontrolerze 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 równolegle uruchamiać sale testowe, 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 wdrożyć model szumu, wykonaj te czynności, aby wygenerować model szumu umieść model w HAL aparatu.

Aby wygenerować model szumu dla każdej kamery, uruchom dng_noise_model.py skrypt w katalogu tools. Powoduje to wyświetlenie fragmentu 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.