Line-of-Sight and Area-of-Sight terrain analysis (#122)

* feat(los): add Line-of-Sight tool with live cursor tracking

Adds a new "Line of Sight" entry to the Measure menu. After placing an
observer with the first click, the LoS recomputes on every pointermove
against the Mapbox-RGB terrain tile source and renders the visible
segment in green, the blocked segment as a dashed red line and the
first blocker as a red diamond. Distance, eye-height delta and
first-blocker distance are shown in the OSD.

Range is clamped to 10 km (clip marker drawn at the cap); the second
click finalises the LoS and leaves it on the map, so multiple
Line-of-Sights can coexist in a session. Earth curvature and
atmospheric refraction (k=0.13) are applied unconditionally to keep
results realistic at the relevant distances.

The command is gated on terrain availability and WebGL2 support (the
latter is a prerequisite for the planned Area-of-Sight feature and is
checked here for consistency). Observer/target heights default to
1.70 m AGL; an editor for these plus persistence will follow in a
separate change.

* feat(los): persist Line-of-Sight features across reloads

Adds a LOS scope (los:{uuid}) to the id catalogue and rewires the
line-of-sight module to be store-driven. Finalised LoS results are
written to the store, restored on app start, and rebuilt incrementally
on subsequent put/del operations.

The in-progress (live-preview) overlay is unchanged. On finalisation
the live features are handed over directly to the persistent map so
there is no flicker, and a fresh losId is inserted into the store. A
small race-safe initial-load path waits for a terrain layer to be
available before rendering the persisted set.

Heights are still fixed to the 1.70 m defaults; the per-feature
height editor will land alongside selection support in a separate
change.

* feat(los): selection + properties panel with height editor

Selecting a finalised LoS on the map (click) now opens a Properties
panel with editable observer/target height fields and a read-only
distance display. Edits flow through store.update, our batch handler
detects the change and rebuilds the visual representation; the
existing clipboard-delete pipeline removes a selected LoS without
any extra wiring.

All sub-features of a LoS (observer point, visible/blocked segments,
blocker diamond, clip marker) carry the same losId as OpenLayers
feature id, so a click on any of them selects the whole document.
The LoS layer is tagged selectable; the map-wide Select interaction
is suspended while the placement tool is live so the first/second
click never doubles as a feature select.

Multi-select shows M/V in the height fields and accepts a value to
apply to all selected LoS at once, mirroring how the other property
panels behave.

* feat(elevation): deterministic terrain sampling at fixed analysis zoom

- ElevationService samples at a data-driven analysis zoom (finest zoom
  resolving <= 15 m/cell) instead of the current view zoom: LoS and
  elevation profile results no longer change with zoom or after reload
- promise-based tile cache deduplicates concurrent downloads; tiles are
  decoded once into Float32 elevations
- profileAlongLine fetches required tiles in parallel, then samples
  synchronously
- getGrid(extent) stitches a tile-aligned Float32 elevation grid
  (foundation for Area-of-Sight), coarsening zoom to fit a cell budget
- drop the WebGL2 gate from the LoS command (LoS is CPU sampling only)

* feat(aos): real-time Area-of-Sight via WebGPU viewshed

- R2 viewshed engine: WebGPU compute shader (one thread per ray),
  10 km @ 10 m in single-digit ms; viewshedCPU as reference and
  fallback when no GPU adapter is available
- tool follows the cursor with a live preview (latest-wins), click
  places the observer and persists the document in the aos: scope
- visibility mask rendered as circular raster overlay (ImageCanvas),
  green/red, no-data cells stay transparent and never block
- selectable observer point with properties panel for radius (default
  2500 m, max 10 km) and observer/target heights; changes recompute
- map clicks no longer deselect LoS/AoS results

* feat(analysis): integrate LoS/AoS into the standard feature pipeline

LoS and AoS documents are now plain GeoJSON features flowing through
featureSource — one feature per document, like measure. This replaces
the parallel rendering paths (private layers, own store sync, multiple
OL features sharing one id) and brings the standard machinery for free:
delete, undo, hide/show, lock, vertex modify and selection.

- LoS: LineString observer→target; the async sight-line analysis lives
  in the style orchestrator (ol/style/los.js) — renders as pending line
  until the profile arrives, recomputes on geometry/height changes and
  once terrain becomes available (bridge: ol/style/losCompute.js)
- AoS: Point observer with radius/height properties; observer point and
  radius rim are pipeline styles (ol/style/aos.js), the visibility
  raster stays in the interaction and now mirrors hidden state
  (including temporary reveal while highlighted in search)
- sidebar/search: options/documents handlers for both scopes with name,
  distance/radius description, rename and tagging
- properties panels operate on GeoJSON properties
- pre-pipeline documents are migrated to GeoJSON on startup

* feat(analysis): adjustable heights and radius during placement

- LoS: arrow up/down adjusts observer height, shift+arrows target
  height while placing; live preview recomputes, values shown in OSD
- AoS: arrow up/down adjusts radius (250 m steps), shift/alt+arrows
  observer/target height; preview recomputes on change
- Escape cancels an active placement
- last-used values persist per project (session store) and become the
  defaults for the next placement; placed objects remain editable via
  the properties panel

* fix(elevation): handle TileJSON sources that are still loading

getTileGrid() returns null until a TileJSON source has fetched its
metadata. setSource treated "terrain layer present" as "terrain ready"
and the AoS initial load crashed on the null tile grid at startup.

- setSource returns false while the tile grid is not available yet
- new onTerrainReady(map, attempt) retries when a layer is added AND
  when a pending source finishes loading; LoS/AoS use it for computer
  registration and initial document rendering
- getGrid/profileAlongLine/elevationAt guard against a missing grid

* fix(analysis): settings hint no longer swallowed by async OSD clears

The emitter dispatches handlers via setImmediate, so the OSD clear from
idle tools' command/draw/cancel resets landed after the freshly shown
placement hint and erased it — the hint only reappeared after the first
arrow-key press.

- reset() clears the OSD only when the tool was actually active
- the hint is re-asserted on pointer move (LoS placing phase, AoS
  preview) so it survives any remaining dispatch-order race

* feat(sidebar): list LoS/AoS under the measurements scope

The measurements scope switch now covers '@measure @Los @aos' (scope
query tokens combine with OR). The active-state check handles
multi-token switches: active when all of its tokens are part of the
current search scope.

Author: ThomasHalwax

src/renderer/components/Toolbar.js

@@ -52,7 +52,9 @@ export const Toolbar = () => {
     commandRegistry.command('MEASURE_DISTANCE'),
     commandRegistry.command('MEASURE_AREA'),
     commandRegistry.command('MEASURE_CIRCLE'),
-    commandRegistry.command('ELEVATION_PROFILE')
+    commandRegistry.command('ELEVATION_PROFILE'),
+    commandRegistry.command('LINE_OF_SIGHT'),
+    commandRegistry.command('AREA_OF_SIGHT')
   ]
 
   const replicationCommands = [

src/renderer/components/map/Map.js

@@ -16,6 +16,8 @@ import registerGraticules from './graticules'
 import measure from '../../ol/interaction/measure'
 import shapeInteraction from '../../ol/interaction/shape-interaction'
 import elevationProfile from '../../ol/interaction/elevation-profile'
+import lineOfSight from '../../ol/interaction/line-of-sight'
+import areaOfSight from '../../ol/interaction/area-of-sight'
 import print from '../print'
 import './Map.css'
 import './ScaleLine.css'
@@ -83,6 +85,8 @@ export const Map = () => {
     measure({ services, map })
     shapeInteraction({ services, map })
     elevationProfile({ services, map })
+    lineOfSight({ services, map })
+    areaOfSight({ services, map })
 
     // Expose a function to query the current map resolution.
     services.getMapResolution = () => map.getView().getResolution()

src/renderer/components/map/eventHandlers.js

@@ -95,9 +95,9 @@ const mapHandlers = (services, map) => {
   map.once('rendercomplete', ({ target }) => sendPreview(services, target))
   map.on('pointermove', throttle(75, event => osdDriver.pointermove(event)))
 
-  // Deselect everything except features and markers.
+  // Deselect everything except features, markers and analysis results.
   map.on('click', () => {
-    const exclude = [ID.isFeatureId, ID.isMarkerId, ID.isMeasureId]
+    const exclude = [ID.isFeatureId, ID.isMarkerId, ID.isMeasureId, ID.isLosId, ID.isAosId]
     const deselect = selection.selected(x => !exclude.some(p => p(x)))
     if (deselect.length) selection.deselect(deselect)
   })

src/renderer/components/properties/AreaOfSightProperties.js

@@ -0,0 +1,51 @@
+/* eslint-disable react/prop-types */
+import React from 'react'
+import textProperty from './textProperty'
+import GridCols2 from './GridCols2'
+import ColSpan2 from './ColSpan2'
+import { DEFAULT_RADIUS_M, MAX_RADIUS_M } from '../../ol/interaction/area-of-sight'
+
+const formatNumber = value => (typeof value === 'number' ? String(value) : '')
+
+const setProperty = (key, valid) => value => feature => {
+  const num = parseFloat(value)
+  if (!valid(num)) return feature
+  return { ...feature, properties: { ...feature.properties, [key]: num } }
+}
+
+const Radius = textProperty({
+  label: `Radius [m] (max ${MAX_RADIUS_M})`,
+  get: feature => formatNumber(feature.properties?.radius ?? DEFAULT_RADIUS_M),
+  set: value => feature => {
+    const num = parseFloat(value)
+    if (!Number.isFinite(num) || num < 100) return feature
+    return {
+      ...feature,
+      properties: { ...feature.properties, radius: Math.min(num, MAX_RADIUS_M) }
+    }
+  }
+})
+
+const ObserverHeight = textProperty({
+  label: 'Observer height [m]',
+  get: feature => formatNumber(feature.properties?.observerHeight),
+  set: setProperty('observerHeight', num => Number.isFinite(num) && num >= 0)
+})
+
+const TargetHeight = textProperty({
+  label: 'Target height [m]',
+  get: feature => formatNumber(feature.properties?.targetHeight),
+  set: setProperty('targetHeight', num => Number.isFinite(num) && num >= 0)
+})
+
+const AreaOfSightProperties = (props) => (
+  <GridCols2>
+    <ObserverHeight {...props} />
+    <TargetHeight {...props} />
+    <ColSpan2>
+      <Radius {...props} />
+    </ColSpan2>
+  </GridCols2>
+)
+
+export default AreaOfSightProperties

src/renderer/components/properties/LineOfSightProperties.js

@@ -0,0 +1,58 @@
+/* eslint-disable react/prop-types */
+import React from 'react'
+import { getLength } from 'ol/sphere'
+import LineString from 'ol/geom/LineString'
+import textProperty from './textProperty'
+import GridCols2 from './GridCols2'
+import ColSpan2 from './ColSpan2'
+
+const formatHeight = h => (typeof h === 'number' ? h.toFixed(2) : '')
+
+const setHeight = key => value => feature => {
+  const num = parseFloat(value)
+  if (!Number.isFinite(num) || num < 0) return feature
+  return { ...feature, properties: { ...feature.properties, [key]: num } }
+}
+
+const ObserverHeight = textProperty({
+  label: 'Observer height [m]',
+  get: feature => formatHeight(feature.properties?.observerHeight),
+  set: setHeight('observerHeight')
+})
+
+const TargetHeight = textProperty({
+  label: 'Target height [m]',
+  get: feature => formatHeight(feature.properties?.targetHeight),
+  set: setHeight('targetHeight')
+})
+
+const distanceKm = (doc) => {
+  const coordinates = doc?.geometry?.type === 'LineString' && doc.geometry.coordinates
+  if (!coordinates || coordinates.length < 2) return null
+  return getLength(new LineString(coordinates)) / 1000
+}
+
+const LineOfSightProperties = (props) => {
+  const docs = Object.values(props.features)
+  const single = docs.length === 1
+  const km = single ? distanceKm(docs[0]) : null
+
+  return (
+    <GridCols2>
+      <ObserverHeight {...props} />
+      <TargetHeight {...props} />
+      {single && km !== null && (
+        <ColSpan2>
+          <div className='form-textfield'>
+            <span className='form-textfield__label'>Distance</span>
+            <span className='form-textfield__input' style={{ paddingTop: 8 }}>
+              {km.toFixed(2)} km
+            </span>
+          </div>
+        </ColSpan2>
+      )}
+    </GridCols2>
+  )
+}
+
+export default LineOfSightProperties

src/renderer/components/properties/Properties.js

@@ -20,6 +20,8 @@ import SKKMUnitProperties from './SKKMUnitProperties'
 import SKKMCommandProperties from './SKKMCommandProperties'
 import ShapeProperties from './ShapeProperties'
 import TextShapeProperties from './TextShapeProperties'
+import LineOfSightProperties from './LineOfSightProperties'
+import AreaOfSightProperties from './AreaOfSightProperties'
 import './Properties.css'
 
 const propertiesPanels = {
@@ -38,7 +40,9 @@ const propertiesPanels = {
   'sse-service': props => <SSEServiceProperties {...props}/>,
   'feature:SKKM/K': props => <SKKMStandardProperties {...props}/>,
   'feature:SKKM/KU': props => <SKKMUnitProperties {...props}/>,
-  'feature:SKKM/KC': props => <SKKMCommandProperties {...props}/>
+  'feature:SKKM/KC': props => <SKKMCommandProperties {...props}/>,
+  los: props => <LineOfSightProperties {...props}/>,
+  aos: props => <AreaOfSightProperties {...props}/>
 }
 
 const singletons = ['tile-service', 'tile-layers', 'sse-service']

src/renderer/components/sidebar/ScopeSwitcher.js

@@ -21,7 +21,7 @@ const SCOPES = {
   [`@${ID.PLACE}`]: 'mdiSearchWeb',
   [`@${ID.TILE_SERVICE}`]: 'mdiEarth',
   [`@${ID.SSE_SERVICE}`]: 'mdiAccessPointNetwork',
-  [`@${ID.MEASURE}`]: 'mdiAndroidStudio',
+  [`@${ID.MEASURE} @${ID.LOS} @${ID.AOS}`]: 'mdiAndroidStudio',
   [`@${ID.INVITED}`]: 'mdiCloudPlusOutline'
 }
 
@@ -36,7 +36,7 @@ const TOOLTIPS = {
   [`@${ID.PLACE}`]: 'Search for addresses based on OSM (online only)',
   [`@${ID.TILE_SERVICE}`]: 'Manage existing tile services for maps',
   [`@${ID.SSE_SERVICE}`]: 'Manage live data sources',
-  [`@${ID.MEASURE}`]: 'Manage existing measurements',
+  [`@${ID.MEASURE} @${ID.LOS} @${ID.AOS}`]: 'Manage existing measurements and sight analyses',
   [`@${ID.INVITED}`]: 'Show invitations and join shared layers'
 }
 
@@ -46,9 +46,12 @@ const TOOLTIPS = {
 const ScopeSwitch = props => {
   const [search, setSearch] = useMemento('ui.sidebar.search', defaultSearch)
 
+  // A switch may cover multiple scope tokens (e.g. '@measure @los @aos');
+  // it is active when all of its tokens are part of the current search.
+  const activeTokens = search.history[0].scope.split(' ')
   const enabled = search.history.length > 1
     ? false
-    : search.history[0].scope.split(' ').includes(props.scope)
+    : props.scope.split(' ').every(token => activeTokens.includes(token))
 
   const className = props.name
     ? 'a74a-named'

src/renderer/ids.js

@@ -29,6 +29,8 @@ export const DEFAULT = 'default'
 export const TAGS = 'tags'
 export const STICKY = 'sticky'
 export const MEASURE = 'measure'
+export const LOS = 'los'
+export const AOS = 'aos'
 export const SHARED = 'shared'
 export const INVITED = 'invited'
 
@@ -45,6 +47,8 @@ export const TILE_PRESET_SCOPE = TILE_PRESET + COLON
 export const TILE_LAYER_SCOPE = TILE_LAYER + COLON
 export const SSE_SERVICE_SCOPE = SSE_SERVICE + COLON
 export const MEASURE_SCOPE = MEASURE + COLON
+export const LOS_SCOPE = LOS + COLON
+export const AOS_SCOPE = AOS + COLON
 
 export const LINK_PREFIX = 'link' + PLUS
 export const STYLE_PREFIX = 'style' + PLUS
@@ -106,6 +110,8 @@ export const isHiddenId = isId(HIDDEN_PREFIX)
 export const isDefaultId = isId(DEFAULT_PREFIX)
 export const isTagsId = isId(TAGS_PREFIX)
 export const isMeasureId = isId(MEASURE_SCOPE)
+export const isLosId = isId(LOS_SCOPE)
+export const isAosId = isId(AOS_SCOPE)
 export const isSharedLayerId = isId(sharedId(LAYER_SCOPE))
 export const isInvitedId = isId(INVITED)
 export const isRoleId = isId(ROLE_PREFIX)
@@ -173,6 +179,8 @@ export const tileLayerId = (tileServiceId, layerId) =>
 export const markerId = () => makeId(MARKER, uuid())
 export const bookmarkId = () => makeId(BOOKMARK, uuid())
 export const measureId = () => makeId(MEASURE, uuid())
+export const losId = () => makeId(LOS, uuid())
+export const aosId = () => makeId(AOS, uuid())
 export const linkId = id => LINK + PLUS + id + SLASH + uuid()
 export const invitationId = () => makeId(INVITED, uuid())
 

src/renderer/model/CommandRegistry.js

@@ -7,6 +7,8 @@ import creationCommand from './commands/CreationCommands'
 import measureCommands from './commands/MeasureCommands'
 import shapeCommands from './commands/ShapeCommands'
 import elevationProfileCommands from './commands/ElevationProfileCommands'
+import lineOfSightCommands from './commands/LineOfSightCommands'
+import areaOfSightCommands from './commands/AreaOfSightCommands'
 import printCommands from './commands/PrintCommands'
 import replicationCommands from './commands/ReplicationCommands'
 
@@ -23,6 +25,8 @@ export function CommandRegistry (services) {
   Object.assign(this, measureCommands(services))
   Object.assign(this, shapeCommands(services))
   Object.assign(this, elevationProfileCommands(services))
+  Object.assign(this, lineOfSightCommands(services))
+  Object.assign(this, areaOfSightCommands(services))
   Object.assign(this, printCommands(services))
   Object.assign(this, replicationCommands(services))