דף זה תורגם על ידי 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.
```
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 הדחוסה.

הגדרת המארח

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

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

כלי פלטפורמת SDK של Android

צריך להתקין את הכלים של Android SDK Platform ו-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 בדיקות.

אם מופיעה הודעת השגיאה libtinfo.so.6: no version information available (required by /bin/sh) זהה בזמן הריצה, מריצים את הפקודה הבאה כדי לשנות את השם של הקובץ libtinfo.so.6.

mv $ENV_DIRECTORY/lib/libtinfo.so.6 $ENV_DIRECTORY/lib/libtinfo.so.6.bak

הגדרת סצנות

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

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

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

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

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

קובצי תצורה

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

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

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