មេរៀនទី១៤៖ កម្មវិធី Earth Engine និងផែនទីវេប¶

ព័ត៌មានមេរៀន

រយៈពេលបង្រៀនដែលស្នើ៖ ៣ ម៉ោង · មេរៀនទី ១៤ ក្នុងចំណោម ១៥

រហូតមកដល់ពេលនេះ លទ្ធផលរបស់យើងរស់នៅក្នុង Code Editor៖ ស្គ្រីប Console និងផ្ទាំង Tasks ដែលមានតែអ្នកមានគណនី Earth Engine ទេដែលប្រើបាន។ ប៉ុន្តែអ្នកដែលត្រូវការលទ្ធផលពិតប្រាកដ (មន្ត្រីខេត្ត អង្គការ កសិករ និស្សិតផ្សេងទៀត) មិនសរសេរកូដទេ។ ពួកគេត្រូវការ តំណមួយ ដែលបើកផែនទី ជ្រើសឆ្នាំ ចុចលើភូមិ ហើយឃើញក្រាប។

មេរៀននេះបង្រៀនការបង្កើត កម្មវិធី Earth Engine (Earth Engine Apps) ដោយ ui API៖ widgets ផ្ទាំង និងផែនទី ព្រឹត្តិការណ៍ និង callback ការរក្សាឱ្យកម្មវិធីលឿន ផែនទីពីរភ្ជាប់គ្នា និងការបោះពុម្ព ព្រមទាំងជម្រើសផ្សេងសម្រាប់ចែករំលែកលទ្ធផល។

១៤.១. គោលបំណងសិក្សា¶

បន្ទាប់ពីបញ្ចប់មេរៀន និស្សិតអាច៖

ពិពណ៌នារចនាសម្ព័ន្ធកម្មវិធី Earth Engine (ui.root ui.Panel ui.Map) និង widgets សំខាន់ៗ។
សរសេរ callback ដែលធ្វើបច្ចុប្បន្នភាពផែនទី និងក្រាប នៅពេលអ្នកប្រើប្ដូរជម្រើស ឬចុចលើផែនទី។
ប្រើ evaluate() ជំនួស getInfo() ហើយពន្យល់ហេតុផល។
បង្កើតផែនទីពីរភ្ជាប់គ្នា (SplitPanel · Linker) សម្រាប់ការប្រៀបធៀបមុន–ក្រោយ។
បោះពុម្ពកម្មវិធី ហើយប្រៀបធៀបជម្រើសចែករំលែកផ្សេង (Export ទៅ QGIS geemap ផែនទីវេប)។

ចំណេះដឹងមុនត្រូវមាន¶

មេរៀនទី២៖ មុខងារ client និង server · មេរៀនទី៥៖ ui.Chart · មេរៀនទី៧៖ ផែនទីទឹក។

១៤.២. ស្ថានភាពបើកមេរៀន៖ ឧបករណ៍តាមដានទន្លេសាប¶

គណៈកម្មាធិការគ្រប់គ្រងគ្រោះមហន្តរាយខេត្តជុំវិញបឹងទន្លេសាប ចង់បានឧបករណ៍សាមញ្ញមួយ៖ ជ្រើសឆ្នាំ និងខែ ឃើញផ្ទៃទឹកលើផែនទី ឃើញក្រាបផ្ទៃទឹកប្រចាំខែ ហើយចុចលើភូមិណាមួយ ដើម្បីដឹងថាទីនោះលិចទឹកញឹកញាប់ប៉ុណ្ណា។ មន្ត្រីមិនមានគណនី Earth Engine ទេ ហើយប្រើទូរស័ព្ទ ឬកុំព្យូទ័រយួរដៃ។

សំណួរដែលមេរៀននេះឆ្លើយ៖

តើកម្មវិធី Earth Engine មានរចនាសម្ព័ន្ធយ៉ាងណា?
តើកម្មវិធីឆ្លើយតបទៅនឹងការចុច និងការជ្រើសរបស់អ្នកប្រើយ៉ាងដូចម្ដេច?
តើត្រូវធ្វើឱ្យកម្មវិធីលឿន ហើយបោះពុម្ពវាយ៉ាងណា?

១៤.៣. ទ្រឹស្ដីស្នូល¶

១៤.៣.១. រចនាសម្ព័ន្ធកម្មវិធី¶

រូបទី១៤.១៖ ផ្ទាំងបញ្ជា + ផែនទី។

អានរូបនេះ

កម្មវិធីភាគច្រើនមានផ្ទាំងបញ្ជា (widgets) នៅម្ខាង និងផែនទីធំនៅម្ខាងទៀត។
Widgets ទាំងអស់ជាវត្ថុ ui.* ដែលដាក់ក្នុង ui.Panel។
អ្នកប្រើមិនឃើញកូដទេ៖ ពួកគេឃើញតែផ្ទាំង ផែនទី និងក្រាប។

Code Editor មាន ui.root ដែលជាផ្ទាំងមេ។ កម្មវិធីភាគច្រើន៖ លុបផ្ទាំងលំនាំដើម បង្កើត ui.Panel សម្រាប់បញ្ជា និង ui.Map សម្រាប់ផែនទី ហើយដាក់ទាំងពីរក្នុង ui.root៖

ui.root.clear();
var map = ui.Map();
map.setOptions('HYBRID');
map.setCenter(104.0, 12.8, 9);
var panel = ui.Panel({style: {width: '340px', padding: '8px'}});
panel.add(ui.Label('ឧបករណ៍តាមដានទន្លេសាប', {fontSize: '20px', fontWeight: 'bold'}));
panel.add(ui.Label('ជ្រើសឆ្នាំ និងខែ ដើម្បីមើលផ្ទៃទឹក។ ចុចលើផែនទី ដើម្បីមើលភាពញឹកញាប់នៃការលិច។'));
ui.root.add(panel);
ui.root.add(map);

១៤.៣.២. Widgets¶

រូបទី១៤.២៖ ប្លុកសាងសង់នៃកម្មវិធី។

អានរូបនេះ

Widget នីមួយៗមាន style (ទំហំ ពណ៌ ពុម្ពអក្សរ) និង callback (មុខងារដែលរត់ពេលអ្នកប្រើធ្វើអ្វីមួយ)។
ui.Chart.* ដដែលក្នុង Console អាចដាក់ក្នុង Panel បាន។
ពុម្ពអក្សរខ្មែរបង្ហាញបានក្នុងកម្មវិធី ប៉ុន្តែទំហំ និងចន្លោះបន្ទាត់ត្រូវកែតាម style។

Widget នីមួយៗមាន style (ទំហំ ពណ៌ ចន្លោះ) និងអាចមាន callback៖

var yearSel = ui.Select({items: ['2016', '2017', '2018', '2019', '2020', '2021'], value: '2020'});
var monthSl = ui.Slider({min: 1, max: 12, step: 1, value: 10});
var info = ui.Label('ចុចលើផែនទី…');
panel.add(ui.Label('ឆ្នាំ')).add(yearSel).add(ui.Label('ខែ')).add(monthSl).add(info);

panel.add() ត្រឡប់ panel វិញ ដូច្នេះអាចភ្ជាប់បានជាខ្សែ។ ui.Select ទទួល items ជាអក្សរ ដូច្នេះត្រូវបម្លែងទៅជាលេខ (parseInt) មុនប្រើ។

១៤.៣.៣. ព្រឹត្តិការណ៍ និង callback¶

រូបទី១៤.៣៖ កម្មវិធីរង់ចាំ ហើយឆ្លើយតប។

អានរូបនេះ

callback គឺជាមុខងារដែលយើងផ្ដល់ឱ្យ widget៖ វារត់តែនៅពេលអ្នកប្រើធ្វើសកម្មភាព។
ប្ដូរស្រទាប់ដោយ layers().set() ជំនួស addLayer() ម្ដងទៀត ដើម្បីកុំឱ្យស្រទាប់ជាន់គ្នារាប់សិប។
គណនាតែអ្វីដែលត្រូវការ៖ កម្មវិធីដែលរង់ចាំយូរ ធ្វើឱ្យអ្នកប្រើចាកចេញ។

កម្មវិធីមិនរត់ពីលើចុះក្រោមម្ដងហើយបញ្ចប់ទេ៖ វា រង់ចាំ ព្រឹត្តិការណ៍ ហើយរត់ callback៖

var gswM = ee.ImageCollection('JRC/GSW1_4/MonthlyHistory');           // ១៩៨៤–២០២១ · 0 គ្មានទិន្នន័យ · 1 ដី · 2 ទឹក
function waterOf(y, m) {
  return gswM.filter(ee.Filter.eq('year', y)).filter(ee.Filter.eq('month', m)).first().eq(2).selfMask();
}
function refresh() {
  var y = parseInt(yearSel.getValue(), 10), m = monthSl.getValue();
  map.layers().set(0, ui.Map.Layer(waterOf(y, m), {palette: ['#1565c0']}, 'ទឹក ' + y + '-' + m));
}
yearSel.onChange(refresh);
monthSl.onChange(refresh);
refresh();

ប្រើ map.layers().set(0, …) ដើម្បីជំនួសស្រទាប់ទី ០ ជំនួសឱ្យ map.addLayer() ដែលនឹងបន្ថែមស្រទាប់ថ្មីរាល់ពេលអ្នកប្រើរំកិល។ JRC Monthly History គ្របរហូតដល់ឆ្នាំ ២០២១ ប៉ុណ្ណោះ៖ សម្រាប់ឆ្នាំថ្មីជាងនេះ ប្រើផែនទីទឹក Sentinel-1 ពីមេរៀនទី៧។

១៤.៣.៤. getInfo() ឬ evaluate()¶

រូបទី១៤.៤៖ កុំឱ្យកម្មវិធីគាំង។

អានរូបនេះ

getInfo() ទាញលទ្ធផលមកម៉ាស៊ីនភ្ញៀវ ហើយរង់ចាំ៖ ក្នុងកម្មវិធី វាធ្វើឱ្យផ្ទាំងទាំងមូលកក។
evaluate() ស្នើលទ្ធផល ហើយបន្តដំណើរការ៖ ពេលចម្លើយមកដល់ callback ធ្វើបច្ចុប្បន្នភាព Label ឬ Chart។
បង្ហាញ «កំពុងគណនា…» មុន evaluate ដើម្បីឱ្យអ្នកប្រើដឹងថាកម្មវិធីកំពុងធ្វើការ (មេរៀនទី២៖ client ធៀប server)។

នៅពេលអ្នកប្រើចុចលើផែនទី យើងចង់បង្ហាញលេខមួយ (ឧ. ភាគរយនៃខែដែលលិច)។ លេខនោះគណនានៅម៉ាស៊ីនមេ (មេរៀនទី២)។ evaluate() ស្នើលទ្ធផល ហើយបន្តដំណើរការ៖

var occ = ee.Image('JRC/GSW1_4/GlobalSurfaceWater').select('occurrence');
map.onClick(function(c) {
  info.setValue('កំពុងគណនា…');
  var pt = ee.Geometry.Point([c.lon, c.lat]);
  map.layers().set(1, ui.Map.Layer(pt, {color: 'red'}, 'ចំណុច'));
  occ.reduceRegion({reducer: ee.Reducer.first(), geometry: pt, scale: 30}).get('occurrence')
    .evaluate(function(v) {
      info.setValue(v === null ? 'មិនដែលមានទឹក (១៩៨៤–២០២១)' : 'មានទឹក ' + v + '% នៃពេលវេលា (១៩៨៤–២០២១)');
    });
});

getInfo() ធ្វើឱ្យកម្មវិធីទាំងមូលកក រហូតដល់ម៉ាស៊ីនមេឆ្លើយ ហើយបើម៉ាស៊ីនមេយឺត អ្នកប្រើនឹងគិតថាកម្មវិធីខូច។ ក្នុងកម្មវិធី ត្រូវប្រើ evaluate() ជានិច្ច ហើយបង្ហាញ «កំពុងគណនា…» មុន។

១៤.៣.៥. ក្រាបក្នុងផ្ទាំង¶

រូបទី១៤.៥៖ ពីកូដ ទៅឧបករណ៍ដែលអ្នកដទៃប្រើបាន។

អានរូបនេះ

កម្មវិធីតាមដានទឹក ទាញផ្ទៃទឹកប្រចាំខែ ហើយបង្ហាញក្រាប និងផែនទីនៃខែដែលអ្នកប្រើចុច។
ក្រាបត្រូវគណនាលើម៉ាស៊ីនមេ៖ ក្រាបដែលមានច្រើនខែ ច្រើនឆ្នាំ អាចយឺត ដូច្នេះគណនាទុកមុនជា Asset បាន។
តម្លៃក្នុងក្រាបនេះជាគំរូ ដើម្បីបង្ហាញទម្រង់។

var chartBox = ui.Panel();
panel.add(chartBox);
var lake = ee.Geometry.Rectangle([103.3, 12.2, 104.7, 13.4]);
function yearChart(y) {
  var fc = ee.FeatureCollection(ee.List.sequence(1, 12).map(function(m) {
    var img = gswM.filter(ee.Filter.eq('year', y)).filter(ee.Filter.eq('month', m)).first();
    var km2 = ee.Image.pixelArea().divide(1e6).updateMask(img.eq(2))
      .reduceRegion({reducer: ee.Reducer.sum(), geometry: lake, scale: 300, maxPixels: 1e9}).get('area');
    return ee.Feature(null, {month: m, km2: km2});
  }));
  chartBox.widgets().reset([ui.Chart.feature.byFeature(fc, 'month', 'km2')
    .setOptions({title: 'ផ្ទៃទឹក ' + y + ' (គម²)', legend: {position: 'none'}})]);
}
yearSel.onChange(function(v) { refresh(); yearChart(parseInt(v, 10)); });
yearChart(2020);

ក្រាបក្នុងកម្មវិធីគួរប្រើ scale ធំល្មម (ឧ. ៣០០ ម) ដើម្បីឱ្យវាលឿន៖ អ្នកប្រើចង់ឃើញលំនាំ មិនមែនលេខត្រឹមត្រូវដល់ហិកតាទេ។ សម្រាប់ស៊េរីវែង គណនាទុកមុនជា FeatureCollection ហើយ Export ទៅ Asset រួចឱ្យកម្មវិធីអាន Asset នោះ៖ វាលឿនជាងការគណនារាល់ពេល។

ពិសោធន៍៖ កម្មវិធីតាមដានទឹក

កម្មវិធីគំរូនេះធ្វើតាមរចនាសម្ព័ន្ធក្នុងមេរៀន៖ ជ្រើសឆ្នាំ រំកិលខែ ហើយចុចលើផែនទី។ មើលផ្ទាំង «កំណត់ហេតុ» ដើម្បីឃើញ callback ណាដែលរត់ ហើយនៅពេលណា។ ទិន្នន័យក្នុងពិសោធន៍ត្រូវបានក្លែងធ្វើ។

១៤.៣.៦. ផែនទីពីរភ្ជាប់គ្នា¶

រូបទី១៤.៦៖ ប្រៀបធៀបដោយអូស។

អានរូបនេះ

ui.Map.Linker ធ្វើឱ្យផែនទីទាំងពីរ zoom និងរំកិលជាមួយគ្នា។
wipe: true បង្កើតរបារអូស ដូចពិសោធន៍ក្រុងព្រះសីហនុ ក្នុងមេរៀនទី១២។
ល្អសម្រាប់ទឹកជំនន់ មុន/ក្រោយ ការបាត់បង់ព្រៃ និងការពង្រីកទីក្រុង។

var left = ui.Map(), right = ui.Map();
ui.Map.Linker([left, right]);
left.addLayer(waterOf(2020, 4), {palette: ['#1565c0']}, 'មេសា');
right.addLayer(waterOf(2020, 10), {palette: ['#1565c0']}, 'តុលា');
ui.root.widgets().reset([ui.SplitPanel({firstPanel: left, secondPanel: right, wipe: true})]);
left.setCenter(104.0, 12.8, 9);

១៤.៣.៧. រចនាកម្មវិធីល្អ¶

សំណួរមួយ កម្មវិធីមួយ៖ កម្មវិធីដែលព្យាយាមធ្វើអ្វីៗគ្រប់យ៉ាង ពិបាកប្រើ។
ពន្យល់ខ្លីៗ៖ ចំណងជើង ការណែនាំមួយប្រយោគ ប្រភពទិន្នន័យ ឆ្នាំ និងដែនកំណត់។
Legend៖ ពណ៌ដោយគ្មាន legend គ្មានន័យ។ បង្កើតដោយ ui.Panel និង ui.Label ដែលមាន backgroundColor។
ល្បឿន៖ scale ធំសម្រាប់ក្រាប · Asset ដែលគណនារួច · កុំ getInfo។
ទូរស័ព្ទ៖ ផ្ទាំងតូច ពុម្ពអក្សរធំ ដាក់ panel ខាងក្រោម ប្រសិនបើអេក្រង់តូច (ui.root.setLayout)។
ភាសា៖ អត្ថបទខ្មែរបង្ហាញបាន៖ ពិនិត្យលើទូរស័ព្ទជាក់ស្ដែង។

១៤.៣.៨. ការបោះពុម្ព និងជម្រើសចែករំលែកផ្សេង¶

រូបទី១៤.៧៖ ចែករំលែកដោយតំណមួយ។

អានរូបនេះ

កម្មវិធីត្រូវភ្ជាប់ជាមួយ Cloud Project ដែលបានចុះឈ្មោះ Earth Engine (មិនមែនពាណិជ្ជកម្ម ឬពាណិជ្ជកម្ម)។
Asset ដែលកម្មវិធីប្រើ (ចំណុច ព្រំដែន) ត្រូវតែអាចអានបានដោយកម្មវិធី។
ពិនិត្យលក្ខខណ្ឌប្រើប្រាស់ និងកូតាជាប្រចាំ៖ ច្បាប់ទាំងនេះប្ដូរតាមពេលវេលា។

ក្នុង Code Editor ចុច Apps → New App ជ្រើសស្គ្រីប និង Cloud Project ហើយចុច Publish។ កម្មវិធីទទួលបាន URL សាធារណៈ ហើយអ្នកប្រើមិនត្រូវការគណនី Earth Engine ទេ។ ការគណនារបស់កម្មវិធីគិតលើ Cloud Project របស់អ្នកបោះពុម្ព ដូច្នេះពិនិត្យកូតា និងលក្ខខណ្ឌប្រើប្រាស់ ដែលអាចប្ដូរតាមពេលវេលា។

ជម្រើសចែករំលែកផ្សេង៖

ជម្រើស	ពេលណាប្រើ
តំណស្គ្រីប (Get Link)	ចែករំលែកជាមួយអ្នកប្រើ Earth Engine (គ្រូ មិត្តរួមការងារ)
Export GeoTIFF/CSV → QGIS	ផែនទីបោះពុម្ព របាយការណ៍ ការវិភាគបន្ត (សៀវភៅទី១–២)
Earth Engine App	ឧបករណ៍អន្តរកម្មសម្រាប់អ្នកមិនសរសេរកូដ
geemap / Python	Jupyter notebook ការវិភាគធំ ការរួមបញ្ចូលជាមួយបណ្ណាល័យ Python
ផែនទីវេបផ្ទាល់ខ្លួន	នាំចេញ tiles ឬ GeoJSON ទៅ Leaflet/MapLibre ពេលមិនចង់ពឹងលើ Earth Engine

១៤.៤. ឧទាហរណ៍ដែលបានដោះស្រាយ៖ កម្មវិធីតាមដានទន្លេសាប¶

ជំហានទី១៖ រចនាសម្ព័ន្ធ¶

ចម្លងកូដផ្នែក ១៤.៣.១ (ផ្ទាំង និងផែនទី) និង ១៤.៣.២ (widgets) ទៅក្នុងស្គ្រីបថ្មី។ រត់៖ អ្នកគួរឃើញផ្ទាំងនៅខាងឆ្វេង និងផែនទីនៅខាងស្ដាំ។

ជំហានទី២៖ ស្រទាប់ទឹក និង callback¶

បន្ថែមកូដផ្នែក ១៤.៣.៣។ រំកិលខែ ហើយពិនិត្យថាស្រទាប់ជំនួសគ្នា (មិនជាន់គ្នា)។

ជំហានទី៣៖ ចុចលើផែនទី និងក្រាប¶

បន្ថែមកូដផ្នែក ១៤.៣.៤ និង ១៤.៣.៥។ ចុចលើបឹង ព្រៃលិចទឹក និងភូមិ ហើយប្រៀបធៀបភាគរយ។

ជំហានទី៤៖ Legend និងប្រភព¶

function legendRow(color, text) {
  return ui.Panel([ui.Label('', {backgroundColor: color, padding: '8px', margin: '4px'}), ui.Label(text)],
                  ui.Panel.Layout.flow('horizontal'));
}
panel.add(legendRow('#1565c0', 'ទឹក (JRC Monthly History)'));
panel.add(ui.Label('ប្រភព៖ EC JRC/Google · Global Surface Water v1.4 · ១៩៨៤–២០២១', {fontSize: '11px', color: 'grey'}));

ជំហានទី៥៖ សាកល្បង និងបោះពុម្ព¶

ឱ្យមិត្តម្នាក់ប្រើកម្មវិធីដោយគ្មានការពន្យល់ ហើយកត់ត្រាកន្លែងដែលគេច្រឡំ។ កែ ហើយបោះពុម្ព (ផ្នែក ១៤.៣.៨)។ សាកល្បង URL លើទូរស័ព្ទ។

«កម្មវិធីតាមដានទន្លេសាប បង្ហាញផ្ទៃទឹកប្រចាំខែ (JRC ១៩៨៤–២០២១) ក្រាបផ្ទៃទឹកប្រចាំឆ្នាំ និងភាពញឹកញាប់នៃការលិចនៅចំណុចដែលអ្នកប្រើចុច។ វាអាចចូលប្រើតាម URL ដោយមិនត្រូវការគណនី Earth Engine។»

អ្វីដែលយើងមិនអាចសន្និដ្ឋាន

កម្មវិធីបង្ហាញទិន្នន័យដែលមានដែនកំណត់របស់វា (JRC មិនមានឆ្នាំក្រោយ ២០២១ ហើយខកទឹកក្រោមព្រៃលិចទឹក)។ អ្នកប្រើមិនឃើញដែនកំណត់ទាំងនេះ លុះត្រាតែយើងសរសេរវាក្នុងកម្មវិធី។

១៤.៥. សកម្មភាពអនុវត្ត¶

លំហាត់ទី១៤៖ បង្កើតកម្មវិធីតាមដានទឹកសម្រាប់ខេត្តរបស់អ្នក ដែលមានការជ្រើសឆ្នាំ/ខែ ក្រាប ការចុចលើផែនទី legend និង SplitPanel ហើយបោះពុម្ព។ មើល លំហាត់ទី១៤។
ក្នុងថ្នាក់៖ និស្សិតប្ដូរកម្មវិធីគ្នា ហើយផ្ដល់មតិ៖ អ្វីដែលច្បាស់ អ្វីដែលច្រឡំ និងអ្វីដែលខ្វះ។

១៤.៦. ការយល់ច្រឡំដែលត្រូវប្រុងប្រយ័ត្ន¶

១. «កម្មវិធីរត់កូដម្ដងពីលើចុះក្រោម» កូដខាងលើរៀបចំផ្ទាំង។ បន្ទាប់មកកម្មវិធីរង់ចាំ ហើយរត់ callback តែពេលអ្នកប្រើធ្វើសកម្មភាព។

២. «getInfo() ងាយ ដូច្នេះប្រើបាន» វាធ្វើឱ្យកម្មវិធីកក។ ក្នុងកម្មវិធី ប្រើ evaluate()។

៣. «map.addLayer() ក្នុង callback គ្មានបញ្ហា» រាល់ការរំកិលបន្ថែមស្រទាប់ថ្មី ហើយកម្មវិធីយឺតទៅៗ។ ប្រើ layers().set()។

៤. «អ្នកប្រើកម្មវិធីត្រូវការគណនី Earth Engine» កម្មវិធីដែលបានបោះពុម្ព បើកបានដោយអ្នកណាក៏ដោយ ដែលមាន URL។

៥. «កម្មវិធីល្អ = widgets ច្រើន» កម្មវិធីល្អឆ្លើយសំណួរមួយបានច្បាស់ ហើយលឿន។

១៤.៧. សេចក្ដីសង្ខេបមេរៀន¶

កម្មវិធី Earth Engine មាន ui.Panel សម្រាប់ widgets និង ui.Map សម្រាប់ផែនទី ក្នុង ui.root។ Widgets (Label Select Slider Button Chart) មាន style និង callback ដែលរត់ពេលអ្នកប្រើធ្វើសកម្មភាព។ ប្រើ layers().set() ដើម្បីជំនួសស្រទាប់ evaluate() ដើម្បីកុំឱ្យកម្មវិធីកក និង scale ធំ ឬ Asset ដែលគណនារួច ដើម្បីល្បឿន។

SplitPanel និង Linker ប្រៀបធៀបមុន–ក្រោយ។ កម្មវិធីបោះពុម្ពតាម Cloud Project ហើយបើកបានដោយគ្មានគណនី។ ជម្រើសផ្សេង (Export ទៅ QGIS geemap ផែនទីវេប) សមសម្រាប់អ្នកប្រើ និងគោលបំណងផ្សេងៗ។

គំនិតស្នូលនៃមេរៀន

ការវិភាគដែលមានតែអ្នកវិភាគអាចប្រើ មានផលប៉ះពាល់តិច។ កម្មវិធីសាមញ្ញ លឿន និងស្មោះត្រង់អំពីដែនកំណត់ នាំលទ្ធផលទៅដល់អ្នកសម្រេចចិត្ត។

១៤.៨. ពាក្យគន្លឹះខ្មែរ–អង់គ្លេស¶

ពាក្យខ្មែរ	ពាក្យអង់គ្លេស	អត្ថន័យខ្លី
កម្មវិធី Earth Engine	Earth Engine App	ស្គ្រីបដែលបោះពុម្ពជាវេប
ធាតុផ្ទាំង	Widget	ប៊ូតុង បញ្ជី របាររំកិល …
ផ្ទាំង	Panel	ប្រអប់ដែលផ្ទុក widgets
ព្រឹត្តិការណ៍	Event	ការចុច ការជ្រើស ការរំកិល
មុខងារហៅត្រឡប់	Callback	មុខងារដែលរត់ពេលមានព្រឹត្តិការណ៍
ការស្នើមិនរង់ចាំ	Asynchronous (evaluate)	ស្នើលទ្ធផលដោយមិនកក
ផែនទីបំបែក	Split panel	ផែនទីពីររំកិលជាមួយគ្នា
ការបោះពុម្ព	Publish	ធ្វើឱ្យកម្មវិធីមាន URL សាធារណៈ

១៤.៩. សំណួររំលឹក និងវាយតម្លៃ¶

ក. សំណួរយល់ដឹង¶

ពិពណ៌នារចនាសម្ព័ន្ធ ui.root ui.Panel និង ui.Map នៃកម្មវិធីមួយ។
callback ជាអ្វី? ផ្ដល់ឧទាហរណ៍ពីរ។
ហេតុអ្វីប្រើ evaluate() ជំនួស getInfo() ក្នុងកម្មវិធី?
ហេតុអ្វីប្រើ layers().set() ជំនួស addLayer() ក្នុង callback?
ប្រៀបធៀបកម្មវិធី Earth Engine និងការ Export ទៅ QGIS៖ ពេលណាប្រើមួយណា?

ខ. សំណួរអនុវត្តគោលគំនិត¶

សរសេរ ui.Select សម្រាប់ខេត្ត ៥ ដែលពេលជ្រើស ធ្វើឱ្យផែនទី zoom ទៅខេត្តនោះ។
សរសេរ ui.Button «ទាញយក CSV» ដែលបង្ហាញតំណទាញយក ដោយប្រើ getDownloadURL និង evaluate។
កម្មវិធីរបស់អ្នកចំណាយពេល ៣០ វិនាទីដើម្បីបង្ហាញក្រាប។ ស្នើដំណោះស្រាយបី។
សរសេរមុខងារ legend ដែលទទួលបញ្ជីពណ៌ និងឈ្មោះ ហើយត្រឡប់ ui.Panel។
ពិពណ៌នាកម្មវិធីមួយ ដោយប្រើមេរៀនណាមួយក្នុងសៀវភៅនេះ ដែលអាចជួយសហគមន៍របស់អ្នក។

គ. កិច្ចការខ្លី¶

បន្ថែម ui.DateSlider ទៅកម្មវិធីទន្លេសាប ដែលបង្ហាញរូបភាព Sentinel-1 VV នៃថ្ងៃដែលជ្រើស (± ៦ ថ្ងៃ)។ សរសេរកថាខណ្ឌមួយពីបញ្ហាដែលអ្នកជួប និងរបៀបដោះស្រាយ។

កំណត់សម្គាល់សម្រាប់គ្រូបង្រៀន¶

ក. ការបែងចែកពេលវេលា ១៨០ នាទី¶

សកម្មភាព	ពេលវេលា
ស្ថានភាពបើកមេរៀន៖ ឧបករណ៍ទន្លេសាប	១០ នាទី
រចនាសម្ព័ន្ធ និង widgets	២៥ នាទី
ព្រឹត្តិការណ៍ callback · evaluate · ពិសោធន៍	៣៥ នាទី
ក្រាប និង SplitPanel	២៥ នាទី
រចនា និងការបោះពុម្ព	២០ នាទី
ឧទាហរណ៍៖ សាងសង់កម្មវិធីជាមួយគ្នា	៥០ នាទី
សង្ខេប និងណែនាំលំហាត់	១៥ នាទី
សរុប	១៨០ នាទី / ៣ ម៉ោង

ខ. ចំណាំ¶

ការបោះពុម្ពកម្មវិធីត្រូវការ Cloud Project ដែលបានចុះឈ្មោះ Earth Engine។ ពិនិត្យជាមុនថានិស្សិតមាន Project រួច (ឧបសម្ព័ន្ធ ក)។
ក្រាបផ្ទៃទឹកក្នុងរូបជាតម្លៃគំរូ។ និស្សិតគណនាតម្លៃពិតក្នុងលំហាត់ទី១៤។

គ. ការភ្ជាប់ទៅមេរៀនបន្ទាប់¶

អ្នកឥឡូវមានឧបករណ៍ពេញលេញ៖ ពីការត្រងទិន្នន័យ ទៅការវិភាគ ការផ្ទៀងផ្ទាត់ និងការចែករំលែក។ ជំហានចុងក្រោយគឺប្រើវាដោយខ្លួនឯង លើបញ្ហាពិតមួយ ពីសំណួររហូតដល់លទ្ធផល ដោយការទទួលខុសត្រូវ។

តើគម្រោងអនុវត្តល្អមួយមានលក្ខណៈអ្វីខ្លះ ហើយយើងត្រូវគិតពីអ្វីខ្លះ មុនចែករំលែកផែនទីដែលអាចប៉ះពាល់ដល់មនុស្ស?

សំណួរនេះនាំទៅ មេរៀនទី១៥៖ គម្រោងអនុវត្តបញ្ចប់វគ្គ និងក្រមសីលធម៌ទិន្នន័យ។

⬅️ មេរៀនទី១៣ · ➡️ មេរៀនទី១៥