कैमरा आईटीएस की खास जानकारी

Camera Image Test Suite (ITS), Android कैमरे से ली गई इमेज पर टेस्ट करने के लिए एक फ़्रेमवर्क है. ITS में हर टेस्ट का सामान्य मकसद, कैमरे को किसी खास तरीके से कॉन्फ़िगर करना, एक या उससे ज़्यादा शॉट लेना, और यह देखने के लिए शॉट की जांच करना है कि उनमें इमेज का ज़रूरी डेटा है या नहीं. कई टेस्ट के लिए, कैमरे को किसी खास टारगेट चार्ट पर पॉइंट करना या किसी खास इंटेंसिटी पर रोशनी डालना ज़रूरी होता है.

ITS, CTS Verifier के टेस्ट हार्नेस में cts/apps/CameraITS में मौजूद है. डिवाइसों को, सीटीएस के सबसेट के तौर पर, तीसरे पक्ष के ऐप्लिकेशन के लिए कैमरा फ़्रेमवर्क की विज्ञापन में बताई गई सुविधाओं के मुताबिक, ITS के टेस्ट पास करने होंगे.

सेटअप

ITS के टेस्ट चलाने के लिए, यह सेटअप करना ज़रूरी है:

• टेस्ट किया जाने वाला डिवाइस (डीयूटी)
• एक होस्ट मशीन (उदाहरण के लिए, Linux डेस्कटॉप या लैपटॉप)
• एक सीन जिसकी फ़ोटो कैमरा लेता है

टेस्ट किए जाने वाले डिवाइस (डीयूटी) का सेटअप

डीयूटी सेट अप करने के लिए, यह तरीका अपनाएं:

1. डीयूटी को यूएसबी केबल से, होस्ट मशीन से कनेक्ट करें.
2. होस्ट को, एडीबी के ज़रिए डीयूटी को ऐक्सेस करने की अनुमति दें.

3. डिवाइस पर, 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

4. डीयूटी पर, डिफ़ॉल्ट कैमरा ऐप्लिकेशन लॉन्च करें और टेस्ट के दौरान होने वाली गड़बड़ियों से बचने के लिए, लॉन्च होने पर दिखने वाली सभी विंडो बंद करें.

होस्ट का सेटअप

ITS के लिए, होस्ट मशीन को यूएसबी केबल से डीयूटी से कनेक्ट करना ज़रूरी है. साथ ही, डिवाइस को कंट्रोल करने और कम्यूनिकेट करने के लिए, एडीबी का इस्तेमाल किया जा सकता है. इसके अलावा, ज़रूरी सॉफ़्टवेयर इंस्टॉल होना चाहिए.

अपनी होस्ट मशीन सेट अप करने के लिए, पक्का करें कि यह सॉफ़्टवेयर इंस्टॉल हो.

Android SDK प्लैटफ़ॉर्म टूल

Android SDK प्लैटफ़ॉर्म टूल इंस्टॉल होने चाहिए. साथ ही, एडीबी, होस्ट मशीन पर चल रहे शेल या टर्मिनल के एक्ज़ीक्यूटेबल पाथ में होना चाहिए. Android SDK प्लैटफ़ॉर्म टूल के सार्वजनिक तौर पर रिलीज़ किए गए वर्शन के लिए, देखें SDK प्लैटफ़ॉर्म टूल के रिलीज़ नोट.

Python

होस्ट मशीन पर Python इंस्टॉल होना चाहिए. हमारा सुझाव है कि कंपैटिबल वर्शन के लिए, बंडल किए गए Python डिस्ट्रिब्यूशन का इस्तेमाल करें. किसी खास रिलीज़ के लिए, Python और पैकेज के कौनसे वर्शन इंस्टॉल करने हैं, इस बारे में जानकारी पाने के लिए, उससे जुड़ी रिलीज़ के लिए Camera ITS के रिलीज़ नोट देखें.

Mobly

Android 12 और इसके बाद के वर्शन के लिए, Mobly टेस्ट फ़्रेमवर्क इंस्टॉल करें. Mobly की मदद से, 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 का इस्तेमाल करना ज़रूरी है.

मैन्युअल तरीके से टेस्ट करने के लिए, पक्का करें कि:

• डीयूटी, ट्राइपॉड पर हो
• हर टेस्ट के लिए, डीयूटी सही सीन पर पॉइंट किया गया हो. (ITS टेस्ट स्क्रिप्ट, नए सीन में टेस्ट शुरू करने से पहले, सीन सेटअप में बदलाव करने के लिए प्रॉम्प्ट देती है.)
• डीयूटी, यूएसबी केबल से होस्ट मशीन से कनेक्ट हो.
• टेस्ट रन के दौरान, डीयूटी न हिले.
• सीन पर, स्थिर और बिना फ़्लक्चुएशन वाले लाइट सोर्स से रोशनी पड़ रही हो. (फ़्लोरेसेंट लाइट का इस्तेमाल न करें, क्योंकि इससे फ़्लिकर की समस्या होती है.)

ITS टेस्ट स्क्रिप्ट, नए सीन में टेस्ट शुरू करने से पहले, सीन सेटअप में बदलाव करने के लिए उपयोगकर्ता को एक प्रॉम्प्ट दिखाती है.

फ़ोन का ओरिएंटेशन इस तरह सेट किया जाना चाहिए, ताकि कैमरा बिना रोटेशन के इमेज ले. इसकी जांच करने का सबसे आसान तरीका, scene2 में मौजूद फ़ेस सीन का इस्तेमाल करना है. ज़्यादातर फ़ोन में, रीयर कैमरे के लिए फ़ोन को एंटी-क्लॉकवाइज़ घुमाकर और फ़्रंट कैमरे के लिए क्लॉकवाइज़ घुमाकर, फ़ोन को लैंडस्केप ओरिएंटेशन में रखा जाता है.

कॉन्फ़िगरेशन फ़ाइलें

Mobly फ़्रेमवर्क का इस्तेमाल करके, आपको Mobly टेस्टबेड को तय करने के लिए, config.yml कॉन्फ़िगरेशन फ़ाइल बनानी होगी. यहां, इस्तेमाल के अलग-अलग उदाहरण दिए गए हैं.

टैबलेट पर आधारित सीन के लिए 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 फ़ाइल की वैल्यू के साथ चलाया जाता है. अगर कमांड लाइन वैल्यू में, कैमरे या सीन के बारे में जानकारी दी गई है, तो ये वैल्यू, config.yml फ़ाइल के TestParams सेक्शन में मौजूद वैल्यू को बदल देती हैं. उदाहरण के लिए:

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

chart_scaling पैरामीटर

Android 17 और इसके बाद के वर्शन में, TEST_BED_TABLET_SCENES के लिए config.yml में chart_scaling पैरामीटर शामिल किया गया है. इस पैरामीटर से, ज़्यादा फ़ील्ड ऑफ़ व्यू (एफ़ओवी) वाले टेली कैमरा डिवाइसों के लिए, चार्ट स्केलिंग की समस्याओं को हल किया जाता है. इससे, सीन को क्रॉप होने से बचाया जाता है और टेस्ट के दौरान डिवाइस को सही तरीके से फ़ोकस किया जाता है.

chart_scaling के लिए, 1, 0.33, 0.5, या 0.67 वैल्यू इस्तेमाल की जा सकती हैं. डिफ़ॉल्ट वैल्यू के तौर पर None का इस्तेमाल किया जाता है. इस तरीके से, डिवाइस अपनी ज़रूरतों के हिसाब से ऑप्टिमल स्केलिंग फ़ैक्टर का इस्तेमाल कर सकते हैं. इससे, सभी डिवाइसों पर फ़ंक्शनल टेस्ट किया जा सकता है.

अगर chart_scaling को None पर सेट किया जाता है, तो टेस्ट, chart_scaling_logic का इस्तेमाल करके, स्केलिंग फ़ैक्टर अपने-आप तय करते हैं. इसके अलावा, config.yml में तय की गई वैल्यू का इस्तेमाल किया जाता है. अगर स्केलिंग की सुविधा उपलब्ध नहीं है, तो गड़बड़ी का फ़्लैग किया जाता है.

chart_scaling पैरामीटर वाली config.yml का एक उदाहरण यहां दिया गया है

TestBeds:
  -   Name: TEST_BED_TABLET_SCENES  # Need 'tablet' in name for tablet scenes
    # Use TEST_BED_MANUAL for manual testing and remove below lines:
    #     - serial <tablet_id>
    #       label: tablet
    # Test configuration for scenes[0:4, 6]
    Controllers:
        AndroidDevice:
          -   serial: <device-id>  # quotes needed if serial id entirely numeric
            label: dut
          -   serial: <tablet-id>  # quotes needed if serial id entirely numeric
            label: tablet
    TestParams:
      brightness: 192
      chart_distance: 22.0
      debug_mode: "False"  # quotes needed
      lighting_cntl: <controller-type>  # can be arduino or "None"
      lighting_ch: <controller-channel>
      camera: <camera-id>
      scene: <scene-name>  # if <scene-name> runs all scenes
      foldable_device: "False"  # "True" if testing foldable device
      chart_scaling: "None"  # use the values available for scene to be tested
      resultstore_upload: "False"  # "True" if results should be uploaded to ResultStore

Camera ITS की चार्ट स्केलिंग की क्षमताओं को चालू करने के लिए, टेस्ट-साइड में बदलाव करना ज़रूरी है. अगर आपके इस्तेमाल किए जा रहे टेस्ट में यह सुविधा काम नहीं करती है, तो गड़बड़ी की शिकायत करें.

chart_scaling पैरामीटर के साथ, टेस्ट-साइड में किए गए बदलाव का एक उदाहरण यहां दिया गया है.

# load chart for scene
      its_session_utils.load_scene(
          cam, props, self.scene, self.tablet, self.chart_distance,
          chart_scaling=self.chart_scaling)

sensor_fusion सीन के लिए config.yml फ़ाइल

sensor_fusion टेस्ट के लिए, config_yml फ़ाइल का एक उदाहरण यहां दिया गया है. 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 टेस्ट चलाने के लिए, यह कमांड चलाएं:

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 रिग टेस्टिंग के लिए config.yml फ़ाइल

TEST_BED_GEN2 टेस्टबेड के लिए, config.yml फ़ाइल का एक उदाहरण यहां दिया गया है. इस टेस्टबेड का इस्तेमाल, 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 रिग उपलब्ध नहीं है और 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 के टेस्ट चलाने के लिए यह तरीका अपनाएं.

1. CTS Verifier ऐप्लिकेशन खोलें. टेस्ट मेन्यू में, Camera ITS Test चुनें. Android 17 और इसके बाद के वर्शन के लिए, sensor_fusion और feature_combination टेस्ट, Camera ITS Sensor Fusion Rig Test नाम की एक और गतिविधि में शामिल हैं.

2. होस्ट मशीन से, CameraITS/ डायरेक्ट्री से ITS के टेस्ट चलाएं. उदाहरण के लिए, फ़्रंट और रीयर कैमरे वाले डिवाइस के लिए, यह कमांड चलाएं:

   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)
   

   स्क्रिप्ट का हर रन, एक लॉग प्रिंट करता है. इसमें ITS के हर टेस्ट के लिए, PASS, FAIL, FAIL* या SKIP दिखता है. FAIL* का मतलब है कि टेस्ट फ़ेल हो गया है. हालांकि, इसे अभी तक ज़रूरी नहीं बनाया गया है. इसलिए, CtsVerifier को टेस्ट की रिपोर्ट PASS के तौर पर दिखेगी. SKIP का मतलब है कि टेस्ट पास हो गया है, क्योंकि डिवाइस ने टेस्ट की जा रही ज़रूरी क्षमता का विज्ञापन नहीं दिखाया. उदाहरण के लिए, अगर कोई डिवाइस, कैमरा इंटरफ़ेस के ज़रिए यह विज्ञापन नहीं दिखाता है कि वह डीएनजी फ़ॉर्मैट में फ़ोटो कैप्चर कर सकता है, तो डीएनजी फ़ाइल कैप्चर से जुड़े टेस्ट स्किप कर दिए जाते हैं और उन्हें PASS के तौर पर गिना जाता है.

3. यह पुष्टि करने के लिए कि टेस्ट, ज़रूरी शर्तों को पूरा करते हैं, सही के निशान वाले हरे बटन पर टैप करें. इसके बाद, CTS Verifier के टेस्ट मेन्यू में मौजूद Camera ITS Test एंट्री हरे रंग की हो जाती है. इससे पता चलता है कि फ़ोन ने Camera ITS पास कर लिया है.

डीयूटी की पैरलल टेस्टिंग

Android 14 या इसके बाद के वर्शन वाले डिवाइसों पर, डीयूटी की पैरलल टेस्टिंग की जा सकती है. इससे, एक साथ कई रिग के साथ डीयूटी की पैरलल टेस्टिंग की जा सकती है. इससे, पूरी टेस्टिंग की प्रोसेस तेज़ हो जाती है. उदाहरण के लिए, पैरलल टेस्टिंग की मदद से, एक रिग में कैमरा 0 और दूसरे रिग में कैमरा 1 को एक साथ टेस्ट किया जा सकता है. Android 17 और इसके बाद के वर्शन के लिए, Camera ITS के टेस्ट को दो गतिविधियों में बांटा गया है. इसलिए, एक डीयूटी पर sensor_fusion और feature_combination टेस्ट चलाए जा सकते हैं. वहीं, दूसरे डीयूटी पर अन्य टेस्ट चलाए जा सकते हैं. पैरलल टेस्टिंग सेशन के लिए, सभी टेस्ट के नतीजे, रेफ़रंस डीयूटी पर CTS Verifier सेशन में एग्रीगेट किए जाते हैं. आपको 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

एग्रीगेट किए गए टेस्ट के नतीजे सबमिट करना

Android 17 और इसके बाद के वर्शन में, बिल्ड को मंज़ूरी पाने के लिए, Camera ITS के एग्रीगेट किए गए टेस्ट के नतीजे सबमिट किए जा सकते हैं. CTS Verifier की मदद से, एक साथ कई डिवाइसों पर कई सीन टेस्ट किए जा सकते हैं. साथ ही, CTS Verifier की कई रिपोर्ट (अलग-अलग टेस्ट रन या डिवाइसों से) से टेस्ट के नतीजे, एक ही सबमिशन में एग्रीगेट किए जा सकते हैं.

सबमिट करने की प्रोसेस

बिल्ड को मंज़ूरी पाने के लिए, Camera ITS के एग्रीगेट किए गए नतीजे सबमिट करने के लिए, यह तरीका अपनाएं:

1. डिवाइस तैयार करना: टेस्ट किए जाने वाले दो से तीन डिवाइस (डीयूटी) इकट्ठा करें. इन सभी डिवाइसों का बिल्ड फ़िंगरप्रिंट एक जैसा होना चाहिए.
2. CTS Verifier इंस्टॉल करना: CTS Verifier का नया APK इंस्टॉल करें. इसे दिए गए बिल्ड एक्सप्लोरर से पाया जा सकता है.

3. पैरलल में टेस्ट करना:

   1. डीयूटी को अलग-अलग रिग में माउंट करें.
   2. हर डिवाइस पर, Camera ITS के अलग-अलग सीन एक साथ चलाएं.
   3. रिपोर्ट इकट्ठा करना: हर रन के बाद, CTS Verifier की रिपोर्ट पुल करें. इसमें वे रिपोर्ट भी शामिल हैं जिनमें सीन फ़ेल हो गए हैं. इसके बाद के रन में, सिर्फ़ फ़ेल हुए सीन को फिर से चलाएं.

4. रिपोर्ट सबमिट करना: सभी डिवाइसों से इकट्ठा की गई, CTS Verifier की कई रिपोर्ट अपलोड करें.

5. नतीजों की समीक्षा करना: रिपोर्ट अपलोड होने के बाद, एग्रीगेट किए गए नतीजों की समीक्षा करें:

   • टेस्ट का विश्लेषण सेक्शन में, चलाए गए सभी सीन की पूरी सूची दिखती है.

   • फ़ेल हुए टेस्ट सेक्शन में, वे सीन दिखते हैं जो नहीं चलाए गए या फ़ेल हो गए.

     

     पहली इमेज. उन सीन के बारे में दस्तावेज़ जिनमें टेस्ट नहीं किया गया या जो फ़ेल हो गए.

   • एग्रीगेट किए गए पास सेक्शन में, वे सीन दिखते हैं जो पास हो गए.

     

     दूसरी इमेज. एग्रीगेट किए गए पास के तौर पर कैटगरी में रखे गए सीन

बिल्ड को मंज़ूरी की स्थिति

बिल्ड को मंज़ूरी तब मिलती है, जब एग्रीगेट की गई रिपोर्ट में, सभी ज़रूरी सीन सही तरीके से पूरे हो जाते हैं.

डीएनजी नॉइज़ मॉडल

जिन डिवाइसों में रॉ या डीएनजी फ़ॉर्मैट में फ़ोटो कैप्चर करने की सुविधा होती है उन्हें हर रॉ शॉट के कैप्चर के नतीजे के मेटाडेटा में नॉइज़ मॉडल देना होगा. इस नॉइज़ मॉडल को, डिवाइस पर मौजूद हर कैमरे (उदाहरण के लिए, फ़्रंट और बैक कैमरे) के लिए, कैमरा HAL में एम्बेड करना होगा. इसके लिए, डिवाइस में यह सुविधा उपलब्ध होनी चाहिए.

नॉइज़ मॉडल लागू करना

नॉइज़ मॉडल लागू करने के लिए, नॉइज़ मॉडल जनरेट करने और मॉडल को कैमरा HAL में एम्बेड करने के लिए, यह तरीका अपनाएं.

1. हर कैमरे के लिए नॉइज़ मॉडल जनरेट करने के लिए, dng_noise_model.py स्क्रिप्ट को tools डायरेक्ट्री में चलाएं. इससे, सी कोड स्निपेट मिलता है. कैमरा और कैप्चर एनवायरमेंट सेट अप करने के तरीके के बारे में ज़्यादा जानकारी के लिए, tools डायरेक्ट्री में मौजूद DngNoiseModel.pdf दस्तावेज़ देखें.

2. डिवाइस के लिए नॉइज़ मॉडल लागू करने के लिए, सी कोड स्निपेट को कट करके, कैमरा HAL में चिपकाएं.

नॉइज़ मॉडल की पुष्टि करना

tests/scene1_1/test_dng_noise_model.py ऑटोमेटेड ITS टेस्ट, नॉइज़ मॉडल की पुष्टि करता है. इसके लिए, यह पुष्टि की जाती है कि कैमरा डेटा में दिए गए शॉट के एक्सपोज़र और गेन के लिए नॉइज़ वैल्यू सही है.

मार्जिन से पास होने वाले टेस्ट (PASS* टेस्ट स्टेटस)

Android 17 और इसके बाद के वर्शन में, मार्जिनल पास (PASS*) का मतलब है कि कोई टेस्ट पास हो गया है. हालांकि, उसकी परफ़ॉर्मेंस मेट्रिक, पास होने के लिए तय की गई थ्रेशोल्ड के बहुत करीब हैं. हालांकि, टेस्ट तकनीकी तौर पर पास होने की ज़रूरी शर्तों को पूरा करता है, लेकिन फ़ेल होने की सीमा के करीब होने की वजह से, इसकी बारीकी से जांच करने की ज़रूरत होती है.

मार्जिनल पास के फ़ायदे

PASS* स्टेटस के कई फ़ायदे हैं:

• अर्ली वॉर्निंग सिस्टम: इससे उन टेस्ट की पहचान की जाती है जो फ़ेल होने वाले हैं. इससे टीमों को, समस्याएं गंभीर होने से पहले उन्हें ठीक करने में मदद मिलती है.

• प्रोऐक्टिव ऑप्टिमाइज़ेशन: इससे टीमों को, उन टेस्ट और कोड को ऑप्टिमाइज़ करने में मदद मिलती है जो स्वीकार की जा सकने वाली रेंज के निचले हिस्से में परफ़ॉर्म कर रहे हैं. इससे, पूरी स्टेबिलिटी बेहतर होती है.

• बेहतर क्वालिटी: इससे क्वालिटी का बेहतर स्टैंडर्ड बनाए रखने में मदद मिलती है. इसके लिए, उन क्षेत्रों को फ़्लैग किया जाता है जिनमें कोड में मामूली बदलाव करने पर, आने वाले समय में गड़बड़ियां हो सकती हैं.

• डीबग करने में लगने वाला समय कम होना: PASS* टेस्ट को पहले ही पकड़ लेने से, आने वाले समय में पूरी तरह से फ़ेल होने वाली गड़बड़ियों को डीबग करने में लगने वाला समय और मेहनत काफ़ी कम हो सकती है.

PASS* की जानकारी

PASS* स्टेटस में यह जानकारी शामिल होती है:

• थ्रेशोल्ड तय करना: Camera ITS में, हर काम के टेस्ट के लिए, मार्जिनल पास के खास थ्रेशोल्ड तय किए जाते हैं.

• ऑटोमेटेड डिटेक्शन: टेस्ट ऑटोमेशन सिस्टम, तय किए गए थ्रेशोल्ड के आधार पर, टेस्ट को PASS* के तौर पर डिटेक्ट और कैटगरी में रखता है.

• चेतावनी देने का तरीका: टीमों को, PASS* के तौर पर फ़्लैग किए गए किसी भी टेस्ट के लिए, ऑटोमेटेड चेतावनियां मिलती हैं. इससे उन्हें उस खास टेस्ट और उसकी मेट्रिक की जांच करने में मदद मिलती है.

• रिपोर्टिंग: मार्जिनल पास के स्टेटस, टेस्ट रिपोर्ट और डैशबोर्ड में साफ़ तौर पर दिखाए जाते हैं. ItsTestSummary रिपोर्ट में, इन्हें PASS* के तौर पर दिखाया जाता है. इसी तरह, not_yet_mandated टेस्ट के लिए, इन्हें Fail* के तौर पर दिखाया जाता है. टेस्ट का स्टेटस हरे रंग का बना रहता है, क्योंकि यह तय किए गए थ्रेशोल्ड के अंदर पास होता रहता है. इससे, आगे होने वाली गड़बड़ियों से बचा जा सकता है. PASS* स्टेटस, सिर्फ़ टेस्ट क्लास पर लागू होता है, पूरे सीन पर नहीं. उदाहरण के लिए, Scene_0 को PASS माना जा सकता है. भले ही test_jitter और test_metadata PASS* हों.

• मॉनिटरिंग: किसी डिवाइस पर मार्जिन से पास होने वाले टेस्ट का परफ़ॉर्मेंस डेटा इकट्ठा किया जाता है. इससे, अगर ये टेस्ट PASS स्टेटस में बदल जाते हैं, तो ओईएम की ओर से किए जाने वाले कैमरे के बेहतर बनाने के लिए, आने वाले समय में मॉनिटरिंग की जा सकती है.

यहां, PASS* के साथ टेस्ट के नतीजों का एक उदाहरण दिया गया है:

INFO:root:Reporting camera 1 ITS results to CtsVerifier
INFO:root:ITS results to CtsVerifier: {'scene0': {'result': 'PASS', 'TEST_STATUS': [{'test': 'test_jitter', 'status': 'PASS*'}, {'test': 'test_metadata', **'status': 'PASS*'**}, {'test': 'test_request_capture_match', 'status': 'PASS'}, {'test': 'test_sensor_events', 'status': 'PASS'}, {'test': 'test_solid_color_test_pattern', 'status': 'PASS'}, {'test': 'test_test_patterns', 'status': 'SKIP'}, {'test': 'test_tonemap_curve', 'status': 'SKIP'}, {'test': 'test_unified_timestamps', 'status': 'PASS'}, {'test': 'test_vibration_restriction', 'status': 'PASS'}], 'mpc_metrics': [], 'performance_metrics': [], 'feature_query_proto': [], 'feature_query_proto_path': [], 'summary': '/tmp/CameraITS_zojk4sdr/cam_id_1/scene0/scene_test_summary.txt', 'start': 1754330630345, 'end': 1754330764534}, 'scene1_1': {'result': 'NOT_EXECUTED'}, 'scene1_2': {'result': 'NOT_EXECUTED'}, 'scene1_3': {'result': 'NOT_EXECUTED'}, 'scene2_a': {'result': 'NOT_EXECUTED'}, 'scene2_b': {'result': 'NOT_EXECUTED'}, 'scene2_c': {'result': 'NOT_EXECUTED'}, 'scene2_d': {'result': 'NOT_EXECUTED'}, 'scene2_e': {'result': 'NOT_EXECUTED'}, 'scene2_f': {'result': 'NOT_EXECUTED'}, 'scene2_g': {'result': 'NOT_EXECUTED'}, 'scene3': {'result': 'NOT_EXECUTED'}, 'scene4': {'result': 'NOT_EXECUTED'}, 'scene6': {'result': 'NOT_EXECUTED'}, 'scene7': {'result': 'NOT_EXECUTED'}, 'scene8': {'result': 'NOT_EXECUTED'}, 'scene9': {'result': 'NOT_EXECUTED'}, 'scene_extensions/scene_hdr': {'result': 'NOT_EXECUTED'}, 'scene_extensions/scene_low_light': {'result': 'NOT_EXECUTED'}, 'scene_tele/scene6_tele': {'result': 'NOT_EXECUTED'}, 'scene_tele/scene7_tele': {'result': 'NOT_EXECUTED'}, 'scene_video': {'result': 'NOT_EXECUTED'}, 'scene5': {'result': 'NOT_EXECUTED'}, 'sensor_fusion': {'result': 'NOT_EXECUTED'}, 'feature_combination': {'result': 'NOT_EXECUTED'}, 'scene_flash': {'result': 'NOT_EXECUTED'}, 'scene_ip': {'result': 'NOT_EXECUTED'}}

पार्टनरों को यह सुझाव दिया जाता है कि वे:

• PASS* की चेतावनियों पर नज़र रखें
• PASS* टेस्ट की मुख्य वजह की जांच करें
• PASS* के तौर पर पहचाने गए टेस्ट और कोड को प्रोऐक्टिव तरीके से ऑप्टिमाइज़ करें

PASS* स्टेटस का मकसद, Camera ITS की टेस्टिंग की मज़बूती और भरोसेमंदता को बेहतर बनाना है. इससे, स्थिर और अच्छी क्वालिटी वाला प्रॉडक्ट मिलता है.