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

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

סקירה כללית של Camera ITS

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

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

הגדרה

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

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

הגדרת המכשיר שנבדק (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 נמצא בנתיב ההפעלה של ה-Shell או הטרמינל שפועלים במחשב המארח. לגרסה שפורסמה לציבור של Android SDK Platform tools, אפשר לעיין בהערות לגבי גרסת 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 מוצגת הנחיה שמבקשת מהמשתמש לשנות את הגדרת הסצנה לפני שמתחילים בדיקות בסצנה חדשה.

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

קובצי תצורה

כדי להגדיר את סביבת הבדיקה של 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=0 scenes=scene_tele
python tools/run_all_tests.py camera=0.4 scenes=4,scene6_tele

קובץ sensor_fusion scene config.yml

קובץ config_yml לדוגמה לבדיקות sensor_fusion: בבדיקות sensor_fusion, מילת המפתח SENSOR_FUSION צריכה להופיע בשם של סביבת הבדיקה. ב-Android מגרסה 13 ואילך יש תמיכה רק בבקר Arduino לאיחוד נתוני חיישנים, בגלל בדיקות של תצוגה מקדימה וייצוב סרטונים. ‫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
python tools/run_all_tests.py scenes=scene_flash,feature_combination
python tools/run_all_tests.py scenes=checkerboard camera=1

קובץ 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

קובץ Gen2 rig testing config.yml

דוגמה לקובץ config.yml של סביבת בדיקה TEST_BED_GEN2: הסביבה הזו משמשת לבדיקות scene_ip, שמתבצעות באמצעות מערכת Gen2](/docs/compatibility/cts/camera-its-box-gen2). בדוגמה הבאה מוצגים הפרמטרים של סביבת הבדיקה כשהמערכת של Gen2 זמינה והבדיקות של scene_ip לא מדלגות.

Testbeds
  - Name: TEST_BED_GEN2
    # Test configuration for scene_ip/test_default_jca_ip.py
    Controllers:
        AndroidDevice:
          - serial: <device-id>  # quotes needed if serial id entirely numeric
            label: dut
    TestParams:
      debug_mode: "False"  # quotes are needed here
      chart_distance: 30
      rotator_cntl: gen2_rotator   # gen2 rig specific. "None" if gen2 rig not available
      rotator_ch: 0
      camera: <camera-id>
      foldable_device: "False"  # "True" if testing foldable device
      tablet_device: "False"  # "True" if testing tablet device
      lighting_cntl: gen2_lights  # gen2 rig specific. "None" if gen2 rig not available
      lighting_ch: 1
      scene: scene_ip

בדוגמה הבאה מוצגים פרמטרים של סביבת בדיקה כשמערכת Gen2 rig לא זמינה והבדיקות scene_ip מדלגות.

Testbeds
  - Name: TEST_BED_GEN2
    # Test configuration for scene_ip/test_default_jca_ip.py
    Controllers:
        AndroidDevice:
          - serial: <device-id>  # quotes needed if serial id entirely numeric
            label: dut
    TestParams:
      debug_mode: "False"  # quotes are needed here
      chart_distance: 30
      rotator_cntl: "None"   # gen2 rig specific. "None" if gen2 rig not available
      rotator_ch: <controller-channel>
      camera: <camera-id>
      foldable_device: "False"  # "True" if testing foldable device
      tablet_device: "False"  # "True" if testing tablet device
      lighting_cntl: "None"  # gen2 rig specific. "None" if gen2 rig not available
      lighting_ch: <controller-channel>
      scene: scene_ip

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

python tests/scene_ip/test_default_jca_ip.py -c config.yml
python tools/run_all_tests.py camera=<camera-id> scenes=scene_ip

הרצת בדיקות ITS

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

הפעלת בדיקות

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

פותחים את האפליקציה CTS Verifier. בתפריט הבדיקות, בוחרים באפשרות Camera ITS Test (בדיקת ITS של המצלמה).
במכונת המארח, מריצים את בדיקות ה-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.

בדיקות מקבילות של מכשירים

מכשירים עם Android מגרסה 14 ואילך תומכים בבדיקות מקבילות של 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 מאמתת את מודל הרעש על ידי בדיקה שהערכים של הרעש בחשיפה ובגיין של הצילום שמופיעים בנתוני המצלמה נכונים.