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

कैमरा आईटीएस

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

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

सेटअप

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

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

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

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

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 फ़ोल्डर का टॉप लेवल.

होस्ट सेटअप

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

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

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

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

Python

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

मोबली

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

pip install mobly

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

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

cd CameraITS
source build/envsetup.sh

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

अगर आपको गड़बड़ी का मैसेज दिखता है, तो 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

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

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

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

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

आईटीएस की जांच की स्क्रिप्ट में, उपयोगकर्ता से सीन बदलने के लिए कहा जाता है सेटअप करें.

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

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

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=1 scenes=2,1,0

सेंसर_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

एक से ज़्यादा testbeds 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

आईटीएस की जांच करना

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

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

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

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

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

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

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

RAW या DNG को कैप्चर करने की क्षमता दिखाने वाले डिवाइसों में ग़ैर-ज़रूरी आवाज़ें होनी चाहिए मॉडल, हर रॉ शॉट के कैप्चर नतीजे के मेटाडेटा में दिखता है. गै़र-ज़रूरी डेटा का यह मॉडल हर कैमरे के लिए, कैमरा एचएएल में एम्बेड होना चाहिए (उदाहरण के लिए, सामने और बैक कैमरा) के साथ काम करता है.

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

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

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

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

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