Web GIS, Spatial Data Infrastructure and Emerging Trends
Open in the Padhaiko app8.1 Web GIS architecture, map servers and web mapping libraries
Web GIS delivers geospatial data, maps, and spatial analysis over HTTP/HTTPS using a three-tier client–server architecture:
- Data Tier: Spatial databases (PostGIS) and cloud/file repositories (GeoTIFF/COG, GeoPackage, GeoParquet).
- Application / Map Server Tier: Middleware that reads data, applies cartographic styling (SLD/CSS), exposes OGC/REST APIs, and caches tiles (GeoServer, MapServer, QGIS Server, pg_tileserv).
- Presentation / Client Tier: Browser or mobile JavaScript applications rendering maps and handling user interaction (Leaflet, OpenLayers, MapLibre GL JS).
Thin Clients vs. Thick Clients
| Aspect | Thin Client Architecture | Thick (Fat) Client Architecture |
|---|---|---|
| Where Processing Runs | Primarily on the server (renders map images, runs spatial analysis) | Primarily in the browser (GPU WebGL rendering, client-side filtering/analysis) |
| Data Transferred | Pre-rendered raster images (PNG/JPEG via WMS/XYZ) | Raw vector data (GeoJSON) or vector tiles (.mvt/.pbf) |
| Client Hardware Load | Very low RAM/CPU; works on low-end devices | Higher browser memory/GPU usage for large datasets |
| Interactivity & Offline | Limited to click/pan/zoom; requires server round-trips to restyle | Instant hover, dynamic restyling, 3D tilt/rotation, Turf.js client analysis |
Map Servers and Web Mapping Libraries
- Map Servers:
- GeoServer: Open-source Java server built on GeoTools with a web admin UI and REST API; natively publishes PostGIS/GeoTIFF layers as WMS, WMTS, WFS/WFS-T, WCS, and OGC APIs.
- MapServer: High-performance C-based engine (CGI/FastCGI) renowned for ultra-fast raster/vector rendering and Mapfile configuration.
- Web Mapping Libraries:
- Leaflet: Lightweight ( gzipped), plugin-rich 2D library ideal for mobile-friendly slippy maps and GeoJSON overlays.
- OpenLayers: Feature-complete enterprise library supporting arbitrary map projections (
proj4js), full OGC protocols (WMS/WFS-T/WMTS), and canvas/WebGL layers. - MapLibre GL JS: Open-source WebGL/WebGPU vector-tile renderer supporting smooth fractional zoom, 3D terrain/building extrusion, map rotation, and client-side data-driven styling.
const map = L.map("map").setView([27.7172, 85.3240], 12);
// Base XYZ raster tile layer
L.tileLayer("https://tile.openstreetmap.org/{z}/{x}/{y}.png", {
maxZoom: 19,
attribution: "© OpenStreetMap contributors"
}).addTo(map);
// Overlay WMS layer served from GeoServer
L.tileLayer.wms("https://example.org/geoserver/nepal/wms", {
layers: "nepal:kathmandu_wards",
format: "image/png",
transparent: true
}).addTo(map);8.2 OGC web services and OGC API standards
The Open Geospatial Consortium (OGC) defines vendor-neutral interface standards so any GIS client can talk to any map server.
Classic OGC Web Services (OWS / XML-KVP Era)
| Service | Full Name | Core Operations | Output & Primary Purpose |
|---|---|---|---|
| WMS | Web Map Service | GetCapabilities, GetMap, GetFeatureInfo | Dynamically rendered map images (PNG/JPEG) for visualization only |
| WMTS | Web Map Tile Service | GetCapabilities, GetTile, GetFeatureInfo | Pre-rendered fixed cached map tiles for fast high-traffic serving |
| WFS | Web Feature Service | GetCapabilities, GetFeature, Transaction (WFS-T) | Raw vector geometries + attributes (GML/GeoJSON); WFS-T allows web editing |
| WCS | Web Coverage Service | GetCapabilities, DescribeCoverage, GetCoverage | Raw multi-band raster cell values (GeoTIFF/NetCDF) for analysis, not just pictures |
| WPS | Web Processing Service | GetCapabilities, DescribeProcess, Execute | Standardized execution of server-side geoprocessing algorithms (buffer, clip) |
| CSW | Catalog Service for the Web | GetCapabilities, GetRecords, GetRecordById | Searches and harvests ISO 19115/19139 metadata catalogs in geoportals |
Modern OGC API Standards
Legacy OWS services relied on verbose XML schemas and SERVICE=...&REQUEST=... query strings that were awkward for modern web developers. The OGC API family modernizes them into clean RESTful JSON + OpenAPI 3.0 endpoints aligned with W3C web best practices:
- OGC API – Features (replaces WFS):
/collections/{id}/items?bbox=...returning GeoJSON/HTML. - OGC API – Tiles & Maps (replace WMTS/WMS):
/collections/{id}/tiles/{tileMatrixSetId}/{z}/{x}/{y}. - OGC API – Coverages (replaces WCS), Processes (replaces WPS), and Records (replaces CSW).
1
A municipal Web GIS application must support three user workflows: (a) displaying a fast background street basemap for concurrent public users, (b) letting authorized field engineers edit water-pipe vertices from a browser, and (c) letting hydrologists download raw -bit elevation values from a DEM for watershed slope calculation. Select the appropriate OGC service for each workflow and justify why alternatives fail.
Workflow (a) — Fast public street basemap ( users): Use WMTS (or OGC API – Tiles). Because WMTS serves pre-rendered cached tiles from a fixed matrix, a CDN or reverse proxy handles users effortlessly—whereas dynamic WMS GetMap would re-render images on the CPU per request and overload the server.
Workflow (b) — Browser-based vector editing of water pipes: Use WFS-T (Transactional WFS) (or OGC API – Features Part 4: Transactions). Standard WMS returns only flat raster pictures (no editable coordinates), and read-only WFS cannot commit inserts/updates/deletes back to PostGIS.
Workflow (c) — Downloading raw -bit DEM elevation values: Use WCS (Web Coverage Service) (or OGC API – Coverages). A WMS returns RGB colorized pixels (e.g., -bit colors) that lose true elevation meters, whereas WCS GetCoverage returns the original unscaled numeric elevation grid (e.g., 32-bit float GeoTIFF).
(a) WMTS (cached tiles scale to high concurrency), (b) WFS-T (transactional vector geometry editing), and (c) WCS (raw quantitative raster cell values rather than styled RGB pictures).
8.3 Spatial data infrastructure (SDI) and National SDI of Nepal
A Spatial Data Infrastructure (SDI) is the institutional, technical, and policy framework that enables seamless discovery, sharing, and reuse of geospatial data across government agencies, academia, and the public—eliminating duplicate data collection.
Five Core Components of an SDI
- Framework & Thematic Data: Authoritative core layers (geodetic control, orthoimagery, hydrography, transportation, elevation, administrative boundaries, cadastral parcels).
- Metadata & Standards: ISO 19115/19139 metadata schemas and OGC service standards ensuring technical interoperability (both syntactic format compatibility and semantic shared definitions).
- Clearinghouse & Geoportals: Web discovery catalogs (powered by CSW / GeoNetwork) allowing users to search metadata, preview WMS layers, and download authorized datasets from one central geoportal.
- Institutional Policy & Legal Framework: Data-sharing mandates, custodian responsibilities, licensing (open data such as ODbL/CC-BY vs. restricted security datasets), pricing, and liability policies.
- People & Capacity: Inter-agency coordination committees, trained GIS professionals, and user communities.
Legal, Privacy, and Ethical Aspects
- Copyright & Licensing: Clear open-data vs. proprietary licensing governs redistribution and commercial reuse (e.g., OpenStreetMap uses ODbL).
- Data Liability: Disclaimers and lineage metadata clarify intended scale/accuracy limits (preventing misuse of hazard maps for parcel-level legal disputes).
- Location Privacy (Geoprivacy): Fine-grained personal trajectories, patient disease coordinates, or household survey points can re-identify individuals even after removing names; mitigated via geomasking (random coordinate jitter), spatial aggregation (ward/hexbin counts), and -anonymity.
National SDI of Nepal (NGIIP)
In Nepal, the Survey Department leads the National Geographic Information Infrastructure Project (NGIIP) to establish Nepal's NSDI. NGIIP operates a national geoportal and clearinghouse integrating fundamental topographic datasets ( / ), administrative boundaries (77 districts, 753 local levels), Central Bureau of Statistics (CBS) census tables, and sectoral ministry layers under standardized MUTM/WGS 84 references and metadata protocols.
8.4 Cloud and big-data geospatial computing
Traditional single-workstation GIS struggles when analyzing decades of global satellite archives or billions of GPS pings. Cloud-native geospatial platforms bring compute to the data rather than downloading terabytes locally:
- Google Earth Engine (GEE):
- Combines a multi-petabyte public catalog (Landsat, Sentinel, MODIS, CHIRPS, SRTM DEM) with Google's distributed compute cluster.
- Uses lazy evaluation (functional DAG execution): JavaScript or Python client scripts compose operations (
filterBounds,map,normalizedDifference,reduceRegion), which GEE executes in parallel across server tiles only when results are displayed or exported.
- Distributed Spatial Processing (Apache Sedona):
- Extends Apache Spark and Apache Flink with distributed
Geometrytypes, spatial partitioning (Quadtree / KDB-tree), local R-tree indexing inside partitions, and Spatial SQL (ST_Intersects,ST_KNN, distance joins) over GeoParquet and cloud object storage (S3/GCS). - Enables spatial joins across billions of trajectory points and millions of polygons in minutes across multi-node clusters.
- Extends Apache Spark and Apache Flink with distributed
import ee
ee.Initialize()
roi = ee.Geometry.Rectangle([85.20, 27.62, 85.45, 27.78]) # Kathmandu Valley
s2 = (ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED")
.filterBounds(roi)
.filterDate("2025-10-01", "2025-11-30")
.filter(ee.Filter.lt("CLOUDY_PIXEL_PERCENTAGE", 10))
.median())
ndvi = s2.normalizedDifference(["B8", "B4"]).rename("NDVI")8.5 GeoAI and emerging trends
- GeoAI (Deep Learning for Remote Sensing & GIS):
- Semantic Segmentation (U-Net, DeepLabv3+, SegFormer): Labels every pixel in high-resolution satellite/UAV imagery into roads, building footprints, water bodies, or landslide scars.
- Object Detection (YOLO, Faster R-CNN): Detects individual vehicles, ships, solar panels, or brick kilns with bounding boxes.
- Spatial–Temporal Foundation Models & Change Detection: Siamese neural networks and Vision Transformers detect illegal deforestation, flood inundation, and post-earthquake building damage automatically.
- Real-Time IoT and Sensor-Based GIS:
- Streaming telemetry from river-level gauges, air-quality nodes, traffic loops, and GNSS fleet trackers ingested via MQTT / Apache Kafka and OGC SensorThings API for live anomaly alerts and dynamic geofencing.
- Mobile Location-Based Services (LBS):
- Fuses multi-constellation GNSS, Wi-Fi/BLE beacons, cellular triangulation, and IMU dead-reckoning for turn-by-turn navigation, geofenced notifications, ride-hailing dispatch, and indoor wayfinding.
- Digital Twins and 3D City Models (CityGML):
- A Urban Digital Twin links a live, continuously updated 3D city model with real-time IoT sensor feeds and physics/traffic simulations ("what-if" flood, solar potential, or emergency-evacuation testing).
- CityGML (OGC open standard) models 3D urban objects (buildings, bridges, tunnels, vegetation, terrain) semantically across five Levels of Detail (LOD0–LOD4):
- LOD0: Regional 2.5D footprints/terrain.
- LOD1: Simple extruded prismatic blocks (flat roofs).
- LOD2: Differentiated roof shapes (gabled, hipped) and textures.
- LOD3: Detailed architectural exteriors (windows, doors, balconies).
- LOD4: Complete interior architecture (rooms, stairs, furniture).
2
A Web GIS portal serves a -tile city map viewport. Each vector tile (.mvt) averages , whereas each high-DPI raster tile (.png) averages .
- Compute the total payload size in megabytes (, ) for both approaches.
- Explain two functional advantages of choosing vector tiles + MapLibre GL JS over raster tiles for a 3D urban Digital Twin portal.
Compute payload sizes for tiles:
Vector tiles reduce network bandwidth by !
Identify two advantages for a 3D Digital Twin portal:
- 3D Extrusion & Smooth Rotation/Pitch: Vector tile building footprints carry height/floor attributes that MapLibre GL JS extrudes directly into interactive 3D LOD1 blocks on the GPU without re-downloading tiles when pitching or rotating.
- Dynamic Client-Side Restyling & Querying: Attribute values embedded in
.mvttiles allow instant thematic recoloring (e.g., toggling energy consumption vs. flood risk) and zero-latency click/hover inspection without round-tripGetFeatureInfoserver requests.
The -tile viewport requires with vector tiles versus with high-DPI raster tiles ( bandwidth savings), while enabling GPU 3D building extrusion/pitch and instant client-side restyling and feature inspection.
added
Compare thin clients and thick clients in Web GIS architecture, and briefly describe the roles of GeoServer and MapLibre GL JS.
Thin vs. Thick Clients:
- Thin client: Delegates rendering and spatial processing to the server; receives static raster images (WMS/XYZ), requiring minimal client CPU/RAM but offering limited offline/styling interactivity.
- Thick client: Downloads vector geometries or vector tiles (GeoJSON/
.mvt) and performs WebGL rendering, styling, and spatial calculations (e.g., Turf.js) inside the browser—delivering smooth 3D interaction and dynamic restyling at higher client memory cost.
Roles of GeoServer and MapLibre GL JS:
- GeoServer: Open-source server middleware connecting PostGIS/GeoTIFF stores to standard web protocols (WMS, WMTS, WFS-T, WCS, OGC API).
- MapLibre GL JS: Open-source client-side WebGL library that renders vector and raster tiles with smooth zooming, 3D pitch, and data-driven styling.
Thin clients render maps server-side as raster images (low device load), whereas thick clients download vector data/tiles for client-side WebGL rendering and analysis. GeoServer publishes spatial stores via OGC/REST services on the server, while MapLibre GL JS renders interactive vector/3D maps in the browser.
Distinguish between WMS, WMTS, WFS, and WCS, and explain why the OGC API family is replacing these older OWS standards.
Distinguish the four OWS standards:
- WMS: Dynamically renders map images (PNG/JPEG) on demand.
- WMTS: Serves pre-generated cached map tiles from fixed tile matrices for high-speed scaling.
- WFS: Transfers raw vector features (GML/GeoJSON) with attributes, and supports web editing via WFS-T.
- WCS: Transfers raw multi-dimensional raster cell values (GeoTIFF) for quantitative analysis.
Why OGC API replaces OWS: Classic OWS used rigid XML schemas, SOAP/KVP URL parameters (SERVICE=WFS&REQUEST=GetFeature), and non-RESTful patterns. OGC API standards (Features, Tiles, Processes, Records) adopt modern RESTful resource URLs, JSON/GeoJSON payloads, and OpenAPI 3.0 specifications, making integration effortless in web and cloud applications.
WMS serves dynamic map images, WMTS serves cached tiles, WFS serves editable vector features, and WCS serves raw numeric raster coverages. OGC API replaces legacy XML/KVP OWS with modern RESTful endpoints, GeoJSON/JSON, and OpenAPI 3.0.
Define Spatial Data Infrastructure (SDI), list its five core components, and explain two geoprivacy techniques used when publishing sensitive public-health spatial data, mentioning Nepal's NGIIP.
SDI and its five components: An SDI is the coordinated technical, institutional, and policy ecosystem enabling cross-agency geospatial discovery and reuse. Its five components are: (1) Framework & thematic data, (2) Metadata & interoperability standards, (3) Clearinghouse/geoportals & network technology, (4) Legal/policy frameworks, and (5) People/institutions. (In Nepal, the Survey Department's NGIIP coordinates the national geoportal and core topographic/census layers.)
Two geoprivacy techniques:
- Spatial Aggregation: Publishing counts per administrative ward or uniform hexagonal grid (e.g., H3) instead of exact household coordinates, often enforcing minimum -anonymity thresholds.
- Geomasking (Random Perturbation): Displacing individual point coordinates by a controlled random distance/direction (weighted by local population density) so cluster statistics remain valid while exact homes cannot be reverse-engineered.
An SDI comprises data, metadata/standards, clearinghouse/geoportal technology, legal/policy frameworks, and people (implemented in Nepal via NGIIP). Sensitive spatial data is protected using spatial aggregation (-anonymity) and geomasking (controlled random coordinate perturbation).
Contrast how Google Earth Engine (GEE) and Apache Sedona tackle big geospatial data computing. If a distributed Apache Sedona cluster processes spatial partitions/tasks at tasks/second across workers with shuffle overhead (factor ), estimate the total execution time in seconds.
Contrast GEE vs. Apache Sedona:
- Google Earth Engine (GEE): Managed cloud platform pairing a multi-petabyte Earth observation catalog (Landsat/Sentinel) with a lazy-evaluated tile-parallel engine ideal for planetary raster composites, time-series reductions, and pixel classification.
- Apache Sedona: Open-source distributed spatial engine extending Apache Spark / Flink with spatial partitioning (KDB-tree/Quadtree), per-partition R-tree indexing, and Spatial SQL—ideal for custom vector joins, trajectory analytics, and GeoParquet data lakes on self-managed or cloud clusters.
Estimate execution time:
GEE is a managed planetary satellite catalog + lazy tile-parallel raster platform, while Apache Sedona adds distributed spatial partitioning and Spatial SQL to Spark/Flink for massive vector/GeoParquet joins. With shuffle overhead, the cluster finishes in .
Explain the role of GeoAI (deep learning) in remote sensing, and describe how CityGML Levels of Detail (LOD0–LOD4) and real-time IoT streams together power an urban Digital Twin.
GeoAI in remote sensing: Deep learning architectures automatically extract high-level information from massive imagery: CNNs / U-Net perform pixel-level semantic segmentation (mapping roads, buildings, floodwater, landslides), YOLO / Faster R-CNN detect discrete objects (vehicles, solar panels), and Siamese/Transformer networks automate multi-date change detection.
CityGML LOD0–LOD4 and IoT in an Urban Digital Twin:
- CityGML provides the semantic 3D structural backbone across five progressive detail levels: LOD0 (2.5D footprints), LOD1 (extruded blocks), LOD2 (roof geometry/textures), LOD3 (architectural facades, windows, doors), and LOD4 (building interiors/rooms).
- Streaming real-time IoT sensors (traffic cameras, smart water meters, air-quality stations via MQTT/OGC SensorThings API) continuously update states inside the 3D CityGML geometry, turning a static 3D city model into a living Digital Twin capable of real-time monitoring and "what-if" scenario simulation.
GeoAI automates semantic segmentation (U-Net), object detection (YOLO), and change detection in remote sensing imagery. CityGML (LOD0–LOD4) supplies semantic 3D urban geometry—from 2.5D footprints to detailed interiors—while real-time IoT sensor feeds synchronize live physical states into it to create an interactive Urban Digital Twin.