कॉन्फ़्रेंस

इमेज पर लीनियर कन्वोल्यूशन करने के लिए, image.convolve() का इस्तेमाल करें. कॉन्वोल्यूट करने के लिए, सिर्फ़ एक आर्ग्युमेंट ee.Kernel होता है. इसे आकार और kernel में मौजूद वज़न से तय किया जाता है. convolve() के ज़रिए जनरेट की गई इमेज के हर पिक्सल का रंग, कर्नेल की वैल्यू और कर्नेल के दायरे में आने वाले इनपुट इमेज पिक्सल के रंग का लीनियर कॉम्बिनेशन होता है. हर बैंड पर अलग-अलग कर्नेल लागू किए जाते हैं. उदाहरण के लिए, हो सकता है कि आपको ज़्यादा फ़्रीक्वेंसी वाली जानकारी हटाने के लिए, लो-पास (स्मूद करने वाले) कर्नेल का इस्तेमाल करना हो. यहां Landsat 8 इमेज पर लागू किए गए 15x15 लो-पास कर्नेल को दिखाया गया है:

// Load and display an image.
var image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318');
Map.setCenter(-121.9785, 37.8694, 11);
Map.addLayer(image, {bands: ['B5', 'B4', 'B3'], max: 0.5}, 'input image');

// Define a boxcar or low-pass kernel.
var boxcar = ee.Kernel.square({
  radius: 7, units: 'pixels', normalize: true
});

// Smooth the image by convolving with the boxcar kernel.
var smooth = image.convolve(boxcar);
Map.addLayer(smooth, {bands: ['B5', 'B4', 'B3'], max: 0.5}, 'smoothed');

लो-पास फ़िल्टर के साथ कॉन्वोल्यूशन का आउटपुट, फ़िगर 1 जैसा दिखना चाहिए. ध्यान दें कि कर्नेल के आर्ग्युमेंट से उसका साइज़ और गुणांक तय होते हैं. खास तौर पर, units पैरामीटर को पिक्सल पर सेट करने पर, radius पैरामीटर से यह पता चलता है कि केंद्र से कितने पिक्सल को कवर किया जाएगा. अगर normalize को 'सही है' पर सेट किया जाता है, तो कर्नेल के गुणांक का योग एक होगा. अगर magnitude पैरामीटर सेट है, तो कोरिलर के गुणांक को मैग्नीट्यूड से गुणा किया जाएगा (अगर normalize भी सही है, तो गुणांक का योग magnitude होगा). अगर कोरिलर के किसी भी गुणांक में कोई नेगेटिव वैल्यू है, तो normalize को 'सही' पर सेट करने से, गुणांक का योग शून्य हो जाएगा.

इमेज प्रोसेसिंग का मनमुताबिक इफ़ेक्ट पाने के लिए, दूसरे कर्नेल का इस्तेमाल करें. इस उदाहरण में, आइसोट्रॉपिक एज डिटेक्शन के लिए, Laplacian kernel का इस्तेमाल किया गया है:

// Define a Laplacian, or edge-detection kernel.
var laplacian = ee.Kernel.laplacian8({ normalize: false });

// Apply the edge-detection kernel.
var edgy = image.convolve(laplacian);
Map.addLayer(edgy,
             {bands: ['B5', 'B4', 'B3'], max: 0.5, format: 'png'},
             'edges');

विज़ुअलाइज़ेशन पैरामीटर में फ़ॉर्मैट के बारे में जानकारी देने वाले टैग को नोट करें. Earth Engine, बेहतर परफ़ॉर्मेंस के लिए, डिसप्ले टाइल को कोड एडिटर में JPEG फ़ॉर्मैट में भेजता है. हालांकि, इमेज की सीमा के बाहर के पिक्सल की पारदर्शिता को मैनेज करने के लिए, एज टाइल को PNG फ़ॉर्मैट में भेजा जाता है. जब विज़ुअल में कटौती होती है, तो फ़ॉर्मैट को PNG पर सेट करने से, विज़ुअल एक जैसा दिखता है. किनारे का पता लगाने वाले Laplacian कर्नेल के साथ कॉन्वोल्यूशन करने पर, इमेज कुछ इस तरह दिखेगी जैसा कि दूसरे चित्र में दिखाया गया है.

ऐनिसोट्रॉपिक एज डिटेक्शन कर्नेल (जैसे, सोबल, प्रीविट, रॉबर्टस) भी होते हैं. इनकी दिशा kernel.rotate() की मदद से बदली जा सकती है. अन्य लो पास कर्नेल में, गॉसियन कर्नेल और एक जैसे वज़न वाले अलग-अलग आकार के कर्नेल शामिल हैं. अपनी पसंद के मुताबिक तय किए गए वज़न और आकार वाले कोर बनाने के लिए, ee.Kernel.fixed() का इस्तेमाल करें. उदाहरण के लिए, यह कोड 1 के 9x9 केर्नेल बनाता है, जिसमें बीच में शून्य होता है:

// Create a list of weights for a 9x9 kernel.
var row = [1, 1, 1, 1, 1, 1, 1, 1, 1];
// The center of the kernel is zero.
var centerRow = [1, 1, 1, 1, 0, 1, 1, 1, 1];
// Assemble a list of lists: the 9x9 kernel weights as a 2-D matrix.
var rows = [row, row, row, row, centerRow, row, row, row, row];
// Create the kernel from the weights.
var kernel = ee.Kernel.fixed(9, 9, rows, -4, -4, false);
print(kernel);