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

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

कैमरा आईटीएस

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

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

सेटअप

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

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

जांचा जा रहा डिवाइस (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 Platform टूल इंस्टॉल होने चाहिए और एडीबी, होस्ट मशीन पर चल रहे शेल या टर्मिनल के एक्ज़ीक्यूटेबल पाथ में होना चाहिए. 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-in-a-box की ज़रूरत होती है.

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

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

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

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

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

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

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

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 rig का इस्तेमाल किया जाता है](/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 टेस्ट चलाएं.

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 नॉइज़ मॉडल

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

शोर कम करने वाला मॉडल लागू करना

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

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

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

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