החל מ-27 במרץ 2025, מומלץ להשתמש ב-android-latest-release במקום ב-aosp-main כדי ליצור תרומות ל-AOSP. מידע נוסף זמין במאמר שינויים ב-AOSP.

דף זה תורגם על ידי 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.
כדי לאשר שהבדיקות עברו את דרישות הבדיקה, מקישים על הלחצן עם סימן הווי הירוק. לאחר מכן, הרשומה Camera ITS Test בתפריט הבדיקות של 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 מאמתת את מודל הרעש על ידי בדיקה שערכי הרעש של החשיפות והרווחים שצוינו בנתוני המצלמה נכונים.