easygee

name

easygee

description

Build, debug, and run Google Earth Engine Python and geemap workflows. Use for Earth Engine/geemap authorization, authentication, Cloud project setup, quotas, notebooks, browser map previews, Python scripts, 5,000+ official/community GEE dataset discovery, bilingual dataset selection by id/theme/task, dataset recommendation/comparison/verification, geospatial export, Sentinel/Landsat/MODIS/VIIRS/SAR/population collections, interactive maps, JavaScript-to-Python migration, local GIS integration, remote-sensing AI methods such as detection, segmentation, change detection, pixel regression, SAM, embeddings, vision-language models, QGIS GeoAI, or OpenGeo/opengeos patterns such as GeoAgent, GeoLibre, leafmap, anymap, GEE agents, and catalog-driven assistants. Prefer this skill for reproducible GEE/geemap setup, notebooks, batch exports, map-first AI workflows, GeoAI method execution, and auth/quota/project troubleshooting.

EasyGEE

Use this skill to work with Google Earth Engine (GEE), the earthengine-api Python client, and geemap in a way that is reproducible and credential-safe.

First Steps

1. Route the interaction intent before choosing tools:
   • Run python scripts/route_easygee_interaction.py "<task>" --json for nontrivial analysis or visualization requests, or apply the same rules inline for small requests.
   • compute_first: run GEE/API/local work headlessly and return stats/tables/files/exports without opening the browser by default.
   • map_first: open or update the EasyGEE Map Console when the user asks to see, display, map, draw, inspect, or annotate.
   • mixed: compute first, then hand off meaningful layers, anomalies, AOIs, or QA targets to the browser.
2. Route the geospatial method backend when the request has data/method choices, local files, CRS, ML, STAC/COG, domain science, or uncertainty about GEE vs local GIS:
   • Run python scripts/route_geospatial_method.py "<task>" --json.
   • gee_first: use Earth Engine/geemap for cloud-scale catalog data, reducers, visualization, and exports.
   • local_first: use GeoMaster local GIS knowledge for local files, CRS-heavy work, topology, point clouds, networks, or windowed rasters.
   • hybrid: use GEE for data access/preprocessing and local tools for COG, STAC, ML, advanced statistics, or exact file-based GIS.
   • catalog_first: search/verify datasets before analysis.
   • browser_first: draw AOI or inspect map state before computation.
   • For remote-sensing AI tasks, also read references/geoai-encyclopedia.md and route to the smallest bundled chapter under references/geoai-with-python/. Keep EasyGEE responsible for GEE/export orchestration and GeoMaster responsible for general GIS correctness.
3. Identify the target mode:
   • Notebook exploration: use geemap for interactive maps, inspectors, layer styling, quick plots, and HTML/PNG map export.
   • Batch/script workflow: use ee directly for deterministic processing, exports, scheduled jobs, and non-interactive pipelines.
   • Migration: use geemap to help translate Earth Engine JavaScript examples into Python, then refactor into plain ee functions when the result must run headlessly.
   • Browser preview: export a geemap/local map page to HTML, serve it from localhost, and open it in the in-app Browser when visual QA or interaction is useful.
4. Check the environment before installing or authenticating:
   • Run python scripts/check_gee_geemap.py from this skill directory, or read the script and run it with an explicit Python executable.
   • Use --project <cloud-project-id> --initialize only when the user has provided the project id or it is discoverable from the current repo config.
5. Never print, store, document, or commit Earth Engine credentials, OAuth tokens, service account keys, or Cloud project secrets.
6. If the task needs remote-sensing domain methods beyond GEE/geemap plumbing (cloud masks, indices, classification, CRS, raster/vector operations), and the local geomaster skill exists, load it as a companion reference.
7. If the user mentions GEEer成长日记, a Chinese GEE tutorial/article corpus, or asks what that article collection suggests, load gee-growth-diary as a secondary source index. Keep EasyGEE references and official Earth Engine docs as the authority for dataset ids, scale factors, QA masks, exports, and current API behavior.
8. If the user mentions OpenGeoAgent, GeoLibre, OpenGeo/opengeos projects, QGIS AI assistants, catalog browsers, map agents, or "distilling" Qiusheng Wu's geospatial workflow style, read references/opengeos-patterns.md.
9. If the user asks to execute a remote-sensing AI method, read references/geoai-encyclopedia.md first, then load only the relevant references/geoai-with-python/chapters/ file(s). Use its data contract, training/inference loop, spatial evaluation, and georeferenced-output rules as the method layer; do not treat a model name or score as a completed analysis.
10. If the user asks a multimodal model to detect, count, outline, or segment visible targets in local or GEE imagery and export CRS-aware vectors, use the sibling multimodal-geo-vector skill. Keep EasyGEE responsible for GEE discovery, project/auth, preprocessing, and export; let that skill handle annotation JSON, tiling, pixel-to-map conversion, deduplication, and GeoPackage/GeoJSON handoff.

Resource Map

• Read references/setup-auth.md for installation, environment choices, the standard authentication workflow, project initialization, auth modes, credential safety, and common auth failures.
• Read references/quota-monitoring.md when the user asks to show Earth Engine quota values, current usage, quota limits, or sends a Google Cloud Console quotas URL.
• Read references/interaction-router.md before deciding whether a request should open/update the in-app Browser, stay headless, or compute first and then hand off a map result.
• Read references/geomaster-integration.md when a task may need GeoMaster's broader geospatial methods, local GIS libraries, CRS/format decisions, STAC/COG, ML, point clouds, networks, or scientific-domain guidance.
• Read references/geomaster-knowledge-index.json as the compact lookup table for GeoMaster reference routing before opening heavy GeoMaster files.
• Read references/geoai-encyclopedia.md for task-oriented remote-sensing AI routing. Its bundled references/geoai-with-python/ directory preserves the method skill's chapters, patterns, glossary, cheatsheet, and source map.
• Read references/browser-preview.md when the user asks for an interactive map preview, persistent browser visualization, in-app Browser handoff, or local lightweight map page.
• Read references/gee-agent-playbook.md before writing non-trivial Earth Engine code, especially when reducers, mapping, exports, quotas, debugging, client/server behavior, projections, or getInfo() are involved.
• Read references/geemap-agent-recipes.md when building notebooks, map inspection workflows, export utilities, JavaScript-to-Python conversions, local data bridges, or ML/geemap examples.
• Read references/geemap-api-surface.md when choosing specific geemap backends, map methods, drawing tools, catalog search, local-data bridges, export helpers, zonal statistics helpers, conversion tools, or timelapse/app utilities.
• Read references/export-patterns.md when the user asks to export, download, save to Drive/Cloud Storage/Asset/local files, or gives a natural-language output request that must be turned into raster/table/vector/map export parameters.
• Read references/data-layer-records.md when dataset choice, official-vs- community provenance, band semantics, scale factors, QA masks, class labels, transformations, or output suitability must be made explicit.
• Read references/dataset-discovery.md when searching the 5,000+ record official/community catalog by id, theme, or task; recommending a multi-role dataset bundle; comparing candidates; handling no-match clarification; or verifying a final asset before coding.

Operating Rules

• Prefer ee.Initialize(project='...') over project-less initialization. Earth Engine now expects an explicit Cloud project in most local Python workflows.
• Treat the Earth Engine project id as user-level local configuration, not repository state. Do not hard-code a user's project id into docs, code, test fixtures, generated HTML committed to git, or plugin bundles. After a successful authorization, persist it only through EasyGEE local settings or the user's Earth Engine/gcloud environment, and reuse it on later plugin runs.
• For authentication, follow the standard ladder in references/setup-auth.md: diagnose with check_gee_geemap.py, generate user-run steps with ee_auth_workflow.py, let the user complete OAuth, then verify with check_gee_geemap.py --initialize.
• For geemap authorization specifically, use geemap_auth_workflow.py as the user-facing entrypoint while keeping the same credential-safety rules. Do not imply geemap has a separate login system.
• For one-sentence geemap authorization requests, run authorize_geemap_once.py --project PROJECT first to show the safe plan. If the user has clearly asked to start the authorization, run it with --run --quota-mode required in the intended Python environment, let the user approve Google OAuth / Google Cloud CLI login in the browser when prompted, then report the final verification status for both geemap and quota access. Never ask the user to paste OAuth codes, auth URLs, tokens, service account keys, or credential file contents into chat.
• For quota display, parse the project id from the Console URL when present, run show_ee_quotas.py, and never print gcloud auth print-access-token output, OAuth URLs, service account keys, or credential file contents.
• For normal Map Console pages, leave live quota lookup enabled so the UI can show Cloud Quotas / Monitoring status. Use --no-live-quota only for offline tests, smoke runs, or explicitly requested no-network previews; for non-sample pages the generator requires the explicit --allow-default-quota-state guard before it will write default-only quota state.
• For UI-only Map Console maintenance, do not regenerate a user-facing page with --no-live-quota or --no-quota-usage. Patch the source/generated HTML for the UI change, then run refresh_map_console_quota.py if the page's embedded quota state needs refreshing. If live quota lookup is unavailable, leave the existing page state unchanged and explain the quota lookup failure instead of downgrading the UI to default-only quota status.
• For interactive visualization, prefer the browser-preview flow: export HTML, serve it locally, open it in the in-app Browser, and keep the preview server running only while the user needs the page.

Minimal Patterns

Notebook

import ee
import geemap

PROJECT = "my-earthengine-project"

# One-time setup only, if credentials are missing:
# ee.Authenticate(auth_mode="localhost")
ee.Initialize(project=PROJECT)

m = geemap.Map()
roi = ee.Geometry.Point([120.16, 30.25]).buffer(10_000)
s2 = (
    ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED")
    .filterBounds(roi)
    .filterDate("2024-01-01", "2024-12-31")
    .filter(ee.Filter.lt("CLOUDY_PIXEL_PERCENTAGE", 20))
    .linkCollection(
        ee.ImageCollection("GOOGLE/CLOUD_SCORE_PLUS/V1/S2_HARMONIZED"),
        ["cs_cdf"],
    )
    .map(lambda image: image.updateMask(image.select("cs_cdf").gte(0.60)))
)
image = (
    s2
    .median()
)
m.centerObject(roi, 10)
m.addLayer(image, {"bands": ["B4", "B3", "B2"], "min": 0, "max": 3000}, "S2 median")
m

Script

import ee

PROJECT = "my-earthengine-project"

def main():
    ee.Initialize(project=PROJECT)
    roi = ee.Geometry.Rectangle([119.8, 30.0, 120.5, 30.5])
    s2 = (
        ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED")
        .filterBounds(roi)
        .filterDate("2024-01-01", "2024-12-31")
        .filter(ee.Filter.lt("CLOUDY_PIXEL_PERCENTAGE", 20))
        .linkCollection(
            ee.ImageCollection("GOOGLE/CLOUD_SCORE_PLUS/V1/S2_HARMONIZED"),
            ["cs_cdf"],
        )
        .map(lambda image: image.updateMask(image.select("cs_cdf").gte(0.60)))
    )
    ndvi = (
        s2
        .median()
        .normalizedDifference(["B8", "B4"])
        .rename("NDVI")
    )
    print(ndvi.reduceRegion(ee.Reducer.mean(), roi, scale=30, maxPixels=1e9).getInfo())

if __name__ == "__main__":
    main()

Validation Before Finishing

Before reporting a GEE/geemap task as done:

1. Confirm the code imports ee and, when needed, geemap.
2. Confirm initialization uses the intended project or clearly explains why it is deferred.
3. For notebooks, ensure maps are displayable and cells do not require hidden state from earlier experiments.
4. For exports, report the export destination, task name, scale, region, and whether the task was merely created or actually started.
5. Run scripts/review_ee_code.py on generated scripts/notebooks when the deliverable includes non-trivial Earth Engine code.
6. For quota tasks, state whether the numbers came from live project quota APIs or the official default/fixed quota reference.
7. When interaction routing affected the workflow, report the route mode, browser policy, produced artifacts, and whether the browser was opened, updated, or intentionally deferred.
8. For GeoAI tasks, report the AI task type, selected chapter, data contract, model/inference choice, spatial evaluation design, output CRS/schema, and any unrun or unverifiable step.
9. For browser previews, report the localhost URL, whether it was opened in the in-app Browser, and whether map tiles/layers visibly rendered.
10. When method routing affected the workflow, report gee_first, local_first, hybrid, catalog_first, or browser_first, the backends used, GeoMaster references consulted or deferred, and the artifact handoff.
11. Mention any unrun pieces caused by missing credentials, quota, permissions, or user authentication.