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

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

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

सेटअप

आईटीएस टेस्ट चलाने के लिए, ये चीज़ें सेट अप होनी चाहिए:

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

जांच किए जा रहे डिवाइस (डीयूटी) का सेटअप

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

1. यूएसबी केबल की मदद से, डीयूटी को होस्ट मशीन से कनेक्ट करें.
2. डीयूटी पर डेवलपर के लिए सेटिंग और टूल कॉन्फ़िगर करें:
   • स्क्रीन को चालू रखना और यूएसबी डीबग करने की सुविधा चालू करें.
   • सिस्टम अपने-आप अपडेट होने की सुविधा और यूएसबी पर ऐप्लिकेशन की पुष्टि करें को बंद करें.
3. होस्ट को ADB के ज़रिए DUT को ऐक्सेस करने की अनुमतियां दें.

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

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

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

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

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

Android SDK Platform Tools

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

Python

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

Mobly

Android 12 और उसके बाद के वर्शन के लिए, Mobly टेस्ट फ़्रेमवर्क इंस्टॉल करें. Mobly की मदद से, its_base_test क्लास में DUT और चार्ट टैबलेट सेट अप किया जा सकता है. Mobly टेस्ट फ़्रेमवर्क इंस्टॉल करने के लिए, यह कमांड चलाएं:

pip install mobly

एनवायरमेंट सेटअप करना

टेस्ट एनवायरमेंट सेट अप करने के लिए, यह कमांड चलाएं:

cd CameraITS
source build/envsetup.sh

यह कमांड, Python के इंस्टॉलेशन की जांच करती है. साथ ही, PYTHONPATH एनवायरमेंट वैरिएबल सेट अप करती है और utils/*.py मॉड्यूल पर यूनिट टेस्ट चलाती है. अगर टर्मिनल पर कोई गड़बड़ी नहीं दिखती है, तो इसका मतलब है कि एनवायरमेंट, ITS टेस्ट चलाने के लिए तैयार है.

सीन सेटअप करना

सीन सेट अप करने के लिए, हमारा सुझाव है कि आप कैमरा आईटीएस-इन-अ-बॉक्स सेटअप का इस्तेमाल करें. इससे ऑटोमेशन को आसानी से लागू किया जा सकता है. साथ ही, टेस्टिंग के दौरान भरोसेमंद और असरदार नतीजे मिलते हैं. ITS-in-a-box टेस्ट रिग, ITS की सभी ज़रूरतों को पूरा करते हैं. जैसे, लाइटिंग, सेंटरिंग, और चार्ट बदलने की सुविधा. साथ ही, कैमरा एक्सटेंशन की टेस्टिंग के लिए, ITS-in-a-box की ज़रूरत होती है.

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

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

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

फ़ोन का ओरिएंटेशन इस तरह सेट होना चाहिए कि कैमरा बिना किसी रोटेशन के इमेज ले सके. इसकी जांच करने का सबसे आसान तरीका, 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 और इसके बाद के वर्शन में, chart_scaling पैरामीटर को TEST_BED_TABLET_SCENES के लिए config.yml में शामिल किया गया है. यह पैरामीटर, ज़्यादा फ़ील्ड ऑफ़ व्यू (FoV) वाले टेली कैमरा डिवाइसों के लिए, चार्ट स्केलिंग से जुड़ी समस्याओं को ठीक करता है. इससे सीन क्रॉप होने से बचता है और टेस्टिंग के दौरान डिवाइस को सही तरीके से फ़ोकस करने में मदद मिलती है.

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

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

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 scene 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

आईटीएस टेस्ट चल रहे हैं

इस सेक्शन में, आईटीएस टेस्ट चलाने का तरीका बताया गया है.

टेस्ट शुरू करना

डिवाइस, होस्ट मशीन (इसमें एनवायरमेंट भी शामिल है), और फ़िज़िकल सीन सेट अप करने के बाद, इस प्रोसेस का इस्तेमाल करके आईटीएस टेस्ट चलाएं.

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 सीन में से किसी एक को चुनें और उसे एक ही टेस्ट में इस्तेमाल करें. इससे आपको नतीजे तुरंत मिलेंगे.

   मैन्युअल टेस्टिंग के लिए, हर सीन पर आईटीएस टेस्ट का सेट चलाने से पहले, स्क्रिप्ट मौजूदा सीन की एक फ़ोटो लेती है. इसके बाद, उसे 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 दिखता है. FAIL* का मतलब है कि टेस्ट पूरा नहीं हुआ. हालांकि, अभी टेस्ट करना ज़रूरी नहीं है. इसलिए, CtsVerifier को टेस्ट की रिपोर्ट PASS के तौर पर भेजी जाएगी. SKIP का मतलब है कि टेस्ट पास हो गया है, क्योंकि डिवाइस ने उस सुविधा का विज्ञापन नहीं दिखाया जिसकी जांच की जा रही है. उदाहरण के लिए, अगर कोई डिवाइस कैमरा इंटरफ़ेस के ज़रिए यह जानकारी नहीं देता है कि वह DNG फ़ॉर्मैट को सपोर्ट करता है, तो DNG फ़ाइल कैप्चर करने से जुड़े टेस्ट छोड़ दिए जाते हैं. साथ ही, उन्हें PASS के तौर पर गिना जाता है.

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

DUT की पैरलल टेस्टिंग

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

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

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

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

   • जिन सीन को एक्ज़ीक्यूट नहीं किया गया है या जो काम नहीं कर रहे हैं उन्हें काम नहीं कर रहे हैं सेक्शन में दिखाया जाता है.

     

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

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

     

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

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

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

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

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

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

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

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

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

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

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

थोड़े अंतर से पास होने वाले टेस्ट (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 की टेस्टिंग को बेहतर और भरोसेमंद बनाना है. इससे, अच्छी क्वालिटी वाला और भरोसेमंद प्रॉडक्ट तैयार किया जा सकेगा.