Upload README.md with huggingface_hub

README.md

@@ -1,151 +1,458 @@
+# Raster Processing with RDPro (GDAL / rasterio–style)
+
+Raster data is one of the most common formats for geospatial analysis.  
+In libraries such as **GDAL** and **rasterio**, raster datasets are treated as
+**multidimensional grids (images)** with spatial metadata such as coordinate
+reference systems (CRS), resolution, and geographic extent.
+
+**RDPro (Raster Distributed Processor)** follows the same conceptual model as
+GDAL and rasterio, but executes raster operations **in parallel on Apache Spark**.
+If you are familiar with GDAL or rasterio, you can think of RDPro as providing
+the same raster operations—opening datasets, raster math, reprojection,
+resampling, stacking, and writing outputs—at distributed scale.
+
+This page describes the basic raster processing functionality provided by RDPro
+in Beast.
+
+---
+
+## Setup
+
+Before using RDPro, follow the [setup page](dev-setup.md) to configure your
+project for Beast.
+
+In Scala, import Beast features:
+
+```scala
+import edu.ucr.cs.bdlab.beast._
+```
+
+---
+
+## Raster Data Model (GDAL-style concepts)
+
+RDPro explicitly models the same spatial concepts used implicitly in GDAL and
+rasterio.
+
+### Grid space (pixel coordinates)
+
+A raster is represented as a **2D pixel grid**:
+
+- Width **W** (columns)
+- Height **H** (rows)
+- Origin **(0, 0)** at the **top-left corner**
+
+Pixel coordinates are represented as `(i, j)` where `i` is the column index and
+`j` is the row index. These coordinates are independent of geography, just like
+array indexing in NumPy or rasterio.
+
+---
+
+### Raster tiles (distributed blocks)
+
+For distributed processing, the raster grid is divided into **tiles**:
+
+- Each tile has dimensions `(tileWidth × tileHeight)`
+- Edge tiles may be smaller
+- Each tile has a unique **tile ID**
+
+This is analogous to block/window processing in GDAL, but exposed explicitly to
+enable parallel execution.
+
+---
+
+### World space (geographic coordinates)
+
+World space represents a rectangular geographic region on the Earth’s surface
+defined by four coordinates:
+
+```
+[x1, x2) × [y1, y2)
+```
+
+Coordinates are expressed in the raster’s CRS, exactly as in GDAL datasets.
+
+---
+
+### Grid ↔ World transformations
+
+- **Grid → World (G2W)**: affine transform from pixel coordinates to geographic
+  coordinates
+- **World → Grid (W2G)**: inverse transform from geographic coordinates to pixel
+  indices
+
+These correspond directly to GDAL’s geotransform and inverse geotransform.
+
+---
+
+## RDPro Data Abstractions
+
+### `ITile[T]` — atomic raster unit
+
+An `ITile[T]` represents a single raster tile and is the smallest unit of
+processing in RDPro.
+
+```scala
+@tparam T              Pixel value type
+@param tileID          Tile identifier
+@param rasterMetadata  Spatial metadata
+@param rasterFeature   Optional auxiliary attributes (e.g., filename, time)
+```
+
+---
+
+### `RasterMetadata` — dataset-level metadata
+
+`RasterMetadata` holds the same information as a GDAL dataset’s spatial metadata:
+
+```scala
+@param x1, y1, x2, y2   Geographic extent
+@param tileWidth        Tile width (pixels)
+@param tileHeight       Tile height (pixels)
+@param srid             CRS (e.g., EPSG:4326)
+@param g2m              Grid-to-world affine transform
+```
+
+---
+
+### `RasterRDD[T]`
+
+`RasterRDD[T]` is an alias for `RDD[ITile[T]]` and represents a **distributed
+raster dataset**, analogous to a GDAL or rasterio dataset, but partitioned across
+Spark.
+
+All examples below assume an initialized `SparkContext` named `sc`.
+
+---
+
+## Opening Raster Datasets (GeoTIFF / HDF)
+
+In GDAL or rasterio, raster processing starts by **opening a dataset from disk**.
+RDPro follows the same idea, except datasets are loaded as distributed
+collections.
+
+```scala
+// Load a GeoTIFF
+val raster: RasterRDD[Int] = sc.geoTiff("glc2000_v1_1.tif")
+
+// Load an HDF subdataset (similar to GDAL subdatasets)
+val temperatureK: RasterRDD[Float] =
+  sc.hdfFile(
+    "MOD11A1.A2022173.h08v05.006.2022174092443.hdf",
+    "LST_Day_1km"
+  )
+```
+
+The input can be a single file or a directory containing many files; in both
+cases, the data are loaded into a single `RasterRDD`.
+
+---
+
+### Determining pixel data types
+
+Similar to inspecting `dataset.dtypes` in rasterio, RDPro allows you to inspect
+pixel types:
+
+```scala
+val raster = sc.geoTiff("glc2000_v1_1.tif")
+println(raster.first.pixelType)
+```
+
+Example output:
+```
+IntegerType
+```
+
+Supported types:
+
+| Pixel type                  | Loading statement            |
+|-----------------------------|------------------------------|
+| IntegerType                 | `sc.geoTiff[Int]`            |
+| FloatType                   | `sc.geoTiff[Float]`          |
+| ArrayType(IntegerType,true) | `sc.geoTiff[Array[Int]]`     |
+| ArrayType(FloatType,true)   | `sc.geoTiff[Array[Float]]`   |
+
+---
+
+## Creating Raster Datasets Programmatically
+
+In addition to reading files, rasters can be constructed directly from pixel
+values, similar to manually creating arrays in NumPy.
+
+### Rasterizing grid coordinates
+
+```scala
+val metadata = RasterMetadata.create(
+  x1 = -50, y1 = 40, x2 = -60, y2 = 30,
+  srid = 4326,
+  rasterWidth = 10, rasterHeight = 10,
+  tileWidth = 10, tileHeight = 10
+)
+
+val pixels = sc.parallelize(Seq(
+  (0, 0, 100),
+  (3, 4, 200),
+  (8, 9, 300)
+))
+
+val raster = sc.rasterizePixels(pixels, metadata)
+```
+
 ---
-pretty_name: "GS-QA2: Question Answering over Raster–Vector Geospatial Data"
-license: odbl
-language:
-- en
-task_categories:
-- question-answering
-- text-generation
-tags:
-- geospatial
-- gis
-- spatial-reasoning
-- text-to-sql
-- openstreetmap
-- digital-elevation-model
-- raster
-- vector
-- benchmark
-- postgis
-size_categories:
-- 1K<n<10K
-configs:
-- config_name: vector
-  data_files:
-  - split: test
-    path: data/vector-*.parquet
-- config_name: raster_only
-  default: true
-  data_files:
-  - split: test
-    path: data/raster_only.jsonl
-- config_name: raster_vector
-  data_files:
-  - split: test
-    path: data/raster_vector.jsonl
-- config_name: extended
-  data_files:
-  - split: test
-    path: data/extended.jsonl
+
+### Rasterizing geographic coordinates
+
+Instead of grid indices, pixel values can be defined using geographic
+coordinates:
+
+```scala
+val pixels = sc.parallelize(Seq(
+  (-51.3, 30.4, 100),
+  (-55.2, 34.5, 200),
+  (-56.4, 39.2, 300)
+))
+
+val raster = sc.rasterizePoints(pixels, metadata)
+```
+
 ---
 
-# GS-QA2: A Benchmark for Question Answering over Raster–Vector Data
+## Pixel-wise Raster Operations
+
+Pixel-level operations correspond to **element-wise raster math** in NumPy or
+rasterio.
+
+### MapPixels (element-wise transform)
+
+```scala
+val temperatureF: RasterRDD[Float] =
+  temperatureK.mapPixels(k => (k - 273.15f) * 9 / 5 + 32)
+```
+
+This produces an output raster with the same shape and metadata.
 
-GS-QA2 is a benchmark for **geospatial question answering over both vector and raster data**. It extends [GS-QA](https://arxiv.org/abs/2605.22811) — a vector-only benchmark built on OpenStreetMap features in a PostGIS database — with a U.S. Digital Elevation Model (DEM) raster layer and 25 new question templates that require terrain reasoning: elevation lookups, slope, aspect, ruggedness, and questions that combine vector filtering with raster analysis.
-
-Each record pairs a natural-language question with an **executable PostGIS SQL query** and its **ground-truth answer**, so every question is verifiable without manual annotation. This release contains the complete benchmark: the **2,800 vector-only pairs** (V1–V28, 100 per template) inherited from [GS-QA](https://arxiv.org/abs/2605.22811) by Saeedan, Rashid, Eldawy, and Hristidis, plus the **500 raster-related pairs** (25 templates × 20 questions) that GS-QA2 adds — **3,300 questions in total**.
+---
 
-Code, ingestion scripts, generation pipeline, and baseline implementations live in the companion repository: **https://github.com/ZhuochengShang/QARV**
+### FilterPixels (masking)
 
-## Why this benchmark
+Equivalent to masking raster values based on a condition:
 
-Existing geospatial QA benchmarks evaluate vector data only (points, lines, polygons), while vision-oriented raster benchmarks target perception over imagery rather than structured reasoning over raster values. GS-QA2 fills the gap: it measures whether LLM-based systems (Text2SQL, RAG, multi-stage SQL agents, code-writing GIS agents) can reason over continuous terrain surfaces and their interaction with discrete vector features. In the paper's evaluation, systems answered simple point-elevation queries reasonably well but accuracy dropped sharply on terrain derivatives (slope, aspect) and combined raster–vector operations — zonal and global raster operations collapsed to near zero for every baseline.
+```scala
+temperatureK
+  .filterPixels(_ > 300)
+  .saveAsGeoTiff("temperature_high")
+```
 
-## Dataset structure
+---
 
-Four configurations, mirroring the paper's template groups of increasing raster-reasoning complexity:
+### Flatten (raster → samples)
 
-| Config | Templates | Records | Description |
-|---|---|---|---|
-| `vector` | V1–V28 | 2,800 | Vector-only questions from the original GS-QA benchmark — range, nearest-neighbor, direction, towards, and intersects queries over OSM features, with entity-name, location, direction, count, distance, area, and length answers |
-| `raster_only` | R1–R11 | 220 | Direct DEM queries — elevation, slope, aspect, ruggedness, elevation thresholds — anchored at POIs and roads |
-| `raster_vector` | VR9–VR14 | 120 | New raster–vector templates requiring tight interaction: zonal aggregation, comparison, and ranking of POIs by terrain properties |
-| `extended` | VR1–VR8 | 160 | Standard vector queries augmented with a terrain condition or terrain output (e.g., range queries with elevation filters) |
+`flatten` extracts all non-empty pixels into a non-raster RDD, similar to
+converting a raster into point samples for global statistics.
 
-All 3,300 questions form a single evaluation set, published as the `test` split of each config. The `vector` config is stored as zstd-compressed Parquet (its ground-truth answer lists are large); the three raster configs are plain JSONL. Questions were instantiated from templates by sampling real geographic entities (POIs, roads, parks, regions across the contiguous United States), executing the paired SQL against the reference PostGIS database (OSM + 30 m DEM, 265,950 raster tiles), and retaining only questions with valid, non-empty ground truth.
+```scala
+val histogram: Map[Int, Long] =
+  raster.flatten.map(_._4).countByValue().toMap
+```
 
-### Data fields
+Each output record contains:
+- Pixel `(x, y)` indices
+- Raster metadata
+- Pixel value
 
-| Field | Type | Description |
-|---|---|---|
-| `id` | string | Unique ID: `{group}/{template}/{index}` |
-| `template_id` | string | Paper template ID: `V1`–`V28` (vector), `R1`–`R11` (raster-only), `VR1`–`VR8` (extended), `VR9`–`VR14` (raster–vector) |
-| `group` | string | `vector`, `raster_only`, `raster_vector`, or `extended` |
-| `template` | string | Template file name, e.g. `elevation+poi`, `slope+route`, `range+name+elevation_condition` |
-| `question` | string | Natural-language question |
-| `sql` | string | Executable PostGIS SQL query that produces the ground truth |
-| `answer_type` | string | Expected output type, e.g. `elevation - point based`, `slope`, `entity name` |
-| `answers` | string (JSON) | Ground-truth answer rows as a JSON-encoded list of objects. Keys vary by template (`elevation`, `slope_degrees`, `poi_name`, `distance_m`, …), so the list is serialized as a JSON string — parse with `json.loads` |
-| `question_entities` | string (JSON) | JSON-encoded metadata for the entities used to instantiate the template: display name, category, WKT geometry, and full OSM attributes |
+---
 
-The untouched original template files (one JSONL per template, grouped by folder) are preserved under `raw/qa2/` for provenance. `raw/qa2/` additionally contains 9 exploratory templates (180 QA pairs — regional/area elevation and slope aggregates and an elevation-count template) that were generated during benchmark construction but are not part of the canonical 500-question evaluation set exposed in the configs above.
+## Stacking Rasters (Multi-band Datasets)
 
-### Example record (`raster_only`, template `elevation+poi`)
+In GDAL, multiple rasters can be combined into a **multi-band dataset**.  
+RDPro provides the same functionality via `overlay`.
 
-```json
-{
-  "question": "What is the elevation at Cousins Subs, Chicago, IL?",
-  "sql": "SELECT ST_Value(rast, 1, ST_GeomFromText('POINT (-87.631702 41.88228)',4326)) AS elevation FROM public.dem_us WHERE ST_Intersects(rast, ST_GeomFromText('POINT (-87.631702 41.88228)',4326)) LIMIT 1;",
-  "answers": [{"elevation": 286.0}],
-  "answer_type": "elevation - point based"
-}
+```scala
+val stacked: RasterRDD[Array[Int]] =
+  raster1.overlay(raster2)
 ```
 
-## Usage
+All input rasters must have the same CRS, resolution, and tile size.
+
+---
 
-```python
-import json
-from datasets import load_dataset
+## Reshaping Rasters (GDAL Warp–style Operations)
 
-ds = load_dataset("Zoe/GS-QA2", "raster_only", split="test")
+### Retile (change block layout)
 
-example = ds[0]
-print(example["question"])
-print(example["sql"])
-answers = json.loads(example["answers"])        # list of ground-truth rows
-entities = json.loads(example["question_entities"])
+```scala
+val retiled = raster.retile(64, 64)
+retiled.saveAsGeoTiff("glc_retiled")
 ```
 
-To *execute* the SQL and reproduce ground truths or run the baselines, you need the reference PostGIS database (OSM vector tables + DEM raster tiles). Raw OSM extracts, DEM files, and database dumps are not included here — see the ingestion instructions in the [QARV repository](https://github.com/ZhuochengShang/QARV) (`GS-QA/ingestion/`).
+---
+
+### Explode (tile-wise outputs)
 
-## Evaluation
+Useful when each tile should be written as a separate file (e.g., ML pipelines):
 
-Answers are scored per output type, following the paper (Tables 9–10): token-level F1 ≥ 0.8 for entity names, geodesic distance error ≤ 5 m for locations, circular angular error ≤ 5° for directions and aspect, absolute error ≤ 10 m for elevations, ≤ 5° for slope, and relative error ≤ 0.05 for areas, lengths, distances, and counts. Compound outputs are correct only when every component passes. Evaluation scripts are in `GS-QA/baselines/evaluation/` of the companion repository.
+```scala
+raster
+  .retile(64, 64)
+  .explode
+  .saveAsGeoTiff("glc_retiled", GeoTiffWriter.WriteMode -> "distributed")
+```
+
+---
 
-## Benchmark construction
+### Reproject (change CRS)
 
-1. **Template selection** — 25 raster-related templates organized by Tomlin's map-algebra operation types (local, focal, zonal, global) plus spatial predicates (range, nearest neighbor, intersects, …).
-2. **Parameter sampling** — placeholders (`[ANCH_POI]`, `[DISTANCE]`, `[ELEV_COND]`, …) filled with real entities and values sampled from the database.
-3. **NL generation** — natural-language phrasing with grammar correction; duplicates removed via canonicalized SQL comparison.
-4. **Ground-truth execution** — each paired SQL runs against the PostGIS reference database (120 s timeout); empty/invalid results are discarded and regenerated. 20 questions are kept per template.
+Equivalent to `gdal.Warp` with a new CRS:
 
-## Source data and licensing
+```scala
+val temperature: RasterRDD[Float] =
+  sc.hdfFile("MOD11A1.A2022173.h08v05.006.2022174092443.hdf", "LST_Day_1km")
+
+temperature.reproject(4326)
+```
 
-- **Vector features:** © [OpenStreetMap](https://www.openstreetmap.org/copyright) contributors, available under the [Open Database License (ODbL)](https://opendatacommons.org/licenses/odbl/). Question text, entity metadata, and ground-truth answers are derived from OSM data, so this dataset is shared under ODbL.
-- **Terrain:** elevation values derive from the [Copernicus DEM](https://doi.org/10.5270/ESA-c5d3d65) (© ESA), 30 m resolution over the contiguous United States.
+---
 
-## Citation
+### Rescale (change resolution)
 
-If you use the `vector` config (V1–V28), please also cite the original GS-QA benchmark:
+Equivalent to GDAL resampling:
 
-```bibtex
-@article{saeedan2026gsqa,
-  title   = {GS-QA: A Benchmark for Geospatial Question Answering},
-  author  = {Saeedan, Majid and Shihab Rashid, Muhammad and Eldawy, Ahmed and Hristidis, Vagelis},
-  journal = {arXiv preprint arXiv:2605.22811},
-  year    = {2026}
-}
+```scala
+val rescaled = raster.rescale(360, 180)
+rescaled.saveAsGeoTiff("glc_small", GeoTiffWriter.WriteMode -> "compatibility")
 ```
 
-```bibtex
-@inproceedings{shang2026gsqa2,
-  title     = {GS-QA2: A Benchmark for Question Answering over Raster--Vector Data},
-  author    = {Shang, Zhuocheng and Elmahallawy, Shahd and Al Nazi, Zabir and Hristidis, Vagelis and Eldawy, Ahmed},
-  year      = {2026},
-  note      = {Benchmark and code: https://github.com/ZhuochengShang/QARV}
-}
+---
+
+### Reshape (general warp)
+
+The most general operation for changing CRS, extent, resolution, and tile size
+in one step:
+
+```scala
+val reshaped =
+  RasterOperationsFocal.reshapeNN(
+    raster,
+    RasterMetadata.create(-124, 42, -114, 32, 4326, 1000, 1000, 100, 100)
+  )
+
+reshaped.saveAsGeoTiff("glc_ca")
 ```
 
-## Contact
+Supported interpolation methods:
+- Nearest Neighbor (`reshapeNN`)
+- Average (`reshapeAverage`)
+
+---
+
+## Raster–Vector Analysis (Raptor)
+
+Raptor enables joint raster–vector processing, similar to zonal statistics in
+GDAL.
+
+```scala
+val raster: RasterRDD[Int] = sc.geoTiff[Int]("glc2000_v1_1.tif")
+val trees = raster.filterPixels(lc => lc >= 1 && lc <= 10)
+val countries = sc.shapefile("ne_10m_admin_0_countries.zip")
+
+val result =
+  RaptorJoin.raptorJoinFeature(trees, countries, Seq())
+    .map(x => x.feature.getAs[String]("NAME"))
+    .countByValue()
+    .toMap
+println(result)
+```
+
+---
+
+## Writing Raster Outputs (GeoTIFF)
+
+Writing rasters follows the same model as rasterio write profiles.
+
+```scala
+val temperatureK: RasterRDD[Float] =
+  sc.hdfFile("MOD11A1.A2022173.h08v05.006.2022174092443.hdf", "LST_Day_1km")
+val temperatureF: RasterRDD[Float] =
+  temperatureK.mapPixels(k => (k-273.15f) * 9 / 5 + 32)
+temperatureF.saveAsGeoTiff("temperature_f")
+```
+
+### Advanced GeoTIFF Options
+
+For advanced options (compression, write mode, bit compaction), add imports:
+
+```scala
+import edu.ucr.cs.bdlab.raptor.GeoTiffWriter
+import edu.ucr.cs.bdlab.beast.io.tiff.TiffConstants
+```
+
+#### Compression
+
+```scala
+raster.saveAsGeoTiff("temperature_f",
+  GeoTiffWriter.Compression -> TiffConstants.COMPRESSION_LZW)
+
+raster.saveAsGeoTiff("temperature_f",
+  GeoTiffWriter.Compression -> TiffConstants.COMPRESSION_DEFLATE)
+
+raster.saveAsGeoTiff("temperature_f",
+  GeoTiffWriter.Compression -> TiffConstants.COMPRESSION_NONE)
+```
+
+#### Write mode
+
+Distributed mode writes one file per Spark partition (fast, Beast-friendly).  
+Compatibility mode writes a single GeoTIFF compatible with traditional GIS tools.
+
+```scala
+raster.saveAsGeoTiff("temperature_f",
+  GeoTiffWriter.WriteMode -> "distributed")
+
+raster.saveAsGeoTiff("temperature_f",
+  GeoTiffWriter.WriteMode -> "compatibility")
+```
+
+Hint: Use `Seq` to pass multiple options.
+
+```scala
+raster.saveAsGeoTiff("temperature_f",
+  Seq(
+    GeoTiffWriter.Compression -> TiffConstants.COMPRESSION_LZW,
+    GeoTiffWriter.WriteMode -> "compatibility"
+  )
+)
+```
+
+#### Bit compaction
+
+```scala
+raster.saveAsGeoTiff("temperature_f", GeoTiffWriter.CompactBits -> true)
+```
+
+#### BitsPerSample
+
+```scala
+raster.saveAsGeoTiff("temperature_f", GeoTiffWriter.BitsPerSample -> "8,8,8")
+```
+
+---
+
+## Concept Mapping (for GDAL / rasterio users)
+
+| GDAL / rasterio concept | RDPro |
+|------------------------|-------|
+| `gdal.Open` / `rasterio.open` | `sc.geoTiff` |
+| HDF subdataset selection | `sc.hdfFile(path, dataset)` |
+| Raster math (NumPy-style) | `mapPixels` |
+| Masking | `filterPixels` |
+| Band stacking / multi-band | `overlay` |
+| Warp / resample | `reproject`, `rescale`, `reshape` |
+| GeoTIFF write | `saveAsGeoTiff` |
+
+---
+
+## Takeaway
 
-Zhuocheng Shang — zshan011@ucr.edu — University of California, Riverside
+**RDPro implements the same raster operations as GDAL and rasterio**, but executes
+them **at scale on Apache Spark**. This README intentionally uses GDAL-style
+terminology so that both users and LLMs can immediately recognize the workflow.