update

Author: ForestCGuy

figures/logo.svg

@@ -1,38 +1,35 @@
 # Introduction and motivation
 
-Ecology and forest management often require information across large areas and through time. Forests change because of seasonal phenology, growth, harvesting, fire, windthrow, insects, flooding, regeneration, and land-use change. Many of these processes leave spatial and temporal signals that can be explored with satellite imagery.
+Ecology and forest management often require information across large areas and through time. Forests change because of phenology, growth, harvesting, fire, windthrow, insects, flooding, regeneration, and land-use change. Many of these changes leave spatial and temporal signals that can be explored with satellite imagery.
 
-Google Earth Engine (GEE) provides access to large geospatial datasets and cloud-based processing tools. This makes it possible to explore forest and ecological questions without downloading and processing large image archives locally.
+Google Earth Engine (GEE) provides access to large geospatial datasets and cloud-based processing tools. This makes it possible to filter, analyze, visualize, and export satellite data without downloading large image archives locally.
 
 ## Why this workshop?
 
-This workshop introduces the potential of GEE through practical applications in ecology and forest management.
+This workshop introduces the potential of GEE through practical, beginner-friendly examples.
 
-The goal is to show what kinds of analyses are possible, how typical GEE workflows are structured, and how satellite data can support ecological interpretation and forest monitoring.
+The goal is to show how GEE workflows are structured and how satellite data can support ecological analysis and forest monitoring.
 
 We move from basic visualization to applied examples:
 
-- terrain analysis using elevation data
-- seasonal vegetation dynamics using Sentinel-2 NDVI
-- long-term forest disturbance detection using Landsat NBR
-- supervised classification using Random Forest
+- terrain analysis with SRTM elevation data
+- seasonal vegetation monitoring with Sentinel-2 NDVI
+- forest disturbance detection with Landsat NBR
+- land-cover classification with Random Forest
 
-These examples are not meant to cover every detail of GEE. They are designed to provide a clear starting point for understanding the platform and adapting similar workflows to other questions.
+These examples are not meant to cover every detail of GEE. They provide a starting point for adapting similar workflows to other ecological and forest management questions.
 
 ## Key concepts
 
-- Ecological and forest processes often vary across both space and time.
-- Satellite imagery can help describe vegetation condition, terrain context, and landscape change.
 - GEE allows users to access, filter, analyze, visualize, and export large geospatial datasets in the cloud.
+- Satellite imagery can describe vegetation condition, terrain context, and landscape change.
 - Spectral indices such as NDVI and NBR are useful indicators, but they are not direct ecological measurements.
-- Interpretation requires field knowledge, reference data, and validation.
-- The same GEE workflow logic can be adapted to many applications in ecology and forest management.
+- Interpretation requires ecological knowledge, reference data, and validation.
+- The same GEE workflow logic can be adapted to many applications.
 
 ## Learning questions
 
 1. What kinds of ecological and forest management questions can be explored with GEE?
-2. How can satellite imagery help us observe forest conditions and forest change through time?
-3. What is the difference between detecting a spatial pattern and explaining its ecological cause?
-4. How does cloud-based processing make large-scale geospatial analysis easier?
-5. What are the limits of using spectral indices such as NDVI or NBR to interpret ecological and management processes?
-
+2. How does GEE make satellite image analysis easier?
+3. What is the difference between detecting a spatial pattern and explaining its cause?
+4. What are the limits of using indices such as NDVI or NBR?

modules/01_introduction_motivation.md

@@ -1,34 +1,30 @@
-# Google Earth Engine fundamentals and potential
+# Fundamentals and potential
 
 Google Earth Engine (GEE) is a cloud-based platform for geospatial analysis. It provides access to large satellite image archives, environmental datasets, and tools for processing data directly in the cloud.
 
-For ecology and forest management, GEE is useful because it allows users to explore spatial patterns, build time series, calculate spectral indices, summarize raster values, and export results without downloading large image collections locally.
-
-This section introduces the basic objects and operations that appear throughout the hands-on activities.
+This section introduces the main Earth Engine objects and operations used throughout the workshop.
 
 ## Core Earth Engine objects
 
-### Image
+### `ee.Image`
 
 An `ee.Image` is a raster dataset. It can contain one band or many bands.
 
-For example, SRTM elevation is loaded as a single image:
-
 ```javascript
 var srtm = ee.Image("USGS/SRTMGL1_003");
 ````
 
-An image can represent elevation, reflectance, NDVI, NBR, classification results, or disturbance year.
+Images can represent elevation, reflectance, NDVI, NBR, classification results, or disturbance year.
 
-### ImageCollection
+### `ee.ImageCollection`
 
-An `ee.ImageCollection` is a set of images. Many satellite datasets are stored as image collections because they contain repeated observations through time.
+An `ee.ImageCollection` is a set of images, often representing repeated observations through time.
 
 ```javascript
 var s2 = ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED");
 ```
 
-For example, a Sentinel-2 image collection contains many images acquired on different dates. We can filter the collection by location, date, cloud cover, and other properties.
+Image collections can be filtered by location, date, cloud cover, and other metadata.
 
 ### Geometry
 
@@ -40,7 +36,7 @@ var point = ee.Geometry.Point([-79.3, 48.45]);
 
 In this workshop, geometries are used to define the region of interest, select pixels, clip rasters, and summarize values.
 
-### Feature and FeatureCollection
+### `ee.Feature` and `ee.FeatureCollection`
 
 A feature is a geometry with attributes. A feature collection is a set of features.
 
@@ -50,37 +46,27 @@ var waterbody = ee.FeatureCollection(
 );
 ```
 
-Feature collections can represent waterbodies, forest inventory polygons, training samples, roads, plots, or management units.
-
-## Common operations
-
-### Filter by region
-
-```javascript
-.filterBounds(roi)
-```
-
-This keeps images that intersect the region of interest.
+Feature collections can represent waterbodies, roads, plots, training samples, management units, or forest inventory polygons.
 
-For example, if the ROI is around Forêt Duparquet, `.filterBounds(roi)` keeps only images that overlap that area.
+## Common GEE operations
 
-### Filter by date
+### Filter an image collection
 
 ```javascript
-.filterDate("2023-01-01", "2023-12-31")
+var s2Filtered = s2
+  .filterBounds(roi)
+  .filterDate("2023-01-01", "2023-12-31");
 ```
 
-This keeps images acquired within a specific date range.
-
-Date filters are essential for phenology, annual composites, disturbance detection, and before-after comparisons.
+Filtering keeps only the images needed for the study area and time period.
 
 ### Select bands
 
 ```javascript
 var nir = image.select("B8");
 ```
 
-Band selection keeps only the bands needed for analysis. For example, NDVI requires near-infrared and red bands, while NBR requires near-infrared and shortwave-infrared bands.
+Band selection keeps the variables needed for analysis. For example, NDVI uses near-infrared and red bands, while NBR uses near-infrared and shortwave-infrared bands.
 
 ### Calculate an index
 
@@ -101,11 +87,9 @@ var withNDVI = s2.map(function(image) {
 
 `.map()` applies the same function to every image in an image collection.
 
-In this example, NDVI is calculated for every Sentinel-2 image.
-
 ### Reduce values
 
-Reducers summarize many values into fewer values.
+Reducers summarize many pixel values into a smaller result.
 
 ```javascript
 var stats = image.reduceRegion({
@@ -115,29 +99,15 @@ var stats = image.reduceRegion({
 });
 ```
 
-This example calculates the mean value of an image inside the ROI.
-
-Common reducers include:
-
-```javascript
-ee.Reducer.mean()
-ee.Reducer.minMax()
-ee.Reducer.sum()
-ee.Reducer.stdDev()
-ee.Reducer.count()
-```
-
-Reducers are used to summarize elevation, calculate mean NDVI, estimate disturbed area, and assess classification results.
+Reducers are used to calculate summary statistics, mean NDVI, disturbed area, and accuracy metrics.
 
 ### Display a layer
 
 ```javascript
 Map.addLayer(image, visParams, "Layer name");
 ```
 
-`Map.addLayer()` displays data in the Earth Engine Code Editor map. Visualization parameters control the displayed colors and value range.
-
-Displaying a layer does not export or save the result. It only shows the data on the map.
+`Map.addLayer()` displays data in the Code Editor map. It does not export or save the result.
 
 ### Export a result
 
@@ -152,111 +122,89 @@ Export.image.toDrive({
 });
 ```
 
-Exporting creates a task that saves a raster result to Google Drive. Exports are useful when you want to use the result in QGIS, ArcGIS, R, Python, or another workflow.
+Exporting creates a task that saves a raster result outside Earth Engine, for example to Google Drive.
 
 ## Client-side and server-side thinking
 
-Most Earth Engine objects are server-side objects. This means they describe a computation that will be sent to Google’s servers, rather than a value stored directly in your browser. For more details, see the Earth Engine documentation on [client-side and server-side objects](https://developers.google.com/earth-engine/guides/client_server)
+Most Earth Engine objects are server-side objects. They describe computations that run on Google’s servers.
+
+A normal JavaScript number is client-side. An `ee.Number` is server-side. A normal JavaScript list is client-side. An `ee.ImageCollection` is server-side.
 
 The key rule is:
 
 > Use Earth Engine methods for Earth Engine objects.
 
-For example, an `ee.Number` is not the same as a normal JavaScript number. An `ee.ImageCollection` is not the same as a normal JavaScript list.
-
-This is why direct JavaScript operations sometimes fail on Earth Engine objects. When working with Earth Engine objects, use Earth Engine functions such as `.map()`, `.filterDate()`, `.filterBounds()`, `.select()`, `.addBands()`, and `.reduceRegion()`.
+For example, use `.map()`, `.filterDate()`, `.filterBounds()`, `.select()`, `.addBands()`, and `.reduceRegion()` with Earth Engine objects.
 
 ## Lazy evaluation
 
-Earth Engine uses lazy evaluation. This means it does not immediately run every operation when a line of code is written.
+Earth Engine uses lazy evaluation. This means it does not run every operation immediately.
 
-Instead, the script builds a processing plan. Earth Engine executes that plan when a result is requested, such as when you display a layer, print a value, create a chart, or start an export.
+Instead, the script builds a processing plan. Earth Engine executes that plan when an output is requested, such as a map layer, printed value, chart, or export.
 
-This makes it possible to describe large computations without downloading or processing everything locally.
+## Why `system:time_start` matters?
 
-## Why `system:time_start` matters
+Time series charts need a date for each image. Earth Engine usually stores this date in the `system:time_start` property.
 
-Time series charts need a date for each image. Earth Engine usually stores that date in the `system:time_start` property. 
-
-For derived composites, such as monthly NDVI or annual NBR images, we often assign this property manually:
+For derived composites, such as monthly NDVI or annual NBR images, we often assign it manually:
 
 ```javascript
 .set("system:time_start", ee.Date.fromYMD(year, month, 15).millis())
 ```
 
-This places the composite at a specific date in the chart.
-
-The date is converted to milliseconds because Earth Engine stores time as milliseconds since 1970-01-01 UTC, also called the Unix epoch.
-
+This places each composite correctly on a chart.
 
 ## Visualizing versus exporting
 
-It is important to separate map visualization from data export.
+Map visualization and data export are different.
 
 ```javascript
 Map.addLayer(image, visParams, "Layer name");
 ```
 
-This displays an image on the map.
+This displays an image using colors and value ranges.
 
 ```javascript
 Export.image.toDrive({...});
 ```
 
-This saves an image as a raster file.
-
-A layer may look good on the map because of the visualization parameters, but the exported raster contains the original data values unless you explicitly export a visualized image.
+This saves raster values to a file.
 
-## Why this matters for the hands-on activities
+A layer may look good on the map because of the visualization settings, but the exported raster contains the original data values unless you explicitly export a visualized image.
 
-The same GEE logic appears throughout the workshop:
+## Basic GEE workflow
 
-* define an ROI
-* load an image or image collection
-* filter by date and region
-* mask unwanted pixels
-* calculate indices or terrain products
-* summarize values with reducers
-* display maps and charts
-* export final outputs
+Most workshop examples follow the same structure:
 
-Once this workflow is clear, it can be adapted to many ecological and forest management applications.
+1. define a region of interest
+2. load an image or image collection
+3. filter by date and region
+4. mask unwanted pixels
+5. calculate indices or terrain products
+6. summarize values with reducers
+7. display maps and charts
+8. export final outputs
 
 ## Questions
 
 1. What is the difference between an `ee.Image` and an `ee.ImageCollection`?
 2. Why do we filter image collections by date and region?
 3. What does `.map()` do in Earth Engine?
-4. Why is cloud masking important before analysis?
-5. What does a reducer do?
-6. What is the difference between client-side and server-side objects?
-7. Why does Earth Engine use lazy evaluation?
-8. What is the purpose of `system:time_start` in time series analysis?
-9. What is the difference between visualizing a layer and exporting a result?
-10. Why should we define a clear region of interest before analysis?
+4. What does a reducer do?
+5. What is the difference between visualizing a layer and exporting a result?
 
 <details>
 <summary>Answers</summary>
 
 1. An `ee.Image` is one raster dataset. An `ee.ImageCollection` is a set of images, often representing repeated observations through time.
 
-2. Filtering by date and region keeps only the images relevant to the question and study area. This reduces unnecessary processing and focuses the analysis.
+2. Filtering keeps only the images relevant to the study area and time period.
 
 3. `.map()` applies the same function to every image in a collection.
 
-4. Cloud masking removes cloud, shadow, snow, or other poor-quality pixels that can distort indices, composites, charts, and change detection.
+4. A reducer summarizes many values into fewer values, such as a mean, sum, minimum, maximum, or count.
 
-5. A reducer summarizes many values into fewer values. For example, it can calculate the mean NDVI inside an ROI or the total disturbed area in hectares.
-
-6. Client-side objects exist in the browser as normal JavaScript values. Server-side Earth Engine objects describe computations that run on Google’s servers.
-
-7. Lazy evaluation allows Earth Engine to build a processing plan and run it only when an output is requested. This makes large-scale analysis more efficient.
-
-8. `system:time_start` stores the date of an image. Time series charts use it to place images correctly on the x-axis.
-
-9. Visualization displays data on the map using colors and value ranges. Export saves raster data to a file for use outside Earth Engine.
-
-10. A clear ROI limits the analysis to the area of interest, reduces unnecessary processing, and makes summaries and exports more meaningful.
+5. Visualization displays data on the map. Export saves raster data to a file for use outside Earth Engine.
 
 </details>
 
@@ -280,8 +228,6 @@ var s2 = ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED");
 .filterDate("2023-01-01", "2023-12-31")
 ```
 
-4. Why is this not the same as downloading data to your computer?
-
 <details>
 <summary>Answers</summary>
 
@@ -291,7 +237,5 @@ var s2 = ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED");
 
 3. It keeps only images acquired between January 1 and December 31, 2023.
 
-4. The data remain in Earth Engine’s cloud environment. The script describes and runs computations on the server. Data are only downloaded if you explicitly export or download a result.
-
 </details>