ऑब्जेक्ट पर आधारित तरीके

Colab का लोगो Google Colab में चलाएं GitHub का लोगो GitHub पर सोर्स देखें

इमेज ऑब्जेक्ट, एक जैसे पूर्णांक वैल्यू वाले कनेक्ट किए गए पिक्सल के सेट होते हैं. कैटगरी वाला, बाइन किया गया, और बूलियन इमेज डेटा, ऑब्जेक्ट के विश्लेषण के लिए सही होता है.

Earth Engine, हर ऑब्जेक्ट को यूनीक आईडी से लेबल करने, ऑब्जेक्ट बनाने वाले पिक्सल की संख्या गिनने, और ऑब्जेक्ट के इंटरसेक्शन वाले पिक्सल की वैल्यू के लिए आंकड़ों का हिसाब लगाने के तरीके उपलब्ध कराता है.

  • connectedComponents(): हर ऑब्जेक्ट को यूनीक आइडेंटिफ़ायर से लेबल करें.
  • connectedPixelCount(): हर ऑब्जेक्ट में पिक्सल की संख्या का हिसाब लगाएं.
  • reduceConnectedComponents(): हर ऑब्जेक्ट में पिक्सल के लिए आंकड़ा कैलकुलेट करें.

थर्मल हॉटस्पॉट

नीचे दिए गए सेक्शन में, ऑब्जेक्ट पर आधारित उन तरीकों के उदाहरण दिए गए हैं जिन्हें Landsat 8 के सतह के तापमान पर लागू किया गया है. हर सेक्शन में, पिछले सेक्शन के आधार पर जानकारी दी गई है. बेस इमेज जनरेट करने के लिए, अगला स्निपेट चलाएं: सैन फ़्रांसिस्को के एक छोटे इलाके के लिए, थर्मल हॉटस्पॉट (303 डिग्री केल्विन से ज़्यादा).

कोड एडिटर (JavaScript)

// Make an area of interest geometry centered on San Francisco.
var point = ee.Geometry.Point(-122.1899, 37.5010);
var aoi = point.buffer(10000);

// Import a Landsat 8 image, subset the thermal band, and clip to the
// area of interest.
var kelvin = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318')
  .select(['B10'], ['kelvin'])
  .clip(aoi);

// Display the thermal band.
Map.centerObject(point, 13);
Map.addLayer(kelvin, {min: 288, max: 305}, 'Kelvin');

// Threshold the thermal band to set hot pixels as value 1, mask all else.
var hotspots = kelvin.gt(303)
  .selfMask()
  .rename('hotspots');

// Display the thermal hotspots on the Map.
Map.addLayer(hotspots, {palette: 'FF0000'}, 'Hotspots');

Python सेटअप

Python API के बारे में जानकारी पाने और इंटरैक्टिव डेवलपमेंट के लिए geemap का इस्तेमाल करने के लिए, Python एनवायरमेंट पेज देखें.

import ee
import geemap.core as geemap

Colab (Python)

# Make an area of interest geometry centered on San Francisco.
point = ee.Geometry.Point(-122.1899, 37.5010)
aoi = point.buffer(10000)

# Import a Landsat 8 image, subset the thermal band, and clip to the
# area of interest.
kelvin = (
    ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318')
    .select(['B10'], ['kelvin'])
    .clip(aoi)
)

# Threshold the thermal band to set hot pixels as value 1, mask all else.
hotspots = kelvin.gt(303).selfMask().rename('hotspots')

# Define a map centered on Redwood City, California.
map_objects = geemap.Map(center=[37.5010, -122.1899], zoom=13)

# Add the image layers to the map.
map_objects.add_layer(kelvin, {'min': 288, 'max': 305}, 'Kelvin')
map_objects.add_layer(hotspots, {'palette': 'FF0000'}, 'Hotspots')

पहली इमेज. सैन फ़्रांसिस्को के किसी इलाके का तापमान. जिन पिक्सल का तापमान 303 डिग्री केल्विन से ज़्यादा है उन्हें लाल रंग (थर्मल हॉटस्पॉट) से अलग किया जाता है.

ऑब्जेक्ट लेबल करना

ऑब्जेक्ट का विश्लेषण करने के लिए, अक्सर ऑब्जेक्ट को लेबल करना सबसे पहला चरण होता है. यहां, इमेज ऑब्जेक्ट की पहचान करने और हर ऑब्जेक्ट को एक यूनीक आईडी असाइन करने के लिए, connectedComponents() फ़ंक्शन का इस्तेमाल किया जाता है. किसी ऑब्जेक्ट से जुड़े सभी पिक्सल को एक ही पूर्णांक आईडी वैल्यू असाइन की जाती है. इसका नतीजा, इनपुट इमेज की एक कॉपी होती है. इसमें एक अतिरिक्त "लेबल" बैंड होता है, जो पिक्सल को ऑब्जेक्ट आईडी वैल्यू से जोड़ता है. यह वैल्यू, इमेज के पहले बैंड में पिक्सल की कनेक्टिविटी के आधार पर तय होती है.

कोड एडिटर (JavaScript)

// Uniquely label the hotspot image objects.
var objectId = hotspots.connectedComponents({
  connectedness: ee.Kernel.plus(1),
  maxSize: 128
});

// Display the uniquely ID'ed objects to the Map.
Map.addLayer(objectId.randomVisualizer(), null, 'Objects');

Python सेटअप

Python API के बारे में जानकारी पाने और इंटरैक्टिव डेवलपमेंट के लिए geemap का इस्तेमाल करने के लिए, Python एनवायरमेंट पेज देखें.

import ee
import geemap.core as geemap

Colab (Python)

# Uniquely label the hotspot image objects.
object_id = hotspots.connectedComponents(
    connectedness=ee.Kernel.plus(1), maxSize=128
)

# Add the uniquely ID'ed objects to the map.
map_objects.add_layer(object_id.randomVisualizer(), None, 'Objects')

ध्यान दें कि पैच का ज़्यादा से ज़्यादा साइज़ 128 पिक्सल पर सेट होता है. ज़्यादा पिक्सल वाले ऑब्जेक्ट को मास्क किया जाता है. कनेक्टिविटी की जानकारी, ee.Kernel.plus(1) कर्नल से मिलती है. यह चार-पड़ोसी कनेक्टिविटी के बारे में बताता है. आठ-पड़ोसी कनेक्टिविटी के लिए, ee.Kernel.square(1) का इस्तेमाल करें.


दूसरी इमेज. यूनीक आईडी से लेबल और स्टाइल किए गए थर्मल हॉटस्पॉट ऑब्जेक्ट.

ऑब्जेक्ट का साइज़

पिक्सल की संख्या

connectedPixelCount() इमेज के तरीके का इस्तेमाल करके, ऑब्जेक्ट बनाने वाले पिक्सल की संख्या का हिसाब लगाएं. किसी ऑब्जेक्ट में पिक्सल की संख्या जानने से, ऑब्जेक्ट के साइज़ के हिसाब से उन्हें मास्क करने और ऑब्जेक्ट के एरिया का हिसाब लगाने में मदद मिल सकती है. नीचे दिया गया स्निपेट, पिछले सेक्शन में बताई गई objectId इमेज के "लेबल" बैंड पर connectedPixelCount() लागू करता है.

कोड एडिटर (JavaScript)

// Compute the number of pixels in each object defined by the "labels" band.
var objectSize = objectId.select('labels')
  .connectedPixelCount({
    maxSize: 128, eightConnected: false
  });

// Display object pixel count to the Map.
Map.addLayer(objectSize, null, 'Object n pixels');

Python सेटअप

Python API के बारे में जानकारी पाने और इंटरैक्टिव डेवलपमेंट के लिए geemap का इस्तेमाल करने के लिए, Python एनवायरमेंट पेज देखें.

import ee
import geemap.core as geemap

Colab (Python)

# Compute the number of pixels in each object defined by the "labels" band.
object_size = object_id.select('labels').connectedPixelCount(
    maxSize=128, eightConnected=False
)

# Add the object pixel count to the map.
map_objects.add_layer(object_size, None, 'Object n pixels')

connectedPixelCount(), इनपुट इमेज की एक कॉपी दिखाता है. इसमें हर बैंड के हर पिक्सल में, चार या आठ पड़ोसियों के कनेक्शन नियम के हिसाब से, पड़ोसियों की संख्या होती है. यह नियम, eightConnected पैरामीटर में पास किए गए बूलियन आर्ग्युमेंट से तय होता है. ध्यान दें कि कनेक्टिविटी का पता, इनपुट इमेज के हर बैंड के लिए अलग-अलग लगाया जाता है. इस उदाहरण में, ऑब्जेक्ट आईडी दिखाने वाली एक-बैंड इमेज (objectId) को इनपुट के तौर पर दिया गया था. इसलिए, एक-बैंड इमेज को "लेबल" बैंड (इनपुट इमेज में इस तरह मौजूद है) के साथ दिखाया गया था. हालांकि, अब वैल्यू में ऑब्जेक्ट बनाने वाले पिक्सल की संख्या दिखती है. हर ऑब्जेक्ट के हर पिक्सल की पिक्सल की संख्या एक ही होगी.


तीसरा डायग्राम. थर्मल हॉटस्पॉट ऑब्जेक्ट, जिन्हें साइज़ के हिसाब से लेबल और स्टाइल किया गया है.

क्षेत्र

किसी ऑब्जेक्ट का क्षेत्रफल निकालने के लिए, एक पिक्सल के क्षेत्रफल को उस ऑब्जेक्ट के पिक्सल की संख्या से गुणा करें. ऑब्जेक्ट के पिक्सल की संख्या, connectedPixelCount() से तय होती है. पिक्सल का क्षेत्रफल, ee.Image.pixelArea() से जनरेट की गई इमेज से मिलता है.

कोड एडिटर (JavaScript)

// Get a pixel area image.
var pixelArea = ee.Image.pixelArea();

// Multiply pixel area by the number of pixels in an object to calculate
// the object area. The result is an image where each pixel
// of an object relates the area of the object in m^2.
var objectArea = objectSize.multiply(pixelArea);

// Display object area to the Map.
Map.addLayer(objectArea,
             {min: 0, max: 30000, palette: ['0000FF', 'FF00FF']},
             'Object area m^2');

Python सेटअप

Python API के बारे में जानकारी पाने और इंटरैक्टिव डेवलपमेंट के लिए geemap का इस्तेमाल करने के लिए, Python एनवायरमेंट पेज देखें.

import ee
import geemap.core as geemap

Colab (Python)

# Get a pixel area image.
pixel_area = ee.Image.pixelArea()

# Multiply pixel area by the number of pixels in an object to calculate
# the object area. The result is an image where each pixel
# of an object relates the area of the object in m^2.
object_area = object_size.multiply(pixel_area)

# Add the object area to the map.
map_objects.add_layer(
    object_area,
    {'min': 0, 'max': 30000, 'palette': ['0000FF', 'FF00FF']},
    'Object area m^2',
)

इसका नतीजा एक ऐसी इमेज होती है जिसमें किसी ऑब्जेक्ट का हर पिक्सल, ऑब्जेक्ट के क्षेत्रफल को वर्ग मीटर में दिखाता है. इस उदाहरण में, objectSize इमेज में एक बैंड है. अगर यह मल्टी-बैंड होती, तो गुणा करने की कार्रवाई, इमेज के हर बैंड पर लागू की जाती.

ऑब्जेक्ट को साइज़ के हिसाब से फ़िल्टर करना

ऑब्जेक्ट के साइज़ का इस्तेमाल, मास्क की शर्त के तौर पर किया जा सकता है.इससे, विश्लेषण को किसी खास साइज़ के ऑब्जेक्ट पर फ़ोकस किया जा सकता है. उदाहरण के लिए, बहुत छोटे ऑब्जेक्ट को मास्क करना. यहां पिछले चरण में कैलकुलेट की गई objectArea इमेज का इस्तेमाल मास्क के तौर पर किया गया है, ताकि एक हेक्टेयर से कम क्षेत्र वाले ऑब्जेक्ट हटाए जा सकें.

कोड एडिटर (JavaScript)

// Threshold the `objectArea` image to define a mask that will mask out
// objects below a given size (1 hectare in this case).
var areaMask = objectArea.gte(10000);

// Update the mask of the `objectId` layer defined previously using the
// minimum area mask just defined.
objectId = objectId.updateMask(areaMask);
Map.addLayer(objectId, null, 'Large hotspots');

Python सेटअप

Python API के बारे में जानकारी पाने और इंटरैक्टिव डेवलपमेंट के लिए geemap का इस्तेमाल करने के लिए, Python एनवायरमेंट पेज देखें.

import ee
import geemap.core as geemap

Colab (Python)

# Threshold the `object_area` image to define a mask that will mask out
# objects below a given size (1 hectare in this case).
area_mask = object_area.gte(10000)

# Update the mask of the `object_id` layer defined previously using the
# minimum area mask just defined.
object_id = object_id.updateMask(area_mask)
map_objects.add_layer(object_id, None, 'Large hotspots')

इसका नतीजा, objectId इमेज की एक कॉपी है, जिसमें एक हेक्टेयर से कम क्षेत्र वाले ऑब्जेक्ट को मास्क किया गया है.
चौथा चित्र. यूनीक आईडी के हिसाब से लेबल और स्टाइल किए गए थर्मल हॉटस्पॉट ऑब्जेक्ट. चौथा चित्र. कम से कम क्षेत्र (1 हेक्टेयर) के हिसाब से फ़िल्टर किए गए थर्मल हॉटस्पॉट ऑब्जेक्ट.

ज़ोन के हिसाब से आंकड़े

reduceConnectedComponents() तरीका, यूनीक ऑब्जेक्ट बनाने वाले पिक्सल पर रिड्यूसर लागू करता है. नीचे दिया गया स्निपेट, हॉटस्पॉट ऑब्जेक्ट के औसत तापमान का हिसाब लगाने के लिए इसका इस्तेमाल करता है. reduceConnectedComponents() के लिए, ऐसी इनपुट इमेज की ज़रूरत होती है जिसमें कम किए जाने वाले बैंड (या बैंड) और ऑब्जेक्ट लेबल तय करने वाले बैंड हों. यहां, सही इनपुट इमेज बनाने के लिए, objectID "लेबल" इमेज बैंड को kelvin तापमान की इमेज में जोड़ा गया है.

कोड एडिटर (JavaScript)

// Make a suitable image for `reduceConnectedComponents()` by adding a label
// band to the `kelvin` temperature image.
kelvin = kelvin.addBands(objectId.select('labels'));

// Calculate the mean temperature per object defined by the previously added
// "labels" band.
var patchTemp = kelvin.reduceConnectedComponents({
  reducer: ee.Reducer.mean(),
  labelBand: 'labels'
});

// Display object mean temperature to the Map.
Map.addLayer(
  patchTemp,
  {min: 303, max: 304, palette: ['yellow', 'red']},
  'Mean temperature'
);

Python सेटअप

Python API के बारे में जानकारी पाने और इंटरैक्टिव डेवलपमेंट के लिए geemap का इस्तेमाल करने के लिए, Python एनवायरमेंट पेज देखें.

import ee
import geemap.core as geemap

Colab (Python)

# Make a suitable image for `reduceConnectedComponents()` by adding a label
# band to the `kelvin` temperature image.
kelvin = kelvin.addBands(object_id.select('labels'))

# Calculate the mean temperature per object defined by the previously added
# "labels" band.
patch_temp = kelvin.reduceConnectedComponents(
    reducer=ee.Reducer.mean(), labelBand='labels'
)

# Add object mean temperature to the map and display it.
map_objects.add_layer(
    patch_temp,
    {'min': 303, 'max': 304, 'palette': ['yellow', 'red']},
    'Mean temperature',
)
display(map_objects)

इसका नतीजा, ऑब्जेक्ट तय करने के लिए इस्तेमाल किए गए बैंड के बिना इनपुट इमेज की कॉपी होती है. इसमें पिक्सल वैल्यू, हर ऑब्जेक्ट और हर बैंड के लिए, पिक्सल की संख्या में कमी के नतीजे को दिखाती हैं.


पांचवां चित्र. थर्मल हॉटस्पॉट ऑब्जेक्ट पिक्सल, जिनमें औसत तापमान के हिसाब से खास जानकारी दी गई है और जिनका स्टाइल किया गया है.