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

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

מצלמת ITS
קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

הכלי לבדיקת תמונות מהמצלמה (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.

Python

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

Mobly

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

pip install mobly

הגדרת סביבה

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

cd CameraITS
source build/envsetup.sh

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

הגדרת סצנות

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

קובץ 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. בתפריט הבדיקות, בוחרים בדיקת ה-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.
כדי לאשר שהבדיקות עברו את דרישות הבדיקה, מקישים על הלחצן עם סימן הווי הירוק. הערך בדיקת ITS של המצלמה ב-CTS Verifier לאחר מכן תפריט הבדיקות הופך לירוק ומציין שהטלפון עבר את מצלמת ה-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 חייבים להשמיע רעש במטא-נתונים של תוצאת הצילום של כל צילום גולמי. מודל הרעשי הזה צריך להיות מוטמע ב-HAL של המצלמה לכל מצלמה (לדוגמה, מצלמה קדמית ומצלמה אחורית) במכשיר שבו מצוין שיש תמיכה.

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

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

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

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

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