इस पेज का अनुवाद Cloud Translation API से किया गया है.

कैमरा आईटीएस

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

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

सेटअप

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

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

डिवाइस की जांच की जा रही है (DUT) सेटअप

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

DUT को यूएसबी की मदद से होस्ट मशीन से कनेक्ट करें.
होस्ट को एडीबी के ज़रिए डीयूटी को ऐक्सेस करने की अनुमतियां दें.
डिवाइस पर 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
```
ध्यान दें: अगर ऐप्लिकेशन को पूरे Android सोर्स ट्री के बजाय, सीटीएस की पुष्टि करने वाले बंडल (android-cts-verifier.zip) से इंस्टॉल किया जा रहा है, तो CtsVerifier.apk और CameraITS/ डायरेक्ट्री, ज़िप किए गए android-cts-verifier फ़ोल्डर के सबसे ऊपरी लेवल पर मिल सकती हैं.

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

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

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

Android SDK Platform Tools

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

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 टेस्ट करने के लिए तैयार है.

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

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

मैन्युअल टेस्टिंग के लिए, इन बातों का ध्यान रखें:

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

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

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

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

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

टैबलेट पर दिखने वाले सीन की 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=1 scenes=2,1,0

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

एक से ज़्यादा टेस्टबेड की 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 टेस्ट चलाएं.

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

एक साथ कई डीयूटी की जांच करना

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

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

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

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

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

शोर के मॉडल की पुष्टि करना

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