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

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

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

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

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

सेटअप

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

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

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

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

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

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

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

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

Android SDK Platform Tools

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

Python

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

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

DUT को ट्राइपॉड पर रखा गया हो
हर टेस्ट के लिए, 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

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

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

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

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

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

CTS Verifier ऐप्लिकेशन खोलें. टेस्ट मेन्यू में, Camera ITS Test चुनें.
होस्ट मशीन से, 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 के तौर पर गिना जाता है.
यह पुष्टि करने के लिए कि टेस्ट, ज़रूरी शर्तों को पूरा करते हैं, हरे रंग के सही के निशान वाले बटन पर टैप करें. इसके बाद, CTS Verifier के टेस्ट मेन्यू में Camera ITS Test एंट्री हरे रंग की हो जाती है. इसका मतलब है कि फ़ोन ने Camera ITS पास कर लिया है.

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

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

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

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

आस-पास के शोर को कम करने वाले मॉडल को लागू करना

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

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

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

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