हमारा सुझाव है कि 27 मार्च, 2025 से AOSP को बनाने और उसमें योगदान देने के लिए, aosp-main के बजाय android-latest-release का इस्तेमाल करें. ज़्यादा जानकारी के लिए, AOSP में हुए बदलाव लेख पढ़ें.

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

कैमरा आईटीएस
संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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

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

सेटअप

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

टेस्ट में डिवाइस (डीयूटी)
होस्ट मशीन (उदाहरण के लिए, 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 फ़ोल्डर के सबसे ऊपरी लेवल पर मिल सकती हैं.

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

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

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

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

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

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

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

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

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

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

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

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

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

जांच शुरू करना

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

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

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

साथ-साथ 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

DNG नॉइज़ मॉडल

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

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

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

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

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

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