विजेट

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

ui.Label

लेबल, वे जगहें होती हैं जहां टेक्स्ट दिखता है. उदाहरण के लिए, नीचे दिया गया कोड एक लेबल प्रिंट करता है:

कोड एडिटर (JavaScript)

var label = ui.Label('Cool label!');
print(label);

यह कुछ ऐसा दिखता है:

ui_label.png

लंबे लेबल को छोटे लेबल में बांटने के लिए, नई लाइन वाला वर्ण (\n) डालें. साथ ही, whiteSpace स्टाइल प्रॉपर्टी आर्ग्युमेंट को 'pre' पर सेट करें:

print(ui.Label('Here is a:\nnew line', {whiteSpace: 'pre'}));

ui.Button

बटन, एक इंटरैक्टिव यूज़र इंटरफ़ेस (यूआई) विजेट होता है. इस पर क्लिक किया जा सकता है. जब कोई उपयोगकर्ता बटन पर क्लिक करता है, तब कॉल किए जाने वाले फ़ंक्शन ("कॉलबैक" फ़ंक्शन) के बारे में बताया जा सकता है. (कॉलबैक फ़ंक्शन की मदद से इवेंट मैनेज करने के बारे में ज़्यादा जानने के लिए, इवेंट पेज देखें). नीचे दिए गए उदाहरण में, बटन पर क्लिक करने पर मैप का मौजूदा सेंटर प्रिंट होता है:

कोड एडिटर (JavaScript)

var button = ui.Button({
  label: 'Get Map Center',
  onClick: function() {
    print(Map.getCenter());
  }
});
print(button);

यह कुछ ऐसा दिखता है:

ui_button.png

ui.Checkbox

चेकबॉक्स एक ऐसा विजेट है जिसकी मदद से उपयोगकर्ता किसी बॉक्स पर सही का निशान लगा सकता है या हटा सकता है. जब चेकबॉक्स की स्थिति बदलती है, तो विजेट में रजिस्टर किए गए कॉलबैक को एक बूलियन वैल्यू पास की जाती है. इससे पता चलता है कि चेकबॉक्स पर अब सही का निशान लगा है या नहीं. उदाहरण के लिए:

कोड एडिटर (JavaScript)

var checkbox = ui.Checkbox('Show SRTM layer', true);

checkbox.onChange(function(checked) {
  // Shows or hides the first map layer based on the checkbox's value.
  Map.layers().get(0).setShown(checked);
});

Map.addLayer(ee.Image('CGIAR/SRTM90_V4'));
print(checkbox);

प्रिंट किया गया चेकबॉक्स कुछ ऐसा दिखना चाहिए:

ui_checkbox.png

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

ui.Slider

स्लाइडर एक ऐसा विजेट है जिसकी मदद से उपयोगकर्ता, स्लाइडर की रेंज में कोई संख्या पाने के लिए स्लाइडर को अडजस्ट कर सकता है. कंस्ट्रक्टर का इस्तेमाल करके या स्लाइडर की प्रॉपर्टी सेट करके, रेंज को कॉन्फ़िगर करें. इस उदाहरण में, मैप पर पहली लेयर की ओपैसिटी सेट करने के लिए, स्लाइडर का इस्तेमाल किया गया है:

कोड एडिटर (JavaScript)

var slider = ui.Slider();

slider.setValue(0.9);  // Set a default value.
slider.onChange(function(value) {
  Map.layers().get(0).setOpacity(value);
});

Map.addLayer(ee.Image(255), {palette: 'blue'});
print(slider);

स्लाइडर कुछ ऐसा दिखना चाहिए:

ui_slider.png

ध्यान दें कि स्लाइडर की वैल्यू, स्लाइडर की दाईं ओर दिखती है.

ui.DateSlider

DateSlider विजेट, Slider विजेट की तरह ही है. हालांकि, यह तारीखों को साफ़ तौर पर मैनेज करता है. जून 2018 में से कोई दिन चुनने के लिए कॉन्फ़िगर किया गया DateSlider ऐसा दिखता है:

DateSlider.png

DateSlider का इस्तेमाल, कलेक्शन को फ़िल्टर करने के लिए किया जाता है. जैसा कि इस उदाहरण में दिखाया गया है, DateSlider में सेट किए गए DateRange के आधार पर, सालाना कंपोज़िट बनाया जाता है:

कोड एडिटर (JavaScript)

// Use a DateSlider to create annual composites of this collection.
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1');
// Use the start of the collection and now to bound the slider.
var start = ee.Image(collection.first()).date().get('year').format();
var now = Date.now();
var end = ee.Date(now).format();

// Run this function on a change of the dateSlider.
var showMosaic = function(range) {
  var mosaic = ee.Algorithms.Landsat.simpleComposite({
    collection: collection.filterDate(range.start(), range.end())
  });
  // Asynchronously compute the name of the composite.  Display it.
  range.start().get('year').evaluate(function(name) {
    var visParams = {bands: ['B4', 'B3', 'B2'], max: 100};
    var layer = ui.Map.Layer(mosaic, visParams, name + ' composite');
    Map.layers().set(0, layer);
  });
};

// Asynchronously compute the date range and show the slider.
var dateRange = ee.DateRange(start, end).evaluate(function(range) {
  var dateSlider = ui.DateSlider({
    start: range['dates'][0],
    end: range['dates'][1],
    value: null,
    period: 365,
    onChange: showMosaic,
    style: {width: '180px'}
  });
  Map.add(dateSlider.setValue(now));
});

// Initialize the map location at southern Africa.
Map.setCenter(23.861, -27.144, 6);

ui.Textbox

टेक्स्टबॉक्स, उपयोगकर्ता के डाले गए टेक्स्ट को इकट्ठा करने की जगह है. उदाहरण के लिए:

कोड एडिटर (JavaScript)

var textbox = ui.Textbox({
  placeholder: 'Enter text here...',
  onChange: function(text) {
    print('So what you are saying is ' + text + '?');
  }
});
print(textbox);

टेक्स्टबॉक्स कुछ ऐसा दिखना चाहिए:

ui_textbox.png

ध्यान दें कि कॉलबैक सिर्फ़ तब ट्रिगर होता है, जब उपयोगकर्ता टेक्स्ट डालना खत्म कर देता है (और वापस जाएं बटन दबाता है) या उपयोगकर्ता टेक्स्टबॉक्स से दूर क्लिक करता है.

ui.Select

चुनने वाला विजेट, विकल्पों का एक ड्रॉप-डाउन मेन्यू दिखाता है. इसमें से उपयोगकर्ता कोई एक विकल्प चुन सकता है. नीचे दिए गए उदाहरण में, ड्रॉप-डाउन मेन्यू दिखाया गया है. इससे उपयोगकर्ता को कोई जगह चुनने की सुविधा मिलती है:

कोड एडिटर (JavaScript)

var places = {
  MTV: [-122.0849, 37.3887],
  PEK: [116.4056, 39.9097],
  ZRH: [8.536, 47.376]
};

var select = ui.Select({
  items: Object.keys(places),
  onChange: function(key) {
    Map.setCenter(places[key][0], places[key][1]);
  }
});

// Set a place holder.
select.setPlaceholder('Choose a location...');

print(select);

चुनने वाला विजेट कुछ ऐसा दिखना चाहिए:

ui_select.png

ui.Chart

ui.Chart पैकेज में मौजूद चार्ट, Chart पैकेज में मौजूद चार्ट की तरह ही काम करते हैं. खास तौर पर, ui.Chart, Google Visualization API के ChartWrapper के इंस्टेंस के आस-पास एक पतली शेल होती है. ChartWrapper ऑब्जेक्ट में बदलाव करने के बारे में ज़्यादा जानने के लिए, यह रेफ़रंस देखें. Earth Engine में चार्ट हेल्पर फ़ंक्शन के बारे में ज़्यादा जानने के लिए, चार्ट के दस्तावेज़ देखें.

ui.Thumbnail

थंबनेल विजेट का इस्तेमाल, ee.Image और ee.ImageCollection ऑब्जेक्ट की झलक देखने के लिए किया जा सकता है. ee.Image देने पर, विजेट एक स्टैटिक इमेज दिखाएगा. वहीं, ee.ImageCollection देने पर, यह इनपुट में मौजूद हर इमेज के लिए एक फ़्रेम वाला ऐनिमेशन दिखाएगा. ee.Image.getThumbURL() और ee.ImageCollection.getVideoThumbURL() की तरह ही, थंबनेल के फ़ॉर्मैट और डाइमेंशन को कंट्रोल करने के लिए पैरामीटर तय किए जा सकते हैं:

कोड एडिटर (JavaScript)

// Create a box around an area in the Brazilian Amazon.
var box = ee.Geometry.Polygon([[
  [-62.9564, 2.5596], [-62.9550, 2.4313], [-62.8294, 2.4327], [-62.8294, 2.5596]
]]);

// Visualize the image in RGB.
var image = ee.Image('LANDSAT/LE07/C02/T1_L2/LE07_233058_20011113')
                .select(['SR_B[1-3]'])  // blue, green, red reflectance
                .multiply(0.0000275).add(-0.2)  // apply scaling factors
                .visualize({
                  bands: ['SR_B3', 'SR_B2', 'SR_B1'],
                  min: 0,
                  max: 0.12,
                  gamma: 1.3
                });

// Print a thumbnail to the console.
print(ui.Thumbnail({
  image: image,
  params: {dimensions: '256x256', region: box, format: 'png'},
  style: {height: '300px', width: '300px'}
}));

थंबनेल कुछ ऐसा दिखना चाहिए:

ui_thumbnail.png

ui.Map

ui.Map एक मैप विजेट है. (असल में, डिफ़ॉल्ट कोड एडिटर मैप इस क्लास का एक इंस्टेंस है). अन्य विजेट की तरह, कंसोल पर मैप को प्रिंट किया जा सकता है. मैप के कॉन्टेंट में बदलाव करने के लिए, अलग-अलग लेयर को मिटाएं, पाएं या सेट करें. यहां दिए गए उदाहरण में, कंसोल पर एक मैप प्रिंट किया गया है. इसमें कोड एडिटर के मैप की सीमाएं दिखाई गई हैं:

कोड एडिटर (JavaScript)

// Make a little map.
var map = ui.Map();

// Make the little map display an inset of the big map.
var createInset = function() {
  var bounds = ee.Geometry.Rectangle(Map.getBounds());
  map.centerObject(bounds);
  map.clear();
  map.addLayer(bounds);
};

// Run it once to initialize.
createInset();

// Get a new inset map whenever you click on the big map.
Map.onClick(createInset);

// Display the inset map in the console.
print(map);

इन्सर्ट मैप कुछ ऐसा दिखना चाहिए:

ui_map.png

इस उदाहरण में, उपयोगकर्ता को बड़े मैप पर क्लिक करना होगा, ताकि छोटे मैप में इनसेट को ड्रॉ किया जा सके.

मैप इंस्टेंस पर layers() को कॉल करके, मैप पर लेयर में बदलाव भी किया जा सकता है. layers(), ui.data.ActiveList को दिखाता है. यह अरे जैसा ऑब्जेक्ट होता है. इसे बदलने पर, मैप पर मौजूद लेयर भी बदल जाती हैं. ui.Map.Layer सेक्शन में जाकर ज़्यादा जानें.

ui.Map.Layer

लेयर, ui.Button की तरह स्टाइल किया जा सकने वाला विजेट नहीं है. यह मैप पर लेयर के डेटा को दिखाने का एक तरीका है. यहां दिए गए उदाहरण में, लेयर बनाकर और उपयोगकर्ता के इनपुट के आधार पर लेयर की प्रॉपर्टी अपडेट करके, मैप को अपडेट करने का तरीका बताया गया है:

कोड एडिटर (JavaScript)

var consoleMap = ui.Map({
  lon: -2.0174,
  lat: 48.6474,
  zoom: 13
});

// Create a Layer from this Sentinel-2 image
var image = ee.Image('COPERNICUS/S2_HARMONIZED/20150821T111616_20160314T094808_T30UWU');
var visParams = {bands: ['B4', 'B3', 'B2'], max: 2048, gamma: 1};
var layer = ui.Map.Layer(image, visParams);

// Update the map by updating the layers list.
var layers = consoleMap.layers();
layers.add(layer);

// Make a textbox to accept a gamma value.
// Update the layer when the gamma value is entered.
var gammaBox = ui.Textbox({
  value: 1,
  onChange: function(value) {
    // visParams is NOT an ActiveDictionary, so set it again.
    visParams.gamma = value;
    layer.setVisParams(visParams);
  }
});

print(ui.Label('Enter a gamma value:'));
print(gammaBox);
print(consoleMap);

ui.Map.CloudStorageLayer

अगर आपको किसी ऐसी लेयर को दिखाना है जिसे कंप्यूट करने में ज़्यादा खर्च आता है (उदाहरण के लिए, किसी ऐप्लिकेशन में), तो बेहतर परफ़ॉर्मेंस के लिए, अपने डेटा को Cloud Storage बकेट में एक्सपोर्ट करना सही रहेगा. ये स्टैटिक और सिर्फ़ विज़ुअलाइज़ेशन वाली लेयर, आपके ऐप्लिकेशन और स्क्रिप्ट को ज़्यादा रिस्पॉन्सिव बना सकती हैं. इसके लिए, Export.map.toCloudStorage() का इस्तेमाल करके, स्टैटिक डिसप्ले लेयर बनाई जा सकती है. Export.map.toCloudStorage() से पहले एक्सपोर्ट किए गए टाइल सेट का इस्तेमाल करने के लिए, Cloud Storage की किसी बकेट और पाथ से नया ui.Map.Layer बनाएं:

Map.add(ui.Map.CloudStorageLayer({
  bucket: 'earthenginepartners-hansen',
  path: 'tiles/gfc_v1.4/loss_year',
  maxZoom: 12,
  suffix: '.png'
}));

Cloud Storage लेयर को लोड करने वाली स्क्रिप्ट चलाते समय, आपको चेतावनी वाला यह मैसेज दिख सकता है:

बादलों की परत की चेतावनी

ui.Map.DrawingTools

कोड एडिटर में Map में डिफ़ॉल्ट रूप से, ज्यामिति ड्रॉइंग टूल का एक सेट जोड़ा जाता है. Map.drawingTools() को कॉल करके, डिफ़ॉल्ट Map में इन टूल के काम करने के तरीके को बदला जा सकता है. उदाहरण के लिए, ड्रॉइंग टूल छिपाने के लिए:

कोड एडिटर (JavaScript)

Map.drawingTools().setShown(false);

नए मैप में, ड्रॉइंग टूल डिफ़ॉल्ट रूप से नहीं मिलते. हालांकि, मैप पर drawingTools() मेथड को कॉल करके, इन्हें चालू किया जा सकता है:

कोड एडिटर (JavaScript)

var map = ui.Map();
// Prints true since drawingTools() adds drawing tools to the map.
print(map.drawingTools().getShown());
// Replace the default Map with the newly created map.
ui.root.widgets().reset([map]);

ड्रॉइंग टूल से बनाई गई ज्यामिति लेयर को ui.data.ActiveList में डाला जाता है. इसे Map.drawingTools().layers() को कॉल करके ऐक्सेस किया जा सकता है. ज्यामिति लेयर की सूची, अन्य ऐक्टिव सूचियों की तरह ही इवेंट के हिसाब से काम करती है. उदाहरण के लिए, Map.layers() से मिले Map पर लेयर की सूची. नीचे दिए गए उदाहरण में, टूल से बनाई गई ज्यामिति लेयर की विज़िबिलिटी सेट करने का तरीका बताया गया है. ये लेयर डिफ़ॉल्ट रूप से दिखती हैं:

कोड एडिटर (JavaScript)

Map.drawingTools().layers().forEach(function(layer) {
  layer.setShown(false);
});

ड्रॉइंग टूल में प्रोग्राम के हिसाब से लेयर जोड़ने के लिए, ड्रॉइंग टूल पर addLayer तरीके को कॉल करें या लेयर की सूची में सीधे लेयर जोड़ें:

कोड एडिटर (JavaScript)

var geometries = [ee.Geometry.Point([0,0]), ee.Geometry.Rectangle([[0,0], [1,1]])];
Map.drawingTools().addLayer(geometries, 'my_geometry1', 'red');

var layer = ui.Map.GeometryLayer(geometries, 'my_geometry2', 'blue');
Map.drawingTools().layers().add(layer);

ऐप्लिकेशन पब्लिश करने पर, ड्रॉइंग टूल की स्थिति भी सेव हो जाती है. अगर आपने ड्रॉइंग टूल दिखाए या छिपाए हैं, तो वे आपके ऐप्लिकेशन में भी दिखेंगे या छिप जाएंगे. इंपोर्ट की गई ज्यामिति भी आपके ऐप्लिकेशन में सेव हो जाएगी.

ui.Map.GeometryLayer

GeometryLayer, ज्यामिति का एक कलेक्शन होता है. यह एक Geometry, GeometryCollection या FeatureCollection के तौर पर काम करता है. इसे आपकी स्क्रिप्ट के सबसे ऊपर मौजूद इंपोर्ट सेक्शन में जोड़ा जाता है. साथ ही, कोड में इसका रेफ़रंस दिया जा सकता है.

ड्रॉइंग टूल से बनाए गए GeometryLayer का डिफ़ॉल्ट ऐक्शन और सेटिंग होता है. इसे नए कॉलबैक फ़ंक्शन देकर बदला जा सकता है. उदाहरण के लिए, मान लें कि आपको किसी इवेंट को ट्रिगर करने के लिए, ज्यामिति में इंटरैक्टिव बदलाव करने हैं. किसी खास व्यवहार को लागू करने के लिए, टूल पर onEdit(), onErase() या onDraw() तरीके सेट किए जा सकते हैं, ताकि उपयोगकर्ता की कार्रवाइयों का जवाब दिया जा सके. नीचे दिए गए उदाहरण में, उपयोगकर्ता के कोई ज्यामिति जोड़ने/उसमें बदलाव करने/उसे मिटाने पर, कैलकुलेशन को ट्रिगर करने और कैलकुलेशन के नतीजे के साथ लेबल को अपडेट करने का तरीका बताया गया है:

कोड एडिटर (JavaScript)

// Load elevation data.
var srtm = ee.Image('NASA/NASADEM_HGT/001').select('elevation');
Map.addLayer(srtm, {min: 0, max: 5000}, 'SRTM');

// Make a label to display mean elevation at drawn points.
var label = new ui.Label('Draw points to calculate mean elevation');
var inspector = new ui.Panel([label]);
Map.add(inspector);
// Don't make imports that correspond to the drawn points.
Map.drawingTools().setLinked(false);
// Limit the draw modes to points.
Map.drawingTools().setDrawModes(['point']);
// Add an empty layer to hold the drawn points.
Map.drawingTools().addLayer([]);
// Set the geometry type to be point.
Map.drawingTools().setShape('point');
// Enter drawing mode.
Map.drawingTools().draw();

// This function gets called when the geometry layer changes.
// Use debounce to call the function at most every 100 milliseconds.
var getAverageElevation = ui.util.debounce(function() {
  var points = Map.drawingTools().layers().get(0).toGeometry();
  var elevation = srtm.reduceRegion({
    reducer: ee.Reducer.mean(),
    geometry: points,
    scale: 30
  }).get('elevation');
  // Asynchronously evaluate the mean elevation.
  elevation.evaluate(showElevation);
}, 100);

// Set the callback function on changes of the geometry layer.
Map.drawingTools().onEdit(getAverageElevation);
Map.drawingTools().onDraw(getAverageElevation);
Map.drawingTools().onErase(getAverageElevation);

// Set the label to the result of the mean reduction.
function showElevation(elevation) {
  inspector.clear();
  var elevationLabel = ui.Label('Mean elevation: ' + elevation);
  inspector.add(elevationLabel);
}

ध्यान दें कि setLinked() का इस्तेमाल, कोड एडिटर के ज्यामिति ड्रॉइंग टूल और इंपोर्ट सेक्शन के बीच कनेक्शन को टॉगल करने के लिए किया जाता है. इस उदाहरण में, ज्यामिति टूल अनलिंक किए गए हैं, ताकि इंपोर्ट न बनाए जा सकें. toGeometry का इस्तेमाल, लेयर को ee.Geometry में बदलने के लिए किया जाता है. अगर इंपोर्ट की गई लेयर, Feature या FeatureCollection को दिखाती है, तो getEeObject() का इस्तेमाल करके, EE ऑब्जेक्ट को वापस पाया जा सकता है. ui.util.debounce के इस्तेमाल पर भी ध्यान दें, ताकि ज्यामिति के हर मूवमेंट से कॉलबैक फ़ंक्शन ट्रिगर न हो. खास तौर पर, फ़ंक्शन तब तक ट्रिगर नहीं होगा, जब तक कि पिछले इवेंट के बाद 100 मिलीसेकंड न बीत जाएं. इससे यह पक्का करने में मदद मिलती है कि फ़ंक्शन सिर्फ़ तब चले, जब उपयोगकर्ता ने बदलाव करने की कार्रवाई पूरी कर ली हो.

इंपोर्ट की गई फ़ाइलों में मौजूद ज्यामिति लेयर, Geometry या GeometryCollection से जुड़ी होती है. इसलिए, इसमें सिर्फ़ एक जैसी जियोडेसिक स्थिति वाली ज्यामिति शामिल हो सकती हैं. ऐसा इसलिए, क्योंकि GeoJSON फ़ॉर्मैट में ज्यामिति के कलेक्शन के लिए, सिर्फ़ एक जियोडेसिक स्थिति की अनुमति होती है. ज़्यादा जानकारी के लिए, जियोडेसिक बनाम प्लेनर ज्यामिति पेज देखें. लेयर के नाम के बगल में मौजूद गियर आइकॉन को दबाकर, ज्यामिति लेयर को FeatureCollection में बदला जा सकता है. इससे आपको एक ही लेयर में जियोडेसिक और प्लेनर ज्यामिति जोड़ने की सुविधा मिलेगी. हालांकि, इसे वापस Geometry में बदलने पर गड़बड़ी होगी. इससे बचने के लिए, या तो FeatureCollection में बदलें या ज्यामिति को तब तक मिटाएं, जब तक कि लेयर में सिर्फ़ एक जियोडेसिक स्टेट न रह जाए.

ui.Map.Linker

लेयर की तरह, लिंकर को भी स्टाइल नहीं किया जा सकता. यह पर्दे के पीछे काम करने वाली एक सुविधा है. इसका इस्तेमाल, ui.Map के कई इंस्टेंस के मूवमेंट को सिंक करने के लिए किया जा सकता है:

कोड एडिटर (JavaScript)

// Add two maps to the screen.
var left = ui.Map();
var right = ui.Map();
ui.root.clear();
ui.root.add(left);
ui.root.add(right);

// Link the "change-bounds" event for the maps.
// When the user drags one map, the other will be moved in sync.
ui.Map.Linker([left, right], 'change-bounds');

ui.SplitPanel

ui.SplitPanel का इस्तेमाल, चीज़ों की अगल-बगल में तुलना करने के लिए किया जाता है. दो सामान्य पैनल के मुकाबले, ui.SplitPanel का फ़ायदा यह है कि ui.SplitPanel में पैनल के बीच वाइप ट्रांज़िशन पाने के लिए, हैंडल का इस्तेमाल किया जा सकता है. यहां दिए गए उदाहरण में, जलने के निशान के स्पेक्ट्रल अंतर को दिखाने के लिए, ui.SplitPanel का इस्तेमाल किया गया है:

कोड एडिटर (JavaScript)

// Load an image of the Santa Rosa, California 2017 fires.
var image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_045033_20171011');

// Add a color-SWIR composite to the default Map.
Map.setCenter(-122.6624, 38.5011, 12);
Map.addLayer(image, {bands: ['B7', 'B5', 'B3'], max: 0.3}, 'color-SWIR');

// Make another map and add a color-NIR composite to it.
var linkedMap = ui.Map();
linkedMap.addLayer(image, {bands: ['B5', 'B4', 'B3'], max: 0.3}, 'color-NIR');
// Add a thermal image to the map.
linkedMap.addLayer(image, {
  bands: ['B11'],
  min: 290,
  max: 305,
  palette: ['gray', 'white', 'yellow', 'red']
}, 'Thermal');

// Link the default Map to the other map.
var linker = ui.Map.Linker([ui.root.widgets().get(0), linkedMap]);

// Make an inset map and add it to the linked map.
var inset = ui.Map();
inset.style().set({position: 'bottom-right', width: '300px', height: '250px'});
inset.setControlVisibility({all: false, mapTypeControl: true});
linkedMap.add(inset);

// Register a function to the linked map to update the inset map.
linkedMap.onChangeBounds(function() {
  var bounds = ee.Geometry.Rectangle(Map.getBounds());
  inset.centerObject(bounds);
  inset.layers().set(0, bounds);
});

// Create a SplitPanel which holds the linked maps side-by-side.
var splitPanel = ui.SplitPanel({
  firstPanel: linker.get(0),
  secondPanel: linker.get(1),
  orientation: 'horizontal',
  wipe: true,
  style: {stretch: 'both'}
});

// Set the SplitPanel as the only thing in root.
ui.root.widgets().reset([splitPanel]);

ध्यान दें कि wipe पैरामीटर को true पर सेट किया गया है, ui.SplitPanel कंस्ट्रक्टर में, ताकि उपयोगकर्ता हैंडल को स्वाइप कर सके दोनों विज़ुअलाइज़ेशन के बीच आगे और पीछे.

विजेट की स्टाइल सेट करना

किसी विजेट की स्टाइल को, विजेट की स्टाइल प्रॉपर्टी की डिक्शनरी से कंट्रोल किया जाता है. विजेट पर style() को कॉल करके, शब्दकोश को ऐक्सेस किया जा सकता है. style() से मिला ऑब्जेक्ट, ui.data.ActiveDictionary का एक इंस्टेंस है. इसका मतलब है कि स्टाइल डिक्शनरी की प्रॉपर्टी सेट करने से, विजेट के दिखने का तरीका अपने-आप अपडेट हो जाता है. हर विजेट की स्टाइल डिक्शनरी के लिए इस्तेमाल की जा सकने वाली कुंजियों के बारे में, style() कॉल के लिए विजेट के रेफ़रंस दस्तावेज़ों में बताया गया है.

विजेट की स्टाइल को कंस्ट्रक्टर के साथ सेट किया जा सकता है. इसके लिए, style().set() को कॉल करें या डिक्शनरी आर्ग्युमेंट के साथ style() को कॉल करें. उदाहरण के लिए:

कोड एडिटर (JavaScript)

var redLabel = ui.Label('Big, Red Label');

redLabel.style().set('color', 'red');
redLabel.style().set('fontWeight', 'bold');
redLabel.style().set({
  fontSize: '32px',
  padding: '10px'
});

print(redLabel);

ध्यान दें कि इस उदाहरण में, लेबल को पहले कुंजी और वैल्यू आर्ग्युमेंट के साथ style().set() को कॉल करके स्टाइल किया गया है. इसके बाद, डिक्शनरी आर्ग्युमेंट के साथ style().set() को कॉल करके स्टाइल किया गया है. दूसरा कॉल, पहले कॉल को ओवरराइड नहीं करता. यह स्टाइल डिक्शनरी को बदलने के बजाय, अलग-अलग स्टाइल प्रॉपर्टी को जोड़ता और बदलता है.

विजेट के लिए स्टाइलिंग के विकल्पों के बारे में ज़्यादा जानने के लिए, हर विजेट के लिए style() दस्तावेज़ में दी गई स्टाइल के लिए, यह कैस्केडिंग स्टाइल शीट (सीएसएस) रेफ़रंस देखें. ध्यान दें कि Earth Engine विजेट के लिए इस्तेमाल की जा सकने वाली स्टाइल, कई जगहों पर सीएसएस स्टाइल से अलग होती हैं. खास तौर पर, font-style और font-weight के लिए, fontSize और fontWeight.

स्टाइल डिक्शनरी में ऐसी कुंजियां भी होती हैं जो विजेट की पोज़िशन को कंट्रोल करती हैं. पोज़िशन से जुड़ी प्रॉपर्टी इस्तेमाल करने के तरीके के बारे में ज़्यादा जानने के लिए, पैनल और लेआउट पेज देखें.