דף זה תורגם על ידי Cloud Translation API.

מצלמה ITS

Camera Image Test Suite‏ (ITS) הוא מסגרת לריצה של בדיקות על תמונות שנוצרו על ידי מצלמת Android. המטרה הכללית של כל בדיקה ב-ITS היא להגדיר את המצלמה באופן ספציפי, לצלם תמונה אחת או יותר ולבדוק אם הן מכילות את נתוני התמונה הצפויים. בחלק מהבדיקות צריך להפנות את המצלמה אל תרשים יעד ספציפי או להאיר אותה בעוצמה ספציפית.

ITS נמצא במערך הבדיקות של CTS Verifier ב-cts/apps/CameraITS. המכשירים חייבים לעבור את בדיקות ה-ITS שתואמות לתכונות הנתמכות שמפורסמות על ידי מסגרת המצלמה לאפליקציות של צד שלישי, כקבוצת משנה של CTS.

הגדרה

כדי להריץ בדיקות ITS, צריך להגדיר את הפריטים הבאים:

מכשיר לבדיקה (DUT)
מחשב מארח (למשל, מחשב שולחני או מחשב נייד עם Linux)
סצנה שהמצלמה מצלמת

הגדרת המכשיר לבדיקה (DUT)

כדי להגדיר DUT:

מחברים את ה-DUT למכונה המארחת באמצעות USB.
נותנים למארח הרשאות גישה ל-DUT דרך ADB.
צריך להתקין את האפליקציה CTS Verifier (CtsVerifier.apk) במכשיר. למידע נוסף, ראו שימוש ב-CTS Verifier.
```
extract root/out/host/linux-x86/cts-verfier/android-cts-verifier.zip
cd android-cts-verifier
adb install -r -g CtsVerifier.apk
```
הערה: אם מתקינים את האפליקציה מחבילת CTS Verifier (android-cts-verifier.zip) ולא מעץ מקור מלא של Android, אפשר למצוא את CtsVerifier.apk ואת הספרייה CameraITS/ ברמה העליונה של התיקייה הארוזת android-cts-verifier.

הגדרת המארח

כדי להשתמש ב-ITS, המחשב המארח צריך להיות מחובר ל-DUT באמצעות USB, להיות מסוגל להשתמש ב-ADB לשליטה ולתקשורת במכשיר, ולכלול את התוכנה הנדרשת.

כדי להגדיר את המכונה המארחת, צריך לוודא שהתוכנות הבאות מותקנות.

Android SDK Platform Tools

צריך להתקין את כלי הפלטפורמה של Android SDK, ו-ADB צריך להיות בנתיב ההפעלה של המעטפת או המסוף שפועלים במכונה המארחת. לגרסה הציבורית של כלי הפלטפורמה של Android SDK, אפשר לעיין בנתוני הגרסה של SDK Platform Tools.

Python

צריך להתקין את Python במכונה המארחת. מומלץ להשתמש בחלוקה של Python כדי להבטיח תמיכה בגרסאות תואמות. לפרטים על גרסאות ה-Python וגרסאות החבילה שצריך להתקין בשביל גרסה ספציפית, קראו את נתוני הגרסה של Camera ITS לגבי הגרסה המתאימה.

Mobly

ב-Android מגרסה 12 ואילך, צריך להתקין את מסגרת הבדיקה של Mobly. Mobly מאפשרת להגדיר טאבלט DUT וטאבלט תרשים במחלקה its_base_test. כדי להתקין את מסגרת הבדיקה של Mobly, מריצים את הפקודה:

pip install mobly

הגדרת סביבה

כדי להגדיר את סביבת הבדיקה, מריצים את הפקודה:

cd CameraITS
source build/envsetup.sh

הפקודה הזו בודקת את ההתקנה של Python, מגדירה את משתנה הסביבה PYTHONPATH ומריצה בדיקות יחידה במודולים utils/*.py. אם לא מודפסות שגיאות בטרמינל, הסביבה מוכנה להריץ את בדיקות ITS.

הגדרת סצנות

כדי להגדיר את הסצנות, מומלץ להשתמש בהגדרה של Camera ITS-in-a-box כדי להקל על האוטומציה, לשפר את המהימנות והיעילות של הבדיקה. ערכות הבדיקה של ITS-in-a-box תומכות בכל הדרישות של ITS לגבי תאורה, מרכוז ושינוי תרשימים. בנוסף, נדרשת ITS-in-a-box לבדיקה של תוספים למצלמה.

לבדיקות ידניות, צריך לוודא את הפרטים הבאים:

מכשיר ה-DUT מונח על חצובה
מכשיר ה-DUT מכוון לזירת הבדיקה הנכונה לכל בדיקה. (בסקריפט הבדיקה של ITS מופיעות הנחיות לשינוי הגדרות הסצנה לפני שמתחילים לבצע בדיקות בסצנה חדשה).
מכשיר ה-DUT מחובר למכונה המארחת באמצעות USB.
ה-DUT לא זז במהלך הרצת הבדיקה.
הסצנה מוארת במקור אור יציב ולא דולף. (אין להשתמש בתאורת פלורסנט כי היא גורמת לרטט).

סקריפט הבדיקה של ITS מציג בקשה למשתמש לשנות את הגדרת הסצנה לפני שהוא מתחיל את הבדיקות בסצנה חדשה.

צריך להגדיר את כיוון הטלפון כך שהמצלמה תצלם תמונות ללא רוטציה. הדרך הקלה ביותר לבדוק את זה היא באמצעות סצנות הפנים בסצנה 2. ברוב הטלפונים, הטלפון בכיוון אופקי, כשהמצלמה האחורית פונה לכיוון השעון ההפוך והמצלמה הקדמית פונה לכיוון השעון.

קובצי תצורה

באמצעות מסגרת Mobly, צריך ליצור קובץ תצורה config.yml כדי להגדיר את מיטת הבדיקה של Mobly. בהמשך מפורטות דוגמאות למקרים לדוגמה שונים.

קובץ config.yml של סצנות מבוססות-טאבלט

קובץ config.yml לדוגמה של סצנות לשימוש בטאבלטים: לבדיקות בטאבלט, מילת המפתח TABLET חייבת להופיע בשם של מיטת הבדיקה. במהלך ההפעלה, הכלי להרצת בדיקות של Mobly מפעיל את הפרמטרים בקובץ ומעביר אותם לבדיקות הנפרדות.

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

כדי להפעיל את מיטת הבדיקה, מריצים את הפקודה tools/run_all_tests.py. אם אין ערכים בשורת הפקודה שמציינים מצלמות או סצנות, הבדיקה מופעלת עם הערכים בקובץ config.yml. אם יש ערכים בשורת הפקודה למצלמות או לזירת צילום, הם מבטלים את הערכים בקטע TestParams בקובץ config.yml. לדוגמה:

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

קובץ config.yml של סצנה ב-sensor_fusion

קובץ config_yml לדוגמה לבדיקות sensor_fusion: לבדיקת sensor_fusion, מילת המפתח SENSOR_FUSION חייבת להופיע בשם של מצע הבדיקה. ב-Android 13 ואילך יש תמיכה רק ב-Arduino Controller למיזוג חיישנים, בגלל בדיקות של תצוגה מקדימה ויישור וידאו. ב-Android 12 יש תמיכה בבקרים של Arduino ו-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

כדי להריץ בדיקות sensor_fusion באמצעות sensor fusion box, מריצים את הפקודה:

python tools/run_all_tests.py scenes=sensor_fusion
python tools/run_all_tests.py scenes=sensor_fusion camera=0

קובץ config.yml למספר בדיקות

קובץ config.yml לדוגמה עם כמה מערכות בדיקה, מערכות בדיקה של טאבלטים ומערכות בדיקה של sensor_fusion. משטח הבדיקה הנכון נקבע לפי הסצנות שנבדקות.

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

קובץ config.yml לבדיקה ידנית

קובץ config.yml לדוגמה לבדיקה ידנית. מגרסה Android 14, יש תמיכה בבדיקות ידניות בכל הבדיקות, מלבד הבדיקות של scene_extensions. לבדיקות ידניות, מילת המפתח MANUAL חייבת להופיע בשם של מיטת הבדיקה. בנוסף, החלק AndroidDevice לא יכול לכלול קטע של מספר סידורי או תווית לטאבלט.

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

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

הרצת בדיקות ITS

בקטע הזה נסביר איך מריצים בדיקות ITS.

הפעלת בדיקות

אחרי שמגדירים את המכשיר, את המכונה המארחת (כולל הסביבה) ואת הסצנה הפיזית, מריצים את בדיקות ITS לפי התהליך הבא.

פותחים את אפליקציית CTS Verifer, בתפריט הבדיקות בוחרים באפשרות Camera ITS Test.
במכונה המארחת, מריצים את בדיקות ITS מהספרייה CameraITS/. לדוגמה, במכשיר עם מצלמה קדמית ומצלמה אחורית, מריצים את הפקודה הבאה:
```
python tools/run_all_tests.py
```
הסקריפט עובר על המצלמות ועל סצנות הבדיקה על סמך הקובץ config.yml. להגדרות של ניפוי באגים, מומלץ להריץ אחת מהסצנות של scene2 באמצעות בדיקה אחת, כדי להשיג את התוצאה המהירה ביותר.

בבדיקה ידנית, לפני שמתחילים להריץ את קבוצת הבדיקות של ITS בכל סצנה, הסקריפט מצלם את הסצנה הנוכחית, שומר אותה כקובץ JPEG, מדפיס את הנתיב לקובץ ה-JPEG במסוף ומבקש מהמשתמש לאשר שהתמונה תקינה. התהליך הזה של צילום ואישור חוזר על עצמו עד שהמשתמש מאשר שהתמונה תקינה. אלה ההודעות בתהליך הזה.
```
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)
```
בכל הפעלה של הסקריפט מודפס יומן שבו מוצגים הערכים PASS, ‏ FAIL,‏ FAIL* או SKIP לכל בדיקת ITS. הערך FAIL* מציין שהבדיקה נכשלה, אבל מכיוון שהבדיקה עדיין לא חובה, הבדיקה תדווח כ-PASS ל-CtsVerifier. הערך SKIP מציין שהבדיקה עברה כי המכשיר לא פרסם את היכולת הבסיסית שנבדקה. לדוגמה, אם המכשיר לא מפרסם דרך ממשקי המצלמה שהוא תומך ב-DNG, המערכת תדלג על הבדיקות שקשורות לצילום קובצי DNG ותספור אותן כ-PASS.
כדי לאשר שהבדיקות עברו את דרישות הבדיקה, מקישים על הלחצן עם סימן הווי הירוק. לאחר מכן הערך בדיקת ITS של המצלמה בתפריט הבדיקות של CTS Verifier הופך לירוק ומציין שהטלפון עבר את Camera ITS.

בדיקת DUT מקבילה

מכשירי Android מגרסה 14 ואילך תומכים בבדיקות DUT במקביל. כך אפשר לבדוק DUT במקביל עם מספר התקנים כדי לזרז את הבדיקה הכוללת. לדוגמה, בדיקה מקבילה מאפשרת לבדוק את מצלמה 0 במכשיר אחד ואת מצלמה 1 במכשיר אחר בו-זמנית. כל הבדיקות של סשנים מקבילים של בדיקות נצברות בסשן של CTS Verifier ב-DUT לדוגמה. עליכם להריץ בדיקה מקבילה עם בקרת תאורה של Arduino, כי אין תמיכה בבקרת תאורה ידנית בבדיקות מקבילות. חשוב לוודא ששידור של ערוץ אחר באותו בקר Arduino שולט בתאורה של כל ערכת צילום.

קובץ config.yml לדוגמה שמגדיר שלושה מיטות בדיקה להרצה במקביל:

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"

כדי להריץ את מיטות הבדיקה במקביל, משתמשים בפקודה הבאה:

for i in 0 1 2; do python3 tools/run_all_tests.py testbed_index=$i num_testbeds=3 & done; wait

מודל רעש DNG

במכשירים שמפרסמים את היכולת לצלם בפורמט RAW או DNG, צריך לספק מודל רעש במטא-נתונים של תוצאת הצילום של כל צילום בפורמט RAW. מודל הרעשי הזה צריך להיות מוטמע ב-HAL של המצלמה לכל מצלמה (לדוגמה, מצלמה קדמית ומצלמה אחורית) במכשיר שבו מצוין שיש תמיכה.

הטמעת מודל רעש

כדי להטמיע מודל רעש, צריך לפעול לפי השלבים הבאים כדי ליצור מודל רעש ולהטמיע את המודל ב-HAL של המצלמה.

כדי ליצור מודל רעש לכל מצלמה, מריצים את הסקריפט dng_noise_model.py בתיקייה tools. הפלט הוא קטע קוד ב-C. למידע נוסף על הגדרת המצלמה וסביבת הצילום, קראו את המסמך DngNoiseModel.pdf בספרייה tools.
כדי להטמיע את מודל הרעש במכשיר, חותכים את קטע הקוד ב-C ומדביקים אותו ב-HAL של המצלמה.

אימות מודל הרעש

בדיקת ה-ITS האוטומטית tests/scene1_1/test_dng_noise_model.py מאמתת את מודל הרעש על ידי בדיקה שערכי הרעש של החשיפות והרווחים שצוינו בנתוני המצלמה נכונים.