From 912a2d0b15b873923698126ac8112d1aa4bdbb1a Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 10:08:22 +0100 Subject: wasm: experimental browser spike Proves the gipfel core can run in the browser via WASM. Enabled by the earlier GSL removal: the core is now pure Rust. gipfel-core gains byte-oriented entry points (no filesystem) alongside the existing path-based ones: - hill::load_from_bytes, Panorama::load_data_from_bytes - metadata: load_image_from_bytes, read_jpeg_comment_from_bytes, write_jpeg_comment_to_bytes, save_image_to_bytes (EXIF via Cursor) New crate gipfel-wasm (experimental, not shipped with the app): - wasm-bindgen surface: version() + fit_demo(db_bytes, jpg_bytes) which runs the whole pipeline in memory: parse hill DB, read gipfel JPEG comment / EXIF, synthesize 5 observations from visible hills, perturb, refit (pure-Rust LM), report JSON with reprojection error - demo/index.html: file pickers + result pane (wasm-pack --target web) - build.sh: adds the wasm target, builds with wasm-pack, prints serve cmd - native test runs the same pipeline against gipfel.dat + test.jpg and asserts sub-pixel reprojection error (passes here) To try on a machine with rustup: cd crates/gipfel-wasm && ./build.sh --- crates/gipfel-core/src/hill.rs | 22 +++--- crates/gipfel-core/src/metadata.rs | 43 +++++++++-- crates/gipfel-core/src/panorama.rs | 10 +++ crates/gipfel-wasm/Cargo.toml | 14 ++++ crates/gipfel-wasm/build.sh | 22 ++++++ crates/gipfel-wasm/demo/index.html | 39 ++++++++++ crates/gipfel-wasm/src/lib.rs | 147 +++++++++++++++++++++++++++++++++++++ 7 files changed, 278 insertions(+), 19 deletions(-) create mode 100644 crates/gipfel-wasm/Cargo.toml create mode 100755 crates/gipfel-wasm/build.sh create mode 100644 crates/gipfel-wasm/demo/index.html create mode 100644 crates/gipfel-wasm/src/lib.rs (limited to 'crates') diff --git a/crates/gipfel-core/src/hill.rs b/crates/gipfel-core/src/hill.rs index a904948..4ae0f89 100644 --- a/crates/gipfel-core/src/hill.rs +++ b/crates/gipfel-core/src/hill.rs @@ -2,9 +2,6 @@ //! //! Faithful port of gipfel's `Hill.cxx`. -use std::fs::File; -use std::io::{BufRead, BufReader}; - pub const FLAG_DUPLIC: u32 = 1 << 0; pub const FLAG_KNOWN: u32 = 1 << 1; pub const FLAG_HIDDEN: u32 = 1 << 2; @@ -77,16 +74,20 @@ fn atof(s: &str) -> f64 { 0.0 } -/// Load a hill database. Two line formats are accepted: +/// Load a hill database from a file path. +pub fn load(path: &str) -> std::io::Result> { + load_from_bytes(&std::fs::read(path)?) +} + +/// Load a hill database from raw bytes. Two line formats are accepted: /// - `SHORT,NAME,DESC,LAT,LON,HEIGHT` (6 fields) /// - `LAT,LON,HEIGHT` (3 fields, track point) -pub fn load(path: &str) -> std::io::Result> { - let file = File::open(path)?; +/// +/// Byte-oriented entry point (no filesystem): used by the WASM build and +/// by tests. The database is Latin-1; bytes decode to Unicode code points. +pub fn load_from_bytes(raw: &[u8]) -> std::io::Result> { let mut hills = Vec::new(); - - // the database is Latin-1; decode to Unicode code points - for line in BufReader::new(file).split(b'\n') { - let raw = line?; + for raw in raw.split(|b| *b == b'\n') { let line: String = raw.iter().map(|b| *b as char).collect(); // strsep() semantics: split into at most 10 fields, keeping empties let vals: Vec<&str> = line.split(',').take(10).collect(); @@ -109,7 +110,6 @@ pub fn load(path: &str) -> std::io::Result> { hills.push(h); } } - Ok(hills) } diff --git a/crates/gipfel-core/src/metadata.rs b/crates/gipfel-core/src/metadata.rs index e2a888f..f55bf1c 100644 --- a/crates/gipfel-core/src/metadata.rs +++ b/crates/gipfel-core/src/metadata.rs @@ -3,9 +3,6 @@ //! //! Faithful port of gipfel's `ImageMetaData.cxx`. -use std::fs::File; -use std::io::{BufReader, Write}; - use exif::{In, Tag, Value}; pub const NAN: f64 = f64::NAN; @@ -66,6 +63,16 @@ impl ImageMetaData { self.load_image_exif(path); } + /// Like [`ImageMetaData::load_image`] but from raw bytes (no filesystem); + /// used by the WASM build. + pub fn load_image_from_bytes(&mut self, bytes: &[u8]) { + *self = ImageMetaData::new(); + if let Some(com) = read_jpeg_comment_from_bytes(bytes) { + self.parse_gipfel_comment(&com); + } + self.load_image_exif_bytes(bytes); + } + /// Write the gipfel comment into a copy of `in_img`, saved as `out_img`. /// Writes atomically via a temp file, like the C original. pub fn save_image(&self, in_img: &str, out_img: &str) -> std::io::Result<()> { @@ -76,6 +83,12 @@ impl ImageMetaData { Ok(()) } + /// Like [`ImageMetaData::save_image`] but bytes in / bytes out (no + /// filesystem); used by the WASM build. + pub fn save_image_to_bytes(&self, in_bytes: &[u8]) -> std::io::Result> { + write_jpeg_comment_to_bytes(in_bytes, self.format_comment().as_bytes()) + } + pub fn format_comment(&self) -> String { format!( "gipfel: longitude {}, latitude {}, height {}, direction {}, nick {}, tilt {}, focal_length_35mm {}, projection type {}, k0 {}, k1 {}, x0 {}", @@ -149,8 +162,12 @@ impl ImageMetaData { } fn load_image_exif(&mut self, path: &str) { - let Ok(file) = File::open(path) else { return }; - let mut reader = BufReader::new(file); + let Ok(bytes) = std::fs::read(path) else { return }; + self.load_image_exif_bytes(&bytes); + } + + fn load_image_exif_bytes(&mut self, bytes: &[u8]) { + let mut reader = std::io::Cursor::new(bytes); let Ok(exif) = exif::Reader::new().read_from_container(&mut reader) else { return; }; @@ -366,6 +383,11 @@ fn marker_len_ok(marker: u8) -> bool { /// Return the payload of the first COM segment before SOS, if any. pub fn read_jpeg_comment(path: &str) -> Option> { let bytes = std::fs::read(path).ok()?; + read_jpeg_comment_from_bytes(&bytes) +} + +/// Byte-oriented twin of [`read_jpeg_comment`] (no filesystem; WASM-safe). +pub fn read_jpeg_comment_from_bytes(bytes: &[u8]) -> Option> { if bytes.len() < 2 || bytes[0] != 0xFF || bytes[1] != 0xD8 { return None; } @@ -406,6 +428,13 @@ pub fn read_jpeg_comment(path: &str) -> Option> { /// fresh COM segment right after SOI. pub fn write_jpeg_comment(in_img: &str, out_img: &str, comment: &[u8]) -> std::io::Result<()> { let bytes = std::fs::read(in_img)?; + let out = write_jpeg_comment_to_bytes(&bytes, comment)?; + std::fs::write(out_img, out) +} + +/// Byte-oriented twin of [`write_jpeg_comment`] (no filesystem; WASM-safe): +/// drop all COM segments and insert a fresh COM segment after the last APPn. +pub fn write_jpeg_comment_to_bytes(bytes: &[u8], comment: &[u8]) -> std::io::Result> { if bytes.len() < 2 || bytes[0] != 0xFF || bytes[1] != 0xD8 { return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, "not a JPEG file")); } @@ -469,9 +498,7 @@ pub fn write_jpeg_comment(in_img: &str, out_img: &str, comment: &[u8]) -> std::i out.extend_from_slice(&bytes[copy_rest_from..]); - let mut f = File::create(out_img)?; - f.write_all(&out)?; - f.flush() + Ok(out) } /// Read raw image dimensions (width, height) of a JPEG. diff --git a/crates/gipfel-core/src/panorama.rs b/crates/gipfel-core/src/panorama.rs index 9e27251..9216037 100644 --- a/crates/gipfel-core/src/panorama.rs +++ b/crates/gipfel-core/src/panorama.rs @@ -74,6 +74,16 @@ impl Panorama { Ok(()) } + /// Like [`Panorama::load_data`] but from raw bytes (no filesystem); + /// used by the WASM build. + pub fn load_data_from_bytes(&mut self, raw: &[u8]) -> std::io::Result<()> { + let mut hills = crate::hill::load_from_bytes(raw)?; + crate::hill::mark_duplicates(&mut hills, 0.00001); + self.hills = hills; + self.update_angles(); + Ok(()) + } + pub fn add_hills(&mut self, extra: &[Hill]) { self.hills.extend_from_slice(extra); crate::hill::mark_duplicates(&mut self.hills, 0.00001); diff --git a/crates/gipfel-wasm/Cargo.toml b/crates/gipfel-wasm/Cargo.toml new file mode 100644 index 0000000..34cbbbd --- /dev/null +++ b/crates/gipfel-wasm/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "gipfel-wasm" +version.workspace = true +edition.workspace = true +license.workspace = true +description = "EXPERIMENT: WebAssembly bindings for gipfel-core (browser spike, not part of the app)" + +[lib] +crate-type = ["cdylib", "rlib"] + +[dependencies] +gipfel-core = { path = "../gipfel-core" } +image.workspace = true +wasm-bindgen = "0.2" diff --git a/crates/gipfel-wasm/build.sh b/crates/gipfel-wasm/build.sh new file mode 100755 index 0000000..8d1d812 --- /dev/null +++ b/crates/gipfel-wasm/build.sh @@ -0,0 +1,22 @@ +#!/bin/sh +# Build the gipfel WASM spike and serve the demo page. +# Requires: rustup (for the wasm target) and wasm-pack. +set -e +cd "$(dirname "$0")" + +if ! rustup target list --installed 2>/dev/null | grep -q wasm32-unknown-unknown; then + echo "adding wasm32-unknown-unknown target ..." + rustup target add wasm32-unknown-unknown +fi +command -v wasm-pack >/dev/null 2>&1 || { + echo "wasm-pack not found. Install it once with:" + echo " cargo install wasm-pack (or: cargo binstall wasm-pack)" + exit 1 +} + +wasm-pack build --target web + +echo +echo "built. serve the demo with:" +echo " (cd crates/gipfel-wasm && python3 -m http.server 8080)" +echo "then open http://localhost:8080/demo/" diff --git a/crates/gipfel-wasm/demo/index.html b/crates/gipfel-wasm/demo/index.html new file mode 100644 index 0000000..f8e764d --- /dev/null +++ b/crates/gipfel-wasm/demo/index.html @@ -0,0 +1,39 @@ + + + + + gipfel WASM spike + + + +

gipfel WASM spike

+

core version: loading…

+

Pick a hill database and a JPEG (ideally one saved by gipfel, or with EXIF GPS data):

+ + + +
pick both files, then run
+ + + + diff --git a/crates/gipfel-wasm/src/lib.rs b/crates/gipfel-wasm/src/lib.rs new file mode 100644 index 0000000..b521829 --- /dev/null +++ b/crates/gipfel-wasm/src/lib.rs @@ -0,0 +1,147 @@ +//! EXPERIMENT: browser spike exposing the gipfel core pipeline to JavaScript. +//! +//! The whole computational core (hill DB, geodesy, projections, LM fit, +//! JPEG comment + EXIF I/O) is pure Rust and WASM-friendly — the GSL +//! removal made this possible. This crate proves the pipeline end-to-end +//! in the browser: bytes in (hill DB + JPEG), fit report out. +//! +//! Build (requires rustup): +//! rustup target add wasm32-unknown-unknown +//! cargo install wasm-pack # once +//! cd crates/gipfel-wasm && wasm-pack build --target web +//! python3 -m http.server 8080 # then open /demo/ + +use wasm_bindgen::prelude::*; + +/// Crate version (from Cargo.toml, via the workspace). +#[wasm_bindgen] +pub fn version() -> String { + env!("CARGO_PKG_VERSION").to_string() +} + +/// End-to-end pipeline smoke test, all in memory: +/// +/// 1. parse the hill database (`db` = gipfel.dat bytes, Latin-1 CSV) +/// 2. read gipfel metadata from the JPEG bytes (comment, else EXIF) +/// 3. build the panorama, take up to 5 visible hills as synthetic +/// "user-marked" observations, perturb the view parameters, refit +/// 4. return a JSON report (recovered parameters + max reprojection error) +/// +/// This mirrors the native golden fit test; a correct WASM build reports +/// a reprojection error well below one pixel. +#[wasm_bindgen] +pub fn fit_demo(db: &[u8], jpg: &[u8]) -> String { + match fit_inner(db, jpg) { + Ok(json) => json, + Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e.replace('\\', "\\\\").replace('"', "\\\"")), + } +} + +fn fit_inner(db: &[u8], jpg: &[u8]) -> Result { + use gipfel_core::metadata::{apply_image_metadata, ImageMetaData}; + use gipfel_core::panorama::Panorama; + use gipfel_core::projection::projection_from_type; + + let mut pan = Panorama::new(); + pan.load_data_from_bytes(db).map_err(|e| format!("hill db: {e}"))?; + + let mut md = ImageMetaData::new(); + md.load_image_from_bytes(jpg); + + let (w, h) = image::ImageReader::new(std::io::Cursor::new(jpg)) + .with_guessed_format() + .map_err(|e| format!("image: {e}"))? + .into_dimensions() + .map_err(|e| format!("image: {e}"))?; + if w == 0 || h == 0 { + return Err("image has zero dimensions".into()); + } + + let have = apply_image_metadata(&mut pan, &md, w, h); + if !have { + // demo fallback: a fixed Alpine viewpoint so the pipeline always runs + pan.set_view_lat(47.36); + pan.set_view_long(11.15); + pan.set_view_height(2100.0); + pan.set_center_angle(20.0); + pan.set_pitch_angle(0.0); + pan.set_roll_angle(1.0); + pan.set_scale(3000.0); + } + + let n = pan.visible.len().min(5); + if n < 2 { + return Err("fewer than 2 hills visible from this viewpoint".into()); + } + // snapshot the "observations" (what a user would have marked) + let obs: Vec<_> = pan.visible[..n].iter().map(|&i| pan.hills[i].clone()).collect(); + let known: Vec = (0..n).collect(); + + // perturb, then refit (distortion stays locked for the spike) + let center0 = pan.get_center_angle(); + let scale0 = pan.get_scale(); + pan.set_center_angle(center0 + 0.5); + pan.set_scale(scale0 * 0.95); + pan.comp_params_with(&obs, &known, false)?; + + // reprojection error of the recovered parameters against the snapshot + let proj = projection_from_type(pan.projection_type); + let mut max_err = 0.0f64; + for ob in &obs { + let (x, y) = proj.get_coordinates(ob.alph, ob.a_elev, &pan.parms); + max_err = max_err.max((x - ob.x).hypot(y - ob.y)); + } + + Ok(format!( + concat!( + "{{\"ok\":true,\"hills_in_db\":{},\"image\":\"{}x{}\",\"had_gipfel_info\":{},", + "\"observations\":{},\"viewpoint\":{{\"lat\":{:.5},\"lon\":{:.5},\"height_m\":{:.0}}},", + "\"perturbed\":{{\"center_deg\":{:.4},\"scale\":{:.1}}},", + "\"refitted\":{{\"center_deg\":{:.6},\"pitch_deg\":{:.6},\"roll_deg\":{:.6},\"scale\":{:.2}}},", + "\"max_reproj_err_px\":{:.4}}}" + ), + pan.hills.len(), + w, + h, + have, + n, + pan.get_view_lat(), + pan.get_view_long(), + pan.get_view_height(), + center0 + 0.5, + scale0 * 0.95, + pan.get_center_angle(), + pan.get_pitch_angle(), + pan.get_roll_angle(), + pan.get_scale(), + max_err, + )) +} + +#[cfg(test)] +mod tests { + use crate::fit_demo; + + /// The spike must also work natively (the wasm-bindgen attribute is a + /// no-op off-wasm), so CI here covers the whole byte-oriented pipeline. + /// Skips when the repo data files are not present (e.g. stripped checkouts). + #[test] + fn fit_demo_native_pipeline() { + let (Ok(db), Ok(jpg)) = ( + std::fs::read("../../gipfel.dat"), + std::fs::read("../../tests/golden/test.jpg"), + ) else { + eprintln!("gipfel.dat / test.jpg not found, skipping"); + return; + }; + let out = fit_demo(&db, &jpg); + assert!(out.contains(r#""ok":true"#), "fit_demo failed: {out}"); + // recovered parameters must reproduce the observations sub-pixel + let err = out + .split("max_reproj_err_px\":") + .nth(1) + .and_then(|s| s.trim_end_matches('}').parse::().ok()) + .expect("error value present"); + assert!(err < 0.01, "reprojection error too large: {out}"); + } +} -- cgit v1.2.3 From 459ecc314e082579d80d3b301e60360f32b63c5c Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 10:26:34 +0100 Subject: wasm: record verified spike result (sub-pixel refit in-browser, 50 ms) --- crates/gipfel-wasm/README.md | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 crates/gipfel-wasm/README.md (limited to 'crates') diff --git a/crates/gipfel-wasm/README.md b/crates/gipfel-wasm/README.md new file mode 100644 index 0000000..20d7dc7 --- /dev/null +++ b/crates/gipfel-wasm/README.md @@ -0,0 +1,36 @@ +# gipfel-wasm (EXPERIMENT) + +Browser spike proving the gipfel core runs as WebAssembly. Enabled by the +GSL removal — the core is pure Rust end to end. + +## Status: spike verified (2026-10-26) + +`fit_demo()` ran the full pipeline in a real browser on a 4080×3072 +gipfel-annotated photo (21324 hills, gipfel JPEG comment found): + +```json +{"ok":true,"hills_in_db":21324,"image":"4080x3072","had_gipfel_info":true, + "observations":5,"viewpoint":{"lat":47.65526,"lon":11.61856,"height_m":1319}, + "perturbed":{"center_deg":245.8905,"scale":2558.0}, + "refitted":{"center_deg":245.390505,"pitch_deg":-7.763227,"roll_deg":1.245000,"scale":2692.61}, + "max_reproj_err_px":0.0000} +``` + +Wall time 50 ms. The refit exactly undid the synthetic perturbation +(center to 5e-6 deg, scale to 7e-6 rel) — identical convergence to the +native golden tests. + +## Build & run (requires rustup) + +```sh +cd crates/gipfel-wasm +./build.sh # wasm-pack build --target web +python3 -m http.server 8080 # then open /demo/ +``` + +## What is proven / what is not +- Proven: hill DB parsing, JPEG comment + EXIF I/O, geodesy, projections, + Levenberg-Marquardt fit — all in wasm at native speed. +- Not built: the UI shell (libcosmic has no browser story). Next step if + pursued: Yew (or Leptos) + canvas 2D reusing the viewport/compass logic + and the pixel-based dump renderer. -- cgit v1.2.3 From 2ac8e530b8fb9ca4fa073e1e25a4230a83d99c5d Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 10:48:03 +0100 Subject: web: W1 scaffold — Yew app with image display, pan and zoom MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit First milestone of wasm-plan.md: - new crate gipfel-web: Yew 0.21 (csr), canvas 2D viewport - file input + drag-and-drop; browser-native decode via createImageBitmap (faster than image-crate decode in wasm, GPU-backed blitting) - pan (pointer drag with capture, touch-ready) and cursor-anchored wheel zoom, DPR-aware canvas sizing, fit-to-window - dark sidebar shell: open/fit buttons, status line - Trunk.toml + www/ (index.html, style.css); README with dev setup Verified: cargo check clean (native and wasm32-unknown-unknown), release wasm builds (5.3 MB pre-wasm-opt), all 38 native tests pass. Runtime behavior to be confirmed with trunk serve on a desktop browser. --- .gitignore | 1 + Cargo.lock | 645 ++++++++++++++++++++++++++++++++++- Cargo.toml | 2 +- crates/gipfel-web/Cargo.toml | 37 ++ crates/gipfel-web/README.md | 46 +++ crates/gipfel-web/Trunk.toml | 2 + crates/gipfel-web/src/app.rs | 193 +++++++++++ crates/gipfel-web/src/bridge.rs | 45 +++ crates/gipfel-web/src/canvas_view.rs | 148 ++++++++ crates/gipfel-web/src/main.rs | 7 + crates/gipfel-web/www/index.html | 11 + crates/gipfel-web/www/style.css | 77 +++++ 12 files changed, 1201 insertions(+), 13 deletions(-) create mode 100644 crates/gipfel-web/Cargo.toml create mode 100644 crates/gipfel-web/README.md create mode 100644 crates/gipfel-web/Trunk.toml create mode 100644 crates/gipfel-web/src/app.rs create mode 100644 crates/gipfel-web/src/bridge.rs create mode 100644 crates/gipfel-web/src/canvas_view.rs create mode 100644 crates/gipfel-web/src/main.rs create mode 100644 crates/gipfel-web/www/index.html create mode 100644 crates/gipfel-web/www/style.css (limited to 'crates') diff --git a/.gitignore b/.gitignore index 07849dd..fbccf5e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ /target tests/harness/build/ crates/gipfel-wasm/pkg/ +crates/gipfel-web/dist/ *.tmp gipfel-app-bin.tar.gz diff --git a/Cargo.lock b/Cargo.lock index 02fdc71..a01b90b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -172,6 +172,12 @@ dependencies = [ "libc", ] +[[package]] +name = "anymap2" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d301b3b94cb4b2f23d7917810addbbaff90738e0ca2be692bd027e70d7e0330c" + [[package]] name = "apply" version = "0.3.0" @@ -475,6 +481,15 @@ dependencies = [ "serde", ] +[[package]] +name = "bincode" +version = "1.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" +dependencies = [ + "serde", +] + [[package]] name = "bit-set" version = "0.8.0" @@ -551,6 +566,12 @@ dependencies = [ "piper", ] +[[package]] +name = "boolinator" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfa8873f51c92e232f9bac4065cddef41b714152812bfc5f7672ba16d6ef8cd9" + [[package]] name = "borsh" version = "1.8.1" @@ -791,6 +812,16 @@ version = "3.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "031ad3d167622974ed636505ae4556267ed4aa2aea0464122fa6bc9698a32825" +[[package]] +name = "console_error_panic_hook" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" +dependencies = [ + "cfg-if", + "wasm-bindgen", +] + [[package]] name = "const-oid" version = "0.10.2" @@ -1705,8 +1736,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" dependencies = [ "cfg-if", + "js-sys", "libc", "wasi", + "wasm-bindgen", ] [[package]] @@ -1782,6 +1815,18 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "gipfel-web" +version = "0.5.5" +dependencies = [ + "gipfel-core", + "js-sys", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "yew", +] + [[package]] name = "gl_generator" version = "0.14.0" @@ -1799,6 +1844,353 @@ version = "0.25.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "151665d9be52f9bb40fc7966565d39666f2d1e69233571b71b87791c7e0528b3" +[[package]] +name = "gloo" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28999cda5ef6916ffd33fb4a7b87e1de633c47c0dc6d97905fee1cdaa142b94d" +dependencies = [ + "gloo-console 0.2.3", + "gloo-dialogs 0.1.1", + "gloo-events 0.1.2", + "gloo-file 0.2.3", + "gloo-history 0.1.5", + "gloo-net 0.3.1", + "gloo-render 0.1.1", + "gloo-storage 0.2.2", + "gloo-timers 0.2.6", + "gloo-utils 0.1.7", + "gloo-worker 0.2.1", +] + +[[package]] +name = "gloo" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd35526c28cc55c1db77aed6296de58677dbab863b118483a27845631d870249" +dependencies = [ + "gloo-console 0.3.0", + "gloo-dialogs 0.2.0", + "gloo-events 0.2.0", + "gloo-file 0.3.0", + "gloo-history 0.2.2", + "gloo-net 0.4.0", + "gloo-render 0.2.0", + "gloo-storage 0.3.0", + "gloo-timers 0.3.0", + "gloo-utils 0.2.0", + "gloo-worker 0.4.0", +] + +[[package]] +name = "gloo-console" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82b7ce3c05debe147233596904981848862b068862e9ec3e34be446077190d3f" +dependencies = [ + "gloo-utils 0.1.7", + "js-sys", + "serde", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-console" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a17868f56b4a24f677b17c8cb69958385102fa879418052d60b50bc1727e261" +dependencies = [ + "gloo-utils 0.2.0", + "js-sys", + "serde", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-dialogs" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67062364ac72d27f08445a46cab428188e2e224ec9e37efdba48ae8c289002e6" +dependencies = [ + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-dialogs" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf4748e10122b01435750ff530095b1217cf6546173459448b83913ebe7815df" +dependencies = [ + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-events" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68b107f8abed8105e4182de63845afcc7b69c098b7852a813ea7462a320992fc" +dependencies = [ + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-events" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27c26fb45f7c385ba980f5fa87ac677e363949e065a083722697ef1b2cc91e41" +dependencies = [ + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-file" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8d5564e570a38b43d78bdc063374a0c3098c4f0d64005b12f9bbe87e869b6d7" +dependencies = [ + "gloo-events 0.1.2", + "js-sys", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-file" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97563d71863fb2824b2e974e754a81d19c4a7ec47b09ced8a0e6656b6d54bd1f" +dependencies = [ + "gloo-events 0.2.0", + "js-sys", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-history" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85725d90bf0ed47063b3930ef28e863658a7905989e9929a8708aab74a1d5e7f" +dependencies = [ + "gloo-events 0.1.2", + "gloo-utils 0.1.7", + "serde", + "serde-wasm-bindgen 0.5.0", + "serde_urlencoded", + "thiserror 1.0.69", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-history" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "903f432be5ba34427eac5e16048ef65604a82061fe93789f2212afc73d8617d6" +dependencies = [ + "getrandom 0.2.17", + "gloo-events 0.2.0", + "gloo-utils 0.2.0", + "serde", + "serde-wasm-bindgen 0.6.5", + "serde_urlencoded", + "thiserror 1.0.69", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-net" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a66b4e3c7d9ed8d315fd6b97c8b1f74a7c6ecbbc2320e65ae7ed38b7068cc620" +dependencies = [ + "futures-channel", + "futures-core", + "futures-sink", + "gloo-utils 0.1.7", + "http", + "js-sys", + "pin-project", + "serde", + "serde_json", + "thiserror 1.0.69", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "gloo-net" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ac9e8288ae2c632fa9f8657ac70bfe38a1530f345282d7ba66a1f70b72b7dc4" +dependencies = [ + "futures-channel", + "futures-core", + "futures-sink", + "gloo-utils 0.2.0", + "http", + "js-sys", + "pin-project", + "serde", + "serde_json", + "thiserror 1.0.69", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "gloo-render" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2fd9306aef67cfd4449823aadcd14e3958e0800aa2183955a309112a84ec7764" +dependencies = [ + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-render" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56008b6744713a8e8d98ac3dcb7d06543d5662358c9c805b4ce2167ad4649833" +dependencies = [ + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-storage" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d6ab60bf5dbfd6f0ed1f7843da31b41010515c745735c970e821945ca91e480" +dependencies = [ + "gloo-utils 0.1.7", + "js-sys", + "serde", + "serde_json", + "thiserror 1.0.69", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-storage" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbc8031e8c92758af912f9bc08fbbadd3c6f3cfcbf6b64cdf3d6a81f0139277a" +dependencies = [ + "gloo-utils 0.2.0", + "js-sys", + "serde", + "serde_json", + "thiserror 1.0.69", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-timers" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b995a66bb87bebce9a0f4a95aed01daca4872c050bfcb21653361c03bc35e5c" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "gloo-timers" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "gloo-utils" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037fcb07216cb3a30f7292bd0176b050b7b9a052ba830ef7d5d65f6dc64ba58e" +dependencies = [ + "js-sys", + "serde", + "serde_json", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-utils" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5555354113b18c547c1d3a98fbf7fb32a9ff4f6fa112ce823a21641a0ba3aa" +dependencies = [ + "js-sys", + "serde", + "serde_json", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gloo-worker" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13471584da78061a28306d1359dd0178d8d6fc1c7c80e5e35d27260346e0516a" +dependencies = [ + "anymap2", + "bincode", + "gloo-console 0.2.3", + "gloo-utils 0.1.7", + "js-sys", + "serde", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "gloo-worker" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76495d3dd87de51da268fa3a593da118ab43eb7f8809e17eb38d3319b424e400" +dependencies = [ + "bincode", + "futures", + "gloo-utils 0.2.0", + "gloo-worker-macros", + "js-sys", + "pinned", + "serde", + "thiserror 1.0.69", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "gloo-worker-macros" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "956caa58d4857bc9941749d55e4bd3000032d8212762586fa5705632967140e7" +dependencies = [ + "proc-macro-crate 1.3.1", + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "glow" version = "0.16.0" @@ -1958,6 +2350,17 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df" +[[package]] +name = "http" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" +dependencies = [ + "bytes", + "fnv", + "itoa", +] + [[package]] name = "hybrid-array" version = "0.4.15" @@ -2409,6 +2812,26 @@ version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "edcd27d72f2f071c64249075f42e205ff93c9a4c5f6c6da53e79ed9f9832c285" +[[package]] +name = "implicit-clone" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8a9aa791c7b5a71b636b7a68207fdebf171ddfc593d9c8506ec4cbc527b6a84" +dependencies = [ + "implicit-clone-derive", + "indexmap", +] + +[[package]] +name = "implicit-clone-derive" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "699c1b6d335e63d0ba5c1e1c7f647371ce989c3bcbe1f7ed2b85fa56e3bd1a21" +dependencies = [ + "quote", + "syn 2.0.119", +] + [[package]] name = "indexmap" version = "2.14.2" @@ -3098,6 +3521,16 @@ dependencies = [ "libm", ] +[[package]] +name = "num_cpus" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b" +dependencies = [ + "hermit-abi", + "libc", +] + [[package]] name = "num_enum" version = "0.7.6" @@ -3114,7 +3547,7 @@ version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8" dependencies = [ - "proc-macro-crate", + "proc-macro-crate 3.5.0", "proc-macro2", "quote", "syn 2.0.119", @@ -3567,6 +4000,17 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "13bee6c73da26345c729282832b60b0363cf3dd9f4bfd81d8551b7a1c889a113" +[[package]] +name = "pinned" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a829027bd95e54cfe13e3e258a1ae7b645960553fb82b75ff852c29688ee595b" +dependencies = [ + "futures", + "rustversion", + "thiserror 1.0.69", +] + [[package]] name = "piper" version = "0.2.5" @@ -3675,13 +4119,57 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa" +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn 2.0.119", +] + +[[package]] +name = "proc-macro-crate" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919" +dependencies = [ + "once_cell", + "toml_edit 0.19.15", +] + [[package]] name = "proc-macro-crate" version = "3.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" dependencies = [ - "toml_edit", + "toml_edit 0.25.17+spec-1.1.0", +] + +[[package]] +name = "proc-macro-error" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" +dependencies = [ + "proc-macro-error-attr", + "proc-macro2", + "quote", + "syn 1.0.109", + "version_check", +] + +[[package]] +name = "proc-macro-error-attr" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" +dependencies = [ + "proc-macro2", + "quote", + "version_check", ] [[package]] @@ -3734,6 +4222,23 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5" +[[package]] +name = "prokio" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03b55e106e5791fa5a13abd13c85d6127312e8e09098059ca2bc9b03ca4cf488" +dependencies = [ + "futures", + "gloo 0.8.1", + "num_cpus", + "once_cell", + "pin-project", + "pinned", + "tokio", + "tokio-stream", + "wasm-bindgen-futures", +] + [[package]] name = "pxfm" version = "0.1.30" @@ -4101,6 +4606,12 @@ dependencies = [ "unicode-script", ] +[[package]] +name = "ryu" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" + [[package]] name = "same-file" version = "1.0.6" @@ -4157,6 +4668,28 @@ dependencies = [ "serde_derive", ] +[[package]] +name = "serde-wasm-bindgen" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3b143e2833c57ab9ad3ea280d21fd34e285a42837aeb0ee301f4f41890fa00e" +dependencies = [ + "js-sys", + "serde", + "wasm-bindgen", +] + +[[package]] +name = "serde-wasm-bindgen" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b" +dependencies = [ + "js-sys", + "serde", + "wasm-bindgen", +] + [[package]] name = "serde_core" version = "1.0.229" @@ -4203,6 +4736,18 @@ dependencies = [ "syn 3.0.9", ] +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + [[package]] name = "sha2" version = "0.11.1" @@ -4459,6 +5004,16 @@ dependencies = [ "zeno", ] +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "unicode-ident", +] + [[package]] name = "syn" version = "2.0.119" @@ -4718,6 +5273,12 @@ dependencies = [ "serde", ] +[[package]] +name = "toml_datetime" +version = "0.6.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" + [[package]] name = "toml_datetime" version = "1.1.2+spec-1.1.0" @@ -4727,6 +5288,17 @@ dependencies = [ "serde_core", ] +[[package]] +name = "toml_edit" +version = "0.19.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421" +dependencies = [ + "indexmap", + "toml_datetime 0.6.11", + "winnow 0.5.40", +] + [[package]] name = "toml_edit" version = "0.25.17+spec-1.1.0" @@ -4734,9 +5306,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3641d5bbb5349a79e1020a242d251efbc546ad8048d133958323ce9c40a9c9c" dependencies = [ "indexmap", - "toml_datetime", + "toml_datetime 1.1.2+spec-1.1.0", "toml_parser", - "winnow", + "winnow 1.0.4", ] [[package]] @@ -4745,7 +5317,7 @@ version = "1.1.5+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baa693a8032d7e1cada7d0041e96126df243179ff061456783ac7f12bda4744c" dependencies = [ - "winnow", + "winnow 1.0.4", ] [[package]] @@ -6081,6 +6653,15 @@ dependencies = [ "xkbcommon-dl", ] +[[package]] +name = "winnow" +version = "0.5.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876" +dependencies = [ + "memchr", +] + [[package]] name = "winnow" version = "1.0.4" @@ -6190,6 +6771,46 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e01738255b5a16e78bbb83e7fbba0a1e7dd506905cfc53f4622d89015a03fbb5" +[[package]] +name = "yew" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f1a03f255c70c7aa3e9c62e15292f142ede0564123543c1cc0c7a4f31660cac" +dependencies = [ + "console_error_panic_hook", + "futures", + "gloo 0.10.0", + "implicit-clone", + "indexmap", + "js-sys", + "prokio", + "rustversion", + "serde", + "slab", + "thiserror 1.0.69", + "tokio", + "tracing", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "yew-macro", +] + +[[package]] +name = "yew-macro" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02fd8ca5166d69e59f796500a2ce432ff751edecbbb308ca59fd3fe4d0343de2" +dependencies = [ + "boolinator", + "once_cell", + "prettyplease", + "proc-macro-error", + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "yoke" version = "0.8.4" @@ -6243,7 +6864,7 @@ dependencies = [ "uds_windows", "uuid", "windows-sys 0.61.2", - "winnow", + "winnow 1.0.4", "zbus_macros", "zbus_names", "zvariant", @@ -6279,7 +6900,7 @@ version = "5.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40" dependencies = [ - "proc-macro-crate", + "proc-macro-crate 3.5.0", "proc-macro2", "quote", "syn 3.0.9", @@ -6295,7 +6916,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "812a12be4ead7a59e18ea8f047d08add0066b73bc62fc1467066a2472ae088dd" dependencies = [ "serde", - "winnow", + "winnow 1.0.4", "zvariant", ] @@ -6306,7 +6927,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d1586c021a01ca0a9216dcd874e546382e156a5cbab5fab6cb5f10087e22682a" dependencies = [ "serde", - "winnow", + "winnow 1.0.4", "zbus_names", "zvariant", ] @@ -6453,7 +7074,7 @@ dependencies = [ "enumflags2", "serde", "url", - "winnow", + "winnow 1.0.4", "zcheapstr", "zvariant_derive", "zvariant_utils", @@ -6465,7 +7086,7 @@ version = "5.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ef2672456ba1cb54b5eaec136e63135b3c7495fb938e53b28a62e633496d486d" dependencies = [ - "proc-macro-crate", + "proc-macro-crate 3.5.0", "proc-macro2", "quote", "syn 3.0.9", @@ -6482,5 +7103,5 @@ dependencies = [ "quote", "serde", "syn 3.0.9", - "winnow", + "winnow 1.0.4", ] diff --git a/Cargo.toml b/Cargo.toml index 60a554a..5de748e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [workspace] resolver = "2" -members = ["crates/gipfel-core", "crates/gipfel-cli", "crates/gipfel-app", "crates/gipfel-wasm"] +members = ["crates/gipfel-core", "crates/gipfel-cli", "crates/gipfel-app", "crates/gipfel-wasm", "crates/gipfel-web"] # Single source of truth for metadata inherited by every crate via # `version.workspace = true` etc. Bump `version` here on release; the diff --git a/crates/gipfel-web/Cargo.toml b/crates/gipfel-web/Cargo.toml new file mode 100644 index 0000000..b53fdaa --- /dev/null +++ b/crates/gipfel-web/Cargo.toml @@ -0,0 +1,37 @@ +[package] +name = "gipfel-web" +version.workspace = true +edition.workspace = true +license.workspace = true +description = "gipfel web — browser front end (WASM)" + +[dependencies] +gipfel-core = { path = "../gipfel-core" } +js-sys = "0.3" +wasm-bindgen = "0.2" +wasm-bindgen-futures = "0.4" +yew = { version = "0.21", features = ["csr"] } + +[dependencies.web-sys] +version = "0.3" +features = [ + "Blob", + "CanvasRenderingContext2d", + "DataTransfer", + "Document", + "DomRect", + "DragEvent", + "Element", + "Event", + "EventTarget", + "File", + "FileList", + "HtmlCanvasElement", + "HtmlElement", + "HtmlInputElement", + "ImageBitmap", + "MouseEvent", + "PointerEvent", + "Window", + "WheelEvent", +] diff --git a/crates/gipfel-web/README.md b/crates/gipfel-web/README.md new file mode 100644 index 0000000..2442e67 --- /dev/null +++ b/crates/gipfel-web/README.md @@ -0,0 +1,46 @@ +# gipfel-web + +Browser front end for gipfel (WASM, Yew + canvas 2D). See +[`/wasm-plan.md`](../../wasm-plan.md) for the overall plan and milestones. + +**Status: W1 (scaffold + image display) done** — open/drag-drop a JPEG, +pan (drag) and zoom (wheel, cursor-anchored). Peak identification, +fitting and saving arrive in W2/W3. + +## Development + +Prerequisites: [rustup](https://rustup.rs) and trunk: + +```sh +cargo install --locked trunk +``` + +Serve with hot reload: + +```sh +cd crates/gipfel-web +trunk serve --port 8090 # then open http://localhost:8090 +``` + +Release build (static output in `dist/`, serveable by any web server): + +```sh +trunk build --release +``` + +## Layout + +| File | Purpose | +|---|---| +| `src/main.rs` | entry point | +| `src/app.rs` | root component: sidebar, file loading, state | +| `src/canvas_view.rs` | viewport canvas: bitmap blit, pan/zoom | +| `src/bridge.rs` | JS glue: image decode, blob read, canvas ctx | +| `www/` | index.html, style.css (trunk assets) | + +## Notes + +- The base image is decoded by the browser (`createImageBitmap`), not + by the `image` crate — faster decode and GPU-backed blitting. +- The crate compiles natively (`cargo check -p gipfel-web`) so it can + be checked in CI without a wasm toolchain; runtime is wasm-only. diff --git a/crates/gipfel-web/Trunk.toml b/crates/gipfel-web/Trunk.toml new file mode 100644 index 0000000..1772684 --- /dev/null +++ b/crates/gipfel-web/Trunk.toml @@ -0,0 +1,2 @@ +[build] +target = "www/index.html" diff --git a/crates/gipfel-web/src/app.rs b/crates/gipfel-web/src/app.rs new file mode 100644 index 0000000..9e8c543 --- /dev/null +++ b/crates/gipfel-web/src/app.rs @@ -0,0 +1,193 @@ +//! Root component: sidebar (open/fit/status) + viewport canvas. +//! File loading: `` and drag-and-drop, decoded by the +//! browser into an ImageBitmap (see `bridge`). + +use std::rc::Rc; +use wasm_bindgen::closure::Closure; +use wasm_bindgen::JsCast; +use wasm_bindgen_futures::spawn_local; +use web_sys::{DragEvent, Event, HtmlCanvasElement, HtmlInputElement, MouseEvent}; +use yew::prelude::*; + +use crate::bridge; +use crate::canvas_view::{CanvasView, ViewCallbacks, ViewState}; + +#[function_component(App)] +pub fn app() -> Html { + let bitmap = use_state(|| None::); + let view = use_state(ViewState::default); + let status = use_state(|| "No image loaded.".to_string()); + let tick = use_state(|| 0u32); + let canvas_ref = use_node_ref(); + let file_ref = use_node_ref(); + + // force a redraw when the window is resized so the canvas backing + // store tracks its CSS size (listener lives as long as the app) + { + let tick = tick.clone(); + use_effect_with((), move |_| { + let closure = Closure::wrap(Box::new(move || tick.set(*tick + 1)) as Box); + let _ = bridge::window() + .add_event_listener_with_callback("resize", closure.as_ref().unchecked_ref()); + // the listener is never removed (app lifetime); leak the closure + std::mem::forget(closure); + }); + } + + // Fit the current bitmap into the canvas, centered. + let fit = { + let bitmap = bitmap.clone(); + let view = view.clone(); + let canvas_ref = canvas_ref.clone(); + Callback::from(move |_: MouseEvent| { + let Some(bmp) = bitmap.as_ref() else { return }; + let (cw, ch) = canvas_ref + .cast::() + .map(|c| (c.client_width() as f64, c.client_height() as f64)) + .unwrap_or((800.0, 600.0)); + let (iw, ih) = (bmp.width() as f64, bmp.height() as f64); + if iw <= 0.0 || ih <= 0.0 || cw <= 0.0 || ch <= 0.0 { + return; + } + let scale = (cw / iw).min(ch / ih); + view.set(ViewState { + scale, + ox: (cw - iw * scale) / 2.0, + oy: (ch - ih * scale) / 2.0, + }); + }) + }; + + // Decode dropped/selected bytes and display them, fitting to view. + let load_bytes = { + let bitmap = bitmap.clone(); + let status = status.clone(); + let fit = fit.clone(); + Callback::from(move |(bytes, name): (Vec, String)| { + let (bitmap, status, fit) = (bitmap.clone(), status.clone(), fit.clone()); + spawn_local(async move { + match bridge::decode_bitmap(&bytes).await { + Ok(bmp) => { + status.set(format!( + "{name} — {}×{} px", + bmp.width(), + bmp.height() + )); + bitmap.set(Some(bmp)); + fit.emit(MouseEvent::new("fit").unwrap()); + } + Err(e) => status.set(format!("Failed to load {name}: {e}")), + } + }); + }) + }; + + let read_file = { + let load_bytes = load_bytes.clone(); + let status = status.clone(); + Rc::new(move |file: web_sys::File| { + let (load_bytes, status) = (load_bytes.clone(), status.clone()); + let name = file.name(); + spawn_local(async move { + match bridge::read_blob(&file).await { + Ok(bytes) => load_bytes.emit((bytes, name)), + Err(e) => status.set(format!("Failed to read {name}: {e}")), + } + }); + }) + }; + + let on_file_change = { + let read_file = read_file.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + if let Some(file) = input.files().and_then(|fl| fl.item(0)) { + read_file(file); + } + }) + }; + + let on_drop = { + let read_file = read_file.clone(); + let status = status.clone(); + Callback::from(move |e: DragEvent| { + e.prevent_default(); + match e.data_transfer().and_then(|dt| dt.files()).and_then(|fl| fl.item(0)) { + Some(file) => read_file(file), + None => status.set("Dropped item was not a file.".to_string()), + } + }) + }; + let on_dragover = Callback::from(|e: DragEvent| e.prevent_default()); + + let open_picker = { + let file_ref = file_ref.clone(); + Callback::from(move |_: MouseEvent| { + if let Some(input) = file_ref.cast::() { + input.click(); + } + }) + }; + + let callbacks = ViewCallbacks { + pan: { + let view = view.clone(); + Callback::from(move |(dx, dy): (f64, f64)| { + let mut v = (*view).clone(); + v.ox += dx; + v.oy += dy; + view.set(v); + }) + }, + zoom: { + let view = view.clone(); + Callback::from(move |(cx, cy, factor): (f64, f64, f64)| { + let v = &*view; + let ns = (v.scale * factor).clamp(0.02, 64.0); + let k = ns / v.scale; + view.set(ViewState { + scale: ns, + ox: cx - (cx - v.ox) * k, + oy: cy - (cy - v.oy) * k, + }); + }) + }, + }; + + let zoom_pct = (view.scale * 100.0).round(); + + html! { +
+ +
+ +
+
+ } +} diff --git a/crates/gipfel-web/src/bridge.rs b/crates/gipfel-web/src/bridge.rs new file mode 100644 index 0000000..1353279 --- /dev/null +++ b/crates/gipfel-web/src/bridge.rs @@ -0,0 +1,45 @@ +//! Small JS helpers: window access, browser-native image decode, blob +//! reads, canvas context — the hand-written JS boundary of the app. + +use js_sys::Uint8Array; +use wasm_bindgen::JsCast; +use wasm_bindgen_futures::JsFuture; +use web_sys::{Blob, CanvasRenderingContext2d, HtmlCanvasElement, ImageBitmap, Window}; + +pub fn window() -> Window { + web_sys::window().expect("no global window") +} + +/// Decode image bytes into a browser-native (GPU-backed) bitmap. +/// The browser does the JPEG decode and keeps the pixels where canvas +/// blitting is fast — cheaper than any pure-Rust path in wasm. +pub async fn decode_bitmap(bytes: &[u8]) -> Result { + let array = js_sys::Array::new(); + array.push(&Uint8Array::from(bytes).buffer()); + let blob = Blob::new_with_u8_array_sequence(&array).map_err(|_| "blob failed".to_string())?; + let promise = window() + .create_image_bitmap_with_blob(&blob) + .map_err(|_| "createImageBitmap failed".to_string())?; + let value = JsFuture::from(promise) + .await + .map_err(|e| format!("decode failed: {e:?}"))?; + value + .dyn_into::() + .map_err(|_| "decode produced non-bitmap".to_string()) +} + +/// Read a File/Blob fully into memory. +pub async fn read_blob(blob: &Blob) -> Result, String> { + let buf = JsFuture::from(blob.array_buffer()) + .await + .map_err(|e| format!("read failed: {e:?}"))?; + Ok(Uint8Array::new(&buf).to_vec()) +} + +pub fn ctx2d(canvas: &HtmlCanvasElement) -> Option { + canvas + .get_context("2d") + .ok() + .flatten() + .and_then(|c| c.dyn_into::().ok()) +} diff --git a/crates/gipfel-web/src/canvas_view.rs b/crates/gipfel-web/src/canvas_view.rs new file mode 100644 index 0000000..87b89d9 --- /dev/null +++ b/crates/gipfel-web/src/canvas_view.rs @@ -0,0 +1,148 @@ +//! Viewport canvas: browser-native bitmap blitted with a pan/zoom +//! transform. Overlay drawing (markers, labels, compass) is added in W3. + +use web_sys::{HtmlCanvasElement, ImageBitmap, PointerEvent, WheelEvent};use yew::prelude::*; + +use crate::bridge; + +/// Image -> screen transform: `screen = img * scale + (ox, oy)`. +/// Same convention as the desktop viewport widget. +#[derive(Clone, Debug, PartialEq, Default)] +pub struct ViewState { + pub scale: f64, + pub ox: f64, + pub oy: f64, +} + +#[derive(Clone, PartialEq)] +pub struct ViewCallbacks { + pub pan: Callback<(f64, f64)>, + /// (cursor x, cursor y, factor) — zoom anchored at the cursor. + pub zoom: Callback<(f64, f64, f64)>, +} + +#[derive(Properties, PartialEq)] +pub struct Props { + pub bitmap: Option, + pub view: ViewState, + pub callbacks: ViewCallbacks, + pub canvas_ref: NodeRef, + /// bumped on window resize to force a redraw + pub tick: u32, +} + +#[function_component(CanvasView)] +pub fn canvas_view(props: &Props) -> Html { + let dragging = use_mut_ref(|| false); + let last = use_mut_ref(|| (0.0f64, 0.0f64)); + + // redraw on every view/bitmap change and on resize ticks + { + let bitmap = props.bitmap.clone(); + let view = props.view.clone(); + let canvas_ref = props.canvas_ref.clone(); + use_effect_with((bitmap, view, props.tick), move |(bitmap, view, _tick)| { + let Some(canvas) = canvas_ref.cast::() else { + return; + }; + let Some(ctx) = bridge::ctx2d(&canvas) else { + return; + }; + let dpr = bridge::window().device_pixel_ratio(); + let cw = canvas.client_width() as f64; + let ch = canvas.client_height() as f64; + // keep the backing store in sync with the CSS size + let bw = (cw * dpr).max(1.0) as u32; + let bh = (ch * dpr).max(1.0) as u32; + if canvas.width() != bw || canvas.height() != bh { + canvas.set_width(bw); + canvas.set_height(bh); + } + let _ = ctx.set_transform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0); + // web-sys 0.3: set_fill_style takes a JsValue (deprecated alias) + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("#101014")); + ctx.fill_rect(0.0, 0.0, canvas.width() as f64, canvas.height() as f64); + if let Some(bitmap) = bitmap { + let _ = ctx.set_transform( + dpr * view.scale, + 0.0, + 0.0, + dpr * view.scale, + dpr * view.ox, + dpr * view.oy, + ); + let _ = ctx.draw_image_with_image_bitmap(bitmap, 0.0, 0.0); + } + }); + } + + let on_pointerdown = { + let dragging = dragging.clone(); + let last = last.clone(); + let canvas_ref = props.canvas_ref.clone(); + Callback::from(move |e: PointerEvent| { + e.prevent_default(); + if let Some(c) = canvas_ref.cast::() { + let _ = c.set_pointer_capture(e.pointer_id()); + } + *dragging.borrow_mut() = true; + *last.borrow_mut() = (e.client_x() as f64, e.client_y() as f64); + }) + }; + let on_pointermove = { + let dragging = dragging.clone(); + let last = last.clone(); + let pan = props.callbacks.pan.clone(); + Callback::from(move |e: PointerEvent| { + if !*dragging.borrow() { + return; + } + let cur = (e.client_x() as f64, e.client_y() as f64); + let prev = *last.borrow(); + *last.borrow_mut() = cur; + pan.emit((cur.0 - prev.0, cur.1 - prev.1)); + }) + }; + let on_pointerup = { + let dragging = dragging.clone(); + let canvas_ref = props.canvas_ref.clone(); + Callback::from(move |e: PointerEvent| { + *dragging.borrow_mut() = false; + if let Some(c) = canvas_ref.cast::() { + let _ = c.release_pointer_capture(e.pointer_id()); + } + }) + }; + let on_wheel = { + let zoom = props.callbacks.zoom.clone(); + let canvas_ref = props.canvas_ref.clone(); + Callback::from(move |e: WheelEvent| { + e.prevent_default(); + let cx = e.client_x() as f64 + - canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect().left()) + .unwrap_or(0.0); + let cy = e.client_y() as f64 + - canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect().top()) + .unwrap_or(0.0); + let factor = 1.0015f64.powf(-(e.delta_y() as f64)); + zoom.emit((cx, cy, factor)); + }) + }; + + html! { + + } +} diff --git a/crates/gipfel-web/src/main.rs b/crates/gipfel-web/src/main.rs new file mode 100644 index 0000000..6a3e4d4 --- /dev/null +++ b/crates/gipfel-web/src/main.rs @@ -0,0 +1,7 @@ +mod app; +mod bridge; +mod canvas_view; + +fn main() { + yew::Renderer::::new().render(); +} diff --git a/crates/gipfel-web/www/index.html b/crates/gipfel-web/www/index.html new file mode 100644 index 0000000..c601fee --- /dev/null +++ b/crates/gipfel-web/www/index.html @@ -0,0 +1,11 @@ + + + + + + gipfel web + + + + + diff --git a/crates/gipfel-web/www/style.css b/crates/gipfel-web/www/style.css new file mode 100644 index 0000000..5ea080d --- /dev/null +++ b/crates/gipfel-web/www/style.css @@ -0,0 +1,77 @@ +* { + box-sizing: border-box; +} +html, +body { + margin: 0; + height: 100%; + font-family: system-ui, sans-serif; +} +.app { + display: flex; + height: 100vh; + background: #101014; + color: #e8e8ea; +} +.sidebar { + width: 300px; + padding: 16px; + background: #1a1a20; + border-right: 1px solid #2c2c34; + display: flex; + flex-direction: column; + gap: 8px; + overflow-y: auto; +} +.sidebar h1 { + margin: 0; + font-size: 22px; +} +.tag { + margin: 0 0 12px; + color: #8a8a94; + font-size: 12px; + text-transform: uppercase; + letter-spacing: 1px; +} +.sidebar button { + padding: 8px 12px; + background: #3b6fd4; + color: #fff; + border: 0; + border-radius: 6px; + font-size: 14px; + cursor: pointer; +} +.sidebar button:hover { + background: #4a7ee4; +} +.status { + font-size: 13px; + color: #c8c8d0; + word-break: break-word; +} +.hint { + font-size: 12px; + color: #8a8a94; +} +.dim { + opacity: 0.6; +} +.hidden-file { + display: none; +} +.main { + flex: 1; + position: relative; + min-width: 0; +} +canvas.viewport { + position: absolute; + inset: 0; + width: 100%; + height: 100%; + display: block; + touch-action: none; + cursor: grab; +} -- cgit v1.2.3 From 574655e57a3790c08659adc87d3a9c5a45da4f0d Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 11:19:04 +0100 Subject: web: canonical trunk layout (index.html at crate root) trunk resolves the crate manifest next to the entry HTML; with the entry in www/ it looked for www/Cargo.toml and failed. Move the entry to the crate root (standard trunk layout), keep style.css in www/. --- crates/gipfel-web/README.md | 3 ++- crates/gipfel-web/Trunk.toml | 2 -- crates/gipfel-web/index.html | 11 +++++++++++ crates/gipfel-web/www/index.html | 11 ----------- 4 files changed, 13 insertions(+), 14 deletions(-) delete mode 100644 crates/gipfel-web/Trunk.toml create mode 100644 crates/gipfel-web/index.html delete mode 100644 crates/gipfel-web/www/index.html (limited to 'crates') diff --git a/crates/gipfel-web/README.md b/crates/gipfel-web/README.md index 2442e67..74e93c5 100644 --- a/crates/gipfel-web/README.md +++ b/crates/gipfel-web/README.md @@ -36,7 +36,8 @@ trunk build --release | `src/app.rs` | root component: sidebar, file loading, state | | `src/canvas_view.rs` | viewport canvas: bitmap blit, pan/zoom | | `src/bridge.rs` | JS glue: image decode, blob read, canvas ctx | -| `www/` | index.html, style.css (trunk assets) | +| `index.html` | trunk entry point (canonical trunk layout) | +| `www/style.css` | stylesheet (trunk asset) | ## Notes diff --git a/crates/gipfel-web/Trunk.toml b/crates/gipfel-web/Trunk.toml deleted file mode 100644 index 1772684..0000000 --- a/crates/gipfel-web/Trunk.toml +++ /dev/null @@ -1,2 +0,0 @@ -[build] -target = "www/index.html" diff --git a/crates/gipfel-web/index.html b/crates/gipfel-web/index.html new file mode 100644 index 0000000..32ec87f --- /dev/null +++ b/crates/gipfel-web/index.html @@ -0,0 +1,11 @@ + + + + + + gipfel web + + + + + diff --git a/crates/gipfel-web/www/index.html b/crates/gipfel-web/www/index.html deleted file mode 100644 index c601fee..0000000 --- a/crates/gipfel-web/www/index.html +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - gipfel web - - - - - -- cgit v1.2.3 From 21487476293a77518e81c91ecdc0fbd4c4b74a25 Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 11:37:41 +0100 Subject: web: W2 — hill DB, metadata-driven viewpoint, markers and auto-fit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - fetch gipfel.dat.gz at startup, gunzip (flate2, pure Rust) and load into a Panorama held in app state - image loads now also parse the gipfel JPEG comment / EXIF and set the viewpoint via apply_image_metadata (same path as desktop) - markers: click a visible-peak guide dot to mark it, drag to adjust, right-click to remove; refit (comp_params_with, distortion locked by default) after every change once >= 4 markers - sidebar: fit-distortion toggle, marker/zoom readout, fitted az/pitch/roll/scale line - canvas: guide dots for visible peaks, red crosses + shadowed labels - serve-here.sh: dev helper (cargo build --target wasm32 + wasm-bindgen + gzip the DB into the static dist dir) Verified: cargo check clean for wasm32; runtime to be confirmed in browser against a gipfel-saved photo (W2 acceptance: fit must match the desktop result on the same image). --- Cargo.lock | 1 + crates/gipfel-web/Cargo.toml | 3 + crates/gipfel-web/serve-here.sh | 12 ++ crates/gipfel-web/src/app.rs | 219 +++++++++++++++++++++++++--- crates/gipfel-web/src/bridge.rs | 17 +++ crates/gipfel-web/src/canvas_view.rs | 269 +++++++++++++++++++++++++++++------ crates/gipfel-web/src/main.rs | 1 + crates/gipfel-web/src/markers.rs | 48 +++++++ crates/gipfel-web/www/style.css | 12 ++ 9 files changed, 521 insertions(+), 61 deletions(-) create mode 100755 crates/gipfel-web/serve-here.sh create mode 100644 crates/gipfel-web/src/markers.rs (limited to 'crates') diff --git a/Cargo.lock b/Cargo.lock index a01b90b..829f24f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1819,6 +1819,7 @@ dependencies = [ name = "gipfel-web" version = "0.5.5" dependencies = [ + "flate2", "gipfel-core", "js-sys", "wasm-bindgen", diff --git a/crates/gipfel-web/Cargo.toml b/crates/gipfel-web/Cargo.toml index b53fdaa..4d846c1 100644 --- a/crates/gipfel-web/Cargo.toml +++ b/crates/gipfel-web/Cargo.toml @@ -7,6 +7,7 @@ description = "gipfel web — browser front end (WASM)" [dependencies] gipfel-core = { path = "../gipfel-core" } +flate2 = "1" js-sys = "0.3" wasm-bindgen = "0.2" wasm-bindgen-futures = "0.4" @@ -32,6 +33,8 @@ features = [ "ImageBitmap", "MouseEvent", "PointerEvent", + "Request", + "Response", "Window", "WheelEvent", ] diff --git a/crates/gipfel-web/serve-here.sh b/crates/gipfel-web/serve-here.sh new file mode 100755 index 0000000..54038a6 --- /dev/null +++ b/crates/gipfel-web/serve-here.sh @@ -0,0 +1,12 @@ +#!/bin/sh +# Build gipfel-web for wasm and refresh the static dist dir served from +# /tmp/gipfel-web-dist (python http.server on :8090). Dev-only helper. +set -e +cd "$(dirname "$0")/../.." +cargo build -p gipfel-web --target wasm32-unknown-unknown --release +DIST=/tmp/gipfel-web-dist +mkdir -p "$DIST" +wasm-bindgen --target web --out-dir "$DIST" target/wasm32-unknown-unknown/release/gipfel-web.wasm +cp crates/gipfel-web/www/style.css "$DIST/" +gzip -9 -n -c gipfel.dat > "$DIST/gipfel.dat.gz" +echo "dist refreshed: $(ls -la "$DIST" | awk '{s+=$5} END {print s" bytes"}')" diff --git a/crates/gipfel-web/src/app.rs b/crates/gipfel-web/src/app.rs index 9e8c543..8512d6a 100644 --- a/crates/gipfel-web/src/app.rs +++ b/crates/gipfel-web/src/app.rs @@ -1,8 +1,12 @@ -//! Root component: sidebar (open/fit/status) + viewport canvas. -//! File loading: `` and drag-and-drop, decoded by the -//! browser into an ImageBitmap (see `bridge`). +//! Root component: sidebar (open/fit/status/fit-toggle) + viewport canvas. +//! Owns the `Panorama` and the marker list; refits on every marker change. +use std::io::Read; use std::rc::Rc; + +use flate2::read::GzDecoder; +use gipfel_core::metadata::{apply_image_metadata, ImageMetaData}; +use gipfel_core::panorama::Panorama; use wasm_bindgen::closure::Closure; use wasm_bindgen::JsCast; use wasm_bindgen_futures::spawn_local; @@ -10,16 +14,30 @@ use web_sys::{DragEvent, Event, HtmlCanvasElement, HtmlInputElement, MouseEvent} use yew::prelude::*; use crate::bridge; -use crate::canvas_view::{CanvasView, ViewCallbacks, ViewState}; +use crate::canvas_view::{CanvasView, MarkerView, ViewCallbacks, ViewState}; +use crate::markers::{self, Marker}; + +fn gunzip(gz: &[u8]) -> Result, String> { + let mut raw = Vec::new(); + GzDecoder::new(gz) + .read_to_end(&mut raw) + .map(|_| raw) + .map_err(|e| format!("gunzip: {e}")) +} #[function_component(App)] pub fn app() -> Html { let bitmap = use_state(|| None::); let view = use_state(ViewState::default); let status = use_state(|| "No image loaded.".to_string()); + let db_status = use_state(|| "Loading hill database…".to_string()); + let fit_info = use_state(String::new); let tick = use_state(|| 0u32); let canvas_ref = use_node_ref(); let file_ref = use_node_ref(); + let pan = use_mut_ref(Panorama::new); + let markers = use_state(Vec::::new); + let fit_distortion = use_state(|| false); // force a redraw when the window is resized so the canvas backing // store tracks its CSS size (listener lives as long as the app) @@ -34,6 +52,31 @@ pub fn app() -> Html { }); } + // load the hill database once at startup + { + let pan = pan.clone(); + let db_status = db_status.clone(); + use_effect_with((), move |_| { + spawn_local(async move { + let result = async { + let gz = bridge::fetch_bytes("gipfel.dat.gz").await?; + let raw = gunzip(&gz)?; + pan.borrow_mut() + .load_data_from_bytes(&raw) + .map_err(|e| format!("load: {e}")) + } + .await; + match result { + Ok(()) => { + let n = pan.borrow().hills.len(); + db_status.set(format!("Hill database: {n} peaks")); + } + Err(e) => db_status.set(format!("Hill database failed: {e}")), + } + }); + }); + } + // Fit the current bitmap into the canvas, centered. let fit = { let bitmap = bitmap.clone(); @@ -58,21 +101,57 @@ pub fn app() -> Html { }) }; - // Decode dropped/selected bytes and display them, fitting to view. + // refit the projection to the given markers and update the status line + let do_refit = { + let pan = pan.clone(); + let fit_info = fit_info.clone(); + let fit_distortion = fit_distortion.clone(); + Rc::new(move |mk: &[Marker]| { + let info = { + let mut p = pan.borrow_mut(); + match markers::refit(&mut p, mk, *fit_distortion) { + Ok(()) if mk.len() >= 4 => format!( + "fit: az {:.2}° · pitch {:.2}° · roll {:.2}° · scale {:.1}", + p.get_center_angle(), + p.get_pitch_angle(), + p.get_roll_angle(), + p.get_scale() + ), + Ok(()) => format!("{} markers — place at least 4 to fit", mk.len()), + Err(e) => format!("fit failed: {e}"), + } + }; + fit_info.set(info); + }) + }; + + // Decode selected/dropped bytes: display, read metadata, reset markers. let load_bytes = { let bitmap = bitmap.clone(); let status = status.clone(); let fit = fit.clone(); + let pan = pan.clone(); + let markers = markers.clone(); + let fit_info = fit_info.clone(); Callback::from(move |(bytes, name): (Vec, String)| { - let (bitmap, status, fit) = (bitmap.clone(), status.clone(), fit.clone()); + let (bitmap, status, fit, pan, markers, fit_info) = + (bitmap.clone(), status.clone(), fit.clone(), pan.clone(), markers.clone(), fit_info.clone()); spawn_local(async move { match bridge::decode_bitmap(&bytes).await { Ok(bmp) => { - status.set(format!( - "{name} — {}×{} px", - bmp.width(), - bmp.height() - )); + let (w, h) = (bmp.width(), bmp.height()); + let mut md = ImageMetaData::new(); + md.load_image_from_bytes(&bytes); + let have = apply_image_metadata(&mut pan.borrow_mut(), &md, w, h); + let vis = pan.borrow().visible.len(); + let vp = if have { + format!("viewpoint from image · {vis} peaks visible") + } else { + "no gipfel/EXIF viewpoint in this image".to_string() + }; + status.set(format!("{name} — {w}×{h} px · {vp}")); + markers.set(Vec::new()); + fit_info.set(String::new()); bitmap.set(Some(bmp)); fit.emit(MouseEvent::new("fit").unwrap()); } @@ -112,7 +191,11 @@ pub fn app() -> Html { let status = status.clone(); Callback::from(move |e: DragEvent| { e.prevent_default(); - match e.data_transfer().and_then(|dt| dt.files()).and_then(|fl| fl.item(0)) { + match e + .data_transfer() + .and_then(|dt| dt.files()) + .and_then(|fl| fl.item(0)) + { Some(file) => read_file(file), None => status.set("Dropped item was not a file.".to_string()), } @@ -129,6 +212,17 @@ pub fn app() -> Html { }) }; + let on_distortion_toggle = { + let fit_distortion = fit_distortion.clone(); + let markers = markers.clone(); + let do_refit = do_refit.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + fit_distortion.set(input.checked()); + do_refit(&markers); + }) + }; + let callbacks = ViewCallbacks { pan: { let view = view.clone(); @@ -152,15 +246,96 @@ pub fn app() -> Html { }); }) }, + click: { + let pan = pan.clone(); + let markers = markers.clone(); + let view = view.clone(); + let status = status.clone(); + let do_refit = do_refit.clone(); + Callback::from(move |(ix, iy): (f64, f64)| { + let p = pan.borrow_mut(); + match markers::nearest_hill(&p, ix, iy, 20.0 / view.scale) { + None => status.set( + "No peak near click — click on a green dot (zoom in to separate them)." + .to_string(), + ), + Some(idx) => { + let mut mk = (*markers).clone(); + mk.retain(|m| m.hill != idx); + mk.push(Marker { + hill: idx, + x: ix, + y: iy, + }); + drop(p); + do_refit(&mk); + markers.set(mk); + } + } + }) + }, + marker_drag: { + let markers = markers.clone(); + Callback::from(move |(i, dx, dy): (usize, f64, f64)| { + let mut mk = (*markers).clone(); + if let Some(m) = mk.get_mut(i) { + m.x += dx; + m.y += dy; + } + markers.set(mk); + }) + }, + drag_end: { + let markers = markers.clone(); + let do_refit = do_refit.clone(); + Callback::from(move |_: ()| do_refit(&markers)) + }, + context: { + let markers = markers.clone(); + let view = view.clone(); + let status = status.clone(); + let do_refit = do_refit.clone(); + Callback::from(move |(ix, iy): (f64, f64)| { + let mut mk = (*markers).clone(); + let before = mk.len(); + let r = 20.0 / view.scale; + mk.retain(|m| (m.x - ix).hypot(m.y - iy) >= r); + if mk.len() < before { + do_refit(&mk); + markers.set(mk); + status.set("Marker removed.".to_string()); + } else { + status.set("Right-click a marker to remove it.".to_string()); + } + }) + }, + }; + + // overlay data for the canvas + let marker_views: Vec = { + let p = pan.borrow(); + markers + .iter() + .map(|m| MarkerView { + x: m.x, + y: m.y, + name: p.hills[m.hill].name.clone(), + }) + .collect() + }; + let candidates: Vec<(f64, f64)> = { + let p = pan.borrow(); + p.visible.iter().map(|&i| (p.hills[i].x, p.hills[i].y)).collect() }; let zoom_pct = (view.scale * 100.0).round(); + let n_markers = markers.len(); html! {
@@ -186,6 +371,8 @@ pub fn app() -> Html { {callbacks} canvas_ref={canvas_ref.clone()} tick={*tick} + markers={marker_views} + candidates={candidates} />
diff --git a/crates/gipfel-web/src/bridge.rs b/crates/gipfel-web/src/bridge.rs index 1353279..a60b1f6 100644 --- a/crates/gipfel-web/src/bridge.rs +++ b/crates/gipfel-web/src/bridge.rs @@ -36,6 +36,23 @@ pub async fn read_blob(blob: &Blob) -> Result, String> { Ok(Uint8Array::new(&buf).to_vec()) } +/// Fetch a URL (same-origin) into memory. +pub async fn fetch_bytes(url: &str) -> Result, String> { + let resp = JsFuture::from(window().fetch_with_str(url)) + .await + .map_err(|e| format!("fetch {url}: {e:?}"))?; + let resp: web_sys::Response = resp + .dyn_into() + .map_err(|_| "bad response".to_string())?; + if !resp.ok() { + return Err(format!("{url}: HTTP {}", resp.status())); + } + let buf = JsFuture::from(resp.array_buffer().map_err(|_| "array_buffer".to_string())?) + .await + .map_err(|e| format!("body: {e:?}"))?; + Ok(Uint8Array::new(&buf).to_vec()) +} + pub fn ctx2d(canvas: &HtmlCanvasElement) -> Option { canvas .get_context("2d") diff --git a/crates/gipfel-web/src/canvas_view.rs b/crates/gipfel-web/src/canvas_view.rs index 87b89d9..4282bc0 100644 --- a/crates/gipfel-web/src/canvas_view.rs +++ b/crates/gipfel-web/src/canvas_view.rs @@ -1,7 +1,8 @@ //! Viewport canvas: browser-native bitmap blitted with a pan/zoom -//! transform. Overlay drawing (markers, labels, compass) is added in W3. +//! transform, plus the marker overlay and its interactions. -use web_sys::{HtmlCanvasElement, ImageBitmap, PointerEvent, WheelEvent};use yew::prelude::*; +use web_sys::{HtmlCanvasElement, ImageBitmap, MouseEvent, PointerEvent, WheelEvent}; +use yew::prelude::*; use crate::bridge; @@ -14,11 +15,27 @@ pub struct ViewState { pub oy: f64, } +/// A marker in center-relative image coordinates. +#[derive(Clone, Debug, PartialEq)] +pub struct MarkerView { + pub x: f64, + pub y: f64, + pub name: String, +} + #[derive(Clone, PartialEq)] pub struct ViewCallbacks { pub pan: Callback<(f64, f64)>, /// (cursor x, cursor y, factor) — zoom anchored at the cursor. pub zoom: Callback<(f64, f64, f64)>, + /// click on empty space: (x, y) center-relative image coords + pub click: Callback<(f64, f64)>, + /// drag a marker: (marker index, dx, dy) in image coords + pub marker_drag: Callback<(usize, f64, f64)>, + /// a marker drag finished (time to refit) + pub drag_end: Callback<()>, + /// right-click: (x, y) center-relative image coords + pub context: Callback<(f64, f64)>, } #[derive(Properties, PartialEq)] @@ -29,41 +46,66 @@ pub struct Props { pub canvas_ref: NodeRef, /// bumped on window resize to force a redraw pub tick: u32, + pub markers: Vec, + /// projected positions of all visible hills (small guide dots) + pub candidates: Vec<(f64, f64)>, +} + +#[derive(Clone, PartialEq)] +enum DragMode { + Pan, + Marker(usize), +} + +#[derive(PartialEq)] +struct DragState { + mode: Option, + last: (f64, f64), + start: (f64, f64), + moved: bool, } #[function_component(CanvasView)] pub fn canvas_view(props: &Props) -> Html { - let dragging = use_mut_ref(|| false); - let last = use_mut_ref(|| (0.0f64, 0.0f64)); + let drag = use_mut_ref(|| DragState { + mode: None, + last: (0.0, 0.0), + start: (0.0, 0.0), + moved: false, + }); - // redraw on every view/bitmap change and on resize ticks + // redraw on every view/bitmap/marker change and on resize ticks { let bitmap = props.bitmap.clone(); let view = props.view.clone(); let canvas_ref = props.canvas_ref.clone(); - use_effect_with((bitmap, view, props.tick), move |(bitmap, view, _tick)| { - let Some(canvas) = canvas_ref.cast::() else { - return; - }; - let Some(ctx) = bridge::ctx2d(&canvas) else { - return; - }; - let dpr = bridge::window().device_pixel_ratio(); - let cw = canvas.client_width() as f64; - let ch = canvas.client_height() as f64; - // keep the backing store in sync with the CSS size - let bw = (cw * dpr).max(1.0) as u32; - let bh = (ch * dpr).max(1.0) as u32; - if canvas.width() != bw || canvas.height() != bh { - canvas.set_width(bw); - canvas.set_height(bh); - } - let _ = ctx.set_transform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0); - // web-sys 0.3: set_fill_style takes a JsValue (deprecated alias) - #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("#101014")); - ctx.fill_rect(0.0, 0.0, canvas.width() as f64, canvas.height() as f64); - if let Some(bitmap) = bitmap { + let markers = props.markers.clone(); + let candidates = props.candidates.clone(); + use_effect_with( + (bitmap, view, props.tick, markers.clone(), candidates.clone()), + move |(bitmap, view, _tick, markers, candidates)| { + let Some(canvas) = canvas_ref.cast::() else { + return; + }; + let Some(ctx) = bridge::ctx2d(&canvas) else { + return; + }; + let dpr = bridge::window().device_pixel_ratio(); + let cw = canvas.client_width() as f64; + let ch = canvas.client_height() as f64; + // keep the backing store in sync with the CSS size + let bw = (cw * dpr).max(1.0) as u32; + let bh = (ch * dpr).max(1.0) as u32; + if canvas.width() != bw || canvas.height() != bh { + canvas.set_width(bw); + canvas.set_height(bh); + } + let _ = ctx.set_transform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0); + // web-sys 0.3: set_fill_style takes a JsValue (deprecated alias) + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("#101014")); + ctx.fill_rect(0.0, 0.0, canvas.width() as f64, canvas.height() as f64); + let Some(bitmap) = bitmap else { return }; let _ = ctx.set_transform( dpr * view.scale, 0.0, @@ -73,47 +115,183 @@ pub fn canvas_view(props: &Props) -> Html { dpr * view.oy, ); let _ = ctx.draw_image_with_image_bitmap(bitmap, 0.0, 0.0); - } - }); + + // overlays in screen space + let _ = ctx.set_transform(dpr, 0.0, 0.0, dpr, 0.0, 0.0); + let hw = bitmap.width() as f64 / 2.0; + let hh = bitmap.height() as f64 / 2.0; + let sx = |x: f64| (x + hw) * view.scale + view.ox; + let sy = |y: f64| (y + hh) * view.scale + view.oy; + + // guide dots for all visible peaks + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(120, 220, 160, 0.8)")); + for (cx, cy) in candidates { + let (px, py) = (sx(*cx), sy(*cy)); + if px < -4.0 || py < -4.0 || px > cw + 4.0 || py > ch + 4.0 { + continue; + } + ctx.fill_rect(px - 1.5, py - 1.5, 3.0, 3.0); + } + + // markers: red cross + name + ctx.set_font("12px system-ui, sans-serif"); + for m in markers { + let (px, py) = (sx(m.x), sy(m.y)); + #[allow(deprecated)] + ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str("rgb(255, 64, 64)")); + ctx.set_line_width(1.5); + ctx.begin_path(); + ctx.move_to(px - 5.0, py); + ctx.line_to(px + 5.0, py); + ctx.move_to(px, py - 5.0); + ctx.line_to(px, py + 5.0); + ctx.stroke(); + if !m.name.is_empty() { + // dark shadow + white text stays readable on any photo + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.8)")); + ctx.fill_text(&m.name, px + 7.0, py - 5.0).ok(); + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("white")); + ctx.fill_text(&m.name, px + 6.0, py - 6.0).ok(); + } + } + }, + ); } + // screen (client) -> center-relative image coordinates + let to_img = { + let canvas_ref = props.canvas_ref.clone(); + let view = props.view.clone(); + let bitmap = props.bitmap.clone(); + let w = bitmap.as_ref().map(|b| b.width() as f64).unwrap_or(0.0); + let h = bitmap.as_ref().map(|b| b.height() as f64).unwrap_or(0.0); + move |client_x: f64, client_y: f64| -> (f64, f64) { + let rect = canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect()); + let (rx, ry) = match rect { + Some(r) => (client_x - r.left(), client_y - r.top()), + None => (client_x, client_y), + }; + ( + (rx - view.ox) / view.scale - w / 2.0, + (ry - view.oy) / view.scale - h / 2.0, + ) + } + }; + let on_pointerdown = { - let dragging = dragging.clone(); - let last = last.clone(); + let drag = drag.clone(); let canvas_ref = props.canvas_ref.clone(); + let markers = props.markers.clone(); + let view = props.view.clone(); + let bitmap = props.bitmap.clone(); Callback::from(move |e: PointerEvent| { e.prevent_default(); if let Some(c) = canvas_ref.cast::() { let _ = c.set_pointer_capture(e.pointer_id()); } - *dragging.borrow_mut() = true; - *last.borrow_mut() = (e.client_x() as f64, e.client_y() as f64); + let rect = canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect()); + let (rx, ry) = match rect { + Some(r) => (e.client_x() as f64 - r.left(), e.client_y() as f64 - r.top()), + None => (e.client_x() as f64, e.client_y() as f64), + }; + // marker hit-test (screen space, 12 px radius) + let mut mode = DragMode::Pan; + if let Some(bmp) = &bitmap { + let hw = bmp.width() as f64 / 2.0; + let hh = bmp.height() as f64 / 2.0; + for (i, m) in markers.iter().enumerate().rev() { + let px = (m.x + hw) * view.scale + view.ox; + let py = (m.y + hh) * view.scale + view.oy; + if (rx - px).hypot(ry - py) < 12.0 { + mode = DragMode::Marker(i); + break; + } + } + } + let pos = (e.client_x() as f64, e.client_y() as f64); + let mut d = drag.borrow_mut(); + d.mode = Some(mode); + d.last = pos; + d.start = pos; + d.moved = false; }) }; + let on_pointermove = { - let dragging = dragging.clone(); - let last = last.clone(); + let drag = drag.clone(); let pan = props.callbacks.pan.clone(); + let marker_drag = props.callbacks.marker_drag.clone(); + let scale = props.view.scale; Callback::from(move |e: PointerEvent| { - if !*dragging.borrow() { + let mut d = drag.borrow_mut(); + let mode = match &d.mode { + Some(m) => m.clone(), + None => return, + }; + let pos = (e.client_x() as f64, e.client_y() as f64); + let dx = pos.0 - d.last.0; + let dy = pos.1 - d.last.1; + d.last = pos; + if (pos.0 - d.start.0).hypot(pos.1 - d.start.1) > 3.0 { + d.moved = true; + } + if !d.moved { return; } - let cur = (e.client_x() as f64, e.client_y() as f64); - let prev = *last.borrow(); - *last.borrow_mut() = cur; - pan.emit((cur.0 - prev.0, cur.1 - prev.1)); + match mode { + DragMode::Pan => pan.emit((dx, dy)), + DragMode::Marker(i) => marker_drag.emit((i, dx / scale, dy / scale)), + } }) }; + let on_pointerup = { - let dragging = dragging.clone(); + let drag = drag.clone(); let canvas_ref = props.canvas_ref.clone(); + let click = props.callbacks.click.clone(); + let drag_end = props.callbacks.drag_end.clone(); + let to_img = to_img.clone(); Callback::from(move |e: PointerEvent| { - *dragging.borrow_mut() = false; + let mode = drag.borrow_mut().mode.take(); if let Some(c) = canvas_ref.cast::() { let _ = c.release_pointer_capture(e.pointer_id()); } + let moved = drag.borrow().moved; + match mode { + Some(DragMode::Pan) if !moved => { + let (ix, iy) = to_img(e.client_x() as f64, e.client_y() as f64); + click.emit((ix, iy)); + } + Some(DragMode::Marker(_)) if moved => drag_end.emit(()), + _ => {} + } + }) + }; + + let on_pointercancel = { + let drag = drag.clone(); + Callback::from(move |_: PointerEvent| { + drag.borrow_mut().mode = None; }) }; + + let on_contextmenu = { + let context = props.callbacks.context.clone(); + let to_img = to_img.clone(); + Callback::from(move |e: MouseEvent| { + e.prevent_default(); + let (ix, iy) = to_img(e.client_x() as f64, e.client_y() as f64); + context.emit((ix, iy)); + }) + }; + let on_wheel = { let zoom = props.callbacks.zoom.clone(); let canvas_ref = props.canvas_ref.clone(); @@ -140,8 +318,9 @@ pub fn canvas_view(props: &Props) -> Html { class="viewport" onpointerdown={on_pointerdown} onpointermove={on_pointermove} - onpointerup={on_pointerup.clone()} - onpointercancel={on_pointerup} + onpointerup={on_pointerup} + onpointercancel={on_pointercancel} + oncontextmenu={on_contextmenu} onwheel={on_wheel} /> } diff --git a/crates/gipfel-web/src/main.rs b/crates/gipfel-web/src/main.rs index 6a3e4d4..8a39039 100644 --- a/crates/gipfel-web/src/main.rs +++ b/crates/gipfel-web/src/main.rs @@ -1,6 +1,7 @@ mod app; mod bridge; mod canvas_view; +mod markers; fn main() { yew::Renderer::::new().render(); diff --git a/crates/gipfel-web/src/markers.rs b/crates/gipfel-web/src/markers.rs new file mode 100644 index 0000000..279c62c --- /dev/null +++ b/crates/gipfel-web/src/markers.rs @@ -0,0 +1,48 @@ +//! Markers: user observations of hills at image positions, plus the +//! refit entry point. Coordinates are center-relative image pixels, +//! matching the projection output space (same convention as the +//! desktop viewport widget). + +use gipfel_core::hill::Hill; +use gipfel_core::panorama::Panorama; + +#[derive(Clone, Debug, PartialEq)] +pub struct Marker { + /// index into `Panorama::hills` (stable: load order is preserved) + pub hill: usize, + pub x: f64, + pub y: f64, +} + +/// Refit the projection parameters to the current markers. +/// With fewer than 4 markers nothing can be fitted (same rule as desktop). +pub fn refit(pan: &mut Panorama, markers: &[Marker], fit_distortion: bool) -> Result<(), String> { + if markers.len() < 4 { + return Ok(()); + } + let mut obs: Vec = Vec::with_capacity(markers.len()); + for m in markers { + let mut h = pan.hills[m.hill].clone(); + h.x = m.x; + h.y = m.y; + obs.push(h); + } + let known: Vec = (0..markers.len()).collect(); + pan.comp_params_with(&obs, &known, fit_distortion) +} + +/// Nearest visible hill to image position `(x, y)`, within `max_dist` +/// image pixels. Used to resolve marker clicks. +pub fn nearest_hill(pan: &Panorama, x: f64, y: f64, max_dist: f64) -> Option { + let mut best = None; + let mut best_d = max_dist; + for &i in &pan.visible { + let h = &pan.hills[i]; + let d = (h.x - x).hypot(h.y - y); + if d < best_d { + best_d = d; + best = Some(i); + } + } + best +} diff --git a/crates/gipfel-web/www/style.css b/crates/gipfel-web/www/style.css index 5ea080d..187b476 100644 --- a/crates/gipfel-web/www/style.css +++ b/crates/gipfel-web/www/style.css @@ -55,6 +55,18 @@ body { font-size: 12px; color: #8a8a94; } +.row { + display: flex; + gap: 6px; + align-items: center; + font-size: 13px; + cursor: pointer; +} +.fitinfo { + font-size: 12px; + color: #9fd09f; + font-variant-numeric: tabular-nums; +} .dim { opacity: 0.6; } -- cgit v1.2.3 From 9e1d138a29aafc52d2da68b66f7d6ea00081134f Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 11:48:04 +0100 Subject: web: visible guide dots with hover peak identification MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - guide dots: dark outline ring + bright core, readable on any photo - hover over a dot shows 'NAME · height m' in the sidebar (same info the desktop hover status line gives) - pointermove doubles as hover report when not dragging --- crates/gipfel-web/src/app.rs | 23 +++++++++++++++++- crates/gipfel-web/src/canvas_view.rs | 45 ++++++++++++++++++++++++++++++------ crates/gipfel-web/www/style.css | 5 ++++ 3 files changed, 65 insertions(+), 8 deletions(-) (limited to 'crates') diff --git a/crates/gipfel-web/src/app.rs b/crates/gipfel-web/src/app.rs index 8512d6a..f152dcc 100644 --- a/crates/gipfel-web/src/app.rs +++ b/crates/gipfel-web/src/app.rs @@ -38,6 +38,7 @@ pub fn app() -> Html { let pan = use_mut_ref(Panorama::new); let markers = use_state(Vec::::new); let fit_distortion = use_state(|| false); + let hover = use_state(|| Option::::None); // force a redraw when the window is resized so the canvas backing // store tracks its CSS size (listener lives as long as the app) @@ -309,6 +310,23 @@ pub fn app() -> Html { } }) }, + hover: { + let pan = pan.clone(); + let view = view.clone(); + let hover = hover.clone(); + Callback::from(move |(ix, iy): (f64, f64)| { + let p = pan.borrow(); + let name = markers::nearest_hill(&p, ix, iy, 20.0 / view.scale).map(|i| { + let h = &p.hills[i]; + format!("{} · {:.0} m", h.name, h.height) + }); + hover.set(name); + }) + }, + hover_end: { + let hover = hover.clone(); + Callback::from(move |_: ()| hover.set(None)) + }, }; // overlay data for the canvas @@ -356,9 +374,12 @@ pub fn app() -> Html { if !fit_info.is_empty() {

{ (*fit_info).clone() }

} + if let Some(h) = hover.as_ref() { +

{ h.clone() }

+ } }

- { "Click a green dot to mark that peak · drag markers to adjust · right-click a marker to remove." } + { "Hover a green dot to see the peak · click to mark it · drag to adjust · right-click to remove." }

{ "The view is fitted automatically once 4+ markers are placed." } diff --git a/crates/gipfel-web/src/canvas_view.rs b/crates/gipfel-web/src/canvas_view.rs index 4282bc0..d870029 100644 --- a/crates/gipfel-web/src/canvas_view.rs +++ b/crates/gipfel-web/src/canvas_view.rs @@ -36,6 +36,10 @@ pub struct ViewCallbacks { pub drag_end: Callback<()>, /// right-click: (x, y) center-relative image coords pub context: Callback<(f64, f64)>, + /// pointer moved over the image (not dragging): (x, y) center-relative + pub hover: Callback<(f64, f64)>, + /// pointer left the canvas + pub hover_end: Callback<()>, } #[derive(Properties, PartialEq)] @@ -123,15 +127,29 @@ pub fn canvas_view(props: &Props) -> Html { let sx = |x: f64| (x + hw) * view.scale + view.ox; let sy = |y: f64| (y + hh) * view.scale + view.oy; - // guide dots for all visible peaks + // guide dots for all visible peaks: dark outline ring + + // bright core so they stay visible on any photo content #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(120, 220, 160, 0.8)")); + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.85)")); for (cx, cy) in candidates { let (px, py) = (sx(*cx), sy(*cy)); - if px < -4.0 || py < -4.0 || px > cw + 4.0 || py > ch + 4.0 { + if px < -6.0 || py < -6.0 || px > cw + 6.0 || py > ch + 6.0 { continue; } - ctx.fill_rect(px - 1.5, py - 1.5, 3.0, 3.0); + ctx.begin_path(); + ctx.arc(px, py, 4.5, 0.0, std::f64::consts::TAU); + ctx.fill(); + } + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgb(110, 231, 183)")); + for (cx, cy) in candidates { + let (px, py) = (sx(*cx), sy(*cy)); + if px < -6.0 || py < -6.0 || px > cw + 6.0 || py > ch + 6.0 { + continue; + } + ctx.begin_path(); + ctx.arc(px, py, 2.5, 0.0, std::f64::consts::TAU); + ctx.fill(); } // markers: red cross + name @@ -226,14 +244,21 @@ pub fn canvas_view(props: &Props) -> Html { let on_pointermove = { let drag = drag.clone(); - let pan = props.callbacks.pan.clone(); + let pan_cb = props.callbacks.pan.clone(); let marker_drag = props.callbacks.marker_drag.clone(); + let hover = props.callbacks.hover.clone(); + let to_img = to_img.clone(); let scale = props.view.scale; Callback::from(move |e: PointerEvent| { let mut d = drag.borrow_mut(); let mode = match &d.mode { Some(m) => m.clone(), - None => return, + None => { + // free hover: report position for peak identification + let (ix, iy) = to_img(e.client_x() as f64, e.client_y() as f64); + hover.emit((ix, iy)); + return; + } }; let pos = (e.client_x() as f64, e.client_y() as f64); let dx = pos.0 - d.last.0; @@ -246,12 +271,17 @@ pub fn canvas_view(props: &Props) -> Html { return; } match mode { - DragMode::Pan => pan.emit((dx, dy)), + DragMode::Pan => pan_cb.emit((dx, dy)), DragMode::Marker(i) => marker_drag.emit((i, dx / scale, dy / scale)), } }) }; + let on_pointerleave = { + let hover_end = props.callbacks.hover_end.clone(); + Callback::from(move |_: PointerEvent| hover_end.emit(())) + }; + let on_pointerup = { let drag = drag.clone(); let canvas_ref = props.canvas_ref.clone(); @@ -320,6 +350,7 @@ pub fn canvas_view(props: &Props) -> Html { onpointermove={on_pointermove} onpointerup={on_pointerup} onpointercancel={on_pointercancel} + onpointerleave={on_pointerleave} oncontextmenu={on_contextmenu} onwheel={on_wheel} /> diff --git a/crates/gipfel-web/www/style.css b/crates/gipfel-web/www/style.css index 187b476..1e632f2 100644 --- a/crates/gipfel-web/www/style.css +++ b/crates/gipfel-web/www/style.css @@ -67,6 +67,11 @@ body { color: #9fd09f; font-variant-numeric: tabular-nums; } +.hover { + font-size: 14px; + font-weight: 600; + color: #ffffff; +} .dim { opacity: 0.6; } -- cgit v1.2.3 From 70784357c804d3411bb93fa6e0a74c9ffcd3d3ad Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 12:06:13 +0100 Subject: web: W3 — compass strip, parameter sliders, collision-free labels MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - compass.rs: canvas port of the desktop Aligned compass strip — adaptive tick step, direction labels (red N), center triangle and azimuth readout, drag to rotate the view (Newton inverse projection, same solver as desktop; round-trip tests ported and passing) - sidebar sections like the desktop: Viewpoint (lat/lon/height number inputs), Orientation (azimuth/focal/pitch/roll sliders, desktop ranges), Projection (fit-distortion toggle), Display (visibility with the 0.11-r inversion, label size 8-28 px) - every control applies to the Panorama immediately (focal maps via scale = focal * w / 35, same formula as the metadata path) - marker labels: ported the desktop layout_label_y collision push-up with yellow leader lines (cross, vertical, horizontal), label font size live-adjustable - main area split: canvas + 56 px compass strip --- crates/gipfel-web/Cargo.toml | 1 + crates/gipfel-web/src/app.rs | 192 +++++++++++++++++-- crates/gipfel-web/src/canvas_view.rs | 158 ++++++++++++++-- crates/gipfel-web/src/compass.rs | 349 +++++++++++++++++++++++++++++++++++ crates/gipfel-web/src/main.rs | 2 + crates/gipfel-web/src/widgets.rs | 76 ++++++++ crates/gipfel-web/www/style.css | 54 +++++- 7 files changed, 792 insertions(+), 40 deletions(-) create mode 100644 crates/gipfel-web/src/compass.rs create mode 100644 crates/gipfel-web/src/widgets.rs (limited to 'crates') diff --git a/crates/gipfel-web/Cargo.toml b/crates/gipfel-web/Cargo.toml index 4d846c1..4cb78a7 100644 --- a/crates/gipfel-web/Cargo.toml +++ b/crates/gipfel-web/Cargo.toml @@ -35,6 +35,7 @@ features = [ "PointerEvent", "Request", "Response", + "TextMetrics", "Window", "WheelEvent", ] diff --git a/crates/gipfel-web/src/app.rs b/crates/gipfel-web/src/app.rs index f152dcc..0874e9a 100644 --- a/crates/gipfel-web/src/app.rs +++ b/crates/gipfel-web/src/app.rs @@ -15,7 +15,40 @@ use yew::prelude::*; use crate::bridge; use crate::canvas_view::{CanvasView, MarkerView, ViewCallbacks, ViewState}; +use crate::compass::{Compass, CompassData}; use crate::markers::{self, Marker}; +use crate::widgets::{NumItem, SliderItem}; + +/// sidebar-editable view parameters (degrees / meters / mm) +#[derive(Clone, Copy, PartialEq)] +struct UiParams { + lat: f64, + lon: f64, + height: f64, + az: f64, + focal: f64, + pitch: f64, + roll: f64, + /// visibility UI value: 0.11 - height_dist_ratio (right = more visible) + vis: f64, + label_font: f32, +} + +impl Default for UiParams { + fn default() -> Self { + UiParams { + lat: 0.0, + lon: 0.0, + height: 0.0, + az: 0.0, + focal: 50.0, + pitch: 0.0, + roll: 0.0, + vis: 0.04, + label_font: 12.0, + } + } +} fn gunzip(gz: &[u8]) -> Result, String> { let mut raw = Vec::new(); @@ -39,6 +72,8 @@ pub fn app() -> Html { let markers = use_state(Vec::::new); let fit_distortion = use_state(|| false); let hover = use_state(|| Option::::None); + let vp = use_state(UiParams::default); + let img_size = use_state(|| (0u32, 0u32)); // force a redraw when the window is resized so the canvas backing // store tracks its CSS size (listener lives as long as the app) @@ -134,9 +169,13 @@ pub fn app() -> Html { let pan = pan.clone(); let markers = markers.clone(); let fit_info = fit_info.clone(); + let vp = vp.clone(); + let img_size = img_size.clone(); Callback::from(move |(bytes, name): (Vec, String)| { let (bitmap, status, fit, pan, markers, fit_info) = (bitmap.clone(), status.clone(), fit.clone(), pan.clone(), markers.clone(), fit_info.clone()); + let vp = vp.clone(); + let img_size = img_size.clone(); spawn_local(async move { match bridge::decode_bitmap(&bytes).await { Ok(bmp) => { @@ -145,6 +184,22 @@ pub fn app() -> Html { md.load_image_from_bytes(&bytes); let have = apply_image_metadata(&mut pan.borrow_mut(), &md, w, h); let vis = pan.borrow().visible.len(); + let u = { + let p = pan.borrow(); + UiParams { + lat: p.get_view_lat(), + lon: p.get_view_long(), + height: p.get_view_height(), + az: p.get_center_angle().rem_euclid(360.0), + focal: (p.get_scale() * 35.0 / w as f64).clamp(1.0, 300.0), + pitch: p.get_pitch_angle(), + roll: p.get_roll_angle(), + vis: (0.11 - p.height_dist_ratio).clamp(0.01, 0.1), + label_font: vp.label_font, + } + }; + vp.set(u); + img_size.set((w, h)); let vp = if have { format!("viewpoint from image · {vis} peaks visible") } else { @@ -224,6 +279,73 @@ pub fn app() -> Html { }) }; + // sidebar parameter editing: update UI state and apply to the panorama + macro_rules! param_cb { + ($field:ident, $apply:expr) => {{ + let vp = vp.clone(); + let pan = pan.clone(); + Callback::from(move |v: f64| { + let mut u = *vp; + u.$field = v; + vp.set(u); + let f: &dyn Fn(&mut Panorama, f64) = &$apply; + f(&mut pan.borrow_mut(), v); + }) + }}; + } + let on_lat = param_cb!(lat, |p: &mut Panorama, v| p.set_view_lat(v)); + let on_lon = param_cb!(lon, |p, v| p.set_view_long(v)); + let on_height = param_cb!(height, |p, v| p.set_view_height(v)); + let on_az = param_cb!(az, |p, v| p.set_center_angle(v)); + let on_pitch = param_cb!(pitch, |p, v| p.set_pitch_angle(v)); + let on_roll = param_cb!(roll, |p, v| p.set_roll_angle(v)); + let on_vis = param_cb!(vis, |p, v| p.set_height_dist_ratio(0.11 - v)); + let on_focal = { + let vp = vp.clone(); + let pan = pan.clone(); + let img_size = img_size.clone(); + Callback::from(move |v: f64| { + let mut u = *vp; + u.focal = v; + vp.set(u); + let w = img_size.0 as f64; + if w > 0.0 { + pan.borrow_mut().set_scale(v * w / 35.0); + } + }) + }; + let on_font = { + let vp = vp.clone(); + Callback::from(move |v: f64| { + let mut u = *vp; + u.label_font = v as f32; + vp.set(u); + }) + }; + + // compass strip: shares the image transform, drag changes azimuth + let compass_data = { + let p = pan.borrow(); + CompassData { + ptype: p.projection_type, + parms: p.parms, + center_deg: p.get_center_angle(), + zoom: view.scale, + cx: view.ox + img_size.0 as f64 * view.scale / 2.0, + max_view_angle: p.max_view_angle, + } + }; + let compass_change = { + let pan = pan.clone(); + let vp = vp.clone(); + Callback::from(move |deg: f64| { + pan.borrow_mut().set_center_angle(deg); + let mut u = *vp; + u.az = deg.rem_euclid(360.0); + vp.set(u); + }) + }; + let callbacks = ViewCallbacks { pan: { let view = view.clone(); @@ -366,17 +488,41 @@ pub fn app() -> Html {

{ (*status).clone() }

{ (*db_status).clone() }

if bitmap.is_some() { - -

{ format!("{n_markers} markers · zoom {zoom_pct:.0} %") }

- if !fit_info.is_empty() { -

{ (*fit_info).clone() }

- } - if let Some(h) = hover.as_ref() { -

{ h.clone() }

- } + <> +
{ "Viewpoint" }
+ + + +
{ "Orientation" }
+ + + + +
{ "Projection" }
+ +
{ "Display" }
+ + +

{ format!("{n_markers} markers · zoom {zoom_pct:.0} %") }

+ if !fit_info.is_empty() { +

{ (*fit_info).clone() }

+ } + if let Some(h) = hover.as_ref() { +

{ h.clone() }

+ } + }

{ "Hover a green dot to see the peak · click to mark it · drag to adjust · right-click to remove." } @@ -386,15 +532,21 @@ pub fn app() -> Html {

- +
+ +
+ if bitmap.is_some() { + + }
} diff --git a/crates/gipfel-web/src/canvas_view.rs b/crates/gipfel-web/src/canvas_view.rs index d870029..ab72b7f 100644 --- a/crates/gipfel-web/src/canvas_view.rs +++ b/crates/gipfel-web/src/canvas_view.rs @@ -53,6 +53,8 @@ pub struct Props { pub markers: Vec, /// projected positions of all visible hills (small guide dots) pub candidates: Vec<(f64, f64)>, + /// marker label font size, screen px + pub label_font: f32, } #[derive(Clone, PartialEq)] @@ -85,9 +87,10 @@ pub fn canvas_view(props: &Props) -> Html { let canvas_ref = props.canvas_ref.clone(); let markers = props.markers.clone(); let candidates = props.candidates.clone(); + let label_font = props.label_font; use_effect_with( - (bitmap, view, props.tick, markers.clone(), candidates.clone()), - move |(bitmap, view, _tick, markers, candidates)| { + (bitmap, view, props.tick, markers.clone(), candidates.clone(), label_font), + move |(bitmap, view, _tick, markers, candidates, label_font)| { let Some(canvas) = canvas_ref.cast::() else { return; }; @@ -137,7 +140,7 @@ pub fn canvas_view(props: &Props) -> Html { continue; } ctx.begin_path(); - ctx.arc(px, py, 4.5, 0.0, std::f64::consts::TAU); + let _ = ctx.arc(px, py, 4.5, 0.0, std::f64::consts::TAU); ctx.fill(); } #[allow(deprecated)] @@ -148,31 +151,83 @@ pub fn canvas_view(props: &Props) -> Html { continue; } ctx.begin_path(); - ctx.arc(px, py, 2.5, 0.0, std::f64::consts::TAU); + let _ = ctx.arc(px, py, 2.5, 0.0, std::f64::consts::TAU); ctx.fill(); } - // markers: red cross + name - ctx.set_font("12px system-ui, sans-serif"); - for m in markers { - let (px, py) = (sx(m.x), sy(m.y)); + // markers: yellow leader lines, red crosses, collision-free + // labels (port of the desktop viewport drawing) + if !markers.is_empty() { + let label_font = *label_font; + let line_h = label_font * 1.3 + 2.0; + ctx.set_font(&format!("{label_font:.0}px system-ui, sans-serif")); + // layout runs in screen space, sorted by x + let mut order: Vec = (0..markers.len()) + .filter(|&i| { + markers[i].x.abs() * 2.0 <= bitmap.width() as f64 + && markers[i].y.abs() * 2.0 <= bitmap.height() as f64 + }) + .collect(); + order.sort_by(|&a, &b| sx(markers[a].x).total_cmp(&sx(markers[b].x))); + let xs: Vec = order.iter().map(|&i| sx(markers[i].x) as f32).collect(); + let ys: Vec = order.iter().map(|&i| sy(markers[i].y) as f32).collect(); + let widths: Vec = order + .iter() + .map(|&i| { + ctx.measure_text(&markers[i].name) + .map(|m| m.width() as f32) + .unwrap_or_else(|_| markers[i].name.len() as f32 * 7.0) + }) + .collect(); + let in_img = vec![true; order.len()]; + let entries = layout_label_y(&xs, &ys, &widths, &in_img, line_h); + + // leaders (yellow): cross, vertical, horizontal + #[allow(deprecated)] + ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str("rgb(255, 230, 51)")); + ctx.set_line_width(1.0); + for (k, &i) in order.iter().enumerate() { + let (px, py) = (sx(markers[i].x), sy(markers[i].y)); + let (lx, ly) = entries[k]; + let label_line = py + ly as f64 - line_h as f64; + ctx.begin_path(); + ctx.move_to(px - 4.0, py); + ctx.line_to(px + 4.0, py); + ctx.move_to(px, py); + ctx.line_to(px, label_line); + ctx.move_to(px, label_line); + ctx.line_to(px + lx as f64, label_line); + ctx.stroke(); + } + // marker crosses (always red) #[allow(deprecated)] ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str("rgb(255, 64, 64)")); ctx.set_line_width(1.5); - ctx.begin_path(); - ctx.move_to(px - 5.0, py); - ctx.line_to(px + 5.0, py); - ctx.move_to(px, py - 5.0); - ctx.line_to(px, py + 5.0); - ctx.stroke(); - if !m.name.is_empty() { - // dark shadow + white text stays readable on any photo + for &i in &order { + let (px, py) = (sx(markers[i].x), sy(markers[i].y)); + ctx.begin_path(); + ctx.move_to(px - 5.0, py); + ctx.line_to(px + 5.0, py); + ctx.move_to(px, py - 5.0); + ctx.line_to(px, py + 5.0); + ctx.stroke(); + } + // labels: white on dark shadow, right-aligned at leader end + for (k, &i) in order.iter().enumerate() { + if markers[i].name.is_empty() { + continue; + } + let (px, py) = (sx(markers[i].x), sy(markers[i].y)); + let (lx, ly) = entries[k]; + let label_line = py + ly as f64 - line_h as f64; + let tx = px + lx as f64 - widths[k] as f64; + let ty = label_line - 3.0; #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.8)")); - ctx.fill_text(&m.name, px + 7.0, py - 5.0).ok(); + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.85)")); + ctx.fill_text(&markers[i].name, tx + 1.0, ty + 1.0).ok(); #[allow(deprecated)] ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("white")); - ctx.fill_text(&m.name, px + 6.0, py - 6.0).ok(); + ctx.fill_text(&markers[i].name, tx, ty).ok(); } } }, @@ -356,3 +411,68 @@ pub fn canvas_view(props: &Props) -> Html { /> } } + +/// Port of the desktop `viewport::layout_label_y`: place labels right of +/// their crosses, pushing colliding ones up; iterate to a fixed point +/// (the C single pass can leave overlaps). Inputs must be sorted by x. +fn layout_label_y( + xs: &[f32], + ys: &[f32], + widths: &[f32], + in_img: &[bool], + line_h: f32, +) -> Vec<(f32, f32)> { + let n = xs.len(); + let mut label_x = vec![0.0f32; n]; + let mut label_y = vec![0.0f32; n]; + let cross = 4.0f32; + let overlap = |a1: f32, l1: f32, a2: f32, l2: f32| a1 <= a2 + l2 && a1 + l1 >= a2; + + for i in 0..n { + if !in_img[i] { + continue; + } + label_x[i] = widths[i] + 1.0; + label_y[i] = 0.0; + + let mut colliding: Vec = Vec::new(); + for j in (0..i).rev() { + if !in_img[j] { + continue; + } + if overlap(xs[i], label_x[i], xs[j] - cross, label_x[j]) { + colliding.push(j); + } else { + break; + } + } + colliding.sort_by(|&a, &b| { + let ya = ys[a] + label_y[a]; + let yb = ys[b] + label_y[b]; + yb.total_cmp(&ya) + }); + for _round in 0..64 { + let mut pushed = false; + for &j in &colliding { + if overlap( + ys[i] + label_y[i] - line_h, + line_h, + ys[j] + label_y[j] - line_h, + line_h, + ) || overlap(ys[i] + label_y[i] - line_h, line_h, ys[j] - cross, 2.0 * cross) + { + let ny = (ys[j] + label_y[j] - ys[i] - line_h - 2.0).round(); + if ny < label_y[i] { + label_y[i] = ny; + pushed = true; + } + } + } + if !pushed { + break; + } + } + } + + (0..n).map(|i| (label_x[i], label_y[i])).collect() +} diff --git a/crates/gipfel-web/src/compass.rs b/crates/gipfel-web/src/compass.rs new file mode 100644 index 0000000..b539e07 --- /dev/null +++ b/crates/gipfel-web/src/compass.rs @@ -0,0 +1,349 @@ +//! Compass strip (canvas port of the desktop `compass.rs`, Aligned style): +//! shares the image's horizontal transform so each direction sits above +//! its position in the image; drag horizontally to change the view azimuth. + +use web_sys::{HtmlCanvasElement, PointerEvent};use yew::prelude::*; + +use gipfel_core::projection::{projection_from_type, ProjArgs, Projection, ProjectionType, ViewParams}; + +use crate::bridge; + +pub const STRIP_H: f64 = 56.0; + +/// Damped, clamped Newton iteration for a scalar inverse projection: find +/// `a` such that `f(a) ≈ target` (identical to the desktop solver). +pub fn newton_inverse( + target: f64, + mut f: impl FnMut(f64) -> Option, + seed: f64, + lo: f64, + hi: f64, +) -> f64 { + let mut a = seed.clamp(lo, hi); + for _ in 0..6 { + let Some(y) = f(a) else { break }; + let resid = y - target; + let h = 1e-5; + let (Some(y1), Some(y2)) = (f(a + h), f(a - h)) else { + break; + }; + let d = (y1 - y2) / (2.0 * h); + if !d.is_finite() || d.abs() < 1e-9 { + break; + } + let step = (resid / d).clamp(-0.3, 0.3); + a = (a - step).clamp(lo, hi); + if step.abs() < 1e-10 { + break; + } + } + a +} + +/// azimuth whose image x is `x_img`, measured with `c_ref` as center angle +pub fn alph_at_img_x( + ptype: ProjectionType, + proj: &dyn Projection, + p: &ViewParams, + x_img: f64, + c_ref: f64, +) -> f64 { + let mut p = *p; + p.a_center = c_ref; + let seed = match ptype { + ProjectionType::Rectilinear => c_ref + (x_img / p.scale).atan(), + ProjectionType::Cylindrical => c_ref + x_img / p.scale, + }; + let (lo, hi) = match ptype { + ProjectionType::Rectilinear => (c_ref - 1.55, c_ref + 1.55), + ProjectionType::Cylindrical => (c_ref - 3.1, c_ref + 3.1), + }; + newton_inverse( + x_img, + |a| Some(proj.mac_x(ProjArgs::from_params(&p, a, 0.0))), + seed, + lo, + hi, + ) +} + +const DIRS: [(f64, &str); 8] = [ + (0.0, "N"), + (45.0, "NE"), + (90.0, "E"), + (135.0, "SE"), + (180.0, "S"), + (225.0, "SW"), + (270.0, "W"), + (315.0, "NW"), +]; + +/// everything the strip needs; all plain data so Yew can diff it +#[derive(Clone, Copy, PartialEq)] +pub struct CompassData { + pub ptype: ProjectionType, + pub parms: ViewParams, + pub center_deg: f64, + pub zoom: f64, + /// screen x of the image center (strip shares the image transform) + pub cx: f64, + /// lens FOV half-angle limit, radians (0 = none) + pub max_view_angle: f64, +} + +#[derive(Properties, PartialEq)] +pub struct Props { + pub data: CompassData, + /// bumped on window resize to force a redraw + pub tick: u32, + /// new azimuth in degrees while dragging + pub on_change: Callback, +} + +#[function_component(Compass)] +pub fn compass(props: &Props) -> Html { + let canvas_ref = use_node_ref(); + let drag = use_mut_ref(|| Option::<(f64, f64)>::None); // (press x, center_deg) + + let d = props.data; + + // draw + { + let canvas_ref = canvas_ref.clone(); + use_effect_with((d, props.tick), move |(d, _tick)| { + let Some(canvas) = canvas_ref.cast::() else { + return; + }; + let Some(ctx) = bridge::ctx2d(&canvas) else { + return; + }; + let dpr = bridge::window().device_pixel_ratio(); + let w = canvas.client_width() as f64; + let bw = (w * dpr).max(1.0) as u32; + let bh = (STRIP_H * dpr).max(1.0) as u32; + if canvas.width() != bw || canvas.height() != bh { + canvas.set_width(bw); + canvas.set_height(bh); + } + let _ = ctx.set_transform(dpr, 0.0, 0.0, dpr, 0.0, 0.0); + + let on = "rgb(217, 217, 217)"; + let bg = "rgb(41, 41, 41)"; + let divider = "rgb(82, 82, 82)"; + let red = "rgb(255, 102, 64)"; + + let fill = |c: &str| { + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str(c)); + }; + let stroke = |c: &str, width: f64| { + #[allow(deprecated)] + ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str(c)); + ctx.set_line_width(width); + }; + + fill(bg); + ctx.fill_rect(0.0, 0.0, w, STRIP_H); + stroke(divider, 1.0); + ctx.begin_path(); + ctx.move_to(0.0, 0.5); + ctx.line_to(w, 0.5); + ctx.stroke(); + + let label_y = 17.0f64; // text baseline of the direction row + let y0 = (STRIP_H - 10.0).round(); // baseline of the ticks + let tri_y = 25.0f64; + let z = d.zoom; + let proj = projection_from_type(d.ptype); + let cx = d.cx; + let c = d.parms.a_center; + + let x_img_at = |alph: f64| proj.get_coordinates(alph, 0.0, &d.parms).0; + + // adaptive tick step: first that yields >= 6 px spacing + let ppd = ((x_img_at(c + 1f64.to_radians()) - x_img_at(c - 1f64.to_radians())) + * z + / 2.0) + .abs(); + let step = [1.0f64, 2.0, 5.0, 10.0, 15.0, 30.0, 45.0, 90.0] + .into_iter() + .find(|s| s * ppd >= 6.0) + .unwrap_or(90.0); + + let a_lo = alph_at_img_x(d.ptype, &*proj, &d.parms, -cx / z, c) + .min(c - std::f64::consts::PI); + let a_hi = alph_at_img_x(d.ptype, &*proj, &d.parms, (w - cx) / z, c) + .max(c + std::f64::consts::PI); + // rectilinear folds directions behind the camera onto the same + // pixels; also clamp to the lens FOV (distortion can fold + // out-of-view directions back onto the strip) + let mut fold = match d.ptype { + ProjectionType::Rectilinear => 1.535, + ProjectionType::Cylindrical => std::f64::consts::PI, + }; + if d.max_view_angle > 0.0 { + fold = fold.min(d.max_view_angle); + } + let a_lo = a_lo.max(c - fold); + let a_hi = a_hi.min(c + fold); + + // baseline + stroke(on, 1.0); + ctx.begin_path(); + ctx.move_to(0.0, y0 + 0.5); + ctx.line_to(w, y0 + 0.5); + ctx.stroke(); + + // ticks + let step_rad = step.to_radians(); + let mut a = (a_lo / step_rad).floor() * step_rad; + while a <= a_hi { + let x = cx + x_img_at(a) * z; + if x.is_finite() && x >= -1.0 && x <= w + 1.0 { + let rem = a.to_degrees().rem_euclid(45.0); + let major = rem.min(45.0 - rem) < step / 2.0; + let x = x.round(); + ctx.begin_path(); + ctx.move_to(x, y0); + ctx.line_to(x, y0 - if major { 12.0 } else { 6.0 }); + ctx.stroke(); + } + a += step_rad; + } + + // direction labels + ctx.set_font("13px system-ui, sans-serif"); + ctx.set_text_align("center"); + for (deg, name) in DIRS { + let alph = deg.to_radians(); + let rel = (alph - c + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) + - std::f64::consts::PI; + if rel.abs() > fold { + continue; + } + let x = cx + x_img_at(alph) * z; + if !x.is_finite() || x < -20.0 || x > w + 20.0 { + continue; + } + fill(if deg == 0.0 { red } else { on }); + ctx.fill_text(name, x, label_y).ok(); + } + ctx.set_text_align("start"); + + // center marker: triangle + hairline + azimuth readout + fill(red); + ctx.begin_path(); + ctx.move_to(cx - 6.0, tri_y); + ctx.line_to(cx + 6.0, tri_y); + ctx.line_to(cx, tri_y + 8.0); + ctx.close_path(); + ctx.fill(); + stroke(red, 1.0); + ctx.begin_path(); + ctx.move_to(cx.round(), tri_y + 8.0); + ctx.line_to(cx.round(), y0); + ctx.stroke(); + fill(red); + ctx.fill_text(&format!("{:05.1}°", d.center_deg.rem_euclid(360.0)), cx + 10.0, tri_y + 9.0) + .ok(); + }); + } + + let local_x = { + let canvas_ref = canvas_ref.clone(); + move |client_x: f64| { + client_x + - canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect().left()) + .unwrap_or(0.0) + } + }; + + let on_pointerdown = { + let drag = drag.clone(); + let canvas_ref = canvas_ref.clone(); + let center_deg = props.data.center_deg; + Callback::from(move |e: PointerEvent| { + e.prevent_default(); + if let Some(c) = canvas_ref.cast::() { + let _ = c.set_pointer_capture(e.pointer_id()); + } + *drag.borrow_mut() = Some((e.client_x() as f64, center_deg)); + }) + }; + let on_pointermove = { + let drag = drag.clone(); + let on_change = props.on_change.clone(); + let d = props.data; + Callback::from(move |e: PointerEvent| { + let Some((x0, c0_deg)) = *drag.borrow() else { + return; + }; + let proj = projection_from_type(d.ptype); + let c0 = c0_deg.to_radians(); + let lx0 = local_x(e.client_x() as f64); + let a0 = alph_at_img_x(d.ptype, &*proj, &d.parms, (x0 - d.cx) / d.zoom, c0); + let a1 = alph_at_img_x(d.ptype, &*proj, &d.parms, (lx0 - d.cx) / d.zoom, c0); + on_change.emit((c0 - (a1 - a0)).to_degrees()); + }) + }; + let on_pointerup = { + let drag = drag.clone(); + let canvas_ref = canvas_ref.clone(); + Callback::from(move |e: PointerEvent| { + *drag.borrow_mut() = None; + if let Some(c) = canvas_ref.cast::() { + let _ = c.release_pointer_capture(e.pointer_id()); + } + }) + }; + + html! { + + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn roundtrip(ptype: ProjectionType, k0: f64, k1: f64, x0: f64) { + let proj = projection_from_type(ptype); + let mut parms = ViewParams::new(); + parms.a_center = 0.3; + parms.scale = 3000.0; + parms.k0 = k0; + parms.k1 = k1; + parms.x0 = x0; + for x in [-2500.0, -800.0, -50.0, 0.0, 120.0, 900.0, 2400.0] { + let a = alph_at_img_x(ptype, &*proj, &parms, x, parms.a_center); + let (x2, _) = proj.get_coordinates(a, 0.0, &parms); + assert!( + (x2 - x).abs() < 1e-6, + "{ptype:?} x={x}: round-trips to {x2} (alph {a})" + ); + } + } + + #[test] + fn inverse_rectilinear() { + roundtrip(ProjectionType::Rectilinear, 0.0, 0.0, 0.0); + } + #[test] + fn inverse_rectilinear_distorted() { + roundtrip(ProjectionType::Rectilinear, 0.002, -0.0003, 0.01); + } + #[test] + fn inverse_cylindrical() { + roundtrip(ProjectionType::Cylindrical, 0.0, 0.0, 0.0); + } +} diff --git a/crates/gipfel-web/src/main.rs b/crates/gipfel-web/src/main.rs index 8a39039..741393b 100644 --- a/crates/gipfel-web/src/main.rs +++ b/crates/gipfel-web/src/main.rs @@ -1,7 +1,9 @@ mod app; mod bridge; mod canvas_view; +mod compass; mod markers; +mod widgets; fn main() { yew::Renderer::::new().render(); diff --git a/crates/gipfel-web/src/widgets.rs b/crates/gipfel-web/src/widgets.rs new file mode 100644 index 0000000..f93f424 --- /dev/null +++ b/crates/gipfel-web/src/widgets.rs @@ -0,0 +1,76 @@ +//! Small form controls: full-width slider with value readout above +//! (mirrors the desktop `slider_item` layout) and a numeric input row. + +use web_sys::HtmlInputElement; +use yew::prelude::*; + +#[derive(Properties, PartialEq)] +pub struct SliderProps { + pub label: AttrValue, + /// formatted value shown right of the label + pub display: AttrValue, + pub value: f64, + pub min: f64, + pub max: f64, + pub step: f64, + pub onchange: Callback, +} + +#[function_component(SliderItem)] +pub fn slider_item(p: &SliderProps) -> Html { + let onchange = { + let onchange = p.onchange.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + if let Ok(v) = input.value().parse::() { + onchange.emit(v); + } + }) + }; + html! { +
+
+ { p.label.as_ref().to_string() } + { p.display.as_ref().to_string() } +
+ +
+ } +} + +#[derive(Properties, PartialEq)] +pub struct NumProps { + pub label: AttrValue, + pub value: f64, + pub step: f64, + #[prop_or(2)] + pub decimals: usize, + pub onchange: Callback, +} + +#[function_component(NumItem)] +pub fn num_item(p: &NumProps) -> Html { + let onchange = { + let onchange = p.onchange.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + if let Ok(v) = input.value().parse::() { + onchange.emit(v); + } + }) + }; + let display = format!("{:.*}", p.decimals, p.value); + html! { + + } +} diff --git a/crates/gipfel-web/www/style.css b/crates/gipfel-web/www/style.css index 1e632f2..523ee2b 100644 --- a/crates/gipfel-web/www/style.css +++ b/crates/gipfel-web/www/style.css @@ -80,8 +80,14 @@ body { } .main { flex: 1; - position: relative; min-width: 0; + display: flex; + flex-direction: column; +} +.canvaswrap { + flex: 1; + position: relative; + min-height: 0; } canvas.viewport { position: absolute; @@ -92,3 +98,49 @@ canvas.viewport { touch-action: none; cursor: grab; } +canvas.compass { + display: block; + width: 100%; + touch-action: none; + cursor: ew-resize; +} +.section { + margin-top: 14px; + font-size: 11px; + text-transform: uppercase; + letter-spacing: 1px; + color: #8a8a94; + border-bottom: 1px solid #2c2c34; + padding-bottom: 3px; +} +.slider { + display: flex; + flex-direction: column; + gap: 2px; + margin-top: 8px; +} +.sliderhead { + display: flex; + justify-content: space-between; + font-size: 12px; + color: #c8c8d0; +} +.slider input[type="range"] { + width: 100%; +} +.numrow { + display: flex; + justify-content: space-between; + align-items: center; + gap: 8px; + font-size: 13px; + margin-top: 6px; +} +.numrow input { + width: 130px; + padding: 4px 6px; + background: #24242c; + color: #e8e8ea; + border: 1px solid #34343e; + border-radius: 4px; +} -- cgit v1.2.3 From 82c0414f66f4998c3d61764a1c504e06e62e7ab0 Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 12:20:55 +0100 Subject: web: Find Peak dialog, live sliders, graduated fit, load-race fix MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - click away from a dot now opens a Find Peak list (candidates within 60 px, sorted by distance, name/height/pixel-offset labels) — the desktop dialog equivalent for crowded ridgelines - sliders update on input, not on release - fit is graduated like the original: 1 marker fits the center angle, 2 add scale, 4+ the full viewpoint (removed the >=4 gate) - image load now re-fits once more 120 ms after the first paint (same nudge as the desktop app) so the picture never stays hidden --- crates/gipfel-web/Cargo.toml | 1 + crates/gipfel-web/src/app.rs | 168 +++++++++++++++++++++++++++++++++------ crates/gipfel-web/src/bridge.rs | 7 ++ crates/gipfel-web/src/markers.rs | 6 +- crates/gipfel-web/src/widgets.rs | 9 ++- crates/gipfel-web/www/style.css | 38 +++++++++ 6 files changed, 199 insertions(+), 30 deletions(-) (limited to 'crates') diff --git a/crates/gipfel-web/Cargo.toml b/crates/gipfel-web/Cargo.toml index 4cb78a7..303750a 100644 --- a/crates/gipfel-web/Cargo.toml +++ b/crates/gipfel-web/Cargo.toml @@ -31,6 +31,7 @@ features = [ "HtmlElement", "HtmlInputElement", "ImageBitmap", + "InputEvent", "MouseEvent", "PointerEvent", "Request", diff --git a/crates/gipfel-web/src/app.rs b/crates/gipfel-web/src/app.rs index 0874e9a..30704e4 100644 --- a/crates/gipfel-web/src/app.rs +++ b/crates/gipfel-web/src/app.rs @@ -50,6 +50,23 @@ impl Default for UiParams { } } +/// one entry of the Find Peak candidate list +#[derive(Clone, PartialEq)] +struct FpItem { + hill: usize, + label: String, +} + +/// open Find Peak popup: anchor (screen + image coords) and candidates +#[derive(Clone, PartialEq)] +struct FindPeak { + sx: f64, + sy: f64, + ix: f64, + iy: f64, + items: Vec, +} + fn gunzip(gz: &[u8]) -> Result, String> { let mut raw = Vec::new(); GzDecoder::new(gz) @@ -74,6 +91,7 @@ pub fn app() -> Html { let hover = use_state(|| Option::::None); let vp = use_state(UiParams::default); let img_size = use_state(|| (0u32, 0u32)); + let find_peak = use_state(|| Option::::None); // force a redraw when the window is resized so the canvas backing // store tracks its CSS size (listener lives as long as the app) @@ -143,17 +161,20 @@ pub fn app() -> Html { let fit_info = fit_info.clone(); let fit_distortion = fit_distortion.clone(); Rc::new(move |mk: &[Marker]| { + if mk.is_empty() { + fit_info.set(String::new()); + return; + } let info = { let mut p = pan.borrow_mut(); match markers::refit(&mut p, mk, *fit_distortion) { - Ok(()) if mk.len() >= 4 => format!( + Ok(()) => format!( "fit: az {:.2}° · pitch {:.2}° · roll {:.2}° · scale {:.1}", p.get_center_angle(), p.get_pitch_angle(), p.get_roll_angle(), p.get_scale() ), - Ok(()) => format!("{} markers — place at least 4 to fit", mk.len()), Err(e) => format!("fit failed: {e}"), } }; @@ -161,6 +182,19 @@ pub fn app() -> Html { }) }; + // place a marker for a hill at an image position and refit + let mark_peak = { + let markers = markers.clone(); + let do_refit = do_refit.clone(); + Callback::from(move |(idx, ix, iy): (usize, f64, f64)| { + let mut mk = (*markers).clone(); + mk.retain(|m| m.hill != idx); + mk.push(Marker { hill: idx, x: ix, y: iy }); + do_refit(&mk); + markers.set(mk); + }) + }; + // Decode selected/dropped bytes: display, read metadata, reset markers. let load_bytes = { let bitmap = bitmap.clone(); @@ -171,11 +205,13 @@ pub fn app() -> Html { let fit_info = fit_info.clone(); let vp = vp.clone(); let img_size = img_size.clone(); + let find_peak = find_peak.clone(); Callback::from(move |(bytes, name): (Vec, String)| { let (bitmap, status, fit, pan, markers, fit_info) = (bitmap.clone(), status.clone(), fit.clone(), pan.clone(), markers.clone(), fit_info.clone()); let vp = vp.clone(); let img_size = img_size.clone(); + let find_peak = find_peak.clone(); spawn_local(async move { match bridge::decode_bitmap(&bytes).await { Ok(bmp) => { @@ -208,8 +244,22 @@ pub fn app() -> Html { status.set(format!("{name} — {w}×{h} px · {vp}")); markers.set(Vec::new()); fit_info.set(String::new()); + find_peak.set(None); bitmap.set(Some(bmp)); fit.emit(MouseEvent::new("fit").unwrap()); + // same nudge as the desktop app: re-fit shortly + // after the first paint so the image is guaranteed + // to appear even if layout was not ready yet + { + let fit = fit.clone(); + spawn_local(async move { + let _ = wasm_bindgen_futures::JsFuture::from( + bridge::delay_promise(120), + ) + .await; + fit.emit(MouseEvent::new("fit").unwrap()); + }); + } } Err(e) => status.set(format!("Failed to load {name}: {e}")), } @@ -346,6 +396,48 @@ pub fn app() -> Html { }) }; + let fp_close = { + let find_peak = find_peak.clone(); + Callback::from(move |_: MouseEvent| find_peak.set(None)) + }; + + // Find Peak popup (built outside the main html! for macro simplicity) + let findpeak_popup = if let Some(fp) = &*find_peak { + let fp2 = fp.clone(); + let items: Html = fp2 + .items + .iter() + .map(|it| { + let onclick = { + let mark = mark_peak.clone(); + let find_peak = find_peak.clone(); + let (hill, ix, iy) = (it.hill, fp2.ix, fp2.iy); + Callback::from(move |_: MouseEvent| { + mark.emit((hill, ix, iy)); + find_peak.set(None); + }) + }; + html! { + + } + }) + .collect(); + html! { + <> +
+
+
{ "Find Peak" }
+ { items } +
+ + } + } else { + Html::default() + }; + let callbacks = ViewCallbacks { pan: { let view = view.clone(); @@ -371,30 +463,57 @@ pub fn app() -> Html { }, click: { let pan = pan.clone(); - let markers = markers.clone(); let view = view.clone(); let status = status.clone(); - let do_refit = do_refit.clone(); + let mark = mark_peak.clone(); + let find_peak = find_peak.clone(); + let img_size = img_size.clone(); Callback::from(move |(ix, iy): (f64, f64)| { - let p = pan.borrow_mut(); - match markers::nearest_hill(&p, ix, iy, 20.0 / view.scale) { - None => status.set( - "No peak near click — click on a green dot (zoom in to separate them)." - .to_string(), - ), - Some(idx) => { - let mut mk = (*markers).clone(); - mk.retain(|m| m.hill != idx); - mk.push(Marker { - hill: idx, - x: ix, - y: iy, - }); - drop(p); - do_refit(&mk); - markers.set(mk); - } + let scale = view.scale; + let p = pan.borrow(); + // unambiguous click right on a peak: mark directly + if let Some(idx) = markers::nearest_hill(&p, ix, iy, 10.0 / scale) { + drop(p); + find_peak.set(None); + mark.emit((idx, ix, iy)); + return; + } + // otherwise offer a Find Peak list, like the desktop dialog + let r = 60.0 / scale; + let mut cands: Vec<(f64, usize)> = p + .visible + .iter() + .map(|&i| ((p.hills[i].x - ix).hypot(p.hills[i].y - iy), i)) + .filter(|(d, _)| *d <= r) + .collect(); + if cands.is_empty() { + drop(p); + status.set("No peaks near click — zoom in or adjust the view.".to_string()); + find_peak.set(None); + return; } + cands.sort_by(|a, b| a.0.total_cmp(&b.0)); + cands.truncate(15); + let items: Vec = cands + .iter() + .map(|(d, i)| FpItem { + hill: *i, + label: format!( + "{} · {:.0} m · {:.0} px", + p.hills[*i].name, + p.hills[*i].height, + d * scale + ), + }) + .collect(); + let (w, h) = (img_size.0 as f64, img_size.1 as f64); + find_peak.set(Some(FindPeak { + sx: (ix + w / 2.0) * scale + view.ox, + sy: (iy + h / 2.0) * scale + view.oy, + ix, + iy, + items, + })); }) }, marker_drag: { @@ -525,10 +644,10 @@ pub fn app() -> Html { }

- { "Hover a green dot to see the peak · click to mark it · drag to adjust · right-click to remove." } + { "Hover a dot to see the peak · click to mark it (or pick from the list) · drag to adjust · right-click to remove." }

- { "The view is fitted automatically once 4+ markers are placed." } + { "The view is fitted as soon as markers are placed; more markers improve the fit." }

@@ -543,6 +662,7 @@ pub fn app() -> Html { candidates={candidates} label_font={vp.label_font} /> + { findpeak_popup.clone() }
if bitmap.is_some() { diff --git a/crates/gipfel-web/src/bridge.rs b/crates/gipfel-web/src/bridge.rs index a60b1f6..6dbba93 100644 --- a/crates/gipfel-web/src/bridge.rs +++ b/crates/gipfel-web/src/bridge.rs @@ -53,6 +53,13 @@ pub async fn fetch_bytes(url: &str) -> Result, String> { Ok(Uint8Array::new(&buf).to_vec()) } +/// setTimeout as an awaitable Promise. +pub fn delay_promise(ms: i32) -> js_sys::Promise { + js_sys::Promise::new(&mut |resolve, _reject| { + let _ = window().set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms); + }) +} + pub fn ctx2d(canvas: &HtmlCanvasElement) -> Option { canvas .get_context("2d") diff --git a/crates/gipfel-web/src/markers.rs b/crates/gipfel-web/src/markers.rs index 279c62c..d1bf8cb 100644 --- a/crates/gipfel-web/src/markers.rs +++ b/crates/gipfel-web/src/markers.rs @@ -15,9 +15,11 @@ pub struct Marker { } /// Refit the projection parameters to the current markers. -/// With fewer than 4 markers nothing can be fitted (same rule as desktop). +/// Same graduated behavior as the original: 1 marker fits the center +/// angle, 2 add the scale, 4+ the full viewpoint (+ distortion when +/// unlocked and enough markers). pub fn refit(pan: &mut Panorama, markers: &[Marker], fit_distortion: bool) -> Result<(), String> { - if markers.len() < 4 { + if markers.is_empty() { return Ok(()); } let mut obs: Vec = Vec::with_capacity(markers.len()); diff --git a/crates/gipfel-web/src/widgets.rs b/crates/gipfel-web/src/widgets.rs index f93f424..1d22bac 100644 --- a/crates/gipfel-web/src/widgets.rs +++ b/crates/gipfel-web/src/widgets.rs @@ -1,7 +1,7 @@ //! Small form controls: full-width slider with value readout above //! (mirrors the desktop `slider_item` layout) and a numeric input row. -use web_sys::HtmlInputElement; +use web_sys::{HtmlInputElement, InputEvent}; use yew::prelude::*; #[derive(Properties, PartialEq)] @@ -18,9 +18,10 @@ pub struct SliderProps { #[function_component(SliderItem)] pub fn slider_item(p: &SliderProps) -> Html { - let onchange = { + // live update while dragging (oninput), not only on release + let oninput = { let onchange = p.onchange.clone(); - Callback::from(move |e: Event| { + Callback::from(move |e: InputEvent| { let input: HtmlInputElement = e.target_unchecked_into(); if let Ok(v) = input.value().parse::() { onchange.emit(v); @@ -39,7 +40,7 @@ pub fn slider_item(p: &SliderProps) -> Html { max={p.max.to_string()} step={p.step.to_string()} value={p.value.to_string()} - {onchange} + {oninput} /> } diff --git a/crates/gipfel-web/www/style.css b/crates/gipfel-web/www/style.css index 523ee2b..9e7e8a0 100644 --- a/crates/gipfel-web/www/style.css +++ b/crates/gipfel-web/www/style.css @@ -144,3 +144,41 @@ canvas.compass { border: 1px solid #34343e; border-radius: 4px; } +.fpbackdrop { + position: absolute; + inset: 0; + z-index: 9; +} +.findpeak { + position: absolute; + z-index: 10; + background: #1e1e26; + border: 1px solid #3a3a46; + border-radius: 6px; + box-shadow: 0 8px 24px rgba(0, 0, 0, 0.5); + max-height: 320px; + overflow-y: auto; + min-width: 220px; +} +.fphead { + padding: 6px 10px; + font-size: 11px; + text-transform: uppercase; + letter-spacing: 1px; + color: #8a8a94; + border-bottom: 1px solid #2c2c34; +} +.fpitem { + display: block; + width: 100%; + text-align: left; + padding: 6px 10px; + background: none; + border: 0; + color: #e8e8ea; + font-size: 13px; + cursor: pointer; +} +.fpitem:hover { + background: #2f6fd4; +} -- cgit v1.2.3 From 8431ea2ac57d64a98ac79e302934c3edf9bf3e55 Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 12:29:43 +0100 Subject: web: Find Peak becomes a searchable picker over the close-hill list MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Distance-ranked candidates are useless while the initial viewpoint is still rough — the true peak may project far from the click. Mirrors the desktop dialog instead: click opens a search box over pan.close (geographically near hills, dedup/track filtered), name-substring filter, sorted, capped at 300 entries, 'Name (1234 m)' labels, autofocused search, Cancel button. Selection marks the clicked position with the chosen hill, whatever its current projection. --- crates/gipfel-web/src/app.rs | 204 ++++++++++++++++++++++++++-------------- crates/gipfel-web/www/style.css | 39 +++++++- 2 files changed, 170 insertions(+), 73 deletions(-) (limited to 'crates') diff --git a/crates/gipfel-web/src/app.rs b/crates/gipfel-web/src/app.rs index 30704e4..23126e9 100644 --- a/crates/gipfel-web/src/app.rs +++ b/crates/gipfel-web/src/app.rs @@ -5,12 +5,13 @@ use std::io::Read; use std::rc::Rc; use flate2::read::GzDecoder; +use gipfel_core::hill::{FLAG_DUPLIC, FLAG_TRACK_POINT}; use gipfel_core::metadata::{apply_image_metadata, ImageMetaData}; use gipfel_core::panorama::Panorama; use wasm_bindgen::closure::Closure; use wasm_bindgen::JsCast; use wasm_bindgen_futures::spawn_local; -use web_sys::{DragEvent, Event, HtmlCanvasElement, HtmlInputElement, MouseEvent}; +use web_sys::{DragEvent, Event, HtmlCanvasElement, HtmlInputElement, InputEvent, MouseEvent}; use yew::prelude::*; use crate::bridge; @@ -50,21 +51,14 @@ impl Default for UiParams { } } -/// one entry of the Find Peak candidate list -#[derive(Clone, PartialEq)] -struct FpItem { - hill: usize, - label: String, -} - -/// open Find Peak popup: anchor (screen + image coords) and candidates +/// open Find Peak popup: anchor (screen + image coords) and search query #[derive(Clone, PartialEq)] struct FindPeak { sx: f64, sy: f64, ix: f64, iy: f64, - items: Vec, + query: String, } fn gunzip(gz: &[u8]) -> Result, String> { @@ -75,6 +69,81 @@ fn gunzip(gz: &[u8]) -> Result, String> { .map_err(|e| format!("gunzip: {e}")) } +#[derive(Properties, PartialEq)] +struct FpProps { + fp: FindPeak, + items: Vec<(String, usize)>, + on_pick: Callback, + on_query: Callback, + on_close: Callback<()>, +} + +/// searchable Find Peak dialog: type to filter, click to select +#[function_component(FindPeakPanel)] +fn find_peak_panel(p: &FpProps) -> Html { + let input_ref = use_node_ref(); + // focus the search box when the dialog opens + { + let input_ref = input_ref.clone(); + use_effect_with((), move |_| { + if let Some(i) = input_ref.cast::() { + let _ = i.focus(); + } + }); + } + let on_query = { + let on_query = p.on_query.clone(); + Callback::from(move |e: InputEvent| { + let input: HtmlInputElement = e.target_unchecked_into(); + on_query.emit(input.value()); + }) + }; + let on_close = { + let on_close = p.on_close.clone(); + Callback::from(move |_: MouseEvent| on_close.emit(())) + }; + html! { + <> +
+
+
{ "Find Peak" }
+
+ +
+
+ { + for p.items.iter().map(|(label, idx)| { + let onclick = { + let on_pick = p.on_pick.clone(); + let i = *idx; + Callback::from(move |_: MouseEvent| on_pick.emit(i)) + }; + html! { + + } + }) + } + if p.items.is_empty() { +

{ "no matches" }

+ } +
+
+ +
+
+ + } +} + #[function_component(App)] pub fn app() -> Html { let bitmap = use_state(|| None::); @@ -398,41 +467,60 @@ pub fn app() -> Html { let fp_close = { let find_peak = find_peak.clone(); - Callback::from(move |_: MouseEvent| find_peak.set(None)) + Callback::from(move |_: ()| find_peak.set(None)) }; - // Find Peak popup (built outside the main html! for macro simplicity) + // Find Peak picker: searchable list over the geographically close hills + // (same candidate set and filtering as the desktop dialog) let findpeak_popup = if let Some(fp) = &*find_peak { - let fp2 = fp.clone(); - let items: Html = fp2 - .items - .iter() - .map(|it| { - let onclick = { - let mark = mark_peak.clone(); - let find_peak = find_peak.clone(); - let (hill, ix, iy) = (it.hill, fp2.ix, fp2.iy); - Callback::from(move |_: MouseEvent| { - mark.emit((hill, ix, iy)); - find_peak.set(None); - }) - }; - html! { - + let items: Vec<(String, usize)> = { + let p = pan.borrow(); + let q = fp.query.to_uppercase(); + let mut entries: Vec<(String, usize)> = p + .close + .iter() + .filter(|&&i| { + let h = &p.hills[i]; + h.flags & (FLAG_DUPLIC | FLAG_TRACK_POINT) == 0 + && (q.is_empty() || h.name.to_uppercase().contains(&q)) + }) + .map(|&i| { + ( + format!("{} ({} m)", p.hills[i].name, p.hills[i].height as i64), + i, + ) + }) + .collect(); + entries.sort_by(|a, b| a.0.cmp(&b.0)); + entries.truncate(300); + entries + }; + let on_pick = { + let mark = mark_peak.clone(); + let find_peak = find_peak.clone(); + let (ix, iy) = (fp.ix, fp.iy); + Callback::from(move |hill: usize| { + mark.emit((hill, ix, iy)); + find_peak.set(None); + }) + }; + let on_query = { + let find_peak = find_peak.clone(); + Callback::from(move |q: String| { + if let Some(mut fp) = (*find_peak).clone() { + fp.query = q; + find_peak.set(Some(fp)); } }) - .collect(); + }; html! { - <> -
-
-
{ "Find Peak" }
- { items } -
- + } } else { Html::default() @@ -464,55 +552,27 @@ pub fn app() -> Html { click: { let pan = pan.clone(); let view = view.clone(); - let status = status.clone(); let mark = mark_peak.clone(); let find_peak = find_peak.clone(); let img_size = img_size.clone(); Callback::from(move |(ix, iy): (f64, f64)| { let scale = view.scale; - let p = pan.borrow(); // unambiguous click right on a peak: mark directly - if let Some(idx) = markers::nearest_hill(&p, ix, iy, 10.0 / scale) { - drop(p); + if let Some(idx) = markers::nearest_hill(&pan.borrow(), ix, iy, 10.0 / scale) { find_peak.set(None); mark.emit((idx, ix, iy)); return; } - // otherwise offer a Find Peak list, like the desktop dialog - let r = 60.0 / scale; - let mut cands: Vec<(f64, usize)> = p - .visible - .iter() - .map(|&i| ((p.hills[i].x - ix).hypot(p.hills[i].y - iy), i)) - .filter(|(d, _)| *d <= r) - .collect(); - if cands.is_empty() { - drop(p); - status.set("No peaks near click — zoom in or adjust the view.".to_string()); - find_peak.set(None); - return; - } - cands.sort_by(|a, b| a.0.total_cmp(&b.0)); - cands.truncate(15); - let items: Vec = cands - .iter() - .map(|(d, i)| FpItem { - hill: *i, - label: format!( - "{} · {:.0} m · {:.0} px", - p.hills[*i].name, - p.hills[*i].height, - d * scale - ), - }) - .collect(); + // otherwise open the Find Peak picker (searchable, like the + // desktop dialog): the correct peak may project far away + // while the viewpoint is still rough let (w, h) = (img_size.0 as f64, img_size.1 as f64); find_peak.set(Some(FindPeak { sx: (ix + w / 2.0) * scale + view.ox, sy: (iy + h / 2.0) * scale + view.oy, ix, iy, - items, + query: String::new(), })); }) }, diff --git a/crates/gipfel-web/www/style.css b/crates/gipfel-web/www/style.css index 9e7e8a0..5122c43 100644 --- a/crates/gipfel-web/www/style.css +++ b/crates/gipfel-web/www/style.css @@ -152,13 +152,50 @@ canvas.compass { .findpeak { position: absolute; z-index: 10; + width: 280px; background: #1e1e26; border: 1px solid #3a3a46; border-radius: 6px; box-shadow: 0 8px 24px rgba(0, 0, 0, 0.5); + display: flex; + flex-direction: column; +} +.fpsearch { + padding: 8px; + border-bottom: 1px solid #2c2c34; +} +.fpsearch input { + width: 100%; + padding: 5px 8px; + background: #24242c; + border: 1px solid #3a3a46; + border-radius: 4px; + color: #e8e8ea; + font-size: 13px; +} +.fplist { max-height: 320px; overflow-y: auto; - min-width: 220px; +} +.fpempty { + padding: 8px 10px; + font-size: 13px; + color: #8a8a94; + margin: 0; +} +.fpfoot { + padding: 6px 8px; + border-top: 1px solid #2c2c34; + text-align: right; +} +.fpcancel { + padding: 4px 12px; + background: #34343e; + color: #e8e8ea; + border: 0; + border-radius: 4px; + font-size: 12px; + cursor: pointer; } .fphead { padding: 6px 10px; -- cgit v1.2.3 From a436af8b35dacde89ec97e18134b02acf52f159c Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 12:35:11 +0100 Subject: web: fix RefCell double-borrow panic in click fast path `if let Some(idx) = nearest_hill(&pan.borrow(), ...)` keeps the immutable borrow alive through the whole if-let block (temporary lifetime in the scrutinee). Marking a peak from that path called do_refit -> borrow_mut() -> panic, which aborted the wasm instance and froze all further interaction (no marker removal, no drag refit). Scope the borrow to its own block. --- crates/gipfel-web/src/app.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) (limited to 'crates') diff --git a/crates/gipfel-web/src/app.rs b/crates/gipfel-web/src/app.rs index 23126e9..e4fd435 100644 --- a/crates/gipfel-web/src/app.rs +++ b/crates/gipfel-web/src/app.rs @@ -558,7 +558,12 @@ pub fn app() -> Html { Callback::from(move |(ix, iy): (f64, f64)| { let scale = view.scale; // unambiguous click right on a peak: mark directly - if let Some(idx) = markers::nearest_hill(&pan.borrow(), ix, iy, 10.0 / scale) { + // (borrow must be released before mark -> do_refit!) + let near = { + let p = pan.borrow(); + markers::nearest_hill(&p, ix, iy, 10.0 / scale) + }; + if let Some(idx) = near { find_peak.set(None); mark.emit((idx, ix, iy)); return; -- cgit v1.2.3 From 0b85e7989eacb26d3496cdb98ed3221868a4013f Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 13:41:53 +0100 Subject: web: hidden-peak heuristics in the UI with Show-hidden toggle MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The core already ran both visibility heuristics (height/distance threshold via the Visibility slider, occlusion via mark_hidden with the cone-visibility slope test) — the web UI just ignored FLAG_HIDDEN. - guide dots: hidden peaks are filtered out by default; with the new Display > Show hidden peaks toggle they appear grey instead of green - hover and click hit-testing skip hidden peaks unless the toggle is on - Find Peak picker is unchanged (it lists pan.close, which always includes hidden peaks — same as desktop) --- crates/gipfel-web/src/app.rs | 41 +++++++++++++++++++++++++++++------- crates/gipfel-web/src/canvas_view.rs | 17 +++++++++------ crates/gipfel-web/src/markers.rs | 14 ++++++++++-- 3 files changed, 55 insertions(+), 17 deletions(-) (limited to 'crates') diff --git a/crates/gipfel-web/src/app.rs b/crates/gipfel-web/src/app.rs index e4fd435..f4b0de4 100644 --- a/crates/gipfel-web/src/app.rs +++ b/crates/gipfel-web/src/app.rs @@ -5,7 +5,7 @@ use std::io::Read; use std::rc::Rc; use flate2::read::GzDecoder; -use gipfel_core::hill::{FLAG_DUPLIC, FLAG_TRACK_POINT}; +use gipfel_core::hill::{FLAG_DUPLIC, FLAG_HIDDEN, FLAG_TRACK_POINT}; use gipfel_core::metadata::{apply_image_metadata, ImageMetaData}; use gipfel_core::panorama::Panorama; use wasm_bindgen::closure::Closure; @@ -161,6 +161,7 @@ pub fn app() -> Html { let vp = use_state(UiParams::default); let img_size = use_state(|| (0u32, 0u32)); let find_peak = use_state(|| Option::::None); + let show_hidden = use_state(|| false); // force a redraw when the window is resized so the canvas backing // store tracks its CSS size (listener lives as long as the app) @@ -441,6 +442,13 @@ pub fn app() -> Html { vp.set(u); }) }; + let on_show_hidden = { + let show_hidden = show_hidden.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + show_hidden.set(input.checked()); + }) + }; // compass strip: shares the image transform, drag changes azimuth let compass_data = { @@ -555,13 +563,14 @@ pub fn app() -> Html { let mark = mark_peak.clone(); let find_peak = find_peak.clone(); let img_size = img_size.clone(); + let show_hidden = show_hidden.clone(); Callback::from(move |(ix, iy): (f64, f64)| { let scale = view.scale; // unambiguous click right on a peak: mark directly // (borrow must be released before mark -> do_refit!) let near = { let p = pan.borrow(); - markers::nearest_hill(&p, ix, iy, 10.0 / scale) + markers::nearest_hill(&p, ix, iy, 10.0 / scale, *show_hidden) }; if let Some(idx) = near { find_peak.set(None); @@ -620,12 +629,14 @@ pub fn app() -> Html { let pan = pan.clone(); let view = view.clone(); let hover = hover.clone(); + let show_hidden = show_hidden.clone(); Callback::from(move |(ix, iy): (f64, f64)| { let p = pan.borrow(); - let name = markers::nearest_hill(&p, ix, iy, 20.0 / view.scale).map(|i| { - let h = &p.hills[i]; - format!("{} · {:.0} m", h.name, h.height) - }); + let name = markers::nearest_hill(&p, ix, iy, 20.0 / view.scale, *show_hidden) + .map(|i| { + let h = &p.hills[i]; + format!("{} · {:.0} m", h.name, h.height) + }); hover.set(name); }) }, @@ -647,9 +658,19 @@ pub fn app() -> Html { }) .collect() }; - let candidates: Vec<(f64, f64)> = { + let candidates: Vec<(f64, f64, bool)> = { let p = pan.borrow(); - p.visible.iter().map(|&i| (p.hills[i].x, p.hills[i].y)).collect() + p.visible + .iter() + .filter(|&&i| *show_hidden || p.hills[i].flags & FLAG_HIDDEN == 0) + .map(|&i| { + ( + p.hills[i].x, + p.hills[i].y, + p.hills[i].flags & FLAG_HIDDEN != 0, + ) + }) + .collect() }; let zoom_pct = (view.scale * 100.0).round(); @@ -695,6 +716,10 @@ pub fn app() -> Html { { "Fit distortion (needs ≥ 4 markers)" }
{ "Display" }
+ , - /// projected positions of all visible hills (small guide dots) - pub candidates: Vec<(f64, f64)>, + /// projected positions of all visible hills (guide dots) with their + /// hidden-by-occlusion flag + pub candidates: Vec<(f64, f64, bool)>, /// marker label font size, screen px pub label_font: f32, } @@ -131,10 +132,11 @@ pub fn canvas_view(props: &Props) -> Html { let sy = |y: f64| (y + hh) * view.scale + view.oy; // guide dots for all visible peaks: dark outline ring + - // bright core so they stay visible on any photo content + // bright core so they stay visible on any photo content; + // peaks hidden by nearer terrain are drawn grey #[allow(deprecated)] ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.85)")); - for (cx, cy) in candidates { + for (cx, cy, _hidden) in candidates { let (px, py) = (sx(*cx), sy(*cy)); if px < -6.0 || py < -6.0 || px > cw + 6.0 || py > ch + 6.0 { continue; @@ -143,13 +145,14 @@ pub fn canvas_view(props: &Props) -> Html { let _ = ctx.arc(px, py, 4.5, 0.0, std::f64::consts::TAU); ctx.fill(); } - #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgb(110, 231, 183)")); - for (cx, cy) in candidates { + for (cx, cy, hidden) in candidates { let (px, py) = (sx(*cx), sy(*cy)); if px < -6.0 || py < -6.0 || px > cw + 6.0 || py > ch + 6.0 { continue; } + let color = if *hidden { "rgb(150, 150, 150)" } else { "rgb(110, 231, 183)" }; + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str(color)); ctx.begin_path(); let _ = ctx.arc(px, py, 2.5, 0.0, std::f64::consts::TAU); ctx.fill(); diff --git a/crates/gipfel-web/src/markers.rs b/crates/gipfel-web/src/markers.rs index d1bf8cb..d024f2e 100644 --- a/crates/gipfel-web/src/markers.rs +++ b/crates/gipfel-web/src/markers.rs @@ -34,11 +34,21 @@ pub fn refit(pan: &mut Panorama, markers: &[Marker], fit_distortion: bool) -> Re } /// Nearest visible hill to image position `(x, y)`, within `max_dist` -/// image pixels. Used to resolve marker clicks. -pub fn nearest_hill(pan: &Panorama, x: f64, y: f64, max_dist: f64) -> Option { +/// image pixels. Used to resolve marker clicks. Hills hidden by the +/// occlusion heuristic are skipped unless `show_hidden`. +pub fn nearest_hill( + pan: &Panorama, + x: f64, + y: f64, + max_dist: f64, + show_hidden: bool, +) -> Option { let mut best = None; let mut best_d = max_dist; for &i in &pan.visible { + if !show_hidden && pan.hills[i].flags & gipfel_core::hill::FLAG_HIDDEN != 0 { + continue; + } let h = &pan.hills[i]; let d = (h.x - x).hypot(h.y - y); if d < best_d { -- cgit v1.2.3 From f6883fa1d586a040bf228ab886b95ca64457fa34 Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 13:55:35 +0100 Subject: Rename web front end to wipfel MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 'gipfel web' is taken by an existing related project. The browser app is now wipfel — web based gipfel photogrammetry for mountain images: crate gipfel-web -> wipfel, updated titles, docs, plan and dev script. The shared engine crate stays gipfel-core. --- COPYING | 674 +++++++++++++++++++++++++++++++ Cargo.lock | 26 +- Cargo.toml | 2 +- INSTALL | 368 +++++++++++++++++ crates/gipfel-web/Cargo.toml | 42 -- crates/gipfel-web/README.md | 47 --- crates/gipfel-web/index.html | 11 - crates/gipfel-web/serve-here.sh | 12 - crates/gipfel-web/src/app.rs | 763 ----------------------------------- crates/gipfel-web/src/bridge.rs | 69 ---- crates/gipfel-web/src/canvas_view.rs | 481 ---------------------- crates/gipfel-web/src/compass.rs | 349 ---------------- crates/gipfel-web/src/main.rs | 10 - crates/gipfel-web/src/markers.rs | 60 --- crates/gipfel-web/src/widgets.rs | 77 ---- crates/gipfel-web/www/style.css | 221 ---------- crates/wipfel/Cargo.toml | 42 ++ crates/wipfel/README.md | 47 +++ crates/wipfel/index.html | 11 + crates/wipfel/serve-here.sh | 12 + crates/wipfel/src/app.rs | 763 +++++++++++++++++++++++++++++++++++ crates/wipfel/src/bridge.rs | 69 ++++ crates/wipfel/src/canvas_view.rs | 481 ++++++++++++++++++++++ crates/wipfel/src/compass.rs | 349 ++++++++++++++++ crates/wipfel/src/main.rs | 10 + crates/wipfel/src/markers.rs | 60 +++ crates/wipfel/src/widgets.rs | 77 ++++ crates/wipfel/www/style.css | 221 ++++++++++ plan.md | 371 +++++++++++++++++ wasm-plan.md | 10 +- 30 files changed, 3574 insertions(+), 2161 deletions(-) create mode 100644 COPYING create mode 100644 INSTALL delete mode 100644 crates/gipfel-web/Cargo.toml delete mode 100644 crates/gipfel-web/README.md delete mode 100644 crates/gipfel-web/index.html delete mode 100755 crates/gipfel-web/serve-here.sh delete mode 100644 crates/gipfel-web/src/app.rs delete mode 100644 crates/gipfel-web/src/bridge.rs delete mode 100644 crates/gipfel-web/src/canvas_view.rs delete mode 100644 crates/gipfel-web/src/compass.rs delete mode 100644 crates/gipfel-web/src/main.rs delete mode 100644 crates/gipfel-web/src/markers.rs delete mode 100644 crates/gipfel-web/src/widgets.rs delete mode 100644 crates/gipfel-web/www/style.css create mode 100644 crates/wipfel/Cargo.toml create mode 100644 crates/wipfel/README.md create mode 100644 crates/wipfel/index.html create mode 100755 crates/wipfel/serve-here.sh create mode 100644 crates/wipfel/src/app.rs create mode 100644 crates/wipfel/src/bridge.rs create mode 100644 crates/wipfel/src/canvas_view.rs create mode 100644 crates/wipfel/src/compass.rs create mode 100644 crates/wipfel/src/main.rs create mode 100644 crates/wipfel/src/markers.rs create mode 100644 crates/wipfel/src/widgets.rs create mode 100644 crates/wipfel/www/style.css create mode 100644 plan.md (limited to 'crates') diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..f288702 --- /dev/null +++ b/COPYING @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/Cargo.lock b/Cargo.lock index 829f24f..0be6ad5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1815,19 +1815,6 @@ dependencies = [ "wasm-bindgen", ] -[[package]] -name = "gipfel-web" -version = "0.5.5" -dependencies = [ - "flate2", - "gipfel-core", - "js-sys", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", - "yew", -] - [[package]] name = "gl_generator" version = "0.14.0" @@ -6672,6 +6659,19 @@ dependencies = [ "memchr", ] +[[package]] +name = "wipfel" +version = "0.5.5" +dependencies = [ + "flate2", + "gipfel-core", + "js-sys", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "yew", +] + [[package]] name = "wit-bindgen" version = "0.57.1" diff --git a/Cargo.toml b/Cargo.toml index 5de748e..196bcda 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [workspace] resolver = "2" -members = ["crates/gipfel-core", "crates/gipfel-cli", "crates/gipfel-app", "crates/gipfel-wasm", "crates/gipfel-web"] +members = ["crates/gipfel-core", "crates/gipfel-cli", "crates/gipfel-app", "crates/gipfel-wasm", "crates/wipfel"] # Single source of truth for metadata inherited by every crate via # `version.workspace = true` etc. Bump `version` here on release; the diff --git a/INSTALL b/INSTALL new file mode 100644 index 0000000..e82fd21 --- /dev/null +++ b/INSTALL @@ -0,0 +1,368 @@ +Installation Instructions +************************* + + Copyright (C) 1994-1996, 1999-2002, 2004-2017, 2020-2021 Free +Software Foundation, Inc. + + Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. This file is offered as-is, +without warranty of any kind. + +Basic Installation +================== + + Briefly, the shell command './configure && make && make install' +should configure, build, and install this package. The following +more-detailed instructions are generic; see the 'README' file for +instructions specific to this package. Some packages provide this +'INSTALL' file but do not implement all of the features documented +below. The lack of an optional feature in a given package is not +necessarily a bug. More recommendations for GNU packages can be found +in *note Makefile Conventions: (standards)Makefile Conventions. + + The 'configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation. It uses +those values to create a 'Makefile' in each directory of the package. +It may also create one or more '.h' files containing system-dependent +definitions. Finally, it creates a shell script 'config.status' that +you can run in the future to recreate the current configuration, and a +file 'config.log' containing compiler output (useful mainly for +debugging 'configure'). + + It can also use an optional file (typically called 'config.cache' and +enabled with '--cache-file=config.cache' or simply '-C') that saves the +results of its tests to speed up reconfiguring. Caching is disabled by +default to prevent problems with accidental use of stale cache files. + + If you need to do unusual things to compile the package, please try +to figure out how 'configure' could check whether to do them, and mail +diffs or instructions to the address given in the 'README' so they can +be considered for the next release. If you are using the cache, and at +some point 'config.cache' contains results you don't want to keep, you +may remove or edit it. + + The file 'configure.ac' (or 'configure.in') is used to create +'configure' by a program called 'autoconf'. You need 'configure.ac' if +you want to change it or regenerate 'configure' using a newer version of +'autoconf'. + + The simplest way to compile this package is: + + 1. 'cd' to the directory containing the package's source code and type + './configure' to configure the package for your system. + + Running 'configure' might take a while. While running, it prints + some messages telling which features it is checking for. + + 2. Type 'make' to compile the package. + + 3. Optionally, type 'make check' to run any self-tests that come with + the package, generally using the just-built uninstalled binaries. + + 4. Type 'make install' to install the programs and any data files and + documentation. When installing into a prefix owned by root, it is + recommended that the package be configured and built as a regular + user, and only the 'make install' phase executed with root + privileges. + + 5. Optionally, type 'make installcheck' to repeat any self-tests, but + this time using the binaries in their final installed location. + This target does not install anything. Running this target as a + regular user, particularly if the prior 'make install' required + root privileges, verifies that the installation completed + correctly. + + 6. You can remove the program binaries and object files from the + source code directory by typing 'make clean'. To also remove the + files that 'configure' created (so you can compile the package for + a different kind of computer), type 'make distclean'. There is + also a 'make maintainer-clean' target, but that is intended mainly + for the package's developers. If you use it, you may have to get + all sorts of other programs in order to regenerate files that came + with the distribution. + + 7. Often, you can also type 'make uninstall' to remove the installed + files again. In practice, not all packages have tested that + uninstallation works correctly, even though it is required by the + GNU Coding Standards. + + 8. Some packages, particularly those that use Automake, provide 'make + distcheck', which can by used by developers to test that all other + targets like 'make install' and 'make uninstall' work correctly. + This target is generally not run by end users. + +Compilers and Options +===================== + + Some systems require unusual options for compilation or linking that +the 'configure' script does not know about. Run './configure --help' +for details on some of the pertinent environment variables. + + You can give 'configure' initial values for configuration parameters +by setting variables in the command line or in the environment. Here is +an example: + + ./configure CC=c99 CFLAGS=-g LIBS=-lposix + + *Note Defining Variables::, for more details. + +Compiling For Multiple Architectures +==================================== + + You can compile the package for more than one kind of computer at the +same time, by placing the object files for each architecture in their +own directory. To do this, you can use GNU 'make'. 'cd' to the +directory where you want the object files and executables to go and run +the 'configure' script. 'configure' automatically checks for the source +code in the directory that 'configure' is in and in '..'. This is known +as a "VPATH" build. + + With a non-GNU 'make', it is safer to compile the package for one +architecture at a time in the source code directory. After you have +installed the package for one architecture, use 'make distclean' before +reconfiguring for another architecture. + + On MacOS X 10.5 and later systems, you can create libraries and +executables that work on multiple system types--known as "fat" or +"universal" binaries--by specifying multiple '-arch' options to the +compiler but only a single '-arch' option to the preprocessor. Like +this: + + ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ + CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ + CPP="gcc -E" CXXCPP="g++ -E" + + This is not guaranteed to produce working output in all cases, you +may have to build one architecture at a time and combine the results +using the 'lipo' tool if you have problems. + +Installation Names +================== + + By default, 'make install' installs the package's commands under +'/usr/local/bin', include files under '/usr/local/include', etc. You +can specify an installation prefix other than '/usr/local' by giving +'configure' the option '--prefix=PREFIX', where PREFIX must be an +absolute file name. + + You can specify separate installation prefixes for +architecture-specific files and architecture-independent files. If you +pass the option '--exec-prefix=PREFIX' to 'configure', the package uses +PREFIX as the prefix for installing programs and libraries. +Documentation and other data files still use the regular prefix. + + In addition, if you use an unusual directory layout you can give +options like '--bindir=DIR' to specify different values for particular +kinds of files. Run 'configure --help' for a list of the directories +you can set and what kinds of files go in them. In general, the default +for these options is expressed in terms of '${prefix}', so that +specifying just '--prefix' will affect all of the other directory +specifications that were not explicitly provided. + + The most portable way to affect installation locations is to pass the +correct locations to 'configure'; however, many packages provide one or +both of the following shortcuts of passing variable assignments to the +'make install' command line to change installation locations without +having to reconfigure or recompile. + + The first method involves providing an override variable for each +affected directory. For example, 'make install +prefix=/alternate/directory' will choose an alternate location for all +directory configuration variables that were expressed in terms of +'${prefix}'. Any directories that were specified during 'configure', +but not in terms of '${prefix}', must each be overridden at install time +for the entire installation to be relocated. The approach of makefile +variable overrides for each directory variable is required by the GNU +Coding Standards, and ideally causes no recompilation. However, some +platforms have known limitations with the semantics of shared libraries +that end up requiring recompilation when using this method, particularly +noticeable in packages that use GNU Libtool. + + The second method involves providing the 'DESTDIR' variable. For +example, 'make install DESTDIR=/alternate/directory' will prepend +'/alternate/directory' before all installation names. The approach of +'DESTDIR' overrides is not required by the GNU Coding Standards, and +does not work on platforms that have drive letters. On the other hand, +it does better at avoiding recompilation issues, and works well even +when some directory options were not specified in terms of '${prefix}' +at 'configure' time. + +Optional Features +================= + + If the package supports it, you can cause programs to be installed +with an extra prefix or suffix on their names by giving 'configure' the +option '--program-prefix=PREFIX' or '--program-suffix=SUFFIX'. + + Some packages pay attention to '--enable-FEATURE' options to +'configure', where FEATURE indicates an optional part of the package. +They may also pay attention to '--with-PACKAGE' options, where PACKAGE +is something like 'gnu-as' or 'x' (for the X Window System). The +'README' should mention any '--enable-' and '--with-' options that the +package recognizes. + + For packages that use the X Window System, 'configure' can usually +find the X include and library files automatically, but if it doesn't, +you can use the 'configure' options '--x-includes=DIR' and +'--x-libraries=DIR' to specify their locations. + + Some packages offer the ability to configure how verbose the +execution of 'make' will be. For these packages, running './configure +--enable-silent-rules' sets the default to minimal output, which can be +overridden with 'make V=1'; while running './configure +--disable-silent-rules' sets the default to verbose, which can be +overridden with 'make V=0'. + +Particular systems +================== + + On HP-UX, the default C compiler is not ANSI C compatible. If GNU CC +is not installed, it is recommended to use the following options in +order to use an ANSI C compiler: + + ./configure CC="cc -Ae -D_XOPEN_SOURCE=500" + +and if that doesn't work, install pre-built binaries of GCC for HP-UX. + + HP-UX 'make' updates targets which have the same timestamps as their +prerequisites, which makes it generally unusable when shipped generated +files such as 'configure' are involved. Use GNU 'make' instead. + + On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot +parse its '' header file. The option '-nodtk' can be used as a +workaround. If GNU CC is not installed, it is therefore recommended to +try + + ./configure CC="cc" + +and if that doesn't work, try + + ./configure CC="cc -nodtk" + + On Solaris, don't put '/usr/ucb' early in your 'PATH'. This +directory contains several dysfunctional programs; working variants of +these programs are available in '/usr/bin'. So, if you need '/usr/ucb' +in your 'PATH', put it _after_ '/usr/bin'. + + On Haiku, software installed for all users goes in '/boot/common', +not '/usr/local'. It is recommended to use the following options: + + ./configure --prefix=/boot/common + +Specifying the System Type +========================== + + There may be some features 'configure' cannot figure out +automatically, but needs to determine by the type of machine the package +will run on. Usually, assuming the package is built to be run on the +_same_ architectures, 'configure' can figure that out, but if it prints +a message saying it cannot guess the machine type, give it the +'--build=TYPE' option. TYPE can either be a short name for the system +type, such as 'sun4', or a canonical name which has the form: + + CPU-COMPANY-SYSTEM + +where SYSTEM can have one of these forms: + + OS + KERNEL-OS + + See the file 'config.sub' for the possible values of each field. If +'config.sub' isn't included in this package, then this package doesn't +need to know the machine type. + + If you are _building_ compiler tools for cross-compiling, you should +use the option '--target=TYPE' to select the type of system they will +produce code for. + + If you want to _use_ a cross compiler, that generates code for a +platform different from the build platform, you should specify the +"host" platform (i.e., that on which the generated programs will +eventually be run) with '--host=TYPE'. + +Sharing Defaults +================ + + If you want to set default values for 'configure' scripts to share, +you can create a site shell script called 'config.site' that gives +default values for variables like 'CC', 'cache_file', and 'prefix'. +'configure' looks for 'PREFIX/share/config.site' if it exists, then +'PREFIX/etc/config.site' if it exists. Or, you can set the +'CONFIG_SITE' environment variable to the location of the site script. +A warning: not all 'configure' scripts look for a site script. + +Defining Variables +================== + + Variables not defined in a site shell script can be set in the +environment passed to 'configure'. However, some packages may run +configure again during the build, and the customized values of these +variables may be lost. In order to avoid this problem, you should set +them in the 'configure' command line, using 'VAR=value'. For example: + + ./configure CC=/usr/local2/bin/gcc + +causes the specified 'gcc' to be used as the C compiler (unless it is +overridden in the site shell script). + +Unfortunately, this technique does not work for 'CONFIG_SHELL' due to an +Autoconf limitation. Until the limitation is lifted, you can use this +workaround: + + CONFIG_SHELL=/bin/bash ./configure CONFIG_SHELL=/bin/bash + +'configure' Invocation +====================== + + 'configure' recognizes the following options to control how it +operates. + +'--help' +'-h' + Print a summary of all of the options to 'configure', and exit. + +'--help=short' +'--help=recursive' + Print a summary of the options unique to this package's + 'configure', and exit. The 'short' variant lists options used only + in the top level, while the 'recursive' variant lists options also + present in any nested packages. + +'--version' +'-V' + Print the version of Autoconf used to generate the 'configure' + script, and exit. + +'--cache-file=FILE' + Enable the cache: use and save the results of the tests in FILE, + traditionally 'config.cache'. FILE defaults to '/dev/null' to + disable caching. + +'--config-cache' +'-C' + Alias for '--cache-file=config.cache'. + +'--quiet' +'--silent' +'-q' + Do not print messages saying which checks are being made. To + suppress all normal output, redirect it to '/dev/null' (any error + messages will still be shown). + +'--srcdir=DIR' + Look for the package's source code in directory DIR. Usually + 'configure' can determine that directory automatically. + +'--prefix=DIR' + Use DIR as the installation prefix. *note Installation Names:: for + more details, including other options available for fine-tuning the + installation locations. + +'--no-create' +'-n' + Run the configure checks, but stop before creating any output + files. + +'configure' also accepts some other, not widely useful, options. Run +'configure --help' for more details. diff --git a/crates/gipfel-web/Cargo.toml b/crates/gipfel-web/Cargo.toml deleted file mode 100644 index 303750a..0000000 --- a/crates/gipfel-web/Cargo.toml +++ /dev/null @@ -1,42 +0,0 @@ -[package] -name = "gipfel-web" -version.workspace = true -edition.workspace = true -license.workspace = true -description = "gipfel web — browser front end (WASM)" - -[dependencies] -gipfel-core = { path = "../gipfel-core" } -flate2 = "1" -js-sys = "0.3" -wasm-bindgen = "0.2" -wasm-bindgen-futures = "0.4" -yew = { version = "0.21", features = ["csr"] } - -[dependencies.web-sys] -version = "0.3" -features = [ - "Blob", - "CanvasRenderingContext2d", - "DataTransfer", - "Document", - "DomRect", - "DragEvent", - "Element", - "Event", - "EventTarget", - "File", - "FileList", - "HtmlCanvasElement", - "HtmlElement", - "HtmlInputElement", - "ImageBitmap", - "InputEvent", - "MouseEvent", - "PointerEvent", - "Request", - "Response", - "TextMetrics", - "Window", - "WheelEvent", -] diff --git a/crates/gipfel-web/README.md b/crates/gipfel-web/README.md deleted file mode 100644 index 74e93c5..0000000 --- a/crates/gipfel-web/README.md +++ /dev/null @@ -1,47 +0,0 @@ -# gipfel-web - -Browser front end for gipfel (WASM, Yew + canvas 2D). See -[`/wasm-plan.md`](../../wasm-plan.md) for the overall plan and milestones. - -**Status: W1 (scaffold + image display) done** — open/drag-drop a JPEG, -pan (drag) and zoom (wheel, cursor-anchored). Peak identification, -fitting and saving arrive in W2/W3. - -## Development - -Prerequisites: [rustup](https://rustup.rs) and trunk: - -```sh -cargo install --locked trunk -``` - -Serve with hot reload: - -```sh -cd crates/gipfel-web -trunk serve --port 8090 # then open http://localhost:8090 -``` - -Release build (static output in `dist/`, serveable by any web server): - -```sh -trunk build --release -``` - -## Layout - -| File | Purpose | -|---|---| -| `src/main.rs` | entry point | -| `src/app.rs` | root component: sidebar, file loading, state | -| `src/canvas_view.rs` | viewport canvas: bitmap blit, pan/zoom | -| `src/bridge.rs` | JS glue: image decode, blob read, canvas ctx | -| `index.html` | trunk entry point (canonical trunk layout) | -| `www/style.css` | stylesheet (trunk asset) | - -## Notes - -- The base image is decoded by the browser (`createImageBitmap`), not - by the `image` crate — faster decode and GPU-backed blitting. -- The crate compiles natively (`cargo check -p gipfel-web`) so it can - be checked in CI without a wasm toolchain; runtime is wasm-only. diff --git a/crates/gipfel-web/index.html b/crates/gipfel-web/index.html deleted file mode 100644 index 32ec87f..0000000 --- a/crates/gipfel-web/index.html +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - gipfel web - - - - - diff --git a/crates/gipfel-web/serve-here.sh b/crates/gipfel-web/serve-here.sh deleted file mode 100755 index 54038a6..0000000 --- a/crates/gipfel-web/serve-here.sh +++ /dev/null @@ -1,12 +0,0 @@ -#!/bin/sh -# Build gipfel-web for wasm and refresh the static dist dir served from -# /tmp/gipfel-web-dist (python http.server on :8090). Dev-only helper. -set -e -cd "$(dirname "$0")/../.." -cargo build -p gipfel-web --target wasm32-unknown-unknown --release -DIST=/tmp/gipfel-web-dist -mkdir -p "$DIST" -wasm-bindgen --target web --out-dir "$DIST" target/wasm32-unknown-unknown/release/gipfel-web.wasm -cp crates/gipfel-web/www/style.css "$DIST/" -gzip -9 -n -c gipfel.dat > "$DIST/gipfel.dat.gz" -echo "dist refreshed: $(ls -la "$DIST" | awk '{s+=$5} END {print s" bytes"}')" diff --git a/crates/gipfel-web/src/app.rs b/crates/gipfel-web/src/app.rs deleted file mode 100644 index f4b0de4..0000000 --- a/crates/gipfel-web/src/app.rs +++ /dev/null @@ -1,763 +0,0 @@ -//! Root component: sidebar (open/fit/status/fit-toggle) + viewport canvas. -//! Owns the `Panorama` and the marker list; refits on every marker change. - -use std::io::Read; -use std::rc::Rc; - -use flate2::read::GzDecoder; -use gipfel_core::hill::{FLAG_DUPLIC, FLAG_HIDDEN, FLAG_TRACK_POINT}; -use gipfel_core::metadata::{apply_image_metadata, ImageMetaData}; -use gipfel_core::panorama::Panorama; -use wasm_bindgen::closure::Closure; -use wasm_bindgen::JsCast; -use wasm_bindgen_futures::spawn_local; -use web_sys::{DragEvent, Event, HtmlCanvasElement, HtmlInputElement, InputEvent, MouseEvent}; -use yew::prelude::*; - -use crate::bridge; -use crate::canvas_view::{CanvasView, MarkerView, ViewCallbacks, ViewState}; -use crate::compass::{Compass, CompassData}; -use crate::markers::{self, Marker}; -use crate::widgets::{NumItem, SliderItem}; - -/// sidebar-editable view parameters (degrees / meters / mm) -#[derive(Clone, Copy, PartialEq)] -struct UiParams { - lat: f64, - lon: f64, - height: f64, - az: f64, - focal: f64, - pitch: f64, - roll: f64, - /// visibility UI value: 0.11 - height_dist_ratio (right = more visible) - vis: f64, - label_font: f32, -} - -impl Default for UiParams { - fn default() -> Self { - UiParams { - lat: 0.0, - lon: 0.0, - height: 0.0, - az: 0.0, - focal: 50.0, - pitch: 0.0, - roll: 0.0, - vis: 0.04, - label_font: 12.0, - } - } -} - -/// open Find Peak popup: anchor (screen + image coords) and search query -#[derive(Clone, PartialEq)] -struct FindPeak { - sx: f64, - sy: f64, - ix: f64, - iy: f64, - query: String, -} - -fn gunzip(gz: &[u8]) -> Result, String> { - let mut raw = Vec::new(); - GzDecoder::new(gz) - .read_to_end(&mut raw) - .map(|_| raw) - .map_err(|e| format!("gunzip: {e}")) -} - -#[derive(Properties, PartialEq)] -struct FpProps { - fp: FindPeak, - items: Vec<(String, usize)>, - on_pick: Callback, - on_query: Callback, - on_close: Callback<()>, -} - -/// searchable Find Peak dialog: type to filter, click to select -#[function_component(FindPeakPanel)] -fn find_peak_panel(p: &FpProps) -> Html { - let input_ref = use_node_ref(); - // focus the search box when the dialog opens - { - let input_ref = input_ref.clone(); - use_effect_with((), move |_| { - if let Some(i) = input_ref.cast::() { - let _ = i.focus(); - } - }); - } - let on_query = { - let on_query = p.on_query.clone(); - Callback::from(move |e: InputEvent| { - let input: HtmlInputElement = e.target_unchecked_into(); - on_query.emit(input.value()); - }) - }; - let on_close = { - let on_close = p.on_close.clone(); - Callback::from(move |_: MouseEvent| on_close.emit(())) - }; - html! { - <> -
-
-
{ "Find Peak" }
-
- -
-
- { - for p.items.iter().map(|(label, idx)| { - let onclick = { - let on_pick = p.on_pick.clone(); - let i = *idx; - Callback::from(move |_: MouseEvent| on_pick.emit(i)) - }; - html! { - - } - }) - } - if p.items.is_empty() { -

{ "no matches" }

- } -
-
- -
-
- - } -} - -#[function_component(App)] -pub fn app() -> Html { - let bitmap = use_state(|| None::); - let view = use_state(ViewState::default); - let status = use_state(|| "No image loaded.".to_string()); - let db_status = use_state(|| "Loading hill database…".to_string()); - let fit_info = use_state(String::new); - let tick = use_state(|| 0u32); - let canvas_ref = use_node_ref(); - let file_ref = use_node_ref(); - let pan = use_mut_ref(Panorama::new); - let markers = use_state(Vec::::new); - let fit_distortion = use_state(|| false); - let hover = use_state(|| Option::::None); - let vp = use_state(UiParams::default); - let img_size = use_state(|| (0u32, 0u32)); - let find_peak = use_state(|| Option::::None); - let show_hidden = use_state(|| false); - - // force a redraw when the window is resized so the canvas backing - // store tracks its CSS size (listener lives as long as the app) - { - let tick = tick.clone(); - use_effect_with((), move |_| { - let closure = Closure::wrap(Box::new(move || tick.set(*tick + 1)) as Box); - let _ = bridge::window() - .add_event_listener_with_callback("resize", closure.as_ref().unchecked_ref()); - // the listener is never removed (app lifetime); leak the closure - std::mem::forget(closure); - }); - } - - // load the hill database once at startup - { - let pan = pan.clone(); - let db_status = db_status.clone(); - use_effect_with((), move |_| { - spawn_local(async move { - let result = async { - let gz = bridge::fetch_bytes("gipfel.dat.gz").await?; - let raw = gunzip(&gz)?; - pan.borrow_mut() - .load_data_from_bytes(&raw) - .map_err(|e| format!("load: {e}")) - } - .await; - match result { - Ok(()) => { - let n = pan.borrow().hills.len(); - db_status.set(format!("Hill database: {n} peaks")); - } - Err(e) => db_status.set(format!("Hill database failed: {e}")), - } - }); - }); - } - - // Fit the current bitmap into the canvas, centered. - let fit = { - let bitmap = bitmap.clone(); - let view = view.clone(); - let canvas_ref = canvas_ref.clone(); - Callback::from(move |_: MouseEvent| { - let Some(bmp) = bitmap.as_ref() else { return }; - let (cw, ch) = canvas_ref - .cast::() - .map(|c| (c.client_width() as f64, c.client_height() as f64)) - .unwrap_or((800.0, 600.0)); - let (iw, ih) = (bmp.width() as f64, bmp.height() as f64); - if iw <= 0.0 || ih <= 0.0 || cw <= 0.0 || ch <= 0.0 { - return; - } - let scale = (cw / iw).min(ch / ih); - view.set(ViewState { - scale, - ox: (cw - iw * scale) / 2.0, - oy: (ch - ih * scale) / 2.0, - }); - }) - }; - - // refit the projection to the given markers and update the status line - let do_refit = { - let pan = pan.clone(); - let fit_info = fit_info.clone(); - let fit_distortion = fit_distortion.clone(); - Rc::new(move |mk: &[Marker]| { - if mk.is_empty() { - fit_info.set(String::new()); - return; - } - let info = { - let mut p = pan.borrow_mut(); - match markers::refit(&mut p, mk, *fit_distortion) { - Ok(()) => format!( - "fit: az {:.2}° · pitch {:.2}° · roll {:.2}° · scale {:.1}", - p.get_center_angle(), - p.get_pitch_angle(), - p.get_roll_angle(), - p.get_scale() - ), - Err(e) => format!("fit failed: {e}"), - } - }; - fit_info.set(info); - }) - }; - - // place a marker for a hill at an image position and refit - let mark_peak = { - let markers = markers.clone(); - let do_refit = do_refit.clone(); - Callback::from(move |(idx, ix, iy): (usize, f64, f64)| { - let mut mk = (*markers).clone(); - mk.retain(|m| m.hill != idx); - mk.push(Marker { hill: idx, x: ix, y: iy }); - do_refit(&mk); - markers.set(mk); - }) - }; - - // Decode selected/dropped bytes: display, read metadata, reset markers. - let load_bytes = { - let bitmap = bitmap.clone(); - let status = status.clone(); - let fit = fit.clone(); - let pan = pan.clone(); - let markers = markers.clone(); - let fit_info = fit_info.clone(); - let vp = vp.clone(); - let img_size = img_size.clone(); - let find_peak = find_peak.clone(); - Callback::from(move |(bytes, name): (Vec, String)| { - let (bitmap, status, fit, pan, markers, fit_info) = - (bitmap.clone(), status.clone(), fit.clone(), pan.clone(), markers.clone(), fit_info.clone()); - let vp = vp.clone(); - let img_size = img_size.clone(); - let find_peak = find_peak.clone(); - spawn_local(async move { - match bridge::decode_bitmap(&bytes).await { - Ok(bmp) => { - let (w, h) = (bmp.width(), bmp.height()); - let mut md = ImageMetaData::new(); - md.load_image_from_bytes(&bytes); - let have = apply_image_metadata(&mut pan.borrow_mut(), &md, w, h); - let vis = pan.borrow().visible.len(); - let u = { - let p = pan.borrow(); - UiParams { - lat: p.get_view_lat(), - lon: p.get_view_long(), - height: p.get_view_height(), - az: p.get_center_angle().rem_euclid(360.0), - focal: (p.get_scale() * 35.0 / w as f64).clamp(1.0, 300.0), - pitch: p.get_pitch_angle(), - roll: p.get_roll_angle(), - vis: (0.11 - p.height_dist_ratio).clamp(0.01, 0.1), - label_font: vp.label_font, - } - }; - vp.set(u); - img_size.set((w, h)); - let vp = if have { - format!("viewpoint from image · {vis} peaks visible") - } else { - "no gipfel/EXIF viewpoint in this image".to_string() - }; - status.set(format!("{name} — {w}×{h} px · {vp}")); - markers.set(Vec::new()); - fit_info.set(String::new()); - find_peak.set(None); - bitmap.set(Some(bmp)); - fit.emit(MouseEvent::new("fit").unwrap()); - // same nudge as the desktop app: re-fit shortly - // after the first paint so the image is guaranteed - // to appear even if layout was not ready yet - { - let fit = fit.clone(); - spawn_local(async move { - let _ = wasm_bindgen_futures::JsFuture::from( - bridge::delay_promise(120), - ) - .await; - fit.emit(MouseEvent::new("fit").unwrap()); - }); - } - } - Err(e) => status.set(format!("Failed to load {name}: {e}")), - } - }); - }) - }; - - let read_file = { - let load_bytes = load_bytes.clone(); - let status = status.clone(); - Rc::new(move |file: web_sys::File| { - let (load_bytes, status) = (load_bytes.clone(), status.clone()); - let name = file.name(); - spawn_local(async move { - match bridge::read_blob(&file).await { - Ok(bytes) => load_bytes.emit((bytes, name)), - Err(e) => status.set(format!("Failed to read {name}: {e}")), - } - }); - }) - }; - - let on_file_change = { - let read_file = read_file.clone(); - Callback::from(move |e: Event| { - let input: HtmlInputElement = e.target_unchecked_into(); - if let Some(file) = input.files().and_then(|fl| fl.item(0)) { - read_file(file); - } - }) - }; - - let on_drop = { - let read_file = read_file.clone(); - let status = status.clone(); - Callback::from(move |e: DragEvent| { - e.prevent_default(); - match e - .data_transfer() - .and_then(|dt| dt.files()) - .and_then(|fl| fl.item(0)) - { - Some(file) => read_file(file), - None => status.set("Dropped item was not a file.".to_string()), - } - }) - }; - let on_dragover = Callback::from(|e: DragEvent| e.prevent_default()); - - let open_picker = { - let file_ref = file_ref.clone(); - Callback::from(move |_: MouseEvent| { - if let Some(input) = file_ref.cast::() { - input.click(); - } - }) - }; - - let on_distortion_toggle = { - let fit_distortion = fit_distortion.clone(); - let markers = markers.clone(); - let do_refit = do_refit.clone(); - Callback::from(move |e: Event| { - let input: HtmlInputElement = e.target_unchecked_into(); - fit_distortion.set(input.checked()); - do_refit(&markers); - }) - }; - - // sidebar parameter editing: update UI state and apply to the panorama - macro_rules! param_cb { - ($field:ident, $apply:expr) => {{ - let vp = vp.clone(); - let pan = pan.clone(); - Callback::from(move |v: f64| { - let mut u = *vp; - u.$field = v; - vp.set(u); - let f: &dyn Fn(&mut Panorama, f64) = &$apply; - f(&mut pan.borrow_mut(), v); - }) - }}; - } - let on_lat = param_cb!(lat, |p: &mut Panorama, v| p.set_view_lat(v)); - let on_lon = param_cb!(lon, |p, v| p.set_view_long(v)); - let on_height = param_cb!(height, |p, v| p.set_view_height(v)); - let on_az = param_cb!(az, |p, v| p.set_center_angle(v)); - let on_pitch = param_cb!(pitch, |p, v| p.set_pitch_angle(v)); - let on_roll = param_cb!(roll, |p, v| p.set_roll_angle(v)); - let on_vis = param_cb!(vis, |p, v| p.set_height_dist_ratio(0.11 - v)); - let on_focal = { - let vp = vp.clone(); - let pan = pan.clone(); - let img_size = img_size.clone(); - Callback::from(move |v: f64| { - let mut u = *vp; - u.focal = v; - vp.set(u); - let w = img_size.0 as f64; - if w > 0.0 { - pan.borrow_mut().set_scale(v * w / 35.0); - } - }) - }; - let on_font = { - let vp = vp.clone(); - Callback::from(move |v: f64| { - let mut u = *vp; - u.label_font = v as f32; - vp.set(u); - }) - }; - let on_show_hidden = { - let show_hidden = show_hidden.clone(); - Callback::from(move |e: Event| { - let input: HtmlInputElement = e.target_unchecked_into(); - show_hidden.set(input.checked()); - }) - }; - - // compass strip: shares the image transform, drag changes azimuth - let compass_data = { - let p = pan.borrow(); - CompassData { - ptype: p.projection_type, - parms: p.parms, - center_deg: p.get_center_angle(), - zoom: view.scale, - cx: view.ox + img_size.0 as f64 * view.scale / 2.0, - max_view_angle: p.max_view_angle, - } - }; - let compass_change = { - let pan = pan.clone(); - let vp = vp.clone(); - Callback::from(move |deg: f64| { - pan.borrow_mut().set_center_angle(deg); - let mut u = *vp; - u.az = deg.rem_euclid(360.0); - vp.set(u); - }) - }; - - let fp_close = { - let find_peak = find_peak.clone(); - Callback::from(move |_: ()| find_peak.set(None)) - }; - - // Find Peak picker: searchable list over the geographically close hills - // (same candidate set and filtering as the desktop dialog) - let findpeak_popup = if let Some(fp) = &*find_peak { - let items: Vec<(String, usize)> = { - let p = pan.borrow(); - let q = fp.query.to_uppercase(); - let mut entries: Vec<(String, usize)> = p - .close - .iter() - .filter(|&&i| { - let h = &p.hills[i]; - h.flags & (FLAG_DUPLIC | FLAG_TRACK_POINT) == 0 - && (q.is_empty() || h.name.to_uppercase().contains(&q)) - }) - .map(|&i| { - ( - format!("{} ({} m)", p.hills[i].name, p.hills[i].height as i64), - i, - ) - }) - .collect(); - entries.sort_by(|a, b| a.0.cmp(&b.0)); - entries.truncate(300); - entries - }; - let on_pick = { - let mark = mark_peak.clone(); - let find_peak = find_peak.clone(); - let (ix, iy) = (fp.ix, fp.iy); - Callback::from(move |hill: usize| { - mark.emit((hill, ix, iy)); - find_peak.set(None); - }) - }; - let on_query = { - let find_peak = find_peak.clone(); - Callback::from(move |q: String| { - if let Some(mut fp) = (*find_peak).clone() { - fp.query = q; - find_peak.set(Some(fp)); - } - }) - }; - html! { - - } - } else { - Html::default() - }; - - let callbacks = ViewCallbacks { - pan: { - let view = view.clone(); - Callback::from(move |(dx, dy): (f64, f64)| { - let mut v = (*view).clone(); - v.ox += dx; - v.oy += dy; - view.set(v); - }) - }, - zoom: { - let view = view.clone(); - Callback::from(move |(cx, cy, factor): (f64, f64, f64)| { - let v = &*view; - let ns = (v.scale * factor).clamp(0.02, 64.0); - let k = ns / v.scale; - view.set(ViewState { - scale: ns, - ox: cx - (cx - v.ox) * k, - oy: cy - (cy - v.oy) * k, - }); - }) - }, - click: { - let pan = pan.clone(); - let view = view.clone(); - let mark = mark_peak.clone(); - let find_peak = find_peak.clone(); - let img_size = img_size.clone(); - let show_hidden = show_hidden.clone(); - Callback::from(move |(ix, iy): (f64, f64)| { - let scale = view.scale; - // unambiguous click right on a peak: mark directly - // (borrow must be released before mark -> do_refit!) - let near = { - let p = pan.borrow(); - markers::nearest_hill(&p, ix, iy, 10.0 / scale, *show_hidden) - }; - if let Some(idx) = near { - find_peak.set(None); - mark.emit((idx, ix, iy)); - return; - } - // otherwise open the Find Peak picker (searchable, like the - // desktop dialog): the correct peak may project far away - // while the viewpoint is still rough - let (w, h) = (img_size.0 as f64, img_size.1 as f64); - find_peak.set(Some(FindPeak { - sx: (ix + w / 2.0) * scale + view.ox, - sy: (iy + h / 2.0) * scale + view.oy, - ix, - iy, - query: String::new(), - })); - }) - }, - marker_drag: { - let markers = markers.clone(); - Callback::from(move |(i, dx, dy): (usize, f64, f64)| { - let mut mk = (*markers).clone(); - if let Some(m) = mk.get_mut(i) { - m.x += dx; - m.y += dy; - } - markers.set(mk); - }) - }, - drag_end: { - let markers = markers.clone(); - let do_refit = do_refit.clone(); - Callback::from(move |_: ()| do_refit(&markers)) - }, - context: { - let markers = markers.clone(); - let view = view.clone(); - let status = status.clone(); - let do_refit = do_refit.clone(); - Callback::from(move |(ix, iy): (f64, f64)| { - let mut mk = (*markers).clone(); - let before = mk.len(); - let r = 20.0 / view.scale; - mk.retain(|m| (m.x - ix).hypot(m.y - iy) >= r); - if mk.len() < before { - do_refit(&mk); - markers.set(mk); - status.set("Marker removed.".to_string()); - } else { - status.set("Right-click a marker to remove it.".to_string()); - } - }) - }, - hover: { - let pan = pan.clone(); - let view = view.clone(); - let hover = hover.clone(); - let show_hidden = show_hidden.clone(); - Callback::from(move |(ix, iy): (f64, f64)| { - let p = pan.borrow(); - let name = markers::nearest_hill(&p, ix, iy, 20.0 / view.scale, *show_hidden) - .map(|i| { - let h = &p.hills[i]; - format!("{} · {:.0} m", h.name, h.height) - }); - hover.set(name); - }) - }, - hover_end: { - let hover = hover.clone(); - Callback::from(move |_: ()| hover.set(None)) - }, - }; - - // overlay data for the canvas - let marker_views: Vec = { - let p = pan.borrow(); - markers - .iter() - .map(|m| MarkerView { - x: m.x, - y: m.y, - name: p.hills[m.hill].name.clone(), - }) - .collect() - }; - let candidates: Vec<(f64, f64, bool)> = { - let p = pan.borrow(); - p.visible - .iter() - .filter(|&&i| *show_hidden || p.hills[i].flags & FLAG_HIDDEN == 0) - .map(|&i| { - ( - p.hills[i].x, - p.hills[i].y, - p.hills[i].flags & FLAG_HIDDEN != 0, - ) - }) - .collect() - }; - - let zoom_pct = (view.scale * 100.0).round(); - let n_markers = markers.len(); - - html! { -
- -
-
- - { findpeak_popup.clone() } -
- if bitmap.is_some() { - - } -
-
- } -} diff --git a/crates/gipfel-web/src/bridge.rs b/crates/gipfel-web/src/bridge.rs deleted file mode 100644 index 6dbba93..0000000 --- a/crates/gipfel-web/src/bridge.rs +++ /dev/null @@ -1,69 +0,0 @@ -//! Small JS helpers: window access, browser-native image decode, blob -//! reads, canvas context — the hand-written JS boundary of the app. - -use js_sys::Uint8Array; -use wasm_bindgen::JsCast; -use wasm_bindgen_futures::JsFuture; -use web_sys::{Blob, CanvasRenderingContext2d, HtmlCanvasElement, ImageBitmap, Window}; - -pub fn window() -> Window { - web_sys::window().expect("no global window") -} - -/// Decode image bytes into a browser-native (GPU-backed) bitmap. -/// The browser does the JPEG decode and keeps the pixels where canvas -/// blitting is fast — cheaper than any pure-Rust path in wasm. -pub async fn decode_bitmap(bytes: &[u8]) -> Result { - let array = js_sys::Array::new(); - array.push(&Uint8Array::from(bytes).buffer()); - let blob = Blob::new_with_u8_array_sequence(&array).map_err(|_| "blob failed".to_string())?; - let promise = window() - .create_image_bitmap_with_blob(&blob) - .map_err(|_| "createImageBitmap failed".to_string())?; - let value = JsFuture::from(promise) - .await - .map_err(|e| format!("decode failed: {e:?}"))?; - value - .dyn_into::() - .map_err(|_| "decode produced non-bitmap".to_string()) -} - -/// Read a File/Blob fully into memory. -pub async fn read_blob(blob: &Blob) -> Result, String> { - let buf = JsFuture::from(blob.array_buffer()) - .await - .map_err(|e| format!("read failed: {e:?}"))?; - Ok(Uint8Array::new(&buf).to_vec()) -} - -/// Fetch a URL (same-origin) into memory. -pub async fn fetch_bytes(url: &str) -> Result, String> { - let resp = JsFuture::from(window().fetch_with_str(url)) - .await - .map_err(|e| format!("fetch {url}: {e:?}"))?; - let resp: web_sys::Response = resp - .dyn_into() - .map_err(|_| "bad response".to_string())?; - if !resp.ok() { - return Err(format!("{url}: HTTP {}", resp.status())); - } - let buf = JsFuture::from(resp.array_buffer().map_err(|_| "array_buffer".to_string())?) - .await - .map_err(|e| format!("body: {e:?}"))?; - Ok(Uint8Array::new(&buf).to_vec()) -} - -/// setTimeout as an awaitable Promise. -pub fn delay_promise(ms: i32) -> js_sys::Promise { - js_sys::Promise::new(&mut |resolve, _reject| { - let _ = window().set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms); - }) -} - -pub fn ctx2d(canvas: &HtmlCanvasElement) -> Option { - canvas - .get_context("2d") - .ok() - .flatten() - .and_then(|c| c.dyn_into::().ok()) -} diff --git a/crates/gipfel-web/src/canvas_view.rs b/crates/gipfel-web/src/canvas_view.rs deleted file mode 100644 index 9d4338e..0000000 --- a/crates/gipfel-web/src/canvas_view.rs +++ /dev/null @@ -1,481 +0,0 @@ -//! Viewport canvas: browser-native bitmap blitted with a pan/zoom -//! transform, plus the marker overlay and its interactions. - -use web_sys::{HtmlCanvasElement, ImageBitmap, MouseEvent, PointerEvent, WheelEvent}; -use yew::prelude::*; - -use crate::bridge; - -/// Image -> screen transform: `screen = img * scale + (ox, oy)`. -/// Same convention as the desktop viewport widget. -#[derive(Clone, Debug, PartialEq, Default)] -pub struct ViewState { - pub scale: f64, - pub ox: f64, - pub oy: f64, -} - -/// A marker in center-relative image coordinates. -#[derive(Clone, Debug, PartialEq)] -pub struct MarkerView { - pub x: f64, - pub y: f64, - pub name: String, -} - -#[derive(Clone, PartialEq)] -pub struct ViewCallbacks { - pub pan: Callback<(f64, f64)>, - /// (cursor x, cursor y, factor) — zoom anchored at the cursor. - pub zoom: Callback<(f64, f64, f64)>, - /// click on empty space: (x, y) center-relative image coords - pub click: Callback<(f64, f64)>, - /// drag a marker: (marker index, dx, dy) in image coords - pub marker_drag: Callback<(usize, f64, f64)>, - /// a marker drag finished (time to refit) - pub drag_end: Callback<()>, - /// right-click: (x, y) center-relative image coords - pub context: Callback<(f64, f64)>, - /// pointer moved over the image (not dragging): (x, y) center-relative - pub hover: Callback<(f64, f64)>, - /// pointer left the canvas - pub hover_end: Callback<()>, -} - -#[derive(Properties, PartialEq)] -pub struct Props { - pub bitmap: Option, - pub view: ViewState, - pub callbacks: ViewCallbacks, - pub canvas_ref: NodeRef, - /// bumped on window resize to force a redraw - pub tick: u32, - pub markers: Vec, - /// projected positions of all visible hills (guide dots) with their - /// hidden-by-occlusion flag - pub candidates: Vec<(f64, f64, bool)>, - /// marker label font size, screen px - pub label_font: f32, -} - -#[derive(Clone, PartialEq)] -enum DragMode { - Pan, - Marker(usize), -} - -#[derive(PartialEq)] -struct DragState { - mode: Option, - last: (f64, f64), - start: (f64, f64), - moved: bool, -} - -#[function_component(CanvasView)] -pub fn canvas_view(props: &Props) -> Html { - let drag = use_mut_ref(|| DragState { - mode: None, - last: (0.0, 0.0), - start: (0.0, 0.0), - moved: false, - }); - - // redraw on every view/bitmap/marker change and on resize ticks - { - let bitmap = props.bitmap.clone(); - let view = props.view.clone(); - let canvas_ref = props.canvas_ref.clone(); - let markers = props.markers.clone(); - let candidates = props.candidates.clone(); - let label_font = props.label_font; - use_effect_with( - (bitmap, view, props.tick, markers.clone(), candidates.clone(), label_font), - move |(bitmap, view, _tick, markers, candidates, label_font)| { - let Some(canvas) = canvas_ref.cast::() else { - return; - }; - let Some(ctx) = bridge::ctx2d(&canvas) else { - return; - }; - let dpr = bridge::window().device_pixel_ratio(); - let cw = canvas.client_width() as f64; - let ch = canvas.client_height() as f64; - // keep the backing store in sync with the CSS size - let bw = (cw * dpr).max(1.0) as u32; - let bh = (ch * dpr).max(1.0) as u32; - if canvas.width() != bw || canvas.height() != bh { - canvas.set_width(bw); - canvas.set_height(bh); - } - let _ = ctx.set_transform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0); - // web-sys 0.3: set_fill_style takes a JsValue (deprecated alias) - #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("#101014")); - ctx.fill_rect(0.0, 0.0, canvas.width() as f64, canvas.height() as f64); - let Some(bitmap) = bitmap else { return }; - let _ = ctx.set_transform( - dpr * view.scale, - 0.0, - 0.0, - dpr * view.scale, - dpr * view.ox, - dpr * view.oy, - ); - let _ = ctx.draw_image_with_image_bitmap(bitmap, 0.0, 0.0); - - // overlays in screen space - let _ = ctx.set_transform(dpr, 0.0, 0.0, dpr, 0.0, 0.0); - let hw = bitmap.width() as f64 / 2.0; - let hh = bitmap.height() as f64 / 2.0; - let sx = |x: f64| (x + hw) * view.scale + view.ox; - let sy = |y: f64| (y + hh) * view.scale + view.oy; - - // guide dots for all visible peaks: dark outline ring + - // bright core so they stay visible on any photo content; - // peaks hidden by nearer terrain are drawn grey - #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.85)")); - for (cx, cy, _hidden) in candidates { - let (px, py) = (sx(*cx), sy(*cy)); - if px < -6.0 || py < -6.0 || px > cw + 6.0 || py > ch + 6.0 { - continue; - } - ctx.begin_path(); - let _ = ctx.arc(px, py, 4.5, 0.0, std::f64::consts::TAU); - ctx.fill(); - } - for (cx, cy, hidden) in candidates { - let (px, py) = (sx(*cx), sy(*cy)); - if px < -6.0 || py < -6.0 || px > cw + 6.0 || py > ch + 6.0 { - continue; - } - let color = if *hidden { "rgb(150, 150, 150)" } else { "rgb(110, 231, 183)" }; - #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str(color)); - ctx.begin_path(); - let _ = ctx.arc(px, py, 2.5, 0.0, std::f64::consts::TAU); - ctx.fill(); - } - - // markers: yellow leader lines, red crosses, collision-free - // labels (port of the desktop viewport drawing) - if !markers.is_empty() { - let label_font = *label_font; - let line_h = label_font * 1.3 + 2.0; - ctx.set_font(&format!("{label_font:.0}px system-ui, sans-serif")); - // layout runs in screen space, sorted by x - let mut order: Vec = (0..markers.len()) - .filter(|&i| { - markers[i].x.abs() * 2.0 <= bitmap.width() as f64 - && markers[i].y.abs() * 2.0 <= bitmap.height() as f64 - }) - .collect(); - order.sort_by(|&a, &b| sx(markers[a].x).total_cmp(&sx(markers[b].x))); - let xs: Vec = order.iter().map(|&i| sx(markers[i].x) as f32).collect(); - let ys: Vec = order.iter().map(|&i| sy(markers[i].y) as f32).collect(); - let widths: Vec = order - .iter() - .map(|&i| { - ctx.measure_text(&markers[i].name) - .map(|m| m.width() as f32) - .unwrap_or_else(|_| markers[i].name.len() as f32 * 7.0) - }) - .collect(); - let in_img = vec![true; order.len()]; - let entries = layout_label_y(&xs, &ys, &widths, &in_img, line_h); - - // leaders (yellow): cross, vertical, horizontal - #[allow(deprecated)] - ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str("rgb(255, 230, 51)")); - ctx.set_line_width(1.0); - for (k, &i) in order.iter().enumerate() { - let (px, py) = (sx(markers[i].x), sy(markers[i].y)); - let (lx, ly) = entries[k]; - let label_line = py + ly as f64 - line_h as f64; - ctx.begin_path(); - ctx.move_to(px - 4.0, py); - ctx.line_to(px + 4.0, py); - ctx.move_to(px, py); - ctx.line_to(px, label_line); - ctx.move_to(px, label_line); - ctx.line_to(px + lx as f64, label_line); - ctx.stroke(); - } - // marker crosses (always red) - #[allow(deprecated)] - ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str("rgb(255, 64, 64)")); - ctx.set_line_width(1.5); - for &i in &order { - let (px, py) = (sx(markers[i].x), sy(markers[i].y)); - ctx.begin_path(); - ctx.move_to(px - 5.0, py); - ctx.line_to(px + 5.0, py); - ctx.move_to(px, py - 5.0); - ctx.line_to(px, py + 5.0); - ctx.stroke(); - } - // labels: white on dark shadow, right-aligned at leader end - for (k, &i) in order.iter().enumerate() { - if markers[i].name.is_empty() { - continue; - } - let (px, py) = (sx(markers[i].x), sy(markers[i].y)); - let (lx, ly) = entries[k]; - let label_line = py + ly as f64 - line_h as f64; - let tx = px + lx as f64 - widths[k] as f64; - let ty = label_line - 3.0; - #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.85)")); - ctx.fill_text(&markers[i].name, tx + 1.0, ty + 1.0).ok(); - #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("white")); - ctx.fill_text(&markers[i].name, tx, ty).ok(); - } - } - }, - ); - } - - // screen (client) -> center-relative image coordinates - let to_img = { - let canvas_ref = props.canvas_ref.clone(); - let view = props.view.clone(); - let bitmap = props.bitmap.clone(); - let w = bitmap.as_ref().map(|b| b.width() as f64).unwrap_or(0.0); - let h = bitmap.as_ref().map(|b| b.height() as f64).unwrap_or(0.0); - move |client_x: f64, client_y: f64| -> (f64, f64) { - let rect = canvas_ref - .cast::() - .map(|c| c.get_bounding_client_rect()); - let (rx, ry) = match rect { - Some(r) => (client_x - r.left(), client_y - r.top()), - None => (client_x, client_y), - }; - ( - (rx - view.ox) / view.scale - w / 2.0, - (ry - view.oy) / view.scale - h / 2.0, - ) - } - }; - - let on_pointerdown = { - let drag = drag.clone(); - let canvas_ref = props.canvas_ref.clone(); - let markers = props.markers.clone(); - let view = props.view.clone(); - let bitmap = props.bitmap.clone(); - Callback::from(move |e: PointerEvent| { - e.prevent_default(); - if let Some(c) = canvas_ref.cast::() { - let _ = c.set_pointer_capture(e.pointer_id()); - } - let rect = canvas_ref - .cast::() - .map(|c| c.get_bounding_client_rect()); - let (rx, ry) = match rect { - Some(r) => (e.client_x() as f64 - r.left(), e.client_y() as f64 - r.top()), - None => (e.client_x() as f64, e.client_y() as f64), - }; - // marker hit-test (screen space, 12 px radius) - let mut mode = DragMode::Pan; - if let Some(bmp) = &bitmap { - let hw = bmp.width() as f64 / 2.0; - let hh = bmp.height() as f64 / 2.0; - for (i, m) in markers.iter().enumerate().rev() { - let px = (m.x + hw) * view.scale + view.ox; - let py = (m.y + hh) * view.scale + view.oy; - if (rx - px).hypot(ry - py) < 12.0 { - mode = DragMode::Marker(i); - break; - } - } - } - let pos = (e.client_x() as f64, e.client_y() as f64); - let mut d = drag.borrow_mut(); - d.mode = Some(mode); - d.last = pos; - d.start = pos; - d.moved = false; - }) - }; - - let on_pointermove = { - let drag = drag.clone(); - let pan_cb = props.callbacks.pan.clone(); - let marker_drag = props.callbacks.marker_drag.clone(); - let hover = props.callbacks.hover.clone(); - let to_img = to_img.clone(); - let scale = props.view.scale; - Callback::from(move |e: PointerEvent| { - let mut d = drag.borrow_mut(); - let mode = match &d.mode { - Some(m) => m.clone(), - None => { - // free hover: report position for peak identification - let (ix, iy) = to_img(e.client_x() as f64, e.client_y() as f64); - hover.emit((ix, iy)); - return; - } - }; - let pos = (e.client_x() as f64, e.client_y() as f64); - let dx = pos.0 - d.last.0; - let dy = pos.1 - d.last.1; - d.last = pos; - if (pos.0 - d.start.0).hypot(pos.1 - d.start.1) > 3.0 { - d.moved = true; - } - if !d.moved { - return; - } - match mode { - DragMode::Pan => pan_cb.emit((dx, dy)), - DragMode::Marker(i) => marker_drag.emit((i, dx / scale, dy / scale)), - } - }) - }; - - let on_pointerleave = { - let hover_end = props.callbacks.hover_end.clone(); - Callback::from(move |_: PointerEvent| hover_end.emit(())) - }; - - let on_pointerup = { - let drag = drag.clone(); - let canvas_ref = props.canvas_ref.clone(); - let click = props.callbacks.click.clone(); - let drag_end = props.callbacks.drag_end.clone(); - let to_img = to_img.clone(); - Callback::from(move |e: PointerEvent| { - let mode = drag.borrow_mut().mode.take(); - if let Some(c) = canvas_ref.cast::() { - let _ = c.release_pointer_capture(e.pointer_id()); - } - let moved = drag.borrow().moved; - match mode { - Some(DragMode::Pan) if !moved => { - let (ix, iy) = to_img(e.client_x() as f64, e.client_y() as f64); - click.emit((ix, iy)); - } - Some(DragMode::Marker(_)) if moved => drag_end.emit(()), - _ => {} - } - }) - }; - - let on_pointercancel = { - let drag = drag.clone(); - Callback::from(move |_: PointerEvent| { - drag.borrow_mut().mode = None; - }) - }; - - let on_contextmenu = { - let context = props.callbacks.context.clone(); - let to_img = to_img.clone(); - Callback::from(move |e: MouseEvent| { - e.prevent_default(); - let (ix, iy) = to_img(e.client_x() as f64, e.client_y() as f64); - context.emit((ix, iy)); - }) - }; - - let on_wheel = { - let zoom = props.callbacks.zoom.clone(); - let canvas_ref = props.canvas_ref.clone(); - Callback::from(move |e: WheelEvent| { - e.prevent_default(); - let cx = e.client_x() as f64 - - canvas_ref - .cast::() - .map(|c| c.get_bounding_client_rect().left()) - .unwrap_or(0.0); - let cy = e.client_y() as f64 - - canvas_ref - .cast::() - .map(|c| c.get_bounding_client_rect().top()) - .unwrap_or(0.0); - let factor = 1.0015f64.powf(-(e.delta_y() as f64)); - zoom.emit((cx, cy, factor)); - }) - }; - - html! { - - } -} - -/// Port of the desktop `viewport::layout_label_y`: place labels right of -/// their crosses, pushing colliding ones up; iterate to a fixed point -/// (the C single pass can leave overlaps). Inputs must be sorted by x. -fn layout_label_y( - xs: &[f32], - ys: &[f32], - widths: &[f32], - in_img: &[bool], - line_h: f32, -) -> Vec<(f32, f32)> { - let n = xs.len(); - let mut label_x = vec![0.0f32; n]; - let mut label_y = vec![0.0f32; n]; - let cross = 4.0f32; - let overlap = |a1: f32, l1: f32, a2: f32, l2: f32| a1 <= a2 + l2 && a1 + l1 >= a2; - - for i in 0..n { - if !in_img[i] { - continue; - } - label_x[i] = widths[i] + 1.0; - label_y[i] = 0.0; - - let mut colliding: Vec = Vec::new(); - for j in (0..i).rev() { - if !in_img[j] { - continue; - } - if overlap(xs[i], label_x[i], xs[j] - cross, label_x[j]) { - colliding.push(j); - } else { - break; - } - } - colliding.sort_by(|&a, &b| { - let ya = ys[a] + label_y[a]; - let yb = ys[b] + label_y[b]; - yb.total_cmp(&ya) - }); - for _round in 0..64 { - let mut pushed = false; - for &j in &colliding { - if overlap( - ys[i] + label_y[i] - line_h, - line_h, - ys[j] + label_y[j] - line_h, - line_h, - ) || overlap(ys[i] + label_y[i] - line_h, line_h, ys[j] - cross, 2.0 * cross) - { - let ny = (ys[j] + label_y[j] - ys[i] - line_h - 2.0).round(); - if ny < label_y[i] { - label_y[i] = ny; - pushed = true; - } - } - } - if !pushed { - break; - } - } - } - - (0..n).map(|i| (label_x[i], label_y[i])).collect() -} diff --git a/crates/gipfel-web/src/compass.rs b/crates/gipfel-web/src/compass.rs deleted file mode 100644 index b539e07..0000000 --- a/crates/gipfel-web/src/compass.rs +++ /dev/null @@ -1,349 +0,0 @@ -//! Compass strip (canvas port of the desktop `compass.rs`, Aligned style): -//! shares the image's horizontal transform so each direction sits above -//! its position in the image; drag horizontally to change the view azimuth. - -use web_sys::{HtmlCanvasElement, PointerEvent};use yew::prelude::*; - -use gipfel_core::projection::{projection_from_type, ProjArgs, Projection, ProjectionType, ViewParams}; - -use crate::bridge; - -pub const STRIP_H: f64 = 56.0; - -/// Damped, clamped Newton iteration for a scalar inverse projection: find -/// `a` such that `f(a) ≈ target` (identical to the desktop solver). -pub fn newton_inverse( - target: f64, - mut f: impl FnMut(f64) -> Option, - seed: f64, - lo: f64, - hi: f64, -) -> f64 { - let mut a = seed.clamp(lo, hi); - for _ in 0..6 { - let Some(y) = f(a) else { break }; - let resid = y - target; - let h = 1e-5; - let (Some(y1), Some(y2)) = (f(a + h), f(a - h)) else { - break; - }; - let d = (y1 - y2) / (2.0 * h); - if !d.is_finite() || d.abs() < 1e-9 { - break; - } - let step = (resid / d).clamp(-0.3, 0.3); - a = (a - step).clamp(lo, hi); - if step.abs() < 1e-10 { - break; - } - } - a -} - -/// azimuth whose image x is `x_img`, measured with `c_ref` as center angle -pub fn alph_at_img_x( - ptype: ProjectionType, - proj: &dyn Projection, - p: &ViewParams, - x_img: f64, - c_ref: f64, -) -> f64 { - let mut p = *p; - p.a_center = c_ref; - let seed = match ptype { - ProjectionType::Rectilinear => c_ref + (x_img / p.scale).atan(), - ProjectionType::Cylindrical => c_ref + x_img / p.scale, - }; - let (lo, hi) = match ptype { - ProjectionType::Rectilinear => (c_ref - 1.55, c_ref + 1.55), - ProjectionType::Cylindrical => (c_ref - 3.1, c_ref + 3.1), - }; - newton_inverse( - x_img, - |a| Some(proj.mac_x(ProjArgs::from_params(&p, a, 0.0))), - seed, - lo, - hi, - ) -} - -const DIRS: [(f64, &str); 8] = [ - (0.0, "N"), - (45.0, "NE"), - (90.0, "E"), - (135.0, "SE"), - (180.0, "S"), - (225.0, "SW"), - (270.0, "W"), - (315.0, "NW"), -]; - -/// everything the strip needs; all plain data so Yew can diff it -#[derive(Clone, Copy, PartialEq)] -pub struct CompassData { - pub ptype: ProjectionType, - pub parms: ViewParams, - pub center_deg: f64, - pub zoom: f64, - /// screen x of the image center (strip shares the image transform) - pub cx: f64, - /// lens FOV half-angle limit, radians (0 = none) - pub max_view_angle: f64, -} - -#[derive(Properties, PartialEq)] -pub struct Props { - pub data: CompassData, - /// bumped on window resize to force a redraw - pub tick: u32, - /// new azimuth in degrees while dragging - pub on_change: Callback, -} - -#[function_component(Compass)] -pub fn compass(props: &Props) -> Html { - let canvas_ref = use_node_ref(); - let drag = use_mut_ref(|| Option::<(f64, f64)>::None); // (press x, center_deg) - - let d = props.data; - - // draw - { - let canvas_ref = canvas_ref.clone(); - use_effect_with((d, props.tick), move |(d, _tick)| { - let Some(canvas) = canvas_ref.cast::() else { - return; - }; - let Some(ctx) = bridge::ctx2d(&canvas) else { - return; - }; - let dpr = bridge::window().device_pixel_ratio(); - let w = canvas.client_width() as f64; - let bw = (w * dpr).max(1.0) as u32; - let bh = (STRIP_H * dpr).max(1.0) as u32; - if canvas.width() != bw || canvas.height() != bh { - canvas.set_width(bw); - canvas.set_height(bh); - } - let _ = ctx.set_transform(dpr, 0.0, 0.0, dpr, 0.0, 0.0); - - let on = "rgb(217, 217, 217)"; - let bg = "rgb(41, 41, 41)"; - let divider = "rgb(82, 82, 82)"; - let red = "rgb(255, 102, 64)"; - - let fill = |c: &str| { - #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str(c)); - }; - let stroke = |c: &str, width: f64| { - #[allow(deprecated)] - ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str(c)); - ctx.set_line_width(width); - }; - - fill(bg); - ctx.fill_rect(0.0, 0.0, w, STRIP_H); - stroke(divider, 1.0); - ctx.begin_path(); - ctx.move_to(0.0, 0.5); - ctx.line_to(w, 0.5); - ctx.stroke(); - - let label_y = 17.0f64; // text baseline of the direction row - let y0 = (STRIP_H - 10.0).round(); // baseline of the ticks - let tri_y = 25.0f64; - let z = d.zoom; - let proj = projection_from_type(d.ptype); - let cx = d.cx; - let c = d.parms.a_center; - - let x_img_at = |alph: f64| proj.get_coordinates(alph, 0.0, &d.parms).0; - - // adaptive tick step: first that yields >= 6 px spacing - let ppd = ((x_img_at(c + 1f64.to_radians()) - x_img_at(c - 1f64.to_radians())) - * z - / 2.0) - .abs(); - let step = [1.0f64, 2.0, 5.0, 10.0, 15.0, 30.0, 45.0, 90.0] - .into_iter() - .find(|s| s * ppd >= 6.0) - .unwrap_or(90.0); - - let a_lo = alph_at_img_x(d.ptype, &*proj, &d.parms, -cx / z, c) - .min(c - std::f64::consts::PI); - let a_hi = alph_at_img_x(d.ptype, &*proj, &d.parms, (w - cx) / z, c) - .max(c + std::f64::consts::PI); - // rectilinear folds directions behind the camera onto the same - // pixels; also clamp to the lens FOV (distortion can fold - // out-of-view directions back onto the strip) - let mut fold = match d.ptype { - ProjectionType::Rectilinear => 1.535, - ProjectionType::Cylindrical => std::f64::consts::PI, - }; - if d.max_view_angle > 0.0 { - fold = fold.min(d.max_view_angle); - } - let a_lo = a_lo.max(c - fold); - let a_hi = a_hi.min(c + fold); - - // baseline - stroke(on, 1.0); - ctx.begin_path(); - ctx.move_to(0.0, y0 + 0.5); - ctx.line_to(w, y0 + 0.5); - ctx.stroke(); - - // ticks - let step_rad = step.to_radians(); - let mut a = (a_lo / step_rad).floor() * step_rad; - while a <= a_hi { - let x = cx + x_img_at(a) * z; - if x.is_finite() && x >= -1.0 && x <= w + 1.0 { - let rem = a.to_degrees().rem_euclid(45.0); - let major = rem.min(45.0 - rem) < step / 2.0; - let x = x.round(); - ctx.begin_path(); - ctx.move_to(x, y0); - ctx.line_to(x, y0 - if major { 12.0 } else { 6.0 }); - ctx.stroke(); - } - a += step_rad; - } - - // direction labels - ctx.set_font("13px system-ui, sans-serif"); - ctx.set_text_align("center"); - for (deg, name) in DIRS { - let alph = deg.to_radians(); - let rel = (alph - c + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - - std::f64::consts::PI; - if rel.abs() > fold { - continue; - } - let x = cx + x_img_at(alph) * z; - if !x.is_finite() || x < -20.0 || x > w + 20.0 { - continue; - } - fill(if deg == 0.0 { red } else { on }); - ctx.fill_text(name, x, label_y).ok(); - } - ctx.set_text_align("start"); - - // center marker: triangle + hairline + azimuth readout - fill(red); - ctx.begin_path(); - ctx.move_to(cx - 6.0, tri_y); - ctx.line_to(cx + 6.0, tri_y); - ctx.line_to(cx, tri_y + 8.0); - ctx.close_path(); - ctx.fill(); - stroke(red, 1.0); - ctx.begin_path(); - ctx.move_to(cx.round(), tri_y + 8.0); - ctx.line_to(cx.round(), y0); - ctx.stroke(); - fill(red); - ctx.fill_text(&format!("{:05.1}°", d.center_deg.rem_euclid(360.0)), cx + 10.0, tri_y + 9.0) - .ok(); - }); - } - - let local_x = { - let canvas_ref = canvas_ref.clone(); - move |client_x: f64| { - client_x - - canvas_ref - .cast::() - .map(|c| c.get_bounding_client_rect().left()) - .unwrap_or(0.0) - } - }; - - let on_pointerdown = { - let drag = drag.clone(); - let canvas_ref = canvas_ref.clone(); - let center_deg = props.data.center_deg; - Callback::from(move |e: PointerEvent| { - e.prevent_default(); - if let Some(c) = canvas_ref.cast::() { - let _ = c.set_pointer_capture(e.pointer_id()); - } - *drag.borrow_mut() = Some((e.client_x() as f64, center_deg)); - }) - }; - let on_pointermove = { - let drag = drag.clone(); - let on_change = props.on_change.clone(); - let d = props.data; - Callback::from(move |e: PointerEvent| { - let Some((x0, c0_deg)) = *drag.borrow() else { - return; - }; - let proj = projection_from_type(d.ptype); - let c0 = c0_deg.to_radians(); - let lx0 = local_x(e.client_x() as f64); - let a0 = alph_at_img_x(d.ptype, &*proj, &d.parms, (x0 - d.cx) / d.zoom, c0); - let a1 = alph_at_img_x(d.ptype, &*proj, &d.parms, (lx0 - d.cx) / d.zoom, c0); - on_change.emit((c0 - (a1 - a0)).to_degrees()); - }) - }; - let on_pointerup = { - let drag = drag.clone(); - let canvas_ref = canvas_ref.clone(); - Callback::from(move |e: PointerEvent| { - *drag.borrow_mut() = None; - if let Some(c) = canvas_ref.cast::() { - let _ = c.release_pointer_capture(e.pointer_id()); - } - }) - }; - - html! { - - } -} - -#[cfg(test)] -mod tests { - use super::*; - - fn roundtrip(ptype: ProjectionType, k0: f64, k1: f64, x0: f64) { - let proj = projection_from_type(ptype); - let mut parms = ViewParams::new(); - parms.a_center = 0.3; - parms.scale = 3000.0; - parms.k0 = k0; - parms.k1 = k1; - parms.x0 = x0; - for x in [-2500.0, -800.0, -50.0, 0.0, 120.0, 900.0, 2400.0] { - let a = alph_at_img_x(ptype, &*proj, &parms, x, parms.a_center); - let (x2, _) = proj.get_coordinates(a, 0.0, &parms); - assert!( - (x2 - x).abs() < 1e-6, - "{ptype:?} x={x}: round-trips to {x2} (alph {a})" - ); - } - } - - #[test] - fn inverse_rectilinear() { - roundtrip(ProjectionType::Rectilinear, 0.0, 0.0, 0.0); - } - #[test] - fn inverse_rectilinear_distorted() { - roundtrip(ProjectionType::Rectilinear, 0.002, -0.0003, 0.01); - } - #[test] - fn inverse_cylindrical() { - roundtrip(ProjectionType::Cylindrical, 0.0, 0.0, 0.0); - } -} diff --git a/crates/gipfel-web/src/main.rs b/crates/gipfel-web/src/main.rs deleted file mode 100644 index 741393b..0000000 --- a/crates/gipfel-web/src/main.rs +++ /dev/null @@ -1,10 +0,0 @@ -mod app; -mod bridge; -mod canvas_view; -mod compass; -mod markers; -mod widgets; - -fn main() { - yew::Renderer::::new().render(); -} diff --git a/crates/gipfel-web/src/markers.rs b/crates/gipfel-web/src/markers.rs deleted file mode 100644 index d024f2e..0000000 --- a/crates/gipfel-web/src/markers.rs +++ /dev/null @@ -1,60 +0,0 @@ -//! Markers: user observations of hills at image positions, plus the -//! refit entry point. Coordinates are center-relative image pixels, -//! matching the projection output space (same convention as the -//! desktop viewport widget). - -use gipfel_core::hill::Hill; -use gipfel_core::panorama::Panorama; - -#[derive(Clone, Debug, PartialEq)] -pub struct Marker { - /// index into `Panorama::hills` (stable: load order is preserved) - pub hill: usize, - pub x: f64, - pub y: f64, -} - -/// Refit the projection parameters to the current markers. -/// Same graduated behavior as the original: 1 marker fits the center -/// angle, 2 add the scale, 4+ the full viewpoint (+ distortion when -/// unlocked and enough markers). -pub fn refit(pan: &mut Panorama, markers: &[Marker], fit_distortion: bool) -> Result<(), String> { - if markers.is_empty() { - return Ok(()); - } - let mut obs: Vec = Vec::with_capacity(markers.len()); - for m in markers { - let mut h = pan.hills[m.hill].clone(); - h.x = m.x; - h.y = m.y; - obs.push(h); - } - let known: Vec = (0..markers.len()).collect(); - pan.comp_params_with(&obs, &known, fit_distortion) -} - -/// Nearest visible hill to image position `(x, y)`, within `max_dist` -/// image pixels. Used to resolve marker clicks. Hills hidden by the -/// occlusion heuristic are skipped unless `show_hidden`. -pub fn nearest_hill( - pan: &Panorama, - x: f64, - y: f64, - max_dist: f64, - show_hidden: bool, -) -> Option { - let mut best = None; - let mut best_d = max_dist; - for &i in &pan.visible { - if !show_hidden && pan.hills[i].flags & gipfel_core::hill::FLAG_HIDDEN != 0 { - continue; - } - let h = &pan.hills[i]; - let d = (h.x - x).hypot(h.y - y); - if d < best_d { - best_d = d; - best = Some(i); - } - } - best -} diff --git a/crates/gipfel-web/src/widgets.rs b/crates/gipfel-web/src/widgets.rs deleted file mode 100644 index 1d22bac..0000000 --- a/crates/gipfel-web/src/widgets.rs +++ /dev/null @@ -1,77 +0,0 @@ -//! Small form controls: full-width slider with value readout above -//! (mirrors the desktop `slider_item` layout) and a numeric input row. - -use web_sys::{HtmlInputElement, InputEvent}; -use yew::prelude::*; - -#[derive(Properties, PartialEq)] -pub struct SliderProps { - pub label: AttrValue, - /// formatted value shown right of the label - pub display: AttrValue, - pub value: f64, - pub min: f64, - pub max: f64, - pub step: f64, - pub onchange: Callback, -} - -#[function_component(SliderItem)] -pub fn slider_item(p: &SliderProps) -> Html { - // live update while dragging (oninput), not only on release - let oninput = { - let onchange = p.onchange.clone(); - Callback::from(move |e: InputEvent| { - let input: HtmlInputElement = e.target_unchecked_into(); - if let Ok(v) = input.value().parse::() { - onchange.emit(v); - } - }) - }; - html! { -
-
- { p.label.as_ref().to_string() } - { p.display.as_ref().to_string() } -
- -
- } -} - -#[derive(Properties, PartialEq)] -pub struct NumProps { - pub label: AttrValue, - pub value: f64, - pub step: f64, - #[prop_or(2)] - pub decimals: usize, - pub onchange: Callback, -} - -#[function_component(NumItem)] -pub fn num_item(p: &NumProps) -> Html { - let onchange = { - let onchange = p.onchange.clone(); - Callback::from(move |e: Event| { - let input: HtmlInputElement = e.target_unchecked_into(); - if let Ok(v) = input.value().parse::() { - onchange.emit(v); - } - }) - }; - let display = format!("{:.*}", p.decimals, p.value); - html! { - - } -} diff --git a/crates/gipfel-web/www/style.css b/crates/gipfel-web/www/style.css deleted file mode 100644 index 5122c43..0000000 --- a/crates/gipfel-web/www/style.css +++ /dev/null @@ -1,221 +0,0 @@ -* { - box-sizing: border-box; -} -html, -body { - margin: 0; - height: 100%; - font-family: system-ui, sans-serif; -} -.app { - display: flex; - height: 100vh; - background: #101014; - color: #e8e8ea; -} -.sidebar { - width: 300px; - padding: 16px; - background: #1a1a20; - border-right: 1px solid #2c2c34; - display: flex; - flex-direction: column; - gap: 8px; - overflow-y: auto; -} -.sidebar h1 { - margin: 0; - font-size: 22px; -} -.tag { - margin: 0 0 12px; - color: #8a8a94; - font-size: 12px; - text-transform: uppercase; - letter-spacing: 1px; -} -.sidebar button { - padding: 8px 12px; - background: #3b6fd4; - color: #fff; - border: 0; - border-radius: 6px; - font-size: 14px; - cursor: pointer; -} -.sidebar button:hover { - background: #4a7ee4; -} -.status { - font-size: 13px; - color: #c8c8d0; - word-break: break-word; -} -.hint { - font-size: 12px; - color: #8a8a94; -} -.row { - display: flex; - gap: 6px; - align-items: center; - font-size: 13px; - cursor: pointer; -} -.fitinfo { - font-size: 12px; - color: #9fd09f; - font-variant-numeric: tabular-nums; -} -.hover { - font-size: 14px; - font-weight: 600; - color: #ffffff; -} -.dim { - opacity: 0.6; -} -.hidden-file { - display: none; -} -.main { - flex: 1; - min-width: 0; - display: flex; - flex-direction: column; -} -.canvaswrap { - flex: 1; - position: relative; - min-height: 0; -} -canvas.viewport { - position: absolute; - inset: 0; - width: 100%; - height: 100%; - display: block; - touch-action: none; - cursor: grab; -} -canvas.compass { - display: block; - width: 100%; - touch-action: none; - cursor: ew-resize; -} -.section { - margin-top: 14px; - font-size: 11px; - text-transform: uppercase; - letter-spacing: 1px; - color: #8a8a94; - border-bottom: 1px solid #2c2c34; - padding-bottom: 3px; -} -.slider { - display: flex; - flex-direction: column; - gap: 2px; - margin-top: 8px; -} -.sliderhead { - display: flex; - justify-content: space-between; - font-size: 12px; - color: #c8c8d0; -} -.slider input[type="range"] { - width: 100%; -} -.numrow { - display: flex; - justify-content: space-between; - align-items: center; - gap: 8px; - font-size: 13px; - margin-top: 6px; -} -.numrow input { - width: 130px; - padding: 4px 6px; - background: #24242c; - color: #e8e8ea; - border: 1px solid #34343e; - border-radius: 4px; -} -.fpbackdrop { - position: absolute; - inset: 0; - z-index: 9; -} -.findpeak { - position: absolute; - z-index: 10; - width: 280px; - background: #1e1e26; - border: 1px solid #3a3a46; - border-radius: 6px; - box-shadow: 0 8px 24px rgba(0, 0, 0, 0.5); - display: flex; - flex-direction: column; -} -.fpsearch { - padding: 8px; - border-bottom: 1px solid #2c2c34; -} -.fpsearch input { - width: 100%; - padding: 5px 8px; - background: #24242c; - border: 1px solid #3a3a46; - border-radius: 4px; - color: #e8e8ea; - font-size: 13px; -} -.fplist { - max-height: 320px; - overflow-y: auto; -} -.fpempty { - padding: 8px 10px; - font-size: 13px; - color: #8a8a94; - margin: 0; -} -.fpfoot { - padding: 6px 8px; - border-top: 1px solid #2c2c34; - text-align: right; -} -.fpcancel { - padding: 4px 12px; - background: #34343e; - color: #e8e8ea; - border: 0; - border-radius: 4px; - font-size: 12px; - cursor: pointer; -} -.fphead { - padding: 6px 10px; - font-size: 11px; - text-transform: uppercase; - letter-spacing: 1px; - color: #8a8a94; - border-bottom: 1px solid #2c2c34; -} -.fpitem { - display: block; - width: 100%; - text-align: left; - padding: 6px 10px; - background: none; - border: 0; - color: #e8e8ea; - font-size: 13px; - cursor: pointer; -} -.fpitem:hover { - background: #2f6fd4; -} diff --git a/crates/wipfel/Cargo.toml b/crates/wipfel/Cargo.toml new file mode 100644 index 0000000..e1e39e1 --- /dev/null +++ b/crates/wipfel/Cargo.toml @@ -0,0 +1,42 @@ +[package] +name = "wipfel" +version.workspace = true +edition.workspace = true +license.workspace = true +description = "wipfel — web based gipfel photogrammetry for mountain images" + +[dependencies] +gipfel-core = { path = "../gipfel-core" } +flate2 = "1" +js-sys = "0.3" +wasm-bindgen = "0.2" +wasm-bindgen-futures = "0.4" +yew = { version = "0.21", features = ["csr"] } + +[dependencies.web-sys] +version = "0.3" +features = [ + "Blob", + "CanvasRenderingContext2d", + "DataTransfer", + "Document", + "DomRect", + "DragEvent", + "Element", + "Event", + "EventTarget", + "File", + "FileList", + "HtmlCanvasElement", + "HtmlElement", + "HtmlInputElement", + "ImageBitmap", + "InputEvent", + "MouseEvent", + "PointerEvent", + "Request", + "Response", + "TextMetrics", + "Window", + "WheelEvent", +] diff --git a/crates/wipfel/README.md b/crates/wipfel/README.md new file mode 100644 index 0000000..37c09ea --- /dev/null +++ b/crates/wipfel/README.md @@ -0,0 +1,47 @@ +# wipfel + +Browser front end for gipfel (WASM, Yew + canvas 2D). See +[`/wasm-plan.md`](../../wasm-plan.md) for the overall plan and milestones. + +**Status: W1 (scaffold + image display) done** — open/drag-drop a JPEG, +pan (drag) and zoom (wheel, cursor-anchored). Peak identification, +fitting and saving arrive in W2/W3. + +## Development + +Prerequisites: [rustup](https://rustup.rs) and trunk: + +```sh +cargo install --locked trunk +``` + +Serve with hot reload: + +```sh +cd crates/wipfel +trunk serve --port 8090 # then open http://localhost:8090 +``` + +Release build (static output in `dist/`, serveable by any web server): + +```sh +trunk build --release +``` + +## Layout + +| File | Purpose | +|---|---| +| `src/main.rs` | entry point | +| `src/app.rs` | root component: sidebar, file loading, state | +| `src/canvas_view.rs` | viewport canvas: bitmap blit, pan/zoom | +| `src/bridge.rs` | JS glue: image decode, blob read, canvas ctx | +| `index.html` | trunk entry point (canonical trunk layout) | +| `www/style.css` | stylesheet (trunk asset) | + +## Notes + +- The base image is decoded by the browser (`createImageBitmap`), not + by the `image` crate — faster decode and GPU-backed blitting. +- The crate compiles natively (`cargo check -p wipfel`) so it can + be checked in CI without a wasm toolchain; runtime is wasm-only. diff --git a/crates/wipfel/index.html b/crates/wipfel/index.html new file mode 100644 index 0000000..d00adbe --- /dev/null +++ b/crates/wipfel/index.html @@ -0,0 +1,11 @@ + + + + + + wipfel — web based gipfel photogrammetry + + + + + diff --git a/crates/wipfel/serve-here.sh b/crates/wipfel/serve-here.sh new file mode 100755 index 0000000..9667965 --- /dev/null +++ b/crates/wipfel/serve-here.sh @@ -0,0 +1,12 @@ +#!/bin/sh +# Build wipfel for wasm and refresh the static dist dir served from +# /tmp/wipfel-dist (python http.server on :8090). Dev-only helper. +set -e +cd "$(dirname "$0")/../.." +cargo build -p wipfel --target wasm32-unknown-unknown --release +DIST=/tmp/wipfel-dist +mkdir -p "$DIST" +wasm-bindgen --target web --out-dir "$DIST" target/wasm32-unknown-unknown/release/wipfel.wasm +cp crates/wipfel/www/style.css "$DIST/" +gzip -9 -n -c gipfel.dat > "$DIST/gipfel.dat.gz" +echo "dist refreshed: $(ls -la "$DIST" | awk '{s+=$5} END {print s" bytes"}')" diff --git a/crates/wipfel/src/app.rs b/crates/wipfel/src/app.rs new file mode 100644 index 0000000..eeb82d6 --- /dev/null +++ b/crates/wipfel/src/app.rs @@ -0,0 +1,763 @@ +//! Root component: sidebar (open/fit/status/fit-toggle) + viewport canvas. +//! Owns the `Panorama` and the marker list; refits on every marker change. + +use std::io::Read; +use std::rc::Rc; + +use flate2::read::GzDecoder; +use gipfel_core::hill::{FLAG_DUPLIC, FLAG_HIDDEN, FLAG_TRACK_POINT}; +use gipfel_core::metadata::{apply_image_metadata, ImageMetaData}; +use gipfel_core::panorama::Panorama; +use wasm_bindgen::closure::Closure; +use wasm_bindgen::JsCast; +use wasm_bindgen_futures::spawn_local; +use web_sys::{DragEvent, Event, HtmlCanvasElement, HtmlInputElement, InputEvent, MouseEvent}; +use yew::prelude::*; + +use crate::bridge; +use crate::canvas_view::{CanvasView, MarkerView, ViewCallbacks, ViewState}; +use crate::compass::{Compass, CompassData}; +use crate::markers::{self, Marker}; +use crate::widgets::{NumItem, SliderItem}; + +/// sidebar-editable view parameters (degrees / meters / mm) +#[derive(Clone, Copy, PartialEq)] +struct UiParams { + lat: f64, + lon: f64, + height: f64, + az: f64, + focal: f64, + pitch: f64, + roll: f64, + /// visibility UI value: 0.11 - height_dist_ratio (right = more visible) + vis: f64, + label_font: f32, +} + +impl Default for UiParams { + fn default() -> Self { + UiParams { + lat: 0.0, + lon: 0.0, + height: 0.0, + az: 0.0, + focal: 50.0, + pitch: 0.0, + roll: 0.0, + vis: 0.04, + label_font: 12.0, + } + } +} + +/// open Find Peak popup: anchor (screen + image coords) and search query +#[derive(Clone, PartialEq)] +struct FindPeak { + sx: f64, + sy: f64, + ix: f64, + iy: f64, + query: String, +} + +fn gunzip(gz: &[u8]) -> Result, String> { + let mut raw = Vec::new(); + GzDecoder::new(gz) + .read_to_end(&mut raw) + .map(|_| raw) + .map_err(|e| format!("gunzip: {e}")) +} + +#[derive(Properties, PartialEq)] +struct FpProps { + fp: FindPeak, + items: Vec<(String, usize)>, + on_pick: Callback, + on_query: Callback, + on_close: Callback<()>, +} + +/// searchable Find Peak dialog: type to filter, click to select +#[function_component(FindPeakPanel)] +fn find_peak_panel(p: &FpProps) -> Html { + let input_ref = use_node_ref(); + // focus the search box when the dialog opens + { + let input_ref = input_ref.clone(); + use_effect_with((), move |_| { + if let Some(i) = input_ref.cast::() { + let _ = i.focus(); + } + }); + } + let on_query = { + let on_query = p.on_query.clone(); + Callback::from(move |e: InputEvent| { + let input: HtmlInputElement = e.target_unchecked_into(); + on_query.emit(input.value()); + }) + }; + let on_close = { + let on_close = p.on_close.clone(); + Callback::from(move |_: MouseEvent| on_close.emit(())) + }; + html! { + <> +
+
+
{ "Find Peak" }
+
+ +
+
+ { + for p.items.iter().map(|(label, idx)| { + let onclick = { + let on_pick = p.on_pick.clone(); + let i = *idx; + Callback::from(move |_: MouseEvent| on_pick.emit(i)) + }; + html! { + + } + }) + } + if p.items.is_empty() { +

{ "no matches" }

+ } +
+
+ +
+
+ + } +} + +#[function_component(App)] +pub fn app() -> Html { + let bitmap = use_state(|| None::); + let view = use_state(ViewState::default); + let status = use_state(|| "No image loaded.".to_string()); + let db_status = use_state(|| "Loading hill database…".to_string()); + let fit_info = use_state(String::new); + let tick = use_state(|| 0u32); + let canvas_ref = use_node_ref(); + let file_ref = use_node_ref(); + let pan = use_mut_ref(Panorama::new); + let markers = use_state(Vec::::new); + let fit_distortion = use_state(|| false); + let hover = use_state(|| Option::::None); + let vp = use_state(UiParams::default); + let img_size = use_state(|| (0u32, 0u32)); + let find_peak = use_state(|| Option::::None); + let show_hidden = use_state(|| false); + + // force a redraw when the window is resized so the canvas backing + // store tracks its CSS size (listener lives as long as the app) + { + let tick = tick.clone(); + use_effect_with((), move |_| { + let closure = Closure::wrap(Box::new(move || tick.set(*tick + 1)) as Box); + let _ = bridge::window() + .add_event_listener_with_callback("resize", closure.as_ref().unchecked_ref()); + // the listener is never removed (app lifetime); leak the closure + std::mem::forget(closure); + }); + } + + // load the hill database once at startup + { + let pan = pan.clone(); + let db_status = db_status.clone(); + use_effect_with((), move |_| { + spawn_local(async move { + let result = async { + let gz = bridge::fetch_bytes("gipfel.dat.gz").await?; + let raw = gunzip(&gz)?; + pan.borrow_mut() + .load_data_from_bytes(&raw) + .map_err(|e| format!("load: {e}")) + } + .await; + match result { + Ok(()) => { + let n = pan.borrow().hills.len(); + db_status.set(format!("Hill database: {n} peaks")); + } + Err(e) => db_status.set(format!("Hill database failed: {e}")), + } + }); + }); + } + + // Fit the current bitmap into the canvas, centered. + let fit = { + let bitmap = bitmap.clone(); + let view = view.clone(); + let canvas_ref = canvas_ref.clone(); + Callback::from(move |_: MouseEvent| { + let Some(bmp) = bitmap.as_ref() else { return }; + let (cw, ch) = canvas_ref + .cast::() + .map(|c| (c.client_width() as f64, c.client_height() as f64)) + .unwrap_or((800.0, 600.0)); + let (iw, ih) = (bmp.width() as f64, bmp.height() as f64); + if iw <= 0.0 || ih <= 0.0 || cw <= 0.0 || ch <= 0.0 { + return; + } + let scale = (cw / iw).min(ch / ih); + view.set(ViewState { + scale, + ox: (cw - iw * scale) / 2.0, + oy: (ch - ih * scale) / 2.0, + }); + }) + }; + + // refit the projection to the given markers and update the status line + let do_refit = { + let pan = pan.clone(); + let fit_info = fit_info.clone(); + let fit_distortion = fit_distortion.clone(); + Rc::new(move |mk: &[Marker]| { + if mk.is_empty() { + fit_info.set(String::new()); + return; + } + let info = { + let mut p = pan.borrow_mut(); + match markers::refit(&mut p, mk, *fit_distortion) { + Ok(()) => format!( + "fit: az {:.2}° · pitch {:.2}° · roll {:.2}° · scale {:.1}", + p.get_center_angle(), + p.get_pitch_angle(), + p.get_roll_angle(), + p.get_scale() + ), + Err(e) => format!("fit failed: {e}"), + } + }; + fit_info.set(info); + }) + }; + + // place a marker for a hill at an image position and refit + let mark_peak = { + let markers = markers.clone(); + let do_refit = do_refit.clone(); + Callback::from(move |(idx, ix, iy): (usize, f64, f64)| { + let mut mk = (*markers).clone(); + mk.retain(|m| m.hill != idx); + mk.push(Marker { hill: idx, x: ix, y: iy }); + do_refit(&mk); + markers.set(mk); + }) + }; + + // Decode selected/dropped bytes: display, read metadata, reset markers. + let load_bytes = { + let bitmap = bitmap.clone(); + let status = status.clone(); + let fit = fit.clone(); + let pan = pan.clone(); + let markers = markers.clone(); + let fit_info = fit_info.clone(); + let vp = vp.clone(); + let img_size = img_size.clone(); + let find_peak = find_peak.clone(); + Callback::from(move |(bytes, name): (Vec, String)| { + let (bitmap, status, fit, pan, markers, fit_info) = + (bitmap.clone(), status.clone(), fit.clone(), pan.clone(), markers.clone(), fit_info.clone()); + let vp = vp.clone(); + let img_size = img_size.clone(); + let find_peak = find_peak.clone(); + spawn_local(async move { + match bridge::decode_bitmap(&bytes).await { + Ok(bmp) => { + let (w, h) = (bmp.width(), bmp.height()); + let mut md = ImageMetaData::new(); + md.load_image_from_bytes(&bytes); + let have = apply_image_metadata(&mut pan.borrow_mut(), &md, w, h); + let vis = pan.borrow().visible.len(); + let u = { + let p = pan.borrow(); + UiParams { + lat: p.get_view_lat(), + lon: p.get_view_long(), + height: p.get_view_height(), + az: p.get_center_angle().rem_euclid(360.0), + focal: (p.get_scale() * 35.0 / w as f64).clamp(1.0, 300.0), + pitch: p.get_pitch_angle(), + roll: p.get_roll_angle(), + vis: (0.11 - p.height_dist_ratio).clamp(0.01, 0.1), + label_font: vp.label_font, + } + }; + vp.set(u); + img_size.set((w, h)); + let vp = if have { + format!("viewpoint from image · {vis} peaks visible") + } else { + "no gipfel/EXIF viewpoint in this image".to_string() + }; + status.set(format!("{name} — {w}×{h} px · {vp}")); + markers.set(Vec::new()); + fit_info.set(String::new()); + find_peak.set(None); + bitmap.set(Some(bmp)); + fit.emit(MouseEvent::new("fit").unwrap()); + // same nudge as the desktop app: re-fit shortly + // after the first paint so the image is guaranteed + // to appear even if layout was not ready yet + { + let fit = fit.clone(); + spawn_local(async move { + let _ = wasm_bindgen_futures::JsFuture::from( + bridge::delay_promise(120), + ) + .await; + fit.emit(MouseEvent::new("fit").unwrap()); + }); + } + } + Err(e) => status.set(format!("Failed to load {name}: {e}")), + } + }); + }) + }; + + let read_file = { + let load_bytes = load_bytes.clone(); + let status = status.clone(); + Rc::new(move |file: web_sys::File| { + let (load_bytes, status) = (load_bytes.clone(), status.clone()); + let name = file.name(); + spawn_local(async move { + match bridge::read_blob(&file).await { + Ok(bytes) => load_bytes.emit((bytes, name)), + Err(e) => status.set(format!("Failed to read {name}: {e}")), + } + }); + }) + }; + + let on_file_change = { + let read_file = read_file.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + if let Some(file) = input.files().and_then(|fl| fl.item(0)) { + read_file(file); + } + }) + }; + + let on_drop = { + let read_file = read_file.clone(); + let status = status.clone(); + Callback::from(move |e: DragEvent| { + e.prevent_default(); + match e + .data_transfer() + .and_then(|dt| dt.files()) + .and_then(|fl| fl.item(0)) + { + Some(file) => read_file(file), + None => status.set("Dropped item was not a file.".to_string()), + } + }) + }; + let on_dragover = Callback::from(|e: DragEvent| e.prevent_default()); + + let open_picker = { + let file_ref = file_ref.clone(); + Callback::from(move |_: MouseEvent| { + if let Some(input) = file_ref.cast::() { + input.click(); + } + }) + }; + + let on_distortion_toggle = { + let fit_distortion = fit_distortion.clone(); + let markers = markers.clone(); + let do_refit = do_refit.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + fit_distortion.set(input.checked()); + do_refit(&markers); + }) + }; + + // sidebar parameter editing: update UI state and apply to the panorama + macro_rules! param_cb { + ($field:ident, $apply:expr) => {{ + let vp = vp.clone(); + let pan = pan.clone(); + Callback::from(move |v: f64| { + let mut u = *vp; + u.$field = v; + vp.set(u); + let f: &dyn Fn(&mut Panorama, f64) = &$apply; + f(&mut pan.borrow_mut(), v); + }) + }}; + } + let on_lat = param_cb!(lat, |p: &mut Panorama, v| p.set_view_lat(v)); + let on_lon = param_cb!(lon, |p, v| p.set_view_long(v)); + let on_height = param_cb!(height, |p, v| p.set_view_height(v)); + let on_az = param_cb!(az, |p, v| p.set_center_angle(v)); + let on_pitch = param_cb!(pitch, |p, v| p.set_pitch_angle(v)); + let on_roll = param_cb!(roll, |p, v| p.set_roll_angle(v)); + let on_vis = param_cb!(vis, |p, v| p.set_height_dist_ratio(0.11 - v)); + let on_focal = { + let vp = vp.clone(); + let pan = pan.clone(); + let img_size = img_size.clone(); + Callback::from(move |v: f64| { + let mut u = *vp; + u.focal = v; + vp.set(u); + let w = img_size.0 as f64; + if w > 0.0 { + pan.borrow_mut().set_scale(v * w / 35.0); + } + }) + }; + let on_font = { + let vp = vp.clone(); + Callback::from(move |v: f64| { + let mut u = *vp; + u.label_font = v as f32; + vp.set(u); + }) + }; + let on_show_hidden = { + let show_hidden = show_hidden.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + show_hidden.set(input.checked()); + }) + }; + + // compass strip: shares the image transform, drag changes azimuth + let compass_data = { + let p = pan.borrow(); + CompassData { + ptype: p.projection_type, + parms: p.parms, + center_deg: p.get_center_angle(), + zoom: view.scale, + cx: view.ox + img_size.0 as f64 * view.scale / 2.0, + max_view_angle: p.max_view_angle, + } + }; + let compass_change = { + let pan = pan.clone(); + let vp = vp.clone(); + Callback::from(move |deg: f64| { + pan.borrow_mut().set_center_angle(deg); + let mut u = *vp; + u.az = deg.rem_euclid(360.0); + vp.set(u); + }) + }; + + let fp_close = { + let find_peak = find_peak.clone(); + Callback::from(move |_: ()| find_peak.set(None)) + }; + + // Find Peak picker: searchable list over the geographically close hills + // (same candidate set and filtering as the desktop dialog) + let findpeak_popup = if let Some(fp) = &*find_peak { + let items: Vec<(String, usize)> = { + let p = pan.borrow(); + let q = fp.query.to_uppercase(); + let mut entries: Vec<(String, usize)> = p + .close + .iter() + .filter(|&&i| { + let h = &p.hills[i]; + h.flags & (FLAG_DUPLIC | FLAG_TRACK_POINT) == 0 + && (q.is_empty() || h.name.to_uppercase().contains(&q)) + }) + .map(|&i| { + ( + format!("{} ({} m)", p.hills[i].name, p.hills[i].height as i64), + i, + ) + }) + .collect(); + entries.sort_by(|a, b| a.0.cmp(&b.0)); + entries.truncate(300); + entries + }; + let on_pick = { + let mark = mark_peak.clone(); + let find_peak = find_peak.clone(); + let (ix, iy) = (fp.ix, fp.iy); + Callback::from(move |hill: usize| { + mark.emit((hill, ix, iy)); + find_peak.set(None); + }) + }; + let on_query = { + let find_peak = find_peak.clone(); + Callback::from(move |q: String| { + if let Some(mut fp) = (*find_peak).clone() { + fp.query = q; + find_peak.set(Some(fp)); + } + }) + }; + html! { + + } + } else { + Html::default() + }; + + let callbacks = ViewCallbacks { + pan: { + let view = view.clone(); + Callback::from(move |(dx, dy): (f64, f64)| { + let mut v = (*view).clone(); + v.ox += dx; + v.oy += dy; + view.set(v); + }) + }, + zoom: { + let view = view.clone(); + Callback::from(move |(cx, cy, factor): (f64, f64, f64)| { + let v = &*view; + let ns = (v.scale * factor).clamp(0.02, 64.0); + let k = ns / v.scale; + view.set(ViewState { + scale: ns, + ox: cx - (cx - v.ox) * k, + oy: cy - (cy - v.oy) * k, + }); + }) + }, + click: { + let pan = pan.clone(); + let view = view.clone(); + let mark = mark_peak.clone(); + let find_peak = find_peak.clone(); + let img_size = img_size.clone(); + let show_hidden = show_hidden.clone(); + Callback::from(move |(ix, iy): (f64, f64)| { + let scale = view.scale; + // unambiguous click right on a peak: mark directly + // (borrow must be released before mark -> do_refit!) + let near = { + let p = pan.borrow(); + markers::nearest_hill(&p, ix, iy, 10.0 / scale, *show_hidden) + }; + if let Some(idx) = near { + find_peak.set(None); + mark.emit((idx, ix, iy)); + return; + } + // otherwise open the Find Peak picker (searchable, like the + // desktop dialog): the correct peak may project far away + // while the viewpoint is still rough + let (w, h) = (img_size.0 as f64, img_size.1 as f64); + find_peak.set(Some(FindPeak { + sx: (ix + w / 2.0) * scale + view.ox, + sy: (iy + h / 2.0) * scale + view.oy, + ix, + iy, + query: String::new(), + })); + }) + }, + marker_drag: { + let markers = markers.clone(); + Callback::from(move |(i, dx, dy): (usize, f64, f64)| { + let mut mk = (*markers).clone(); + if let Some(m) = mk.get_mut(i) { + m.x += dx; + m.y += dy; + } + markers.set(mk); + }) + }, + drag_end: { + let markers = markers.clone(); + let do_refit = do_refit.clone(); + Callback::from(move |_: ()| do_refit(&markers)) + }, + context: { + let markers = markers.clone(); + let view = view.clone(); + let status = status.clone(); + let do_refit = do_refit.clone(); + Callback::from(move |(ix, iy): (f64, f64)| { + let mut mk = (*markers).clone(); + let before = mk.len(); + let r = 20.0 / view.scale; + mk.retain(|m| (m.x - ix).hypot(m.y - iy) >= r); + if mk.len() < before { + do_refit(&mk); + markers.set(mk); + status.set("Marker removed.".to_string()); + } else { + status.set("Right-click a marker to remove it.".to_string()); + } + }) + }, + hover: { + let pan = pan.clone(); + let view = view.clone(); + let hover = hover.clone(); + let show_hidden = show_hidden.clone(); + Callback::from(move |(ix, iy): (f64, f64)| { + let p = pan.borrow(); + let name = markers::nearest_hill(&p, ix, iy, 20.0 / view.scale, *show_hidden) + .map(|i| { + let h = &p.hills[i]; + format!("{} · {:.0} m", h.name, h.height) + }); + hover.set(name); + }) + }, + hover_end: { + let hover = hover.clone(); + Callback::from(move |_: ()| hover.set(None)) + }, + }; + + // overlay data for the canvas + let marker_views: Vec = { + let p = pan.borrow(); + markers + .iter() + .map(|m| MarkerView { + x: m.x, + y: m.y, + name: p.hills[m.hill].name.clone(), + }) + .collect() + }; + let candidates: Vec<(f64, f64, bool)> = { + let p = pan.borrow(); + p.visible + .iter() + .filter(|&&i| *show_hidden || p.hills[i].flags & FLAG_HIDDEN == 0) + .map(|&i| { + ( + p.hills[i].x, + p.hills[i].y, + p.hills[i].flags & FLAG_HIDDEN != 0, + ) + }) + .collect() + }; + + let zoom_pct = (view.scale * 100.0).round(); + let n_markers = markers.len(); + + html! { +
+ +
+
+ + { findpeak_popup.clone() } +
+ if bitmap.is_some() { + + } +
+
+ } +} diff --git a/crates/wipfel/src/bridge.rs b/crates/wipfel/src/bridge.rs new file mode 100644 index 0000000..6dbba93 --- /dev/null +++ b/crates/wipfel/src/bridge.rs @@ -0,0 +1,69 @@ +//! Small JS helpers: window access, browser-native image decode, blob +//! reads, canvas context — the hand-written JS boundary of the app. + +use js_sys::Uint8Array; +use wasm_bindgen::JsCast; +use wasm_bindgen_futures::JsFuture; +use web_sys::{Blob, CanvasRenderingContext2d, HtmlCanvasElement, ImageBitmap, Window}; + +pub fn window() -> Window { + web_sys::window().expect("no global window") +} + +/// Decode image bytes into a browser-native (GPU-backed) bitmap. +/// The browser does the JPEG decode and keeps the pixels where canvas +/// blitting is fast — cheaper than any pure-Rust path in wasm. +pub async fn decode_bitmap(bytes: &[u8]) -> Result { + let array = js_sys::Array::new(); + array.push(&Uint8Array::from(bytes).buffer()); + let blob = Blob::new_with_u8_array_sequence(&array).map_err(|_| "blob failed".to_string())?; + let promise = window() + .create_image_bitmap_with_blob(&blob) + .map_err(|_| "createImageBitmap failed".to_string())?; + let value = JsFuture::from(promise) + .await + .map_err(|e| format!("decode failed: {e:?}"))?; + value + .dyn_into::() + .map_err(|_| "decode produced non-bitmap".to_string()) +} + +/// Read a File/Blob fully into memory. +pub async fn read_blob(blob: &Blob) -> Result, String> { + let buf = JsFuture::from(blob.array_buffer()) + .await + .map_err(|e| format!("read failed: {e:?}"))?; + Ok(Uint8Array::new(&buf).to_vec()) +} + +/// Fetch a URL (same-origin) into memory. +pub async fn fetch_bytes(url: &str) -> Result, String> { + let resp = JsFuture::from(window().fetch_with_str(url)) + .await + .map_err(|e| format!("fetch {url}: {e:?}"))?; + let resp: web_sys::Response = resp + .dyn_into() + .map_err(|_| "bad response".to_string())?; + if !resp.ok() { + return Err(format!("{url}: HTTP {}", resp.status())); + } + let buf = JsFuture::from(resp.array_buffer().map_err(|_| "array_buffer".to_string())?) + .await + .map_err(|e| format!("body: {e:?}"))?; + Ok(Uint8Array::new(&buf).to_vec()) +} + +/// setTimeout as an awaitable Promise. +pub fn delay_promise(ms: i32) -> js_sys::Promise { + js_sys::Promise::new(&mut |resolve, _reject| { + let _ = window().set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms); + }) +} + +pub fn ctx2d(canvas: &HtmlCanvasElement) -> Option { + canvas + .get_context("2d") + .ok() + .flatten() + .and_then(|c| c.dyn_into::().ok()) +} diff --git a/crates/wipfel/src/canvas_view.rs b/crates/wipfel/src/canvas_view.rs new file mode 100644 index 0000000..9d4338e --- /dev/null +++ b/crates/wipfel/src/canvas_view.rs @@ -0,0 +1,481 @@ +//! Viewport canvas: browser-native bitmap blitted with a pan/zoom +//! transform, plus the marker overlay and its interactions. + +use web_sys::{HtmlCanvasElement, ImageBitmap, MouseEvent, PointerEvent, WheelEvent}; +use yew::prelude::*; + +use crate::bridge; + +/// Image -> screen transform: `screen = img * scale + (ox, oy)`. +/// Same convention as the desktop viewport widget. +#[derive(Clone, Debug, PartialEq, Default)] +pub struct ViewState { + pub scale: f64, + pub ox: f64, + pub oy: f64, +} + +/// A marker in center-relative image coordinates. +#[derive(Clone, Debug, PartialEq)] +pub struct MarkerView { + pub x: f64, + pub y: f64, + pub name: String, +} + +#[derive(Clone, PartialEq)] +pub struct ViewCallbacks { + pub pan: Callback<(f64, f64)>, + /// (cursor x, cursor y, factor) — zoom anchored at the cursor. + pub zoom: Callback<(f64, f64, f64)>, + /// click on empty space: (x, y) center-relative image coords + pub click: Callback<(f64, f64)>, + /// drag a marker: (marker index, dx, dy) in image coords + pub marker_drag: Callback<(usize, f64, f64)>, + /// a marker drag finished (time to refit) + pub drag_end: Callback<()>, + /// right-click: (x, y) center-relative image coords + pub context: Callback<(f64, f64)>, + /// pointer moved over the image (not dragging): (x, y) center-relative + pub hover: Callback<(f64, f64)>, + /// pointer left the canvas + pub hover_end: Callback<()>, +} + +#[derive(Properties, PartialEq)] +pub struct Props { + pub bitmap: Option, + pub view: ViewState, + pub callbacks: ViewCallbacks, + pub canvas_ref: NodeRef, + /// bumped on window resize to force a redraw + pub tick: u32, + pub markers: Vec, + /// projected positions of all visible hills (guide dots) with their + /// hidden-by-occlusion flag + pub candidates: Vec<(f64, f64, bool)>, + /// marker label font size, screen px + pub label_font: f32, +} + +#[derive(Clone, PartialEq)] +enum DragMode { + Pan, + Marker(usize), +} + +#[derive(PartialEq)] +struct DragState { + mode: Option, + last: (f64, f64), + start: (f64, f64), + moved: bool, +} + +#[function_component(CanvasView)] +pub fn canvas_view(props: &Props) -> Html { + let drag = use_mut_ref(|| DragState { + mode: None, + last: (0.0, 0.0), + start: (0.0, 0.0), + moved: false, + }); + + // redraw on every view/bitmap/marker change and on resize ticks + { + let bitmap = props.bitmap.clone(); + let view = props.view.clone(); + let canvas_ref = props.canvas_ref.clone(); + let markers = props.markers.clone(); + let candidates = props.candidates.clone(); + let label_font = props.label_font; + use_effect_with( + (bitmap, view, props.tick, markers.clone(), candidates.clone(), label_font), + move |(bitmap, view, _tick, markers, candidates, label_font)| { + let Some(canvas) = canvas_ref.cast::() else { + return; + }; + let Some(ctx) = bridge::ctx2d(&canvas) else { + return; + }; + let dpr = bridge::window().device_pixel_ratio(); + let cw = canvas.client_width() as f64; + let ch = canvas.client_height() as f64; + // keep the backing store in sync with the CSS size + let bw = (cw * dpr).max(1.0) as u32; + let bh = (ch * dpr).max(1.0) as u32; + if canvas.width() != bw || canvas.height() != bh { + canvas.set_width(bw); + canvas.set_height(bh); + } + let _ = ctx.set_transform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0); + // web-sys 0.3: set_fill_style takes a JsValue (deprecated alias) + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("#101014")); + ctx.fill_rect(0.0, 0.0, canvas.width() as f64, canvas.height() as f64); + let Some(bitmap) = bitmap else { return }; + let _ = ctx.set_transform( + dpr * view.scale, + 0.0, + 0.0, + dpr * view.scale, + dpr * view.ox, + dpr * view.oy, + ); + let _ = ctx.draw_image_with_image_bitmap(bitmap, 0.0, 0.0); + + // overlays in screen space + let _ = ctx.set_transform(dpr, 0.0, 0.0, dpr, 0.0, 0.0); + let hw = bitmap.width() as f64 / 2.0; + let hh = bitmap.height() as f64 / 2.0; + let sx = |x: f64| (x + hw) * view.scale + view.ox; + let sy = |y: f64| (y + hh) * view.scale + view.oy; + + // guide dots for all visible peaks: dark outline ring + + // bright core so they stay visible on any photo content; + // peaks hidden by nearer terrain are drawn grey + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.85)")); + for (cx, cy, _hidden) in candidates { + let (px, py) = (sx(*cx), sy(*cy)); + if px < -6.0 || py < -6.0 || px > cw + 6.0 || py > ch + 6.0 { + continue; + } + ctx.begin_path(); + let _ = ctx.arc(px, py, 4.5, 0.0, std::f64::consts::TAU); + ctx.fill(); + } + for (cx, cy, hidden) in candidates { + let (px, py) = (sx(*cx), sy(*cy)); + if px < -6.0 || py < -6.0 || px > cw + 6.0 || py > ch + 6.0 { + continue; + } + let color = if *hidden { "rgb(150, 150, 150)" } else { "rgb(110, 231, 183)" }; + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str(color)); + ctx.begin_path(); + let _ = ctx.arc(px, py, 2.5, 0.0, std::f64::consts::TAU); + ctx.fill(); + } + + // markers: yellow leader lines, red crosses, collision-free + // labels (port of the desktop viewport drawing) + if !markers.is_empty() { + let label_font = *label_font; + let line_h = label_font * 1.3 + 2.0; + ctx.set_font(&format!("{label_font:.0}px system-ui, sans-serif")); + // layout runs in screen space, sorted by x + let mut order: Vec = (0..markers.len()) + .filter(|&i| { + markers[i].x.abs() * 2.0 <= bitmap.width() as f64 + && markers[i].y.abs() * 2.0 <= bitmap.height() as f64 + }) + .collect(); + order.sort_by(|&a, &b| sx(markers[a].x).total_cmp(&sx(markers[b].x))); + let xs: Vec = order.iter().map(|&i| sx(markers[i].x) as f32).collect(); + let ys: Vec = order.iter().map(|&i| sy(markers[i].y) as f32).collect(); + let widths: Vec = order + .iter() + .map(|&i| { + ctx.measure_text(&markers[i].name) + .map(|m| m.width() as f32) + .unwrap_or_else(|_| markers[i].name.len() as f32 * 7.0) + }) + .collect(); + let in_img = vec![true; order.len()]; + let entries = layout_label_y(&xs, &ys, &widths, &in_img, line_h); + + // leaders (yellow): cross, vertical, horizontal + #[allow(deprecated)] + ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str("rgb(255, 230, 51)")); + ctx.set_line_width(1.0); + for (k, &i) in order.iter().enumerate() { + let (px, py) = (sx(markers[i].x), sy(markers[i].y)); + let (lx, ly) = entries[k]; + let label_line = py + ly as f64 - line_h as f64; + ctx.begin_path(); + ctx.move_to(px - 4.0, py); + ctx.line_to(px + 4.0, py); + ctx.move_to(px, py); + ctx.line_to(px, label_line); + ctx.move_to(px, label_line); + ctx.line_to(px + lx as f64, label_line); + ctx.stroke(); + } + // marker crosses (always red) + #[allow(deprecated)] + ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str("rgb(255, 64, 64)")); + ctx.set_line_width(1.5); + for &i in &order { + let (px, py) = (sx(markers[i].x), sy(markers[i].y)); + ctx.begin_path(); + ctx.move_to(px - 5.0, py); + ctx.line_to(px + 5.0, py); + ctx.move_to(px, py - 5.0); + ctx.line_to(px, py + 5.0); + ctx.stroke(); + } + // labels: white on dark shadow, right-aligned at leader end + for (k, &i) in order.iter().enumerate() { + if markers[i].name.is_empty() { + continue; + } + let (px, py) = (sx(markers[i].x), sy(markers[i].y)); + let (lx, ly) = entries[k]; + let label_line = py + ly as f64 - line_h as f64; + let tx = px + lx as f64 - widths[k] as f64; + let ty = label_line - 3.0; + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.85)")); + ctx.fill_text(&markers[i].name, tx + 1.0, ty + 1.0).ok(); + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("white")); + ctx.fill_text(&markers[i].name, tx, ty).ok(); + } + } + }, + ); + } + + // screen (client) -> center-relative image coordinates + let to_img = { + let canvas_ref = props.canvas_ref.clone(); + let view = props.view.clone(); + let bitmap = props.bitmap.clone(); + let w = bitmap.as_ref().map(|b| b.width() as f64).unwrap_or(0.0); + let h = bitmap.as_ref().map(|b| b.height() as f64).unwrap_or(0.0); + move |client_x: f64, client_y: f64| -> (f64, f64) { + let rect = canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect()); + let (rx, ry) = match rect { + Some(r) => (client_x - r.left(), client_y - r.top()), + None => (client_x, client_y), + }; + ( + (rx - view.ox) / view.scale - w / 2.0, + (ry - view.oy) / view.scale - h / 2.0, + ) + } + }; + + let on_pointerdown = { + let drag = drag.clone(); + let canvas_ref = props.canvas_ref.clone(); + let markers = props.markers.clone(); + let view = props.view.clone(); + let bitmap = props.bitmap.clone(); + Callback::from(move |e: PointerEvent| { + e.prevent_default(); + if let Some(c) = canvas_ref.cast::() { + let _ = c.set_pointer_capture(e.pointer_id()); + } + let rect = canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect()); + let (rx, ry) = match rect { + Some(r) => (e.client_x() as f64 - r.left(), e.client_y() as f64 - r.top()), + None => (e.client_x() as f64, e.client_y() as f64), + }; + // marker hit-test (screen space, 12 px radius) + let mut mode = DragMode::Pan; + if let Some(bmp) = &bitmap { + let hw = bmp.width() as f64 / 2.0; + let hh = bmp.height() as f64 / 2.0; + for (i, m) in markers.iter().enumerate().rev() { + let px = (m.x + hw) * view.scale + view.ox; + let py = (m.y + hh) * view.scale + view.oy; + if (rx - px).hypot(ry - py) < 12.0 { + mode = DragMode::Marker(i); + break; + } + } + } + let pos = (e.client_x() as f64, e.client_y() as f64); + let mut d = drag.borrow_mut(); + d.mode = Some(mode); + d.last = pos; + d.start = pos; + d.moved = false; + }) + }; + + let on_pointermove = { + let drag = drag.clone(); + let pan_cb = props.callbacks.pan.clone(); + let marker_drag = props.callbacks.marker_drag.clone(); + let hover = props.callbacks.hover.clone(); + let to_img = to_img.clone(); + let scale = props.view.scale; + Callback::from(move |e: PointerEvent| { + let mut d = drag.borrow_mut(); + let mode = match &d.mode { + Some(m) => m.clone(), + None => { + // free hover: report position for peak identification + let (ix, iy) = to_img(e.client_x() as f64, e.client_y() as f64); + hover.emit((ix, iy)); + return; + } + }; + let pos = (e.client_x() as f64, e.client_y() as f64); + let dx = pos.0 - d.last.0; + let dy = pos.1 - d.last.1; + d.last = pos; + if (pos.0 - d.start.0).hypot(pos.1 - d.start.1) > 3.0 { + d.moved = true; + } + if !d.moved { + return; + } + match mode { + DragMode::Pan => pan_cb.emit((dx, dy)), + DragMode::Marker(i) => marker_drag.emit((i, dx / scale, dy / scale)), + } + }) + }; + + let on_pointerleave = { + let hover_end = props.callbacks.hover_end.clone(); + Callback::from(move |_: PointerEvent| hover_end.emit(())) + }; + + let on_pointerup = { + let drag = drag.clone(); + let canvas_ref = props.canvas_ref.clone(); + let click = props.callbacks.click.clone(); + let drag_end = props.callbacks.drag_end.clone(); + let to_img = to_img.clone(); + Callback::from(move |e: PointerEvent| { + let mode = drag.borrow_mut().mode.take(); + if let Some(c) = canvas_ref.cast::() { + let _ = c.release_pointer_capture(e.pointer_id()); + } + let moved = drag.borrow().moved; + match mode { + Some(DragMode::Pan) if !moved => { + let (ix, iy) = to_img(e.client_x() as f64, e.client_y() as f64); + click.emit((ix, iy)); + } + Some(DragMode::Marker(_)) if moved => drag_end.emit(()), + _ => {} + } + }) + }; + + let on_pointercancel = { + let drag = drag.clone(); + Callback::from(move |_: PointerEvent| { + drag.borrow_mut().mode = None; + }) + }; + + let on_contextmenu = { + let context = props.callbacks.context.clone(); + let to_img = to_img.clone(); + Callback::from(move |e: MouseEvent| { + e.prevent_default(); + let (ix, iy) = to_img(e.client_x() as f64, e.client_y() as f64); + context.emit((ix, iy)); + }) + }; + + let on_wheel = { + let zoom = props.callbacks.zoom.clone(); + let canvas_ref = props.canvas_ref.clone(); + Callback::from(move |e: WheelEvent| { + e.prevent_default(); + let cx = e.client_x() as f64 + - canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect().left()) + .unwrap_or(0.0); + let cy = e.client_y() as f64 + - canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect().top()) + .unwrap_or(0.0); + let factor = 1.0015f64.powf(-(e.delta_y() as f64)); + zoom.emit((cx, cy, factor)); + }) + }; + + html! { + + } +} + +/// Port of the desktop `viewport::layout_label_y`: place labels right of +/// their crosses, pushing colliding ones up; iterate to a fixed point +/// (the C single pass can leave overlaps). Inputs must be sorted by x. +fn layout_label_y( + xs: &[f32], + ys: &[f32], + widths: &[f32], + in_img: &[bool], + line_h: f32, +) -> Vec<(f32, f32)> { + let n = xs.len(); + let mut label_x = vec![0.0f32; n]; + let mut label_y = vec![0.0f32; n]; + let cross = 4.0f32; + let overlap = |a1: f32, l1: f32, a2: f32, l2: f32| a1 <= a2 + l2 && a1 + l1 >= a2; + + for i in 0..n { + if !in_img[i] { + continue; + } + label_x[i] = widths[i] + 1.0; + label_y[i] = 0.0; + + let mut colliding: Vec = Vec::new(); + for j in (0..i).rev() { + if !in_img[j] { + continue; + } + if overlap(xs[i], label_x[i], xs[j] - cross, label_x[j]) { + colliding.push(j); + } else { + break; + } + } + colliding.sort_by(|&a, &b| { + let ya = ys[a] + label_y[a]; + let yb = ys[b] + label_y[b]; + yb.total_cmp(&ya) + }); + for _round in 0..64 { + let mut pushed = false; + for &j in &colliding { + if overlap( + ys[i] + label_y[i] - line_h, + line_h, + ys[j] + label_y[j] - line_h, + line_h, + ) || overlap(ys[i] + label_y[i] - line_h, line_h, ys[j] - cross, 2.0 * cross) + { + let ny = (ys[j] + label_y[j] - ys[i] - line_h - 2.0).round(); + if ny < label_y[i] { + label_y[i] = ny; + pushed = true; + } + } + } + if !pushed { + break; + } + } + } + + (0..n).map(|i| (label_x[i], label_y[i])).collect() +} diff --git a/crates/wipfel/src/compass.rs b/crates/wipfel/src/compass.rs new file mode 100644 index 0000000..b539e07 --- /dev/null +++ b/crates/wipfel/src/compass.rs @@ -0,0 +1,349 @@ +//! Compass strip (canvas port of the desktop `compass.rs`, Aligned style): +//! shares the image's horizontal transform so each direction sits above +//! its position in the image; drag horizontally to change the view azimuth. + +use web_sys::{HtmlCanvasElement, PointerEvent};use yew::prelude::*; + +use gipfel_core::projection::{projection_from_type, ProjArgs, Projection, ProjectionType, ViewParams}; + +use crate::bridge; + +pub const STRIP_H: f64 = 56.0; + +/// Damped, clamped Newton iteration for a scalar inverse projection: find +/// `a` such that `f(a) ≈ target` (identical to the desktop solver). +pub fn newton_inverse( + target: f64, + mut f: impl FnMut(f64) -> Option, + seed: f64, + lo: f64, + hi: f64, +) -> f64 { + let mut a = seed.clamp(lo, hi); + for _ in 0..6 { + let Some(y) = f(a) else { break }; + let resid = y - target; + let h = 1e-5; + let (Some(y1), Some(y2)) = (f(a + h), f(a - h)) else { + break; + }; + let d = (y1 - y2) / (2.0 * h); + if !d.is_finite() || d.abs() < 1e-9 { + break; + } + let step = (resid / d).clamp(-0.3, 0.3); + a = (a - step).clamp(lo, hi); + if step.abs() < 1e-10 { + break; + } + } + a +} + +/// azimuth whose image x is `x_img`, measured with `c_ref` as center angle +pub fn alph_at_img_x( + ptype: ProjectionType, + proj: &dyn Projection, + p: &ViewParams, + x_img: f64, + c_ref: f64, +) -> f64 { + let mut p = *p; + p.a_center = c_ref; + let seed = match ptype { + ProjectionType::Rectilinear => c_ref + (x_img / p.scale).atan(), + ProjectionType::Cylindrical => c_ref + x_img / p.scale, + }; + let (lo, hi) = match ptype { + ProjectionType::Rectilinear => (c_ref - 1.55, c_ref + 1.55), + ProjectionType::Cylindrical => (c_ref - 3.1, c_ref + 3.1), + }; + newton_inverse( + x_img, + |a| Some(proj.mac_x(ProjArgs::from_params(&p, a, 0.0))), + seed, + lo, + hi, + ) +} + +const DIRS: [(f64, &str); 8] = [ + (0.0, "N"), + (45.0, "NE"), + (90.0, "E"), + (135.0, "SE"), + (180.0, "S"), + (225.0, "SW"), + (270.0, "W"), + (315.0, "NW"), +]; + +/// everything the strip needs; all plain data so Yew can diff it +#[derive(Clone, Copy, PartialEq)] +pub struct CompassData { + pub ptype: ProjectionType, + pub parms: ViewParams, + pub center_deg: f64, + pub zoom: f64, + /// screen x of the image center (strip shares the image transform) + pub cx: f64, + /// lens FOV half-angle limit, radians (0 = none) + pub max_view_angle: f64, +} + +#[derive(Properties, PartialEq)] +pub struct Props { + pub data: CompassData, + /// bumped on window resize to force a redraw + pub tick: u32, + /// new azimuth in degrees while dragging + pub on_change: Callback, +} + +#[function_component(Compass)] +pub fn compass(props: &Props) -> Html { + let canvas_ref = use_node_ref(); + let drag = use_mut_ref(|| Option::<(f64, f64)>::None); // (press x, center_deg) + + let d = props.data; + + // draw + { + let canvas_ref = canvas_ref.clone(); + use_effect_with((d, props.tick), move |(d, _tick)| { + let Some(canvas) = canvas_ref.cast::() else { + return; + }; + let Some(ctx) = bridge::ctx2d(&canvas) else { + return; + }; + let dpr = bridge::window().device_pixel_ratio(); + let w = canvas.client_width() as f64; + let bw = (w * dpr).max(1.0) as u32; + let bh = (STRIP_H * dpr).max(1.0) as u32; + if canvas.width() != bw || canvas.height() != bh { + canvas.set_width(bw); + canvas.set_height(bh); + } + let _ = ctx.set_transform(dpr, 0.0, 0.0, dpr, 0.0, 0.0); + + let on = "rgb(217, 217, 217)"; + let bg = "rgb(41, 41, 41)"; + let divider = "rgb(82, 82, 82)"; + let red = "rgb(255, 102, 64)"; + + let fill = |c: &str| { + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str(c)); + }; + let stroke = |c: &str, width: f64| { + #[allow(deprecated)] + ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str(c)); + ctx.set_line_width(width); + }; + + fill(bg); + ctx.fill_rect(0.0, 0.0, w, STRIP_H); + stroke(divider, 1.0); + ctx.begin_path(); + ctx.move_to(0.0, 0.5); + ctx.line_to(w, 0.5); + ctx.stroke(); + + let label_y = 17.0f64; // text baseline of the direction row + let y0 = (STRIP_H - 10.0).round(); // baseline of the ticks + let tri_y = 25.0f64; + let z = d.zoom; + let proj = projection_from_type(d.ptype); + let cx = d.cx; + let c = d.parms.a_center; + + let x_img_at = |alph: f64| proj.get_coordinates(alph, 0.0, &d.parms).0; + + // adaptive tick step: first that yields >= 6 px spacing + let ppd = ((x_img_at(c + 1f64.to_radians()) - x_img_at(c - 1f64.to_radians())) + * z + / 2.0) + .abs(); + let step = [1.0f64, 2.0, 5.0, 10.0, 15.0, 30.0, 45.0, 90.0] + .into_iter() + .find(|s| s * ppd >= 6.0) + .unwrap_or(90.0); + + let a_lo = alph_at_img_x(d.ptype, &*proj, &d.parms, -cx / z, c) + .min(c - std::f64::consts::PI); + let a_hi = alph_at_img_x(d.ptype, &*proj, &d.parms, (w - cx) / z, c) + .max(c + std::f64::consts::PI); + // rectilinear folds directions behind the camera onto the same + // pixels; also clamp to the lens FOV (distortion can fold + // out-of-view directions back onto the strip) + let mut fold = match d.ptype { + ProjectionType::Rectilinear => 1.535, + ProjectionType::Cylindrical => std::f64::consts::PI, + }; + if d.max_view_angle > 0.0 { + fold = fold.min(d.max_view_angle); + } + let a_lo = a_lo.max(c - fold); + let a_hi = a_hi.min(c + fold); + + // baseline + stroke(on, 1.0); + ctx.begin_path(); + ctx.move_to(0.0, y0 + 0.5); + ctx.line_to(w, y0 + 0.5); + ctx.stroke(); + + // ticks + let step_rad = step.to_radians(); + let mut a = (a_lo / step_rad).floor() * step_rad; + while a <= a_hi { + let x = cx + x_img_at(a) * z; + if x.is_finite() && x >= -1.0 && x <= w + 1.0 { + let rem = a.to_degrees().rem_euclid(45.0); + let major = rem.min(45.0 - rem) < step / 2.0; + let x = x.round(); + ctx.begin_path(); + ctx.move_to(x, y0); + ctx.line_to(x, y0 - if major { 12.0 } else { 6.0 }); + ctx.stroke(); + } + a += step_rad; + } + + // direction labels + ctx.set_font("13px system-ui, sans-serif"); + ctx.set_text_align("center"); + for (deg, name) in DIRS { + let alph = deg.to_radians(); + let rel = (alph - c + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) + - std::f64::consts::PI; + if rel.abs() > fold { + continue; + } + let x = cx + x_img_at(alph) * z; + if !x.is_finite() || x < -20.0 || x > w + 20.0 { + continue; + } + fill(if deg == 0.0 { red } else { on }); + ctx.fill_text(name, x, label_y).ok(); + } + ctx.set_text_align("start"); + + // center marker: triangle + hairline + azimuth readout + fill(red); + ctx.begin_path(); + ctx.move_to(cx - 6.0, tri_y); + ctx.line_to(cx + 6.0, tri_y); + ctx.line_to(cx, tri_y + 8.0); + ctx.close_path(); + ctx.fill(); + stroke(red, 1.0); + ctx.begin_path(); + ctx.move_to(cx.round(), tri_y + 8.0); + ctx.line_to(cx.round(), y0); + ctx.stroke(); + fill(red); + ctx.fill_text(&format!("{:05.1}°", d.center_deg.rem_euclid(360.0)), cx + 10.0, tri_y + 9.0) + .ok(); + }); + } + + let local_x = { + let canvas_ref = canvas_ref.clone(); + move |client_x: f64| { + client_x + - canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect().left()) + .unwrap_or(0.0) + } + }; + + let on_pointerdown = { + let drag = drag.clone(); + let canvas_ref = canvas_ref.clone(); + let center_deg = props.data.center_deg; + Callback::from(move |e: PointerEvent| { + e.prevent_default(); + if let Some(c) = canvas_ref.cast::() { + let _ = c.set_pointer_capture(e.pointer_id()); + } + *drag.borrow_mut() = Some((e.client_x() as f64, center_deg)); + }) + }; + let on_pointermove = { + let drag = drag.clone(); + let on_change = props.on_change.clone(); + let d = props.data; + Callback::from(move |e: PointerEvent| { + let Some((x0, c0_deg)) = *drag.borrow() else { + return; + }; + let proj = projection_from_type(d.ptype); + let c0 = c0_deg.to_radians(); + let lx0 = local_x(e.client_x() as f64); + let a0 = alph_at_img_x(d.ptype, &*proj, &d.parms, (x0 - d.cx) / d.zoom, c0); + let a1 = alph_at_img_x(d.ptype, &*proj, &d.parms, (lx0 - d.cx) / d.zoom, c0); + on_change.emit((c0 - (a1 - a0)).to_degrees()); + }) + }; + let on_pointerup = { + let drag = drag.clone(); + let canvas_ref = canvas_ref.clone(); + Callback::from(move |e: PointerEvent| { + *drag.borrow_mut() = None; + if let Some(c) = canvas_ref.cast::() { + let _ = c.release_pointer_capture(e.pointer_id()); + } + }) + }; + + html! { + + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn roundtrip(ptype: ProjectionType, k0: f64, k1: f64, x0: f64) { + let proj = projection_from_type(ptype); + let mut parms = ViewParams::new(); + parms.a_center = 0.3; + parms.scale = 3000.0; + parms.k0 = k0; + parms.k1 = k1; + parms.x0 = x0; + for x in [-2500.0, -800.0, -50.0, 0.0, 120.0, 900.0, 2400.0] { + let a = alph_at_img_x(ptype, &*proj, &parms, x, parms.a_center); + let (x2, _) = proj.get_coordinates(a, 0.0, &parms); + assert!( + (x2 - x).abs() < 1e-6, + "{ptype:?} x={x}: round-trips to {x2} (alph {a})" + ); + } + } + + #[test] + fn inverse_rectilinear() { + roundtrip(ProjectionType::Rectilinear, 0.0, 0.0, 0.0); + } + #[test] + fn inverse_rectilinear_distorted() { + roundtrip(ProjectionType::Rectilinear, 0.002, -0.0003, 0.01); + } + #[test] + fn inverse_cylindrical() { + roundtrip(ProjectionType::Cylindrical, 0.0, 0.0, 0.0); + } +} diff --git a/crates/wipfel/src/main.rs b/crates/wipfel/src/main.rs new file mode 100644 index 0000000..741393b --- /dev/null +++ b/crates/wipfel/src/main.rs @@ -0,0 +1,10 @@ +mod app; +mod bridge; +mod canvas_view; +mod compass; +mod markers; +mod widgets; + +fn main() { + yew::Renderer::::new().render(); +} diff --git a/crates/wipfel/src/markers.rs b/crates/wipfel/src/markers.rs new file mode 100644 index 0000000..d024f2e --- /dev/null +++ b/crates/wipfel/src/markers.rs @@ -0,0 +1,60 @@ +//! Markers: user observations of hills at image positions, plus the +//! refit entry point. Coordinates are center-relative image pixels, +//! matching the projection output space (same convention as the +//! desktop viewport widget). + +use gipfel_core::hill::Hill; +use gipfel_core::panorama::Panorama; + +#[derive(Clone, Debug, PartialEq)] +pub struct Marker { + /// index into `Panorama::hills` (stable: load order is preserved) + pub hill: usize, + pub x: f64, + pub y: f64, +} + +/// Refit the projection parameters to the current markers. +/// Same graduated behavior as the original: 1 marker fits the center +/// angle, 2 add the scale, 4+ the full viewpoint (+ distortion when +/// unlocked and enough markers). +pub fn refit(pan: &mut Panorama, markers: &[Marker], fit_distortion: bool) -> Result<(), String> { + if markers.is_empty() { + return Ok(()); + } + let mut obs: Vec = Vec::with_capacity(markers.len()); + for m in markers { + let mut h = pan.hills[m.hill].clone(); + h.x = m.x; + h.y = m.y; + obs.push(h); + } + let known: Vec = (0..markers.len()).collect(); + pan.comp_params_with(&obs, &known, fit_distortion) +} + +/// Nearest visible hill to image position `(x, y)`, within `max_dist` +/// image pixels. Used to resolve marker clicks. Hills hidden by the +/// occlusion heuristic are skipped unless `show_hidden`. +pub fn nearest_hill( + pan: &Panorama, + x: f64, + y: f64, + max_dist: f64, + show_hidden: bool, +) -> Option { + let mut best = None; + let mut best_d = max_dist; + for &i in &pan.visible { + if !show_hidden && pan.hills[i].flags & gipfel_core::hill::FLAG_HIDDEN != 0 { + continue; + } + let h = &pan.hills[i]; + let d = (h.x - x).hypot(h.y - y); + if d < best_d { + best_d = d; + best = Some(i); + } + } + best +} diff --git a/crates/wipfel/src/widgets.rs b/crates/wipfel/src/widgets.rs new file mode 100644 index 0000000..1d22bac --- /dev/null +++ b/crates/wipfel/src/widgets.rs @@ -0,0 +1,77 @@ +//! Small form controls: full-width slider with value readout above +//! (mirrors the desktop `slider_item` layout) and a numeric input row. + +use web_sys::{HtmlInputElement, InputEvent}; +use yew::prelude::*; + +#[derive(Properties, PartialEq)] +pub struct SliderProps { + pub label: AttrValue, + /// formatted value shown right of the label + pub display: AttrValue, + pub value: f64, + pub min: f64, + pub max: f64, + pub step: f64, + pub onchange: Callback, +} + +#[function_component(SliderItem)] +pub fn slider_item(p: &SliderProps) -> Html { + // live update while dragging (oninput), not only on release + let oninput = { + let onchange = p.onchange.clone(); + Callback::from(move |e: InputEvent| { + let input: HtmlInputElement = e.target_unchecked_into(); + if let Ok(v) = input.value().parse::() { + onchange.emit(v); + } + }) + }; + html! { +
+
+ { p.label.as_ref().to_string() } + { p.display.as_ref().to_string() } +
+ +
+ } +} + +#[derive(Properties, PartialEq)] +pub struct NumProps { + pub label: AttrValue, + pub value: f64, + pub step: f64, + #[prop_or(2)] + pub decimals: usize, + pub onchange: Callback, +} + +#[function_component(NumItem)] +pub fn num_item(p: &NumProps) -> Html { + let onchange = { + let onchange = p.onchange.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + if let Ok(v) = input.value().parse::() { + onchange.emit(v); + } + }) + }; + let display = format!("{:.*}", p.decimals, p.value); + html! { + + } +} diff --git a/crates/wipfel/www/style.css b/crates/wipfel/www/style.css new file mode 100644 index 0000000..5122c43 --- /dev/null +++ b/crates/wipfel/www/style.css @@ -0,0 +1,221 @@ +* { + box-sizing: border-box; +} +html, +body { + margin: 0; + height: 100%; + font-family: system-ui, sans-serif; +} +.app { + display: flex; + height: 100vh; + background: #101014; + color: #e8e8ea; +} +.sidebar { + width: 300px; + padding: 16px; + background: #1a1a20; + border-right: 1px solid #2c2c34; + display: flex; + flex-direction: column; + gap: 8px; + overflow-y: auto; +} +.sidebar h1 { + margin: 0; + font-size: 22px; +} +.tag { + margin: 0 0 12px; + color: #8a8a94; + font-size: 12px; + text-transform: uppercase; + letter-spacing: 1px; +} +.sidebar button { + padding: 8px 12px; + background: #3b6fd4; + color: #fff; + border: 0; + border-radius: 6px; + font-size: 14px; + cursor: pointer; +} +.sidebar button:hover { + background: #4a7ee4; +} +.status { + font-size: 13px; + color: #c8c8d0; + word-break: break-word; +} +.hint { + font-size: 12px; + color: #8a8a94; +} +.row { + display: flex; + gap: 6px; + align-items: center; + font-size: 13px; + cursor: pointer; +} +.fitinfo { + font-size: 12px; + color: #9fd09f; + font-variant-numeric: tabular-nums; +} +.hover { + font-size: 14px; + font-weight: 600; + color: #ffffff; +} +.dim { + opacity: 0.6; +} +.hidden-file { + display: none; +} +.main { + flex: 1; + min-width: 0; + display: flex; + flex-direction: column; +} +.canvaswrap { + flex: 1; + position: relative; + min-height: 0; +} +canvas.viewport { + position: absolute; + inset: 0; + width: 100%; + height: 100%; + display: block; + touch-action: none; + cursor: grab; +} +canvas.compass { + display: block; + width: 100%; + touch-action: none; + cursor: ew-resize; +} +.section { + margin-top: 14px; + font-size: 11px; + text-transform: uppercase; + letter-spacing: 1px; + color: #8a8a94; + border-bottom: 1px solid #2c2c34; + padding-bottom: 3px; +} +.slider { + display: flex; + flex-direction: column; + gap: 2px; + margin-top: 8px; +} +.sliderhead { + display: flex; + justify-content: space-between; + font-size: 12px; + color: #c8c8d0; +} +.slider input[type="range"] { + width: 100%; +} +.numrow { + display: flex; + justify-content: space-between; + align-items: center; + gap: 8px; + font-size: 13px; + margin-top: 6px; +} +.numrow input { + width: 130px; + padding: 4px 6px; + background: #24242c; + color: #e8e8ea; + border: 1px solid #34343e; + border-radius: 4px; +} +.fpbackdrop { + position: absolute; + inset: 0; + z-index: 9; +} +.findpeak { + position: absolute; + z-index: 10; + width: 280px; + background: #1e1e26; + border: 1px solid #3a3a46; + border-radius: 6px; + box-shadow: 0 8px 24px rgba(0, 0, 0, 0.5); + display: flex; + flex-direction: column; +} +.fpsearch { + padding: 8px; + border-bottom: 1px solid #2c2c34; +} +.fpsearch input { + width: 100%; + padding: 5px 8px; + background: #24242c; + border: 1px solid #3a3a46; + border-radius: 4px; + color: #e8e8ea; + font-size: 13px; +} +.fplist { + max-height: 320px; + overflow-y: auto; +} +.fpempty { + padding: 8px 10px; + font-size: 13px; + color: #8a8a94; + margin: 0; +} +.fpfoot { + padding: 6px 8px; + border-top: 1px solid #2c2c34; + text-align: right; +} +.fpcancel { + padding: 4px 12px; + background: #34343e; + color: #e8e8ea; + border: 0; + border-radius: 4px; + font-size: 12px; + cursor: pointer; +} +.fphead { + padding: 6px 10px; + font-size: 11px; + text-transform: uppercase; + letter-spacing: 1px; + color: #8a8a94; + border-bottom: 1px solid #2c2c34; +} +.fpitem { + display: block; + width: 100%; + text-align: left; + padding: 6px 10px; + background: none; + border: 0; + color: #e8e8ea; + font-size: 13px; + cursor: pointer; +} +.fpitem:hover { + background: #2f6fd4; +} diff --git a/plan.md b/plan.md new file mode 100644 index 0000000..9796beb --- /dev/null +++ b/plan.md @@ -0,0 +1,371 @@ +# Plan: Porting gipfel to a Cosmic DE Application in Rust + +Status: **planning only — no implementation started** +Reference: C++/FLTK sources in `src/` (gipfel 0.4.1, commit `45425dd`) + +--- + +## 1. Analysis of the Existing Application + +### 1.1 What gipfel does + +gipfel is "georeferencing for arbitrary images": given a photo, the GPS position of +the camera, and two or more manually identified peaks in the image, it fits the +camera view parameters and then labels all other peaks/POIs from a GPS database +directly on the image. It also stitches referenced images into panoramas. + +### 1.2 Module map (current C++/FLTK) + +| Component | Files | Responsibility | +|---|---|---| +| Main / control window | `gipfel.cxx` | CLI parsing, two FLTK windows (control + scrolled image), menu bar, sliders/dials, stitching & export CLI modes | +| Image canvas | `GipfelWidget.cxx/.H` | Draws image + labels + markers + GPS track; mouse interaction (see 1.4) | +| Domain model | `Panorama.cxx/.H` | Viewpoint (lat/lon/height), hill DB, azimuth/nick/distance with earth curvature (`EARTH_RADIUS 6371000.785`), refraction model (Tom Chester approximation), hidden-object detection (cone model + `hide_value` / "Visibility" slider), visible-hill computation | +| Projection + fit | `ProjectionLSQ.*`, `ProjectionRectilinear.*`, `ProjectionCylindrical.*` | Non-linear least squares (GSL `gsl_multifit_fdfsolver_lmsder`, max 100 iterations) over `ViewParams {a_center, a_nick, a_tilt, scale, k0, k1, x0}`. Fit level depends on # marked hills: 1 hill → 2 params, 2–3 → 4 params, ≥4 → 7 params (lens distortion calibration) | +| **Symbolic codegen** | `lsq_rectilinear.mac`, `lsq_cylindrical.mac`, `expr2c.mac`, `Makefile.lsq_funcs` | **maxima** computes the projection equations and all analytic partial derivatives (Jacobian) symbolically and emits C functions `mac_x`, `mac_y`, `mac_x_d*` into `Projection*_funcs.cxx` | +| Data model | `Hill.cxx/.H` | `Hill {phi, lam, height, alph, a_nick, dist, x, y, flags}`, `Hills` collection, CSV loader, duplicate marking, sorting | +| Metadata | `ImageMetaData.cxx/.H` | EXIF read via exiv2 (GPS lat/lon/alt, focal length, 35mm-equiv, Make/Model) + own serialization of fit results into the **JPEG comment** (`gipfel: longitude …, latitude …, height …, direction …, nick …, tilt …, focal_length_35mm …, projection type N, k0 …, k1 …, x0 …`) | +| Stitching | `Stitch.*`, `ScanImage.*`, `OutputImage.*`, `JPEG/TIFF/PreviewOutputImage.*` | Resample a view-angle range across referenced images (nearest/bicubic), output JPEG/TIFF (8/16-bit) or on-screen preview | +| Custom widgets | `Fl_Value_Dial.*`, `Fl_Search_Chooser.*`, `choose_hill.*` | Compass dial (view direction), searchable hill picker dialog | +| Preferences | `GipfelWidget.cxx` (Fl_Preferences) | Distortion profiles in `$HOME/.fltk/Johannes.HofmannATgmx.de/gipfel` | +| Data file | `gipfel.dat` (~21k rows) | `SHORTNAME,NAME,DESCRIPTION,LATITUDE,LONGITUDE,HEIGHT` per line | + +### 1.3 Data flow + +``` +gipfel.dat ─┐ +EXIF/JPEG ──┼─► Panorama (viewpoint, angles, distances, refraction, visibility) +user marks ─┘ │ + ▼ + ProjectionLSQ.comp_params() ◄── maxima-generated mac_* + Jacobian + │ ViewParams + ▼ + get_coordinates(alph, nick) → (x, y) per hill ─► GipfelWidget redraw +``` + +### 1.4 Interaction model (to preserve / improve) + +- **Middle-click** a label cross → mark hill as known (turns red) +- **Left-drag** a marked cross → position it on the peak; on release, refit +- **Right-click** → context menu: "Find Peak", "Hide/Unhide " +- **Hover** → tooltip "name (height m), distance x.xkm" +- Control window: compass dial (view direction), sliders (nick, tilt, focal length + in 35mm, visibility, track width), numeric inputs (viewpoint lat/lon/height, + distortion k0/k1/x0) +- CLI modes: `-s` stitch, `-e/-E` export hills, `-p` export position + +### 1.5 Constraints carried into the port + +- **The algorithm stays as-is**: same projection math, same LM fit strategy, same + refraction/visibility models, **same maxima-based symbolic derivative generation**. +- Wire formats stay compatible: `gipfel.dat` CSV, the JPEG-comment parameter string + (so images referenced with the old gipfel still open correctly), distortion + profile semantics. + +--- + +## 2. Target Application + +**gipfel-rs**: a native [Cosmic](https://system76.com/cosmic) DE application built +with `cosmic-toolkit` (`cosmic::app`, iced under the hood), single window, with +optional image zooming. + +### 2.1 UI concept — single window + +The FLTK version uses two windows (control + image) plus modal dialogs. The Cosmic +port consolidates everything into one window: + +``` +┌──────────────────────────────────────────────────────────────────────┐ +│ ⌘ Menu (File / Projection / Distortion / Options / Help) │ +├──────────────────────────────────────────────────────────────────────┤ +│ Viewpoint: [✎] Lat [____] Lon [____] Hgt [____] │ +├───────────────────────────────┬──────────────────────────────────────┤ +│ │ Controls (collapsible sidebar) │ +│ │ ┌───────────┐ ┌────────────────┐ │ +│ Image canvas │ │ compass │ │ Focal length ⌬ │ │ +│ (custom iced Canvas) │ │ dial │ │ Nick ⌬ │ │ +│ │ │ (view dir)│ │ Tilt ⌬ │ │ +│ - pan: drag / space+drag │ └───────────┘ │ Visibility ⌬ │ │ +│ - zoom: ctrl+scroll, +/-, │ │ Track width ⌬ │ │ +│ pinch; fit / 1:1 buttons │ Distortion k0/k1/x0 [advanced] │ +│ - labels, markers, track │ Projection: ○ normal ● panoramic │ +│ │ [Compute] [Reset] [Show hidden ☐] │ +├───────────────────────────────┴──────────────────────────────────────┤ +│ Status: hover → "Simetsberg (1836 m), distance 12.4 km" · zoom 150% │ +└──────────────────────────────────────────────────────────────────────┘ +``` + +Design principles: +- **One window, no modal dialogs for the core loop.** Viewpoint selection becomes an + inline searchable overlay (iced `text_input` + filtered list in a popover/panel), + replacing the `choose_hill` dialog. +- **Zoom is optional and non-destructive**: a viewport transform (scale + offset) + applied at render time; all hit-testing and label placement in image coordinates. + Labels stay screen-space (constant font size) so they remain readable when zoomed. +- Context menus (Find Peak, Hide/Unhide) via `cosmic::widget::popover` / context-menu. +- Overlays (viewpoint picker, find-peak, about) as Cosmic **dialogs** (they render + inside/over the app window) — no secondary top-level windows. + +### 2.2 UI options to explore first (spikes, before committing) + +| Option | Pros | Cons | +|---|---|---| +| **A. cosmic-toolkit (`cosmic::app`)** — recommended | Native look & feel, app menu, dialogs, popover, theming, Cosmic conventions, active development | API still moving; pin a release/tag | +| B. Plain iced 0.13 | More stable API, more examples | Not "Cosmic-native"; lose cosmic widgets/menus/theming | +| C. Slint / GTK4 / Qt | Mature canvas options | Not idiomatic for Cosmic DE | + +Exploration tasks (throwaway prototypes, no product code): +1. **Canvas perf spike**: draw a 6000×4000 JPEG in an iced `Canvas`, pan/zoom at + 60 fps (texture upload cost, `wgpu` backend, downscale-on-zoom-out strategy). +2. **Text spike**: render ~300 hill labels + leader lines via glyphon/iced canvas + text; measure frame times; decide label decluttering strategy. +3. **Input spike**: verify middle-mouse (or map "toggle known" to click + `K` key / + double-click if middle-click is unreliable under Wayland), drag-and-drop of image + files into a Cosmic window, ctrl+scroll zoom gesture. +4. **Widget inventory**: sliders, radio groups, menu bar, dialog, popover, + searchable list — confirm cosmic-widget coverage; identify what needs a custom + canvas widget (compass dial, canvas). +5. **Packaging spike**: minimal `cosmic-app-library` hello-world, `.desktop` file, + `cargo vendor` build without network. + +--- + +## 3. Rust Architecture + +Cargo workspace: + +``` +gipfel-rs/ +├── Cargo.toml # workspace +├── crates/ +│ ├── gipfel-core/ # pure domain logic, no UI, fully testable +│ │ ├── geo.rs # distance/azimuth/nick, earth radius, refraction +│ │ ├── hill.rs # Hill, Hills, flags, CSV loader, duplicate marking +│ │ ├── panorama.rs # Panorama: viewpoint, visible/hidden computation +│ │ ├── projection/ +│ │ │ ├── mod.rs # Projection trait, ViewParams, get_coordinates +│ │ │ ├── rectilinear.rs +│ │ │ ├── cylindrical.rs +│ │ │ └── generated/{rectilinear,cylindrical}_funcs.rs # ← maxima output +│ │ ├── lsq.rs # Levenberg–Marquardt driver (lmsder-equivalent) +│ │ ├── metadata.rs # EXIF read + JPEG-comment read/write (gipfel: string) +│ │ ├── stitch.rs # scan/resample pipeline (nearest + bicubic) +│ │ └── prefs.rs # distortion profiles (~/.config/gipfel/) +│ ├── gipfel-codegen/ # maxima scripts + generator (see 3.2) +│ │ ├── lsq_rectilinear.mac +│ │ ├── lsq_cylindrical.mac +│ │ └── expr2rust.mac +│ └── gipfel-app/ # Cosmic application +│ ├── src/app.rs # cosmic::Application: Model/Message/view/update +│ ├── src/canvas.rs # image viewport widget (pan/zoom/labels/hit-test) +│ ├── src/panels.rs # controls sidebar, viewpoint picker, dialogs +│ └── i18n/ +├── data/gipfel.dat # unchanged format +└── examples/ # CLI: stitch, export (clap subcommands) +``` + +### 3.1 Keeping the algorithm identical + +- Port `Panorama`/`ProjectionLSQ` logic **line-for-line in spirit**: same formulas, + same initial-value heuristics (`comp_scale`, alpha-monotonicity fix in the + cylindrical case), same fit levels (2/4/7 params), same 100-iteration LM loop. +- **Derivatives stay symbolic via maxima** (explicit requirement): + - Port `expr2c.mac` → `expr2rust.mac` (emit `pub fn mac_x(c_view: f64, …) -> f64` + with the same `_1.._n` temporary-variable scheme maxima already produces). + - Reuse `lsq_rectilinear.mac` / `lsq_cylindrical.mac` unchanged except for the + `expr2c(...)` calls. + - Generated `*_funcs.rs` files are **committed to the repo** (like today's + generated `.cxx`), regenerated manually by the maintainer via a `just`/`make` + target; optionally a `build.rs` that regenerates if `maxima` is on `$PATH`. + - Validation: differential test comparing generated Rust vs. original C output + bit-for-bit on a parameter grid, and vs. numerical finite differences. +- **Solver**: two candidates, decide during M2: + 1. `gsl` crate (bind to GSL `multifit_fdfsolver_lmsder`) — bit-identical behavior, + keeps the C dependency (acceptable: Cosmic is Linux-first). + 2. Pure-Rust LM (small problem: n≤2·#hills, p≤7) with QR-based inner steps + (e.g. `levmar`-style, `ndarray` + householder QR) — no C deps, needs + equivalence testing against the GSL reference. + Default preference: **(1) gsl crate** to honor "algorithm stays as it is". + +### 3.2 Replacements for C libraries + +| C dependency | Rust replacement | +|---|---| +| FLTK | `cosmic-toolkit` / iced | +| libjpeg/libtiff (via FLTK/exiv2) | `image` crate (jpeg, tiff features) | +| exiv2 (read) | `kamadak-exif` (EXIF + GPS tags) | +| exiv2 (write JPEG comment) | custom JPEG segment writer: parse markers, replace/insert `COM` (0xFFFE) segment — small, well-defined; keeps the exact `gipfel: …` string format | +| GSL | `gsl` crate (see 3.1) | +| Fl_Preferences | `directories` + simple key-file (or `confy`) for distortion profiles | +| getopt | `clap` (subcommands: `gui`, `stitch`, `export-hills`, `export-position`) | + +### 3.3 State & concurrency model + +- `cosmic::Application` Elm architecture: `App` holds `AppState` (loaded image, + `Panorama` model, viewport transform, UI state). +- Heavy operations (image decode of large JPEGs, LM fit, stitching) run via + `cosmic::task::future` / `tokio` background tasks; messages (`Msg::FitFinished(ViewParams)`, + `Msg::ImageLoaded(..)`) return results to the UI — keeps the window responsive + (the C version blocks with a wait cursor today; this is an improvement we keep). +- The 21k-row hill DB is loaded once and indexed (grid by lat/lon) for the + "close mountains" pre-filter (the C code rescans linearly). + +--- + +## 4. Milestones + +### M0 — UI exploration (spikes from §2.2) — ✅ DONE +Deliverables (see `../gipfel-spikes/`): +- `spike-render/` — headless wgpu+glyphon benchmark, **executed** on lavapipe: + 24 MP JPEG decode 206 ms, texture upload 60 ms (once), image frame 5.3 ms, + 300 glyphon labels 0.8 ms → rendering approach viable +- `spike-canvas/` — iced 0.14 custom viewport widget (zoom/pan/middle-click + markers/300 screen-space labels/sidebar), compile-verified +- `spike-cosmic/` — libcosmic app with menu bar + key binds, dialog, popover, + settings section, `.desktop` file, compile-verified +- `MEMO.md` — decision memo (toolkit = libcosmic pinned to tag; custom `Widget` + viewport; `GSL` crate for `lmsder`; Ctrl tracked via event subscription; + middle-click exists in iced 0.14; cosmic's iced fork = 0.14.2 API parity) + +Deferred (no display server in spike env): interactive runtime feel, middle-click +verification under a real Cosmic session, file-chooser choice. + +### M1 — Core port (`gipfel-core`, headless) — ✅ DONE + +Repo: `~/gipfel-rs` (workspace: `crates/gipfel-core`, `crates/gipfel-cli`, +`codegen/`, `tests/`). All behaviour is verified against the original C++ +through committed golden files (`tests/gen_golden.sh` regenerates them). + +- [x] `hill.rs`: `Hill`/`Hills` + CSV loader (Latin-1, `atof` semantics, both + 6-field and 3-field record layouts), `mark_duplicates`, all five sort orders +- [x] `panorama.rs`: geodesy — `distance`/`alpha`/`nick`/`refraction`/ + `get_earth_radius`/`get_real_distance`, `mark_hidden` (incl. the original's + `fabs(alph_diff > pi/2)` quirk, ported as-is), close/visible bookkeeping +- [x] `projection/`: `Projection` trait (16 macro entry points, defaults `NAN` + like the C++ base class) + rectilinear/cylindrical impls +- [x] `codegen/expr2rust.mac` + `lsq_{rectilinear,cylindrical}.mac` + `fixup.py` + + `regen.sh`; generated `*_funcs.rs` committed (16 + 10 functions) +- [x] `lsq.rs`: `gsl_multifit_fdfsolver_lmsder` via a minimal hand-written FFI, + identical 2/4/7-parameter levels and identical two-pass schedule +- [x] `metadata.rs`: `gipfel:` JPEG-comment read/write (byte-identical format), + EXIF fallback (GPS/focal/make/model), atomic save +- [x] Golden tests: 200-point function grid, full fit for both projections + (agreement to ~1e-15), export output, comment round-trip, real `gipfel.dat` +- [x] `gipfel-cli`: `export-position`, `export-hills`, `info` — `export-position` + is byte-identical to the C binary, `export-hills` matches the C pipeline + +Notes / deviations from the C original (all deliberate): +- `gsl_multifit_fdfsolver_lmsder` is a **pointer** in GSL ≥ 2.7; the FFI models + it as `*const` (the C++ code dereferences implicitly). Using the struct form + yields `failed to allocate space for multifit solver state`. +- Upstream C bug fixed in the reference tree: `ImageMetaData::load_image_jpgcom` + took `c_str()` of a temporary `std::string`, so `-p` read garbage. The Rust + port is correct; the C tree was patched only to produce valid goldens. +- Upstream C bug not reproduced: `Hill`'s copy constructor does not copy + `a_nick`, so fitting a *copy* of a hill fed the solver uninitialised memory. + The harness sets `a_nick` explicitly to model real-app behaviour. +- Rust `Hill` is plain data (no manual `strdup`/`free`); `Panorama` keeps one + `Vec` plus index lists instead of three aliasing pointer arrays. +- `rint` → `round_ties_even` (matches C's round-half-to-even); `atof` prefix + parsing reproduced exactly. + +### M2 — Cosmic app skeleton ✅ DONE (2026-10-25) +- [x] `cosmic::app` project (`crates/gipfel-app`, libcosmic pinned to rev + `430f3d4`), app menu (File/View/Projection/Help), Ctrl+O/S/D/T/V/F/Q + (menu `KeyBind` map is display-only → real dispatch via + `event::listen_with` subscription) +- [x] Open image (xdg-portal file dialog via `cosmic::dialog::file_chooser`, + feature `xdg-portal`), drag&drop (`Event::Window(FileDropped)`), hill DB + load (`--data` / `$GIPFEL_DATA` / XDG + system paths), EXIF/gipfel-comment + driven initial state (`apply_image_metadata`) +- [x] Controls sidebar: custom compass dial widget (center angle), sliders for + focal (1–300), nick (−40…20), tilt (−10…10), visibility (0.01–0.1), + track width (1–500); lat/lon/height + k0/k1/x0 inputs (on submit); + projection radios; show-hidden toggle; zoom/fit buttons +- [x] Status-bar hover info (name/height/distance, like C's FL_MOVE label) +- Notes: cosmic fork text API differs from crates.io iced 0.14 — text is + measured via `paragraph::Plain::` + `fill_paragraph`, and + `cosmic::Renderer` is the *fallback* (wgpu+tiny-skia) renderer. `Point`/`Rectangle` + are f32; hill coords stay f64 in core, cast at the draw boundary. + +### M3 — Canvas & interaction ✅ DONE (2026-10-25) +- [x] `ViewportWidget` production widget (`src/viewport.rs`): ctrl+scroll zoom + anchored at cursor (image-space anchor math), wheel/drag pan, fit/zoom + buttons; single draw pass image→geometry→text +- [x] Crosses + leader lines (yellow), known-hill flags (red ≤3, green >3), + decluttered labels (port of C `set_labels` collision push-up, cached in + widget Tree state keyed by a version counter), GPS track polyline with + distance-scaled width (C `get_rel_track_width`), hidden hills blue and + only drawn with show-hidden on +- [x] Interactions: left-drag known marker → live move + refit on release + (`comp_params`), middle-click **and double-click** toggle known, + right-click context dialog (Find Peak / Hide-Unhide), hover highlight +- [x] Viewpoint & Find-Peak pickers: searchable dialog (name filter, sorted, + 300-row cap), Find Peak places the marker at the right-click position + exactly like C's `find_peak_cb` +- [x] Save Image (file dialog → `md_from_state` → `gipfel:` comment write), + Screen Dump (re-decode + render markers/labels/track via fontdue → PNG/JPG), + Load Track (3-field CSV, `TRACK_POINT` flags, indices remapped by name + across reloads) +- Core change for M3: `Panorama` no longer re-sorts `hills` (keeps insertion + order + `alpha_order` index list) so hill indices are stable handles — the + C port used stable pointers; golden tests unaffected. +- Not yet verified interactively (no display in dev env) — needs a real + Wayland/X11 session run-through. +- Field fixes after live testing on real Wayland: + - text labels + overlay z-order: overlay recorded in its own graphics + layer (`start_layer`/`end_layer`); strong `Plain` paragraph refs kept + alive in widget Tree state (renderer only holds `Weak`) + - **segfault on marker-drag refit**: the hand-written GSL FFI struct + `gsl_multifit_function_fdf` was missing the trailing `nevalf`/`nevaldf` + counters (gsl_multifit_nlin.h) — GSL's `fdfsolver_set` wrote 16 bytes + past the struct, corrupting `lsq()`'s stack. Fixed; regression test + runs the fit on a 128 KB stack (guard-page canary). + +### M4 — Stitching & export ✅ DONE +- [x] Port `ScanImage` (nearest + bicubic) and `Stitch` resampling + (`gipfel-core/src/stitch.rs`; bit-for-bit golden tests vs C harness + `stitchdump.cxx` for nearest/bicubic, rect/cyl, with and without + distortion — sampling on the C 0..=65025 scale, Keys cubic, `rint`) +- [x] `gipfel-cli stitch -j/-t/-4/-w/-h/-r/-b` parity (C defaults kept: + 2000x500, range 0..380 deg); TIFF writer matches C `TIFFOutputImage` + (RGBA, deflate, 8/16-bit, alpha 65025), JPEG q90 +- [x] App: File → “Stitch Cylindrical TIFF…” — exports the current image + as a cylindrical 16-bit TIFF (bicubic) spanning the lens FOV derived + from the fitted projection (edge-angle inverse + vertical Newton), + for external stitching tools (Hugin etc.) +- [ ] Preview of stitched result in-app (optional, not done) + +### M5 — Polish & packaging +- [x] Distortion profiles: `gipfel-core/src/profile.rs` reads/writes the + C version's FLTK prefs file (`~/.fltk/Johannes.HofmannATgmx.de/gipfel/ + DistortionProfiles.prefs`) so profiles are shared with the C binary + (verified both directions with a Fl_Preferences probe). Auto-match by + camera+focal length on load (comment > profile > zero, C order). App: + Distortion section has a profile name field, Save/Load buttons and a + stored-profiles dropdown; CLI gains `profiles`/`profile-save`. +- [ ] Config/data dir handling (`XDG_DATA_HOME`), ship `gipfel.dat` +- [ ] i18n (de/en), theming (light/dark), HiDPI scaling +- [ ] `.desktop` file, icon, Cargo vendor for offline builds, CI (fmt, clippy, tests) +- [ ] Docs: README port, migration notes from the C version + +--- + +## 5. Risks & Mitigations + +| Risk | Mitigation | +|---|---| +| iced canvas performance with huge images + many labels | M0 spike; tile/downscale pyramid; label decluttering; only draw visible viewport | +| cosmic-toolkit API churn | pin to a tagged release; isolate UI in `gipfel-app` only | +| LM solver divergence from GSL reference | use `gsl` crate first; differential golden tests vs C binary | +| JPEG comment writing corner cases (progressive, large EXIF) | dedicated marker-walker with tests on real-world photos; atomic write via temp file (as C version does) | +| maxima output differs from C expectations | generated-code diff tests; keep maxima version pinned/documented | +| Middle-mouse availability on Wayland/touchpads | alternative binding (double-click or key modifier) decided in M0 | + +## 6. Explicit non-goals (for now) + +- No changes to the mathematical models (refraction, cone-visibility, distortion). +- No new projection types, no southern-hemisphere bugfix sweep, no GUI stitching mode. +- No Windows/macOS support; Linux/Cosmic first. +- No database rewrite (keep flat CSV; in-memory index is internal only). diff --git a/wasm-plan.md b/wasm-plan.md index d030b0d..8e73cfe 100644 --- a/wasm-plan.md +++ b/wasm-plan.md @@ -1,4 +1,4 @@ -# gipfel-web — plan for a real browser (WASM) version +# wipfel — plan for a real browser (WASM) version Status: **planning**. Feasibility spike done and verified on this branch (`crates/gipfel-wasm`): the full computational core — hill DB, JPEG @@ -116,11 +116,11 @@ the primary product; the web version is a second front end on the same ## 3. Crate / module layout -New crate `crates/gipfel-web` (on this branch; `gipfel-wasm` folds into +New crate `crates/wipfel` (on this branch; `gipfel-wasm` folds into it or becomes its `demo/`): ``` -crates/gipfel-web/ +crates/wipfel/ src/lib.rs Yew root component, routing between views src/state.rs app state + reducer (port of GipfelApp fields/Message) src/canvas_view.rs viewport canvas: bitmap layer + overlay layer, @@ -208,7 +208,7 @@ spike already retired the two scariest risks (core-in-wasm, fit speed). |---|---|---| | Canvas label metrics differ from iced → label layout drift | cosmetic | layout code is width-driven; tune line-height constant on real browser | | Memory on mobile (4080×3072 RGBA ≈ 50 MB + wasm heap) | OOM on low-end phones | downscale preview bitmap for display (keep full-res only in dump path); measure iOS Safari early (W1) | -| `image`/`exif`/`flate2` wasm compile surprises | days | all pure Rust; verify in W1 scaffold (`cargo check --target wasm32-unknown-unknown -p gipfel-web`) | +| `image`/`exif`/`flate2` wasm compile surprises | days | all pure Rust; verify in W1 scaffold (`cargo check --target wasm32-unknown-unknown -p wipfel`) | | Service worker caching stale DB/app | confusing updates | versioned cache keys, skipWaiting flow with "update available" toast | | Scope creep toward desktop parity | never ships | non-goals table is binding for v1; stitch/GPX explicitly deferred | | Two front ends drift apart (desktop fixes not applied to web) | long-term maintenance | shared core + shared golden tests; web-specific tests only for glue | @@ -218,6 +218,6 @@ spike already retired the two scariest risks (core-in-wasm, fit speed). ## 6. Open questions (decide before W1) 1. **Where does it live?** subdomain (web.gipfel.flpsed.org?) + which static host. 2. **Bundle the full 21k hill DB** (~1 MB gz ≈ 300 KB) or offer regional subsets? Default: full, it fits the budget. -3. Name: same "gipfel" brand for web, or distinct (e.g. "gipfel web")? +3. Name: same "gipfel" brand for web, or distinct (e.g. "wipfel")? 4. Does the web version need its own About/privacy page text (all-local processing statement)? 5. Framework confirmation: Yew per A1, or do you want to evaluate Leptos first? (One-day spike would settle it; Yew default stands.) -- cgit v1.2.3 From e838bb23f8251c7b2d5b0ebfca820f38680cc022 Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 14:01:38 +0100 Subject: web: guarantee initial fit with a ResizeObserver on the canvas The fit at load time (and the 120 ms nudge) could still run before the canvas had a valid layout size, leaving the first image invisible until 'Fit to window' was pressed. A ResizeObserver attached when the first bitmap arrives fires once with the element's real size immediately after observing, then on every later resize; it re-fits automatically unless the user has panned or zoomed by hand since the last load (user_moved flag, reset on each image load). Window resizes now re-fit the image as well instead of only redrawing it. --- crates/wipfel/Cargo.toml | 1 + crates/wipfel/src/app.rs | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 49 insertions(+) (limited to 'crates') diff --git a/crates/wipfel/Cargo.toml b/crates/wipfel/Cargo.toml index e1e39e1..fad31ce 100644 --- a/crates/wipfel/Cargo.toml +++ b/crates/wipfel/Cargo.toml @@ -36,6 +36,7 @@ features = [ "PointerEvent", "Request", "Response", + "ResizeObserver", "TextMetrics", "Window", "WheelEvent", diff --git a/crates/wipfel/src/app.rs b/crates/wipfel/src/app.rs index eeb82d6..879ed91 100644 --- a/crates/wipfel/src/app.rs +++ b/crates/wipfel/src/app.rs @@ -162,6 +162,9 @@ pub fn app() -> Html { let img_size = use_state(|| (0u32, 0u32)); let find_peak = use_state(|| Option::::None); let show_hidden = use_state(|| false); + // set once the user pans or zooms by hand; auto-fit is then suppressed + // until the next image load + let user_moved = use_mut_ref(|| false); // force a redraw when the window is resized so the canvas backing // store tracks its CSS size (listener lives as long as the app) @@ -225,6 +228,44 @@ pub fn app() -> Html { }) }; + // Keep the fit correct even when layout was not ready at load time: + // a ResizeObserver fires once with the element's initial size right + // after it starts observing, then on every later resize. Auto-fit + // whenever the user has not panned or zoomed by hand since the last + // image load — this is what makes the very first image appear. + { + let canvas_ref = canvas_ref.clone(); + let fit = fit.clone(); + let bitmap = bitmap.clone(); + let user_moved = user_moved.clone(); + use_effect_with((*bitmap).is_some(), move |has_image| { + let observer = if *has_image { + canvas_ref + .cast::() + .and_then(|c| { + let fit2 = fit.clone(); + let um = user_moved.clone(); + let closure = wasm_bindgen::closure::Closure::wrap(Box::new( + move |_entries: js_sys::Array, _obs: web_sys::ResizeObserver| { + if !*um.borrow() { + fit2.emit(MouseEvent::new("fit").unwrap()); + } + }, + ) as Box); + let ro = + web_sys::ResizeObserver::new(closure.as_ref().unchecked_ref()).ok()?; + let _ = ro.observe(&c); + // the observer does not own the closure; keep both + // alive until this effect is torn down + Some((ro, closure)) + }) + } else { + None + }; + move || drop(observer) + }); + } + // refit the projection to the given markers and update the status line let do_refit = { let pan = pan.clone(); @@ -276,12 +317,14 @@ pub fn app() -> Html { let vp = vp.clone(); let img_size = img_size.clone(); let find_peak = find_peak.clone(); + let user_moved = user_moved.clone(); Callback::from(move |(bytes, name): (Vec, String)| { let (bitmap, status, fit, pan, markers, fit_info) = (bitmap.clone(), status.clone(), fit.clone(), pan.clone(), markers.clone(), fit_info.clone()); let vp = vp.clone(); let img_size = img_size.clone(); let find_peak = find_peak.clone(); + let user_moved = user_moved.clone(); spawn_local(async move { match bridge::decode_bitmap(&bytes).await { Ok(bmp) => { @@ -315,6 +358,7 @@ pub fn app() -> Html { markers.set(Vec::new()); fit_info.set(String::new()); find_peak.set(None); + *user_moved.borrow_mut() = false; bitmap.set(Some(bmp)); fit.emit(MouseEvent::new("fit").unwrap()); // same nudge as the desktop app: re-fit shortly @@ -537,7 +581,9 @@ pub fn app() -> Html { let callbacks = ViewCallbacks { pan: { let view = view.clone(); + let user_moved = user_moved.clone(); Callback::from(move |(dx, dy): (f64, f64)| { + *user_moved.borrow_mut() = true; let mut v = (*view).clone(); v.ox += dx; v.oy += dy; @@ -546,7 +592,9 @@ pub fn app() -> Html { }, zoom: { let view = view.clone(); + let user_moved = user_moved.clone(); Callback::from(move |(cx, cy, factor): (f64, f64, f64)| { + *user_moved.borrow_mut() = true; let v = &*view; let ns = (v.scale * factor).clamp(0.02, 64.0); let k = ns / v.scale; -- cgit v1.2.3 From 6fa2ffc8964b31c4e85393527599b5da97b53c9a Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 14:18:00 +0100 Subject: web: optional labels for unmarked visible peaks Display > 'Show peak labels' toggle (off by default): every visible peak gets its name drawn next to its guide dot, like the desktop version. Labels join one combined collision-avoidance layout pass with the marker labels (same layout_label_y), so marker labels keep priority and nothing overlaps. Unmarked labels are tinted pale green; hidden peaks and already-marked peaks get no duplicate label. Candidates now carry name + marked flag (DotView), markers carry the hill index (MarkerView::hill) for the dedup. --- crates/wipfel/src/app.rs | 31 +++++++--- crates/wipfel/src/canvas_view.rs | 124 +++++++++++++++++++++++++++++---------- 2 files changed, 117 insertions(+), 38 deletions(-) (limited to 'crates') diff --git a/crates/wipfel/src/app.rs b/crates/wipfel/src/app.rs index 879ed91..2b205fa 100644 --- a/crates/wipfel/src/app.rs +++ b/crates/wipfel/src/app.rs @@ -15,7 +15,7 @@ use web_sys::{DragEvent, Event, HtmlCanvasElement, HtmlInputElement, InputEvent, use yew::prelude::*; use crate::bridge; -use crate::canvas_view::{CanvasView, MarkerView, ViewCallbacks, ViewState}; +use crate::canvas_view::{CanvasView, DotView, MarkerView, ViewCallbacks, ViewState}; use crate::compass::{Compass, CompassData}; use crate::markers::{self, Marker}; use crate::widgets::{NumItem, SliderItem}; @@ -162,6 +162,7 @@ pub fn app() -> Html { let img_size = use_state(|| (0u32, 0u32)); let find_peak = use_state(|| Option::::None); let show_hidden = use_state(|| false); + let peak_labels = use_state(|| false); // set once the user pans or zooms by hand; auto-fit is then suppressed // until the next image load let user_moved = use_mut_ref(|| false); @@ -493,6 +494,13 @@ pub fn app() -> Html { show_hidden.set(input.checked()); }) }; + let on_peak_labels = { + let peak_labels = peak_labels.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + peak_labels.set(input.checked()); + }) + }; // compass strip: shares the image transform, drag changes azimuth let compass_data = { @@ -700,23 +708,25 @@ pub fn app() -> Html { markers .iter() .map(|m| MarkerView { + hill: m.hill, x: m.x, y: m.y, name: p.hills[m.hill].name.clone(), }) .collect() }; - let candidates: Vec<(f64, f64, bool)> = { + let candidates: Vec = { let p = pan.borrow(); + let marked: Vec = markers.iter().map(|m| m.hill).collect(); p.visible .iter() .filter(|&&i| *show_hidden || p.hills[i].flags & FLAG_HIDDEN == 0) - .map(|&i| { - ( - p.hills[i].x, - p.hills[i].y, - p.hills[i].flags & FLAG_HIDDEN != 0, - ) + .map(|&i| DotView { + x: p.hills[i].x, + y: p.hills[i].y, + hidden: p.hills[i].flags & FLAG_HIDDEN != 0, + marked: marked.contains(&i), + name: p.hills[i].name.clone(), }) .collect() }; @@ -768,6 +778,10 @@ pub fn app() -> Html { { "Show hidden peaks" } + Html { tick={*tick} markers={marker_views} candidates={candidates} + peak_labels={*peak_labels} label_font={vp.label_font} /> { findpeak_popup.clone() } diff --git a/crates/wipfel/src/canvas_view.rs b/crates/wipfel/src/canvas_view.rs index 9d4338e..808ba1a 100644 --- a/crates/wipfel/src/canvas_view.rs +++ b/crates/wipfel/src/canvas_view.rs @@ -18,11 +18,24 @@ pub struct ViewState { /// A marker in center-relative image coordinates. #[derive(Clone, Debug, PartialEq)] pub struct MarkerView { + pub hill: usize, pub x: f64, pub y: f64, pub name: String, } +/// A visible (unmarked or marked) peak drawn as a guide dot. +#[derive(Clone, Debug, PartialEq)] +pub struct DotView { + pub x: f64, + pub y: f64, + /// hidden by nearer terrain (drawn grey) + pub hidden: bool, + /// already carries a user marker (no duplicate label) + pub marked: bool, + pub name: String, +} + #[derive(Clone, PartialEq)] pub struct ViewCallbacks { pub pan: Callback<(f64, f64)>, @@ -51,9 +64,10 @@ pub struct Props { /// bumped on window resize to force a redraw pub tick: u32, pub markers: Vec, - /// projected positions of all visible hills (guide dots) with their - /// hidden-by-occlusion flag - pub candidates: Vec<(f64, f64, bool)>, + /// guide dots for all visible hills + pub candidates: Vec, + /// draw name labels for unmarked visible peaks too + pub peak_labels: bool, /// marker label font size, screen px pub label_font: f32, } @@ -89,9 +103,18 @@ pub fn canvas_view(props: &Props) -> Html { let markers = props.markers.clone(); let candidates = props.candidates.clone(); let label_font = props.label_font; + let peak_labels = props.peak_labels; use_effect_with( - (bitmap, view, props.tick, markers.clone(), candidates.clone(), label_font), - move |(bitmap, view, _tick, markers, candidates, label_font)| { + ( + bitmap, + view, + props.tick, + markers.clone(), + candidates.clone(), + label_font, + peak_labels, + ), + move |(bitmap, view, _tick, markers, candidates, label_font, peak_labels)| { let Some(canvas) = canvas_ref.cast::() else { return; }; @@ -136,8 +159,8 @@ pub fn canvas_view(props: &Props) -> Html { // peaks hidden by nearer terrain are drawn grey #[allow(deprecated)] ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.85)")); - for (cx, cy, _hidden) in candidates { - let (px, py) = (sx(*cx), sy(*cy)); + for d in candidates.iter() { + let (px, py) = (sx(d.x), sy(d.y)); if px < -6.0 || py < -6.0 || px > cw + 6.0 || py > ch + 6.0 { continue; } @@ -145,12 +168,12 @@ pub fn canvas_view(props: &Props) -> Html { let _ = ctx.arc(px, py, 4.5, 0.0, std::f64::consts::TAU); ctx.fill(); } - for (cx, cy, hidden) in candidates { - let (px, py) = (sx(*cx), sy(*cy)); + for d in candidates.iter() { + let (px, py) = (sx(d.x), sy(d.y)); if px < -6.0 || py < -6.0 || px > cw + 6.0 || py > ch + 6.0 { continue; } - let color = if *hidden { "rgb(150, 150, 150)" } else { "rgb(110, 231, 183)" }; + let color = if d.hidden { "rgb(150, 150, 150)" } else { "rgb(110, 231, 183)" }; #[allow(deprecated)] ctx.set_fill_style(&wasm_bindgen::JsValue::from_str(color)); ctx.begin_path(); @@ -158,39 +181,75 @@ pub fn canvas_view(props: &Props) -> Html { ctx.fill(); } - // markers: yellow leader lines, red crosses, collision-free - // labels (port of the desktop viewport drawing) - if !markers.is_empty() { + // labels: markers always; unmarked visible peaks when + // peak_labels is on. One combined collision-avoiding + // layout pass sorted by screen x (port of the desktop + // viewport drawing). + if !markers.is_empty() || *peak_labels { let label_font = *label_font; let line_h = label_font * 1.3 + 2.0; ctx.set_font(&format!("{label_font:.0}px system-ui, sans-serif")); + + struct Item { + x: f64, + y: f64, + name: String, + marker: bool, + } + let mut items: Vec = markers + .iter() + .map(|m| Item { + x: m.x, + y: m.y, + name: m.name.clone(), + marker: true, + }) + .collect(); + if *peak_labels { + for d in candidates.iter() { + if d.hidden || d.marked || d.name.is_empty() { + continue; + } + items.push(Item { + x: d.x, + y: d.y, + name: d.name.clone(), + marker: false, + }); + } + } + // layout runs in screen space, sorted by x - let mut order: Vec = (0..markers.len()) + let mut order: Vec = (0..items.len()) .filter(|&i| { - markers[i].x.abs() * 2.0 <= bitmap.width() as f64 - && markers[i].y.abs() * 2.0 <= bitmap.height() as f64 + items[i].x.abs() * 2.0 <= bitmap.width() as f64 + && items[i].y.abs() * 2.0 <= bitmap.height() as f64 }) .collect(); - order.sort_by(|&a, &b| sx(markers[a].x).total_cmp(&sx(markers[b].x))); - let xs: Vec = order.iter().map(|&i| sx(markers[i].x) as f32).collect(); - let ys: Vec = order.iter().map(|&i| sy(markers[i].y) as f32).collect(); + order.sort_by(|&a, &b| sx(items[a].x).total_cmp(&sx(items[b].x))); + let xs: Vec = order.iter().map(|&i| sx(items[i].x) as f32).collect(); + let ys: Vec = order.iter().map(|&i| sy(items[i].y) as f32).collect(); let widths: Vec = order .iter() .map(|&i| { - ctx.measure_text(&markers[i].name) + ctx.measure_text(&items[i].name) .map(|m| m.width() as f32) - .unwrap_or_else(|_| markers[i].name.len() as f32 * 7.0) + .unwrap_or_else(|_| items[i].name.len() as f32 * 7.0) }) .collect(); let in_img = vec![true; order.len()]; let entries = layout_label_y(&xs, &ys, &widths, &in_img, line_h); - // leaders (yellow): cross, vertical, horizontal + // leaders (yellow): cross, vertical, horizontal — + // drawn for markers only #[allow(deprecated)] ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str("rgb(255, 230, 51)")); ctx.set_line_width(1.0); for (k, &i) in order.iter().enumerate() { - let (px, py) = (sx(markers[i].x), sy(markers[i].y)); + if !items[i].marker { + continue; + } + let (px, py) = (sx(items[i].x), sy(items[i].y)); let (lx, ly) = entries[k]; let label_line = py + ly as f64 - line_h as f64; ctx.begin_path(); @@ -207,7 +266,10 @@ pub fn canvas_view(props: &Props) -> Html { ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str("rgb(255, 64, 64)")); ctx.set_line_width(1.5); for &i in &order { - let (px, py) = (sx(markers[i].x), sy(markers[i].y)); + if !items[i].marker { + continue; + } + let (px, py) = (sx(items[i].x), sy(items[i].y)); ctx.begin_path(); ctx.move_to(px - 5.0, py); ctx.line_to(px + 5.0, py); @@ -215,22 +277,24 @@ pub fn canvas_view(props: &Props) -> Html { ctx.line_to(px, py + 5.0); ctx.stroke(); } - // labels: white on dark shadow, right-aligned at leader end + // labels: white on dark shadow, right-aligned at the + // leader end (markers) or just right of the dot for (k, &i) in order.iter().enumerate() { - if markers[i].name.is_empty() { + if items[i].name.is_empty() { continue; } - let (px, py) = (sx(markers[i].x), sy(markers[i].y)); + let (px, py) = (sx(items[i].x), sy(items[i].y)); let (lx, ly) = entries[k]; let label_line = py + ly as f64 - line_h as f64; let tx = px + lx as f64 - widths[k] as f64; let ty = label_line - 3.0; #[allow(deprecated)] ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("rgba(0, 0, 0, 0.85)")); - ctx.fill_text(&markers[i].name, tx + 1.0, ty + 1.0).ok(); + ctx.fill_text(&items[i].name, tx + 1.0, ty + 1.0).ok(); + let color = if items[i].marker { "white" } else { "rgb(196, 240, 214)" }; #[allow(deprecated)] - ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("white")); - ctx.fill_text(&markers[i].name, tx, ty).ok(); + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str(color)); + ctx.fill_text(&items[i].name, tx, ty).ok(); } } }, -- cgit v1.2.3 From a9b47f2414cb662de5fab5660602e6de03eb1ba2 Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 14:38:46 +0100 Subject: web: leader lines for unmarked peak labels The C++ original draws a cross + vertical + horizontal leader for every labeled peak, not just marked ones. Without them, collision- pushed peak labels float unattached and it is impossible to tell which dot they belong to (verified by replaying layout_label_y on a synthetic ridge scene). Peak leaders use the muted pale green of the label text; marker leaders stay yellow with the small cross. --- crates/wipfel/src/canvas_view.rs | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) (limited to 'crates') diff --git a/crates/wipfel/src/canvas_view.rs b/crates/wipfel/src/canvas_view.rs index 808ba1a..8f13a1c 100644 --- a/crates/wipfel/src/canvas_view.rs +++ b/crates/wipfel/src/canvas_view.rs @@ -240,21 +240,27 @@ pub fn canvas_view(props: &Props) -> Html { let in_img = vec![true; order.len()]; let entries = layout_label_y(&xs, &ys, &widths, &in_img, line_h); - // leaders (yellow): cross, vertical, horizontal — - // drawn for markers only - #[allow(deprecated)] - ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str("rgb(255, 230, 51)")); + // leaders: vertical + horizontal line connecting each + // label to its peak (C++ draws these for every + // labeled peak); markers yellow with a small cross, + // unmarked peaks a muted pale green ctx.set_line_width(1.0); for (k, &i) in order.iter().enumerate() { - if !items[i].marker { - continue; - } let (px, py) = (sx(items[i].x), sy(items[i].y)); let (lx, ly) = entries[k]; let label_line = py + ly as f64 - line_h as f64; + let color = if items[i].marker { + "rgb(255, 230, 51)" + } else { + "rgba(196, 240, 214, 0.75)" + }; + #[allow(deprecated)] + ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str(color)); ctx.begin_path(); - ctx.move_to(px - 4.0, py); - ctx.line_to(px + 4.0, py); + if items[i].marker { + ctx.move_to(px - 4.0, py); + ctx.line_to(px + 4.0, py); + } ctx.move_to(px, py); ctx.line_to(px, label_line); ctx.move_to(px, label_line); -- cgit v1.2.3 From f519a707e32679ec512518afc3c56eeec03c260a Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 14:49:24 +0100 Subject: web: process label layout right-to-left like the desktop MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The desktop lays out labels in alpha-descending order (the C pointer-array sort), which on screen means right to left — so the leftmost peak of a collision cluster ends up on top of the stack. The web port sorted by screen x ascending, inverting every stack and making labels look assigned to the wrong peaks. Sort descending; the break-early scan in layout_label_y stays valid because it only relies on monotonic x, and labels extend rightward just like in C. Verified against the desktop rendering of the same panorama photo and a right-to-left replay of the layout in the label simulator. --- crates/wipfel/src/canvas_view.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'crates') diff --git a/crates/wipfel/src/canvas_view.rs b/crates/wipfel/src/canvas_view.rs index 8f13a1c..76aebfc 100644 --- a/crates/wipfel/src/canvas_view.rs +++ b/crates/wipfel/src/canvas_view.rs @@ -220,13 +220,16 @@ pub fn canvas_view(props: &Props) -> Html { } // layout runs in screen space, sorted by x + // descending (right to left): the desktop processes + // hills in alpha-descending order, which puts the + // leftmost peak on top of a collision stack let mut order: Vec = (0..items.len()) .filter(|&i| { items[i].x.abs() * 2.0 <= bitmap.width() as f64 && items[i].y.abs() * 2.0 <= bitmap.height() as f64 }) .collect(); - order.sort_by(|&a, &b| sx(items[a].x).total_cmp(&sx(items[b].x))); + order.sort_by(|&a, &b| sx(items[b].x).total_cmp(&sx(items[a].x))); let xs: Vec = order.iter().map(|&i| sx(items[i].x) as f32).collect(); let ys: Vec = order.iter().map(|&i| sy(items[i].y) as f32).collect(); let widths: Vec = order -- cgit v1.2.3 From f91431fefa0418b80dea1246aecac2c6a9dfc416 Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 14:54:05 +0100 Subject: web: GPX track loading MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - core: track::load_gpx_from_bytes (path wrapper delegates to it; same hardening: size cap, no entity expansion, direct-child ) - sidebar: 'Load GPX Track…' button + hidden .gpx file input; the track swaps in via remove_hills(FLAG_TRACK_POINT) + add_hills, so marker hill indices never shift (track hills always live at the end of the hill list) - rendering: desktop parity — consecutive visible points joined with round-cap strokes, width = scale*track_width/(dist_m*10) clamped to [1,1000] image px, red (blue when hidden by terrain); a Track width slider (50-1000 m, default 200) appears in Display once a track is loaded - track points and duplicates are excluded from guide dots, hover and click hit-testing (they are scenery, not markable peaks) --- crates/gipfel-core/src/track.rs | 33 ++++++++++++-- crates/wipfel/src/app.rs | 94 ++++++++++++++++++++++++++++++++++++++-- crates/wipfel/src/canvas_view.rs | 33 +++++++++++++- crates/wipfel/src/markers.rs | 8 +++- 4 files changed, 160 insertions(+), 8 deletions(-) (limited to 'crates') diff --git a/crates/gipfel-core/src/track.rs b/crates/gipfel-core/src/track.rs index 5450aa8..f7bf755 100644 --- a/crates/gipfel-core/src/track.rs +++ b/crates/gipfel-core/src/track.rs @@ -32,7 +32,18 @@ pub fn load_gpx(path: &str, max_points: usize) -> Result, String> { if size.len() > MAX_GPX_BYTES { return Err(format!("{path}: file too large ({} bytes)", size.len())); } - let data = std::fs::read_to_string(path).map_err(|e| format!("{path}: {e}"))?; + let data = std::fs::read(path).map_err(|e| format!("{path}: {e}"))?; + load_gpx_from_bytes(&data, max_points).map_err(|e| format!("{path}: {e}")) +} + +/// Parse GPX from raw bytes. Same hardening as [`load_gpx`]: size cap, +/// no entity expansion, `` accepted only as direct child of +/// ``. Used directly by the browser front end. +pub fn load_gpx_from_bytes(data: &[u8], max_points: usize) -> Result, String> { + if data.len() as u64 > MAX_GPX_BYTES { + return Err(format!("file too large ({} bytes)", data.len())); + } + let data = String::from_utf8_lossy(data); let mut reader = quick_xml::Reader::from_str(&data); reader.config_mut().trim_text(true); @@ -55,7 +66,7 @@ pub fn load_gpx(path: &str, max_points: usize) -> Result, String> { } loop { - match reader.read_event().map_err(|e| format!("{path}: {e}"))? { + match reader.read_event().map_err(|e| e.to_string())? { Event::Eof => break, Event::Empty(e) => { if e.local_name().as_ref() == b"trkpt" { @@ -112,7 +123,7 @@ pub fn load_gpx(path: &str, max_points: usize) -> Result, String> { } if pts.is_empty() { - return Err(format!("{path}: no track points")); + return Err("no track points".to_string()); } let stride = pts.len().div_ceil(max_points.max(1)); @@ -172,6 +183,22 @@ mod tests { assert!((hills[2].height - 1200.0).abs() < 1e-9); } + #[test] + fn gpx_from_bytes_matches_path_api() { + // the browser front end feeds raw bytes directly + let gpx = br#" + + 2100 + 2150 +"#; + let hills = load_gpx_from_bytes(gpx, 100).unwrap(); + assert_eq!(hills.len(), 2); + assert!(hills.iter().all(|h| h.is_track_point())); + assert!((hills[0].phi - 47.36f64.to_radians()).abs() < 1e-12); + assert!((hills[1].height - 2150.0).abs() < 1e-9); + assert!(load_gpx_from_bytes(b"", 10).is_err()); // no points + } + #[test] fn gpx_vendor_extensions_ignored() { // Garmin-style files are full of vendor extension blocks; they must diff --git a/crates/wipfel/src/app.rs b/crates/wipfel/src/app.rs index 2b205fa..d0c8ecd 100644 --- a/crates/wipfel/src/app.rs +++ b/crates/wipfel/src/app.rs @@ -5,7 +5,8 @@ use std::io::Read; use std::rc::Rc; use flate2::read::GzDecoder; -use gipfel_core::hill::{FLAG_DUPLIC, FLAG_HIDDEN, FLAG_TRACK_POINT}; +use gipfel_core::hill::{FLAG_DUPLIC, FLAG_HIDDEN, FLAG_TRACK_POINT, FLAG_VISIBLE}; +use gipfel_core::track as gpx; use gipfel_core::metadata::{apply_image_metadata, ImageMetaData}; use gipfel_core::panorama::Panorama; use wasm_bindgen::closure::Closure; @@ -15,7 +16,7 @@ use web_sys::{DragEvent, Event, HtmlCanvasElement, HtmlInputElement, InputEvent, use yew::prelude::*; use crate::bridge; -use crate::canvas_view::{CanvasView, DotView, MarkerView, ViewCallbacks, ViewState}; +use crate::canvas_view::{CanvasView, DotView, MarkerView, TrackView, ViewCallbacks, ViewState}; use crate::compass::{Compass, CompassData}; use crate::markers::{self, Marker}; use crate::widgets::{NumItem, SliderItem}; @@ -163,6 +164,10 @@ pub fn app() -> Html { let find_peak = use_state(|| Option::::None); let show_hidden = use_state(|| false); let peak_labels = use_state(|| false); + // hill indices of the GPS track, in file order + let track = use_state(Vec::::new); + let track_width = use_state(|| 200.0f64); + let track_file_ref = use_node_ref(); // set once the user pans or zooms by hand; auto-fit is then suppressed // until the next image load let user_moved = use_mut_ref(|| false); @@ -433,6 +438,50 @@ pub fn app() -> Html { }) }; + let open_track_picker = { + let track_file_ref = track_file_ref.clone(); + Callback::from(move |_: MouseEvent| { + if let Some(input) = track_file_ref.cast::() { + input.click(); + } + }) + }; + + // parse a GPX file and swap it into the panorama as track-point hills + // (always appended last, so marker hill indices never shift) + let on_track_file_change = { + let pan = pan.clone(); + let track = track.clone(); + let status = status.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + let Some(file) = input.files().and_then(|f| f.item(0)) else { + return; + }; + let (pan, track, status) = (pan.clone(), track.clone(), status.clone()); + let name = file.name(); + spawn_local(async move { + match bridge::read_blob(&file).await { + Ok(bytes) => match gpx::load_gpx_from_bytes(&bytes, 2000) { + Ok(hills) => { + let n = hills.len(); + { + let p = &mut *pan.borrow_mut(); + p.remove_hills(FLAG_TRACK_POINT); + p.add_hills(&hills); + track.set((p.hills.len() - n..p.hills.len()).collect()); + } + status.set(format!("Track {name}: {n} points")); + } + Err(err) => status.set(format!("GPX failed: {err}")), + }, + Err(err) => status.set(format!("Failed to read {name}: {err}")), + } + }); + input.set_value(""); // allow re-selecting the same file + }) + }; + let on_distortion_toggle = { let fit_distortion = fit_distortion.clone(); let markers = markers.clone(); @@ -501,6 +550,10 @@ pub fn app() -> Html { peak_labels.set(input.checked()); }) }; + let on_track_width = { + let track_width = track_width.clone(); + Callback::from(move |v: f64| track_width.set(v)) + }; // compass strip: shares the image transform, drag changes azimuth let compass_data = { @@ -720,7 +773,10 @@ pub fn app() -> Html { let marked: Vec = markers.iter().map(|m| m.hill).collect(); p.visible .iter() - .filter(|&&i| *show_hidden || p.hills[i].flags & FLAG_HIDDEN == 0) + .filter(|&&i| { + p.hills[i].flags & (FLAG_DUPLIC | FLAG_TRACK_POINT) == 0 + && (*show_hidden || p.hills[i].flags & FLAG_HIDDEN == 0) + }) .map(|&i| DotView { x: p.hills[i].x, y: p.hills[i].y, @@ -730,6 +786,24 @@ pub fn app() -> Html { }) .collect() }; + let track_views: Vec = { + let p = pan.borrow(); + track + .iter() + .filter(|&&i| p.hills[i].flags & FLAG_VISIBLE != 0) + .map(|&i| { + let h = &p.hills[i]; + // C: scale * track_width / (dist_m * 10), distance in meters + let dist_m = p.get_real_distance(i).max(1.0); + TrackView { + x: h.x, + y: h.y, + hidden: h.flags & FLAG_HIDDEN != 0, + width: (p.get_scale() * *track_width / (dist_m * 10.0)).clamp(1.0, 1000.0), + } + }) + .collect() + }; let zoom_pct = (view.scale * 100.0).round(); let n_markers = markers.len(); @@ -740,6 +814,7 @@ pub fn app() -> Html {

{ "wipfel" }

{ "web gipfel photogrammetry" }

+ Html { class="hidden-file" onchange={on_file_change} /> +

{ (*status).clone() }

{ (*db_status).clone() }

if bitmap.is_some() { @@ -774,6 +856,11 @@ pub fn app() -> Html { { "Fit distortion (needs ≥ 4 markers)" }
{ "Display" }
+ if !track.is_empty() { + + }