diff options
Diffstat (limited to 'crates')
82 files changed, 3786 insertions, 23 deletions
diff --git a/crates/gipfel-cli/examples/overlay.rs b/crates/gipfel-cli/examples/overlay.rs new file mode 100644 index 0000000..3ce8745 --- /dev/null +++ b/crates/gipfel-cli/examples/overlay.rs @@ -0,0 +1,30 @@ +// Dev helper: project hills for a given viewpoint and print image coords. +// usage: overlay <lat> <lon> <height> <az> <pitch> <roll> <focal35> <w> <h> +use gipfel_core::panorama::Panorama; + +fn main() { + let a: Vec<String> = std::env::args().collect(); + let n: Vec<f64> = a[1..].iter().map(|s| s.parse().unwrap()).collect(); + let (lat, lon, height, az, pitch, roll, focal, w, h) = + (n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8]); + let mut p = Panorama::new(); + p.load_data("gipfel.dat").unwrap(); + p.set_view_lat(lat); + p.set_view_long(lon); + p.set_view_height(height); + p.set_scale(focal * w.max(h) / 36.0); + p.set_center_angle(az); + p.set_pitch_angle(pitch); + p.set_roll_angle(roll); + p.max_view_angle = 60_f64.to_radians(); + p.update_visible_mountains(None); + println!("# az={az} pitch={pitch} scale={}", focal * w.max(h) / 36.0); + for &i in &p.visible { + let hill = &p.hills[i]; + let d = p.get_real_distance(i) / 1000.0; + if hill.x.abs() < w / 2.0 && hill.y.abs() < h / 2.0 && hill.height > 1500.0 { + // convert center-relative coords to full image coords + println!("{:.0} {:.0} {} {:.0}m {:.1}km", hill.x + w / 2.0, hill.y + h / 2.0, hill.name, hill.height, d); + } + } +} diff --git a/crates/gipfel-core/src/hill.rs b/crates/gipfel-core/src/hill.rs index b40eb1d..254a9e4 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; @@ -80,16 +77,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<Vec<Hill>> { + 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<Vec<Hill>> { - 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<Vec<Hill>> { 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(); @@ -112,7 +113,6 @@ pub fn load(path: &str) -> std::io::Result<Vec<Hill>> { hills.push(h); } } - Ok(hills) } diff --git a/crates/gipfel-core/src/metadata.rs b/crates/gipfel-core/src/metadata.rs index 9da4f50..d9c98f9 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; @@ -71,6 +68,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<()> { @@ -81,6 +88,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<Vec<u8>> { + 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 {}", @@ -155,8 +168,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; }; @@ -215,6 +232,22 @@ impl ImageMetaData { } } } + // Phone cameras record the shooting direction as GPSImgDirection. + // Used only when no gipfel comment provided a direction. A magnetic + // reference ('M') is converted to true north with the current + // declination of the Eastern Alps (~+2.4 deg east, IGRF 2020s); + // the residual error stays below typical phone compass noise. + if self.direction.is_nan() { + if let Some(f) = exif.get_field(Tag::GPSImgDirection, In::PRIMARY) { + if let Some(v) = field_tofloat(f, 0) { + let mut dir = v; + if exif_ref_is(&exif, Tag::GPSImgDirectionRef, "M") { + dir += 2.4; + } + self.direction = dir; + } + } + } } } @@ -372,6 +405,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<Vec<u8>> { 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<Vec<u8>> { if bytes.len() < 2 || bytes[0] != 0xFF || bytes[1] != 0xD8 { return None; } @@ -412,6 +450,13 @@ pub fn read_jpeg_comment(path: &str) -> Option<Vec<u8>> { /// 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<Vec<u8>> { if bytes.len() < 2 || bytes[0] != 0xFF || bytes[1] != 0xD8 { return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, "not a JPEG file")); } @@ -475,9 +520,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. @@ -725,3 +768,27 @@ mod tests { assert!((pan.get_scale() - 50.0 * 1000.0 / 35.0).abs() < 1e-9); } } + +#[cfg(test)] +mod save_tests { + use super::*; + + #[test] + fn comment_roundtrip_preserves_projection_type() { + let mut md = ImageMetaData::new(); + md.longitude = 10.5; + md.latitude = 47.0; + md.height = 2993.0; + md.direction = 57.4; + md.pitch = -20.0; + md.roll = 0.3; + md.focal_length_35mm = 27.0; + md.projection_type = 1; // cylindrical + // minimal valid JPEG (SOI, empty COM, EOI) + let jpg = b"\xff\xd8\xff\xfe\x00\x02\xff\xd9"; + let out = md.save_image_to_bytes(jpg).unwrap(); + let mut md2 = ImageMetaData::new(); + md2.load_image_from_bytes(&out); + assert_eq!(md2.projection_type, 1, "projection type lost in comment roundtrip"); + } +} diff --git a/crates/gipfel-core/src/panorama.rs b/crates/gipfel-core/src/panorama.rs index 1af64bf..b8ce342 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-core/src/profile.rs b/crates/gipfel-core/src/profile.rs index e8bda68..2eff8f6 100644 --- a/crates/gipfel-core/src/profile.rs +++ b/crates/gipfel-core/src/profile.rs @@ -112,7 +112,19 @@ pub fn sanitize_name(name: &str) -> Result<(), Error> { Ok(()) } -/// Parse a prefs file into ordered (name, profile) pairs. Tolerant: +/// Parse a prefs file into ordered (name, profile) pairs. Tolerant: comments +/// (`;`), the root group `[.]`, blank lines and unknown keys are ignored; +/// values are parsed with Rust's `f64` (superset of C `%g`). +pub fn parse_prefs(text: &str) -> Vec<(String, Profile)> { + parse(text) +} + +/// Serialize profiles in FLTK's layout so the C version can read our file. +pub fn serialize_prefs(profiles: &[(String, Profile)]) -> String { + serialize(profiles) +} + +/// Parse a prefs file into ordered (name, profile) pairs. Tolerant: /// comments (`;`), the root group `[.]`, blank lines and unknown keys are /// ignored; values are parsed with Rust's `f64` (superset of C `%g`). fn parse(text: &str) -> Vec<(String, Profile)> { 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<Vec<Hill>, 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, `<ele>` accepted only as direct child of +/// `<trkpt>`. Used directly by the browser front end. +pub fn load_gpx_from_bytes(data: &[u8], max_points: usize) -> Result<Vec<Hill>, 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<Vec<Hill>, 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<Vec<Hill>, 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)); @@ -173,6 +184,22 @@ mod tests { } #[test] + fn gpx_from_bytes_matches_path_api() { + // the browser front end feeds raw bytes directly + let gpx = br#"<?xml version="1.0" encoding="UTF-8"?> +<gpx version="1.1"><trk><trkseg> + <trkpt lat="47.36" lon="11.15"><ele>2100</ele></trkpt> + <trkpt lat="47.37" lon="11.16"><ele>2150</ele></trkpt> +</trkseg></trk></gpx>"#; + 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"<gpx></gpx>", 10).is_err()); // no points + } + + #[test] fn gpx_vendor_extensions_ignored() { // Garmin-style files are full of vendor extension blocks; they must // not confuse the parser (and must not contribute elevation). diff --git a/crates/gipfel-desktop/.cargo/config.toml b/crates/gipfel-desktop/.cargo/config.toml new file mode 100644 index 0000000..10d19b9 --- /dev/null +++ b/crates/gipfel-desktop/.cargo/config.toml @@ -0,0 +1,3 @@ +# cross-link Windows PE binaries with mingw-w64 +[target.x86_64-pc-windows-gnu] +linker = "x86_64-w64-mingw32-gcc" diff --git a/crates/gipfel-desktop/.gitignore b/crates/gipfel-desktop/.gitignore new file mode 100644 index 0000000..6b0406a --- /dev/null +++ b/crates/gipfel-desktop/.gitignore @@ -0,0 +1,4 @@ +dist/ +node_modules/ +package-lock.json +gen/ diff --git a/crates/gipfel-desktop/Cargo.toml b/crates/gipfel-desktop/Cargo.toml new file mode 100644 index 0000000..468bd4c --- /dev/null +++ b/crates/gipfel-desktop/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "gipfel-desktop" +version.workspace = true +edition.workspace = true +license.workspace = true +description = "gipfel — native desktop shell (Tauri) around the WASM front end" + +[build-dependencies] +tauri-build = { version = "2", features = [] } + +[dependencies] +tauri = { version = "2", features = [] } diff --git a/crates/gipfel-desktop/app-icon.png b/crates/gipfel-desktop/app-icon.png Binary files differnew file mode 100644 index 0000000..9c999de --- /dev/null +++ b/crates/gipfel-desktop/app-icon.png diff --git a/crates/gipfel-desktop/build-frontend.sh b/crates/gipfel-desktop/build-frontend.sh new file mode 100755 index 0000000..72a1687 --- /dev/null +++ b/crates/gipfel-desktop/build-frontend.sh @@ -0,0 +1,15 @@ +#!/bin/sh +# Build the gipfel WASM front end into dist/ for tauri to bundle. +# Runs from crates/gipfel-desktop (tauri beforeBuildCommand). +set -e +HERE="$(cd "$(dirname "$0")" && pwd)" +DIST="$HERE/dist" +mkdir -p "$DIST" +cd "$HERE/../.." +cargo build -p gipfel --target wasm32-unknown-unknown --release +wasm-bindgen --target web --out-dir "$DIST" \ + target/wasm32-unknown-unknown/release/gipfel.wasm +cp crates/gipfel/www/index.html crates/gipfel/www/style.css \ + crates/gipfel/www/loader.js "$DIST/" +gzip -9 -n -c gipfel.dat > "$DIST/gipfel.dat.gz" +echo "frontend dist ready: $DIST" diff --git a/crates/gipfel-desktop/build.rs b/crates/gipfel-desktop/build.rs new file mode 100644 index 0000000..d860e1e --- /dev/null +++ b/crates/gipfel-desktop/build.rs @@ -0,0 +1,3 @@ +fn main() { + tauri_build::build() +} diff --git a/crates/gipfel-desktop/icons/128x128.png b/crates/gipfel-desktop/icons/128x128.png Binary files differnew file mode 100644 index 0000000..677f7e3 --- /dev/null +++ b/crates/gipfel-desktop/icons/128x128.png diff --git a/crates/gipfel-desktop/icons/128x128@2x.png b/crates/gipfel-desktop/icons/128x128@2x.png Binary files differnew file mode 100644 index 0000000..7c6ca8f --- /dev/null +++ b/crates/gipfel-desktop/icons/128x128@2x.png diff --git a/crates/gipfel-desktop/icons/32x32.png b/crates/gipfel-desktop/icons/32x32.png Binary files differnew file mode 100644 index 0000000..b89ad45 --- /dev/null +++ b/crates/gipfel-desktop/icons/32x32.png diff --git a/crates/gipfel-desktop/icons/64x64.png b/crates/gipfel-desktop/icons/64x64.png Binary files differnew file mode 100644 index 0000000..06e1baa --- /dev/null +++ b/crates/gipfel-desktop/icons/64x64.png diff --git a/crates/gipfel-desktop/icons/Square107x107Logo.png b/crates/gipfel-desktop/icons/Square107x107Logo.png Binary files differnew file mode 100644 index 0000000..be100d3 --- /dev/null +++ b/crates/gipfel-desktop/icons/Square107x107Logo.png diff --git a/crates/gipfel-desktop/icons/Square142x142Logo.png b/crates/gipfel-desktop/icons/Square142x142Logo.png Binary files differnew file mode 100644 index 0000000..c392f48 --- /dev/null +++ b/crates/gipfel-desktop/icons/Square142x142Logo.png diff --git a/crates/gipfel-desktop/icons/Square150x150Logo.png b/crates/gipfel-desktop/icons/Square150x150Logo.png Binary files differnew file mode 100644 index 0000000..bc97d99 --- /dev/null +++ b/crates/gipfel-desktop/icons/Square150x150Logo.png diff --git a/crates/gipfel-desktop/icons/Square284x284Logo.png b/crates/gipfel-desktop/icons/Square284x284Logo.png Binary files differnew file mode 100644 index 0000000..c5164ec --- /dev/null +++ b/crates/gipfel-desktop/icons/Square284x284Logo.png diff --git a/crates/gipfel-desktop/icons/Square30x30Logo.png b/crates/gipfel-desktop/icons/Square30x30Logo.png Binary files differnew file mode 100644 index 0000000..803d0b5 --- /dev/null +++ b/crates/gipfel-desktop/icons/Square30x30Logo.png diff --git a/crates/gipfel-desktop/icons/Square310x310Logo.png b/crates/gipfel-desktop/icons/Square310x310Logo.png Binary files differnew file mode 100644 index 0000000..61b7cb9 --- /dev/null +++ b/crates/gipfel-desktop/icons/Square310x310Logo.png diff --git a/crates/gipfel-desktop/icons/Square44x44Logo.png b/crates/gipfel-desktop/icons/Square44x44Logo.png Binary files differnew file mode 100644 index 0000000..0632827 --- /dev/null +++ b/crates/gipfel-desktop/icons/Square44x44Logo.png diff --git a/crates/gipfel-desktop/icons/Square71x71Logo.png b/crates/gipfel-desktop/icons/Square71x71Logo.png Binary files differnew file mode 100644 index 0000000..959fa73 --- /dev/null +++ b/crates/gipfel-desktop/icons/Square71x71Logo.png diff --git a/crates/gipfel-desktop/icons/Square89x89Logo.png b/crates/gipfel-desktop/icons/Square89x89Logo.png Binary files differnew file mode 100644 index 0000000..a40b586 --- /dev/null +++ b/crates/gipfel-desktop/icons/Square89x89Logo.png diff --git a/crates/gipfel-desktop/icons/StoreLogo.png b/crates/gipfel-desktop/icons/StoreLogo.png Binary files differnew file mode 100644 index 0000000..2f6d80f --- /dev/null +++ b/crates/gipfel-desktop/icons/StoreLogo.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-anydpi-v26/ic_launcher.xml b/crates/gipfel-desktop/icons/android/mipmap-anydpi-v26/ic_launcher.xml new file mode 100644 index 0000000..2ffbf24 --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-anydpi-v26/ic_launcher.xml @@ -0,0 +1,5 @@ +<?xml version="1.0" encoding="utf-8"?> +<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android"> + <foreground android:drawable="@mipmap/ic_launcher_foreground"/> + <background android:drawable="@color/ic_launcher_background"/> +</adaptive-icon>
\ No newline at end of file diff --git a/crates/gipfel-desktop/icons/android/mipmap-hdpi/ic_launcher.png b/crates/gipfel-desktop/icons/android/mipmap-hdpi/ic_launcher.png Binary files differnew file mode 100644 index 0000000..89cf08d --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-hdpi/ic_launcher.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-hdpi/ic_launcher_foreground.png b/crates/gipfel-desktop/icons/android/mipmap-hdpi/ic_launcher_foreground.png Binary files differnew file mode 100644 index 0000000..6e365db --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-hdpi/ic_launcher_foreground.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-hdpi/ic_launcher_round.png b/crates/gipfel-desktop/icons/android/mipmap-hdpi/ic_launcher_round.png Binary files differnew file mode 100644 index 0000000..569b423 --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-hdpi/ic_launcher_round.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-mdpi/ic_launcher.png b/crates/gipfel-desktop/icons/android/mipmap-mdpi/ic_launcher.png Binary files differnew file mode 100644 index 0000000..f694785 --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-mdpi/ic_launcher.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-mdpi/ic_launcher_foreground.png b/crates/gipfel-desktop/icons/android/mipmap-mdpi/ic_launcher_foreground.png Binary files differnew file mode 100644 index 0000000..248af68 --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-mdpi/ic_launcher_foreground.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-mdpi/ic_launcher_round.png b/crates/gipfel-desktop/icons/android/mipmap-mdpi/ic_launcher_round.png Binary files differnew file mode 100644 index 0000000..624ac76 --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-mdpi/ic_launcher_round.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-xhdpi/ic_launcher.png b/crates/gipfel-desktop/icons/android/mipmap-xhdpi/ic_launcher.png Binary files differnew file mode 100644 index 0000000..9b8f176 --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-xhdpi/ic_launcher.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-xhdpi/ic_launcher_foreground.png b/crates/gipfel-desktop/icons/android/mipmap-xhdpi/ic_launcher_foreground.png Binary files differnew file mode 100644 index 0000000..b60251d --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-xhdpi/ic_launcher_foreground.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-xhdpi/ic_launcher_round.png b/crates/gipfel-desktop/icons/android/mipmap-xhdpi/ic_launcher_round.png Binary files differnew file mode 100644 index 0000000..2f3158a --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-xhdpi/ic_launcher_round.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-xxhdpi/ic_launcher.png b/crates/gipfel-desktop/icons/android/mipmap-xxhdpi/ic_launcher.png Binary files differnew file mode 100644 index 0000000..bbac643 --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-xxhdpi/ic_launcher.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-xxhdpi/ic_launcher_foreground.png b/crates/gipfel-desktop/icons/android/mipmap-xxhdpi/ic_launcher_foreground.png Binary files differnew file mode 100644 index 0000000..c13ec89 --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-xxhdpi/ic_launcher_foreground.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-xxhdpi/ic_launcher_round.png b/crates/gipfel-desktop/icons/android/mipmap-xxhdpi/ic_launcher_round.png Binary files differnew file mode 100644 index 0000000..48d697d --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-xxhdpi/ic_launcher_round.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-xxxhdpi/ic_launcher.png b/crates/gipfel-desktop/icons/android/mipmap-xxxhdpi/ic_launcher.png Binary files differnew file mode 100644 index 0000000..1ac2c2b --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-xxxhdpi/ic_launcher.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-xxxhdpi/ic_launcher_foreground.png b/crates/gipfel-desktop/icons/android/mipmap-xxxhdpi/ic_launcher_foreground.png Binary files differnew file mode 100644 index 0000000..4a7c684 --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-xxxhdpi/ic_launcher_foreground.png diff --git a/crates/gipfel-desktop/icons/android/mipmap-xxxhdpi/ic_launcher_round.png b/crates/gipfel-desktop/icons/android/mipmap-xxxhdpi/ic_launcher_round.png Binary files differnew file mode 100644 index 0000000..d6dfa8d --- /dev/null +++ b/crates/gipfel-desktop/icons/android/mipmap-xxxhdpi/ic_launcher_round.png diff --git a/crates/gipfel-desktop/icons/android/values/ic_launcher_background.xml b/crates/gipfel-desktop/icons/android/values/ic_launcher_background.xml new file mode 100644 index 0000000..16cdd5a --- /dev/null +++ b/crates/gipfel-desktop/icons/android/values/ic_launcher_background.xml @@ -0,0 +1,4 @@ +<?xml version="1.0" encoding="utf-8"?> +<resources> + <color name="ic_launcher_background">#FFFFFF</color> +</resources>
\ No newline at end of file diff --git a/crates/gipfel-desktop/icons/icon.icns b/crates/gipfel-desktop/icons/icon.icns Binary files differnew file mode 100644 index 0000000..a467c34 --- /dev/null +++ b/crates/gipfel-desktop/icons/icon.icns diff --git a/crates/gipfel-desktop/icons/icon.ico b/crates/gipfel-desktop/icons/icon.ico Binary files differnew file mode 100644 index 0000000..cc0ac92 --- /dev/null +++ b/crates/gipfel-desktop/icons/icon.ico diff --git a/crates/gipfel-desktop/icons/icon.png b/crates/gipfel-desktop/icons/icon.png Binary files differnew file mode 100644 index 0000000..6a3880e --- /dev/null +++ b/crates/gipfel-desktop/icons/icon.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-20x20@1x.png b/crates/gipfel-desktop/icons/ios/AppIcon-20x20@1x.png Binary files differnew file mode 100644 index 0000000..d563874 --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-20x20@1x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-20x20@2x-1.png b/crates/gipfel-desktop/icons/ios/AppIcon-20x20@2x-1.png Binary files differnew file mode 100644 index 0000000..09ff5d1 --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-20x20@2x-1.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-20x20@2x.png b/crates/gipfel-desktop/icons/ios/AppIcon-20x20@2x.png Binary files differnew file mode 100644 index 0000000..09ff5d1 --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-20x20@2x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-20x20@3x.png b/crates/gipfel-desktop/icons/ios/AppIcon-20x20@3x.png Binary files differnew file mode 100644 index 0000000..d137cbf --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-20x20@3x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-29x29@1x.png b/crates/gipfel-desktop/icons/ios/AppIcon-29x29@1x.png Binary files differnew file mode 100644 index 0000000..9dbc33f --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-29x29@1x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-29x29@2x-1.png b/crates/gipfel-desktop/icons/ios/AppIcon-29x29@2x-1.png Binary files differnew file mode 100644 index 0000000..3cb954c --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-29x29@2x-1.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-29x29@2x.png b/crates/gipfel-desktop/icons/ios/AppIcon-29x29@2x.png Binary files differnew file mode 100644 index 0000000..3cb954c --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-29x29@2x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-29x29@3x.png b/crates/gipfel-desktop/icons/ios/AppIcon-29x29@3x.png Binary files differnew file mode 100644 index 0000000..9fae2c7 --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-29x29@3x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-40x40@1x.png b/crates/gipfel-desktop/icons/ios/AppIcon-40x40@1x.png Binary files differnew file mode 100644 index 0000000..09ff5d1 --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-40x40@1x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-40x40@2x-1.png b/crates/gipfel-desktop/icons/ios/AppIcon-40x40@2x-1.png Binary files differnew file mode 100644 index 0000000..8255b8c --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-40x40@2x-1.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-40x40@2x.png b/crates/gipfel-desktop/icons/ios/AppIcon-40x40@2x.png Binary files differnew file mode 100644 index 0000000..8255b8c --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-40x40@2x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-40x40@3x.png b/crates/gipfel-desktop/icons/ios/AppIcon-40x40@3x.png Binary files differnew file mode 100644 index 0000000..a8dbcb6 --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-40x40@3x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-512@2x.png b/crates/gipfel-desktop/icons/ios/AppIcon-512@2x.png Binary files differnew file mode 100644 index 0000000..90fba83 --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-512@2x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-60x60@2x.png b/crates/gipfel-desktop/icons/ios/AppIcon-60x60@2x.png Binary files differnew file mode 100644 index 0000000..a8dbcb6 --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-60x60@2x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-60x60@3x.png b/crates/gipfel-desktop/icons/ios/AppIcon-60x60@3x.png Binary files differnew file mode 100644 index 0000000..036dede --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-60x60@3x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-76x76@1x.png b/crates/gipfel-desktop/icons/ios/AppIcon-76x76@1x.png Binary files differnew file mode 100644 index 0000000..5888f0f --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-76x76@1x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-76x76@2x.png b/crates/gipfel-desktop/icons/ios/AppIcon-76x76@2x.png Binary files differnew file mode 100644 index 0000000..7675933 --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-76x76@2x.png diff --git a/crates/gipfel-desktop/icons/ios/AppIcon-83.5x83.5@2x.png b/crates/gipfel-desktop/icons/ios/AppIcon-83.5x83.5@2x.png Binary files differnew file mode 100644 index 0000000..21a1598 --- /dev/null +++ b/crates/gipfel-desktop/icons/ios/AppIcon-83.5x83.5@2x.png diff --git a/crates/gipfel-desktop/package.json b/crates/gipfel-desktop/package.json new file mode 100644 index 0000000..466edf2 --- /dev/null +++ b/crates/gipfel-desktop/package.json @@ -0,0 +1,14 @@ +{ + "name": "gipfel-desktop", + "version": "1.0.0", + "description": "", + "main": "index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "type": "commonjs", + "devDependencies": { + "@tauri-apps/cli": "^2.12.4" + } +} diff --git a/crates/gipfel-desktop/src/main.rs b/crates/gipfel-desktop/src/main.rs new file mode 100644 index 0000000..a6cd4ff --- /dev/null +++ b/crates/gipfel-desktop/src/main.rs @@ -0,0 +1,11 @@ +//! gipfel desktop shell: a webview window around the static WASM build +//! in `dist/` (produced by build-frontend.sh). All real work happens in +//! the wasm front end; this binary only hosts it. + +#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] + +fn main() { + tauri::Builder::default() + .run(tauri::generate_context!()) + .expect("error while running gipfel"); +} diff --git a/crates/gipfel-desktop/tauri.conf.json b/crates/gipfel-desktop/tauri.conf.json new file mode 100644 index 0000000..0f434f3 --- /dev/null +++ b/crates/gipfel-desktop/tauri.conf.json @@ -0,0 +1,37 @@ +{ + "$schema": "https://schema.tauri.app/config/2", + "productName": "gipfel", + "mainBinaryName": "gipfel", + "version": "0.5.5", + "identifier": "org.flpsed.gipfel", + "build": { + "frontendDist": "dist", + "beforeBuildCommand": "sh build-frontend.sh" + }, + "app": { + "windows": [ + { + "title": "gipfel — Photogrammetry for Mountain Images", + "width": 1280, + "height": 860, + "resizable": true + } + ], + "security": { + "csp": null + } + }, + "bundle": { + "active": true, + "targets": "all", + "category": "Utility", + "shortDescription": "Mountain photo peak identification (photogrammetry)", + "longDescription": "gipfel: open a mountain photo, identify peaks, fit the camera projection and save annotated images. All processing is local; images never leave the machine.", + "icon": [ + "icons/32x32.png", + "icons/128x128.png", + "icons/icon.png", + "icons/icon.ico" + ] + } +} diff --git a/crates/gipfel/Cargo.toml b/crates/gipfel/Cargo.toml new file mode 100644 index 0000000..35df39b --- /dev/null +++ b/crates/gipfel/Cargo.toml @@ -0,0 +1,51 @@ +[package] +name = "gipfel" +version.workspace = true +edition.workspace = true +license.workspace = true +description = "gipfel — web based 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 = [ + "console", + "Blob", + "BlobPropertyBag", + "CanvasRenderingContext2d", + "DataTransfer", + "CssStyleDeclaration", + "Document", + "DomRect", + "DragEvent", + "Element", + "Event", + "EventTarget", + "File", + "FileList", + "HtmlCanvasElement", + "HtmlElement", + "HtmlInputElement", + "HtmlSelectElement", + "ImageBitmap", + "Location", + "UrlSearchParams", + "InputEvent", + "MouseEvent", + "PointerEvent", + "Request", + "Response", + "ResizeObserver", + "Storage", + "TextMetrics", + "Url", + "Window", + "WheelEvent", +] diff --git a/crates/gipfel/README.md b/crates/gipfel/README.md new file mode 100644 index 0000000..37c09ea --- /dev/null +++ b/crates/gipfel/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/gipfel/build-release.sh b/crates/gipfel/build-release.sh new file mode 100755 index 0000000..d118b59 --- /dev/null +++ b/crates/gipfel/build-release.sh @@ -0,0 +1,47 @@ +#!/bin/sh +# Build gipfel and assemble a deployable static site in dist/gipfel/. +# Everything the app loads (wasm, hill database, stylesheet) is fetched +# relative to the page URL, so the directory can be mounted under any +# path on any static server. +set -e +cd "$(dirname "$0")/../.." +ROOT="$(pwd -P)" +# sanity check: refuse to run anywhere that is not the repo root +[ -f "$ROOT/Cargo.toml" ] && [ -d "$ROOT/crates/gipfel" ] || { + echo "error: $ROOT does not look like the gipfel repo root" >&2 + exit 1 +} +DIST="$ROOT/dist/gipfel" +# belt and braces: the only path this script may ever delete +case "$DIST" in + "$ROOT"/dist/gipfel) ;; + *) echo "error: refusing to touch unexpected path $DIST" >&2; exit 1 ;; +esac + +# size-optimized build for the web (the workspace default profile +# targets native binaries); --remove-name-section drops the debug +# symbol names wasm-bindgen adds for devtools +touch crates/gipfel/src/app.rs # re-stamp every build (option_env! does not track STAMP) +STAMP=$(date -u +%Y-%m-%d_%H:%M) CARGO_PROFILE_RELEASE_OPT_LEVEL=z cargo build -p gipfel --target wasm32-unknown-unknown --release + +# stage into a fresh temp dir and swap it in only on success, so a +# failing build never destroys the previous site and the old site is +# removed at the last possible moment +mkdir -p "$ROOT/dist" +TMP="$(mktemp -d "$ROOT/dist/.gipfel-stage.XXXXXX")" +trap 'rm -rf "$TMP"' EXIT INT TERM + +wasm-bindgen --remove-name-section --target web --out-dir "$TMP" \ + target/wasm32-unknown-unknown/release/gipfel.wasm +# the loader page (not the trunk entry point, which is dev-only) +rm -f "$TMP"/gipfel.d.ts "$TMP"/gipfel_bg.wasm.d.ts +cp crates/gipfel/www/index.html crates/gipfel/www/style.css crates/gipfel/www/loader.js "$TMP/" +gzip -9 -n -c gipfel.dat > "$TMP/gipfel.dat.gz" + +rm -rf "$DIST" +chmod 755 "$TMP" +mv "$TMP" "$DIST" +trap - EXIT INT TERM + +echo "site assembled in $DIST ($(du -sh "$DIST" | cut -f1)):" +ls "$DIST" diff --git a/crates/gipfel/index.html b/crates/gipfel/index.html new file mode 100644 index 0000000..bdd883a --- /dev/null +++ b/crates/gipfel/index.html @@ -0,0 +1,11 @@ +<!doctype html> +<html lang="en"> + <head> + <meta charset="utf-8" /> + <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> + <title>gipfel — Photogrammetry for Mountain Images</title> + <link data-trunk rel="css" href="www/style.css" /> + <link data-trunk rel="rust" /> + </head> + <body></body> +</html> diff --git a/crates/gipfel/serve-here.sh b/crates/gipfel/serve-here.sh new file mode 100755 index 0000000..1fd3a46 --- /dev/null +++ b/crates/gipfel/serve-here.sh @@ -0,0 +1,13 @@ +#!/bin/sh +# Build gipfel for wasm and refresh the static dist dir served from +# /tmp/gipfel-dist (python http.server on :8090). Dev-only helper. +set -e +cd "$(dirname "$0")/../.." +touch crates/gipfel/src/app.rs # re-stamp every build (option_env! does not track STAMP) +STAMP=$(date -u +%Y-%m-%d_%H:%M) cargo build -p gipfel --target wasm32-unknown-unknown --release +DIST=/tmp/gipfel-dist +mkdir -p "$DIST" +wasm-bindgen --target web --out-dir "$DIST" target/wasm32-unknown-unknown/release/gipfel.wasm +cp crates/gipfel/www/index.html crates/gipfel/www/style.css crates/gipfel/www/loader.js "$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/src/app.rs b/crates/gipfel/src/app.rs new file mode 100644 index 0000000..9fff27a --- /dev/null +++ b/crates/gipfel/src/app.rs @@ -0,0 +1,1567 @@ +//! 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, FLAG_VISIBLE}; +use gipfel_core::track as gpx; +use gipfel_core::metadata::{apply_image_metadata, ImageMetaData}; +use gipfel_core::panorama::Panorama; +use gipfel_core::projection::ProjectionType; +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, DotView, MarkerView, TrackView, ViewCallbacks, ViewState}; +use crate::compass::{alph_at_img_x, Compass, CompassData}; +use crate::markers::{self, Marker}; +use crate::widgets::{NumItem, SliderItem, TextItem}; + +/// 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, + } + } +} + +/// view parameter overrides from the URL (degrees / mm), applied on +/// top of whatever the image metadata provides +#[derive(Clone, Copy, Default)] +struct Overrides { + az: Option<f64>, + pitch: Option<f64>, + roll: Option<f64>, + focal: Option<f64>, + vis: Option<f64>, +} + +/// 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, +} + +/// Build stamp injected by serve-here.sh / build-release.sh so a +/// quick glance at the sidebar reveals whether the browser is running +/// a cached old bundle. +const BUILD_STAMP: &str = match option_env!("STAMP") { + Some(s) => s, + None => "dev", +}; + +/// Read a query parameter from the page URL (e.g. `/?file=test.jpg`). +fn url_param(name: &str) -> Option<String> { + let search = bridge::window().location().search().ok()?; + let params = web_sys::UrlSearchParams::new_with_str(&search).ok()?; + params.get(name) +} + +fn gunzip(gz: &[u8]) -> Result<Vec<u8>, String> { + let mut raw = Vec::new(); + GzDecoder::new(gz) + .read_to_end(&mut raw) + .map(|_| raw) + .map_err(|e| format!("gunzip: {e}")) +} + +/// localStorage key holding the distortion profile store, in the same +/// FLTK prefs format the desktop app uses on disk (so files can be +/// exported/imported between the two). +const PREFS_KEY: &str = "gipfel-distortion-profiles"; + +fn load_prefs() -> Vec<(String, gipfel_core::profile::Profile)> { + bridge::store_get(PREFS_KEY) + .map(|t| gipfel_core::profile::parse_prefs(&t)) + .unwrap_or_default() +} + +fn save_prefs(list: &[(String, gipfel_core::profile::Profile)]) -> Result<(), String> { + bridge::store_set(PREFS_KEY, &gipfel_core::profile::serialize_prefs(list)) +} + +#[derive(Properties, PartialEq)] +struct FpProps { + fp: FindPeak, + items: Vec<(String, usize)>, + on_pick: Callback<usize>, + on_query: Callback<String>, + 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::<HtmlInputElement>() { + 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! { + <> + <div class="fpbackdrop" onclick={on_close.clone()} /> + <div + class="findpeak" + style={format!("left: {}px; top: {}px", p.fp.sx + 10.0, p.fp.sy + 10.0)} + > + <div class="fphead">{ "Find Peak" }</div> + <div class="fpsearch"> + <input + type="text" + ref={input_ref} + placeholder="search…" + value={p.fp.query.clone()} + oninput={on_query} + /> + </div> + <div class="fplist"> + { + 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! { + <button class="fpitem" {onclick}>{ label.clone() }</button> + } + }) + } + if p.items.is_empty() { + <p class="fpempty">{ "no matches" }</p> + } + </div> + <div class="fpfoot"> + <button class="fpcancel" onclick={on_close}>{ "Cancel" }</button> + </div> + </div> + </> + } +} + +#[function_component(App)] +pub fn app() -> Html { + let bitmap = use_state(|| None::<web_sys::ImageBitmap>); + let view = use_state(ViewState::default); + // Live view state for the event callbacks. A UseStateHandle cloned + // into a callback derefs to its render-time snapshot (documented + // Yew behaviour), so consecutive read-modify-writes within one + // frame clobber each other — this silently killed pinch zoom, where + // the pan emit reverted the zoom emit of the same event. The + // mirror is the live source of truth; every write goes through + // apply_view, which also pushes to the use_state for rendering. + let view_live = use_mut_ref(ViewState::default); + let apply_view: Rc<dyn Fn(&dyn Fn(&mut ViewState))> = { + let view = view.clone(); + let view_live = view_live.clone(); + Rc::new(move |f: &dyn Fn(&mut ViewState)| { + let mut v = (*view_live.borrow()).clone(); + f(&mut v); + *view_live.borrow_mut() = v.clone(); + view.set(v); + }) + }; + 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::<Marker>::new); + let fit_distortion = use_state(|| false); + // 0 = rectilinear, 1 = cylindrical (panoramic); mirrors + // Panorama::projection_type, synced from the image comment on load + let projection = use_state(|| 0u32); + let hover = use_state(|| Option::<String>::None); + let vp = use_state(UiParams::default); + let img_size = use_state(|| (0u32, 0u32)); + let find_peak = use_state(|| Option::<FindPeak>::None); + let show_hidden = use_state(|| false); + let peak_labels = use_state(|| true); + // collapsible control panel (desktop nav bar behaviour): open at + // start so the image picker is reachable even on phones; it + // collapses automatically once an image is loaded on a narrow screen + let nav_open = use_state(|| true); + // hill indices of the GPS track, in file order + let track = use_state(Vec::<usize>::new); + let track_width = use_state(|| 200.0f64); + let track_file_ref = use_node_ref(); + // optional alternative hill database (e.g. a regional list) + let db_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); + // view parameter overrides from the URL query string + let overrides = use_mut_ref(Overrides::default); + // original bytes + name of the loaded image, kept for "Save image" + // (the annotated JPEG is the source image plus a gipfel comment) + let orig = use_mut_ref(|| Option::<(Vec<u8>, String)>::None); + // EXIF metadata of the loaded image (camera name for profile matching) + let img_md = use_mut_ref(ImageMetaData::new); + // distortion profile store (localStorage, FLTK prefs format) + let profile_name = use_state(String::new); + let profiles = use_state(Vec::<String>::new); + let profile_overwrite = 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). + // The live counter lives in a RefCell: a UseStateHandle cloned into + // these persistent closures would deref to its render-time snapshot + // and stall the bump after the first resize. + let tick_live = use_mut_ref(|| 0u32); + { + let tick = tick.clone(); + let live = tick_live.clone(); + use_effect_with((), move |_| { + let closure = Closure::wrap(Box::new(move || { + let v = { + let mut l = live.borrow_mut(); + *l += 1; + *l + }; + tick.set(v); + }) as Box<dyn Fn()>); + 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 { + // aapt gunzips .gz assets, so an APK ships the plain + // gipfel.dat while the web dist ships gipfel.dat.gz + let raw = match bridge::fetch_bytes("gipfel.dat.gz").await { + Ok(gz) => gunzip(&gz)?, + Err(_) => bridge::fetch_bytes("gipfel.dat").await?, + }; + 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 canvas_ref = canvas_ref.clone(); + let apply = apply_view.clone(); + Callback::from(move |_: MouseEvent| { + let Some(bmp) = bitmap.as_ref() else { return }; + let (cw, ch) = canvas_ref + .cast::<HtmlCanvasElement>() + .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); + apply(&move |v| { + v.scale = scale; + v.ox = (cw - iw * scale) / 2.0; + v.oy = (ch - ih * scale) / 2.0; + }); + }) + }; + + // 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 (window + // resize, sidebar collapse, ...). Always bump the redraw tick so the + // canvas backing store tracks its CSS size — otherwise the browser + // stretches the stale bitmap — and additionally re-fit whenever the + // user has not panned or zoomed by hand since the last image load + // (this is also 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(); + let tick = tick.clone(); + use_effect_with((*bitmap).is_some(), move |has_image| { + let observer = if *has_image { + canvas_ref + .cast::<HtmlCanvasElement>() + .and_then(|c| { + let fit2 = fit.clone(); + let um = user_moved.clone(); + let tick2 = tick.clone(); + let live2 = tick_live.clone(); + let closure = wasm_bindgen::closure::Closure::wrap(Box::new( + move |_entries: js_sys::Array, _obs: web_sys::ResizeObserver| { + let v = { + let mut l = live2.borrow_mut(); + *l += 1; + *l + }; + tick2.set(v); + if !*um.borrow() { + fit2.emit(MouseEvent::new("fit").unwrap()); + } + }, + ) as Box<dyn Fn(js_sys::Array, web_sys::ResizeObserver)>); + 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(); + let fit_info = fit_info.clone(); + let fit_distortion = fit_distortion.clone(); + let vp = vp.clone(); + let img_size = img_size.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(()) => { + // push the fitted values into the slider state, + // otherwise Azimuth/Pitch/Roll/Focal keep showing + // the pre-fit numbers + let mut u = *vp; + u.az = p.get_center_angle().rem_euclid(360.0); + u.pitch = p.get_pitch_angle(); + u.roll = p.get_roll_angle(); + let w = img_size.0.max(1) as f64; + u.focal = (p.get_scale() * 36.0 / w).clamp(1.0, 300.0); + vp.set(u); + 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(); + let user_moved = user_moved.clone(); + let nav_open = nav_open.clone(); + let overrides = overrides.clone(); + let orig = orig.clone(); + let img_md = img_md.clone(); + let profile_name = profile_name.clone(); + let profiles = profiles.clone(); + let projection = projection.clone(); + Callback::from(move |(bytes, name): (Vec<u8>, 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(); + let nav_open = nav_open.clone(); + let overrides = overrides.clone(); + let orig = orig.clone(); + let img_md = img_md.clone(); + let profile_name = profile_name.clone(); + let profiles = profiles.clone(); + let projection = projection.clone(); + spawn_local(async move { + match bridge::decode_bitmap(&bytes).await { + Ok(bmp) => { + // narrow screens: give the canvas the room once + // the setup phase is over + let narrow = bridge::window() + .inner_width() + .ok() + .and_then(|w| w.as_f64()) + .unwrap_or(1200.0) + < 900.0; + if narrow { + nav_open.set(false); + } + 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); + // explicit URL parameters win over the metadata, + // e.g. /?file=img.jpg&pitch=-20 for a photo whose + // EXIF lacks (or fakes) the camera orientation + { + let ov = *overrides.borrow(); + let mut p = pan.borrow_mut(); + if let Some(v) = ov.az { + p.set_center_angle(v); + } + if let Some(v) = ov.pitch { + p.set_pitch_angle(v); + } + if let Some(v) = ov.roll { + p.set_roll_angle(v); + } + if let Some(v) = ov.focal { + p.set_scale(v * w.max(h) as f64 / 36.0); + } + if let Some(v) = ov.vis { + // same mapping as the Visibility slider + p.set_height_dist_ratio((0.11 - v).clamp(0.01, 0.1)); + } + } + // keep the source bytes and EXIF for "Save image" + *orig.borrow_mut() = Some((bytes.clone(), name.clone())); + *img_md.borrow_mut() = md.clone(); + // distortion profile: prefill the name field with + // the camera/focal auto-match and apply it when a + // stored profile of that name exists (desktop does + // the same on image load) + { + let auto = gipfel_core::metadata::distortion_profile_name(&md); + profile_name.set(auto.clone().unwrap_or_default()); + let all = load_prefs(); + profiles.set(all.iter().map(|(n, _)| n.clone()).collect()); + if let Some(n) = &auto { + if let Some((_, pr)) = all.iter().find(|(m, _)| m == n) { + pan.borrow_mut().set_distortion_params(pr.k0, pr.k1, pr.x0); + } + } + } + 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() * 36.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); + // a saved gipfel comment may request the panoramic + // projection; sync the dropdown with the result + projection.set(pan.borrow().projection_type as u32); + // force the per-render limit block to re-evaluate: + // its change detection compares against the old + // value, and a metadata-driven switch to cylindrical + // (limit 0) would otherwise look "unchanged" and + // keep the stale visibility list + pan.borrow_mut().max_view_angle = -1.0; + 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); + *user_moved.borrow_mut() = false; + 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}")), + } + }); + }) + }; + + // Auto-load an image given as ?file=<path or http(s) URL> so a photo + // can be opened by link alone, e.g. /?file=test.jpg or + // /?file=https://example.org/pano.jpg&az=57.4. It goes through the + // normal load pipeline, so EXIF viewpoint/focal metadata is applied + // exactly as for a picked file. External URLs need CORS on their + // host; the status line reports failures. + { + let load_bytes = load_bytes.clone(); + let status = status.clone(); + let overrides = overrides.clone(); + use_effect_with((), move |_| { + let Some(path) = url_param("file") else { return }; + let external = path.starts_with("https://") || path.starts_with("http://"); + if path.is_empty() || (!external && path.contains(":/")) { + status.set("?file= must be a path on this host or an http(s) URL".to_string()); + return; + } + let name = path.rsplit('/').next().unwrap_or(&path).to_string(); + *overrides.borrow_mut() = Overrides { + az: url_param("az").and_then(|s| s.parse().ok()), + pitch: url_param("pitch").and_then(|s| s.parse().ok()), + roll: url_param("roll").and_then(|s| s.parse().ok()), + focal: url_param("focal").and_then(|s| s.parse().ok()), + vis: url_param("vis").and_then(|s| s.parse().ok()), + }; + let (load_bytes, status) = (load_bytes.clone(), status.clone()); + let path2 = path.clone(); + spawn_local(async move { + match bridge::fetch_bytes(&path).await { + Ok(bytes) => load_bytes.emit((bytes, name)), + Err(e) => status.set(format!("Could not fetch {path2}: {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::<HtmlInputElement>() { + input.click(); + } + }) + }; + + let open_track_picker = { + let track_file_ref = track_file_ref.clone(); + Callback::from(move |_: MouseEvent| { + if let Some(input) = track_file_ref.cast::<HtmlInputElement>() { + input.click(); + } + }) + }; + + let open_db_picker = { + let db_file_ref = db_file_ref.clone(); + Callback::from(move |_: MouseEvent| { + if let Some(input) = db_file_ref.cast::<HtmlInputElement>() { + input.click(); + } + }) + }; + + // replace the hill database at runtime (e.g. everest.dat for the + // Khumbu); markers and track reference hill indices and are dropped + let on_db_file_change = { + let pan = pan.clone(); + let db_status = db_status.clone(); + let markers = markers.clone(); + let track = track.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, db_status, markers, track) = ( + pan.clone(), + db_status.clone(), + markers.clone(), + track.clone(), + ); + let name = file.name(); + spawn_local(async move { + match bridge::read_blob(&file).await { + Ok(bytes) => { + // accept plain .dat and gzipped variants + let raw = match bytes.first() { + Some(0x1f) if bytes.get(1) == Some(&0x8b) => match gunzip(&bytes) { + Ok(r) => r, + Err(err) => { + db_status.set(format!("gunzip failed: {err}")); + return; + } + }, + _ => bytes, + }; + // NOTE: the borrow must end before the match arm, + // which calls pan.borrow() itself (nested borrow + // would panic and trap the whole wasm module) + let res = pan.borrow_mut().load_data_from_bytes(&raw); + match res { + Ok(()) => { + markers.set(Vec::new()); + track.set(Vec::new()); + let n = pan.borrow().hills.len(); + db_status.set(format!("Hill database {name}: {n} peaks")); + } + Err(err) => db_status.set(format!("Database failed: {err}")), + } + } + Err(err) => db_status.set(format!("Failed to read {name}: {err}")), + } + }); + input.set_value(""); // allow re-selecting the same file + }) + }; + + // 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 + }) + }; + + // "Save image": re-encode the original JPEG with the current fit as + // gipfel comment (same bytes + format as the desktop app writes), + // delivered as a browser download. + let on_save_image = { + let orig = orig.clone(); + let img_md = img_md.clone(); + let pan = pan.clone(); + let img_size = img_size.clone(); + let status = status.clone(); + Callback::from(move |_: MouseEvent| { + let Some((bytes, name)) = orig.borrow().clone() else { + status.set("No image loaded.".to_string()); + return; + }; + // mirror of the desktop md_from_state; the comment keeps the + // historical scale * 35 / max(w,h) focal encoding so saved + // files stay interchangeable with the desktop versions + let mut out = ImageMetaData::new(); + { + let m = img_md.borrow(); + out.manufacturer = m.manufacturer.clone(); + out.model = m.model.clone(); + } + { + let p = pan.borrow(); + out.longitude = p.get_view_long(); + out.latitude = p.get_view_lat(); + out.height = p.get_view_height(); + out.direction = p.get_center_angle(); + out.pitch = p.get_pitch_angle(); + out.roll = p.get_roll_angle(); + out.focal_length_35mm = + p.get_scale() * 35.0 / (img_size.0.max(img_size.1) as f64).max(1.0); + out.projection_type = p.projection_type as i32; + out.k0 = p.parms.k0; + out.k1 = p.parms.k1; + out.x0 = p.parms.x0; + } + match out.save_image_to_bytes(&bytes) { + Ok(jpg) => { + let stem = name + .rsplit_once('.') + .map(|(s, _)| s.to_string()) + .unwrap_or_else(|| name.clone()); + let outname = format!("{stem}-gipfel.jpg"); + match bridge::download(&outname, &jpg, "image/jpeg") { + Ok(()) => status.set(format!("Saved {outname} (browser download).")), + Err(e) => status.set(format!("Download failed: {e}")), + } + } + Err(e) => status.set(format!("Save failed: {e} (input must be JPEG)")), + } + }) + }; + + // distortion profiles: localStorage store in FLTK prefs format + let refresh_profiles = { + let profiles = profiles.clone(); + Rc::new(move || { + profiles.set(load_prefs().into_iter().map(|(n, _)| n).collect()) + }) + }; + let apply_profile = { + let pan = pan.clone(); + let status = status.clone(); + Rc::new(move |name: &str| { + match load_prefs().into_iter().find(|(n, _)| n == name) { + Some((_, p)) => { + pan.borrow_mut().set_distortion_params(p.k0, p.k1, p.x0); + status.set(format!("Loaded distortion profile '{name}'.")); + } + None => status.set(format!("Profile '{name}' not found.")), + } + }) + }; + let on_profile_name = { + let profile_name = profile_name.clone(); + let profile_overwrite = profile_overwrite.clone(); + Callback::from(move |e: InputEvent| { + let input: HtmlInputElement = e.target_unchecked_into(); + profile_name.set(input.value()); + *profile_overwrite.borrow_mut() = false; + }) + }; + let on_profile_save = { + let profile_name = profile_name.clone(); + let pan = pan.clone(); + let status = status.clone(); + let profile_overwrite = profile_overwrite.clone(); + let refresh = refresh_profiles.clone(); + Callback::from(move |_: MouseEvent| { + let name = profile_name.trim().to_string(); + if name.is_empty() { + status.set("Enter a profile name.".into()); + return; + } + if let Err(e) = gipfel_core::profile::sanitize_name(&name) { + status.set(format!("Invalid profile name: {e}")); + return; + } + let prof = { + let p = pan.borrow(); + gipfel_core::profile::Profile { + k0: p.parms.k0, + k1: p.parms.k1, + x0: p.parms.x0, + } + }; + let mut all = load_prefs(); + let exists = all.iter().any(|(n, _)| *n == name); + if exists && !*profile_overwrite.borrow() { + *profile_overwrite.borrow_mut() = true; + status.set(format!("Profile '{name}' exists — press Save again to overwrite.")); + return; + } + all.retain(|(n, _)| *n != name); + all.push((name.clone(), prof)); + match save_prefs(&all) { + Ok(()) => { + *profile_overwrite.borrow_mut() = false; + refresh(); + status.set(format!("Saved distortion profile '{name}'.")); + } + Err(e) => status.set(format!("Profile save failed: {e}")), + } + }) + }; + let on_profile_load = { + let profile_name = profile_name.clone(); + let apply = apply_profile.clone(); + Callback::from(move |_: MouseEvent| apply(profile_name.trim())) + }; + let on_profile_select = { + let profile_name = profile_name.clone(); + let apply = apply_profile.clone(); + Callback::from(move |e: Event| { + let sel: web_sys::HtmlSelectElement = e.target_unchecked_into(); + let name = sel.value(); + profile_name.set(name.clone()); + apply(&name); + }) + }; + + let on_projection = { + let pan = pan.clone(); + let projection = projection.clone(); + Callback::from(move |e: Event| { + let sel: web_sys::HtmlSelectElement = e.target_unchecked_into(); + let cyl = sel.value() == "1"; + projection.set(if cyl { 1 } else { 0 }); + pan.borrow_mut().set_projection(if cyl { + ProjectionType::Cylindrical + } else { + ProjectionType::Rectilinear + }); + }) + }; + + 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)); + // GPS paste field: "47.676,13.32042" — the format gallery apps show + // for coordinates; height stays a separate field + let on_gps = { + let vp = vp.clone(); + let pan = pan.clone(); + let status = status.clone(); + Callback::from(move |text: String| { + let parts: Vec<f64> = text + .replace([';', ' '], ",") + .split(',') + .filter(|p| !p.trim().is_empty()) + .filter_map(|p| p.trim().parse::<f64>().ok()) + .collect(); + if parts.len() < 2 || parts[0].abs() > 90.0 || parts[1].abs() > 180.0 { + status.set("GPS: expected \"lat,lon\" like 47.676,13.32042".to_string()); + return; + } + let mut u = *vp; + u.lat = parts[0]; + u.lon = parts[1]; + let mut p = pan.borrow_mut(); + p.set_view_lat(parts[0]); + p.set_view_long(parts[1]); + vp.set(u); + status.set(format!("Viewpoint: {:.5}, {:.5}", parts[0], parts[1])); + }) + }; + 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 / 36.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()); + }) + }; + 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()); + }) + }; + 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 = { + 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! { + <FindPeakPanel + fp={(*fp).clone()} + {items} + {on_pick} + {on_query} + on_close={fp_close.clone()} + /> + } + } else { + Html::default() + }; + + let callbacks = ViewCallbacks { + pan: { + let apply = apply_view.clone(); + let user_moved = user_moved.clone(); + Callback::from(move |(dx, dy): (f64, f64)| { + *user_moved.borrow_mut() = true; + apply(&move |v| { + v.ox += dx; + v.oy += dy; + }); + }) + }, + zoom: { + let apply = apply_view.clone(); + let user_moved = user_moved.clone(); + Callback::from(move |(cx, cy, factor): (f64, f64, f64)| { + *user_moved.borrow_mut() = true; + apply(&move |v| { + let ns = (v.scale * factor).clamp(0.02, 64.0); + let k = ns / v.scale; + v.ox = cx - (cx - v.ox) * k; + v.oy = cy - (cy - v.oy) * k; + v.scale = ns; + }); + }) + }, + pinch: { + let apply = apply_view.clone(); + let user_moved = user_moved.clone(); + Callback::from(move |(cx, cy, factor, dx, dy): (f64, f64, f64, f64, f64)| { + *user_moved.borrow_mut() = true; + // zoom and pan in ONE update: two separate updates would + // each start from the same stale snapshot and clobber + apply(&move |v| { + let ns = (v.scale * factor).clamp(0.02, 64.0); + let k = ns / v.scale; + v.ox = cx - (cx - v.ox) * k + dx; + v.oy = cy - (cy - v.oy) * k + dy; + v.scale = ns; + }); + }) + }, + 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 · distance {:.2} km", + h.name, + h.height, + p.get_real_distance(i) / 1000.0 + ) + }); + hover.set(name); + }) + }, + hover_end: { + let hover = hover.clone(); + Callback::from(move |_: ()| hover.set(None)) + }, + }; + + // Lens FOV visibility limit, port of the desktop bump(): the angle at + // which the (possibly distorted) projection reaches the image edge. + // Peaks beyond it cannot be inside the photo even if the fitted + // distortion folds their projection back into the image. Cylindrical + // (panoramic) images are exempt: they may cover the full 360°, so the + // limit is set to 0 = unlimited. Running this every render is + // idempotent and cheap; visibility is only rebuilt when the limit + // actually changed. + { + let mut p = pan.borrow_mut(); + let limit = if img_size.0 == 0 || p.projection_type == ProjectionType::Cylindrical { + // 0 = unlimited: no image loaded, or panoramic projection, + // whose image may wrap all the way around the viewpoint + 0.0 + } else { + let c = p.parms.a_center; + let proj = gipfel_core::projection::projection_from_type(p.projection_type); + let a_edge = alph_at_img_x(p.projection_type, &*proj, &p.parms, img_size.0 as f64 / 2.0, c); + (a_edge - c).abs() + }; + if (limit - p.max_view_angle).abs() > 1e-9 { + p.max_view_angle = limit; + let known: Vec<usize> = markers.iter().map(|m| m.hill).collect(); + p.update_visible_mountains(Some(&known)); + } + // ?debug=1 dumps the effective visibility state to the browser + // console on every render (DevTools → Console) + if url_param("debug").is_some() { + web_sys::console::log_1( + &format!( + "gipfel dbg: proj={:?} max_view_angle={:.4} visible={} img={}x{}", + p.projection_type, + p.max_view_angle, + p.visible.len(), + img_size.0, + img_size.1 + ) + .into(), + ); + } + } + + // overlay data for the canvas + let marker_views: Vec<MarkerView> = { + let p = pan.borrow(); + 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<DotView> = { + let p = pan.borrow(); + let marked: Vec<usize> = markers.iter().map(|m| m.hill).collect(); + p.visible + .iter() + .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, + hidden: p.hills[i].flags & FLAG_HIDDEN != 0, + marked: marked.contains(&i), + name: p.hills[i].name.clone(), + }) + .collect() + }; + let track_views: Vec<TrackView> = { + 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 collapse_cb = { + let nav_open = nav_open.clone(); + Callback::from(move |_: MouseEvent| nav_open.set(false)) + }; + + // Google-Maps-style +/- buttons: zoom about the canvas center using + // the same math as wheel/pinch zoom; counts as manual navigation so + // the auto-fit stays out of the way afterwards + let zoom_step = { + let apply = apply_view.clone(); + let user_moved = user_moved.clone(); + let canvas_ref = canvas_ref.clone(); + Rc::new(move |factor: f64| { + let (cx, cy) = canvas_ref + .cast::<HtmlCanvasElement>() + .map(|c| { + ( + c.client_width() as f64 / 2.0, + c.client_height() as f64 / 2.0, + ) + }) + .unwrap_or((400.0, 300.0)); + *user_moved.borrow_mut() = true; + apply(&move |v| { + let ns = (v.scale * factor).clamp(0.02, 64.0); + let k = ns / v.scale; + v.ox = cx - (cx - v.ox) * k; + v.oy = cy - (cy - v.oy) * k; + v.scale = ns; + }); + }) + }; + let zoom_in = { + let zoom = zoom_step.clone(); + Callback::from(move |_: MouseEvent| zoom(1.4)) + }; + let zoom_out = { + let zoom = zoom_step.clone(); + Callback::from(move |_: MouseEvent| zoom(1.0 / 1.4)) + }; + let expand_cb = { + let nav_open = nav_open.clone(); + Callback::from(move |_: MouseEvent| nav_open.set(true)) + }; + + let zoom_pct = (view.scale * 100.0).round(); + let n_markers = markers.len(); + + html! { + <div class="app" ondrop={on_drop} ondragover={on_dragover}> + <aside class={if *nav_open { "sidebar" } else { "sidebar collapsed" }}> + <button class="collapse-btn" title="Hide controls" + onclick={collapse_cb}>{ "◀" }</button> + <h1>{ "gipfel" }</h1> + <a class="tag" href="https://flpsed.org/gipfel.html" target="_blank" + rel="noopener noreferrer">{ "Photogrammetry for Mountain Images" }</a> + <button onclick={open_picker}>{ "Open image…" }</button> + if bitmap.is_some() { + <button onclick={fit}>{ "Fit to window" }</button> + <button onclick={on_save_image}>{ "Save image…" }</button> + } + <input + type="file" + ref={file_ref} + accept="image/*" + class="hidden-file" + onchange={on_file_change} + /> + <input + type="file" + ref={track_file_ref} + accept=".gpx,application/gpx+xml" + class="hidden-file" + onchange={on_track_file_change} + /> + <p class="status">{ (*status).clone() }</p> + <p class="hint">{ (*db_status).clone() }</p> + if bitmap.is_some() { + <> + <div class="section">{ "Viewpoint" }</div> + <NumItem label="Latitude" value={vp.lat} step={0.00001} decimals={5} + onchange={on_lat} /> + <NumItem label="Longitude" value={vp.lon} step={0.00001} decimals={5} + onchange={on_lon} /> + <NumItem label="Height (m)" value={vp.height} step={1.0} decimals={0} + onchange={on_height} /> + <TextItem label="GPS paste" placeholder="47.676,13.32042" + onchange={on_gps} /> + <div class="section">{ "Orientation" }</div> + <SliderItem label="Azimuth" display={format!("{:.1}°", vp.az)} + value={vp.az} min={0.0} max={360.0} step={0.01} onchange={on_az} /> + <SliderItem label="Focal (35mm)" display={format!("{:.1} mm", vp.focal)} + value={vp.focal} min={1.0} max={300.0} step={0.01} onchange={on_focal} /> + <SliderItem label="Pitch" display={format!("{:.1}°", vp.pitch)} + value={vp.pitch} min={-40.0} max={20.0} step={0.01} onchange={on_pitch} /> + <SliderItem label="Roll" display={format!("{:.1}°", vp.roll)} + value={vp.roll} min={-10.0} max={10.0} step={0.01} onchange={on_roll} /> + <div class="section">{ "Projection" }</div> + <select class="textinput" onchange={on_projection}> + <option value="0" selected={*projection == 0}>{ "Rectilinear projection" }</option> + <option value="1" selected={*projection == 1}>{ "Cylindrical (panoramic)" }</option> + </select> + <label class="row"> + <input type="checkbox" checked={*fit_distortion} onchange={on_distortion_toggle} /> + { "Fit distortion (needs ≥ 4 markers)" } + </label> + <div class="subsection">{ "Distortion profiles" }</div> + <input + type="text" + class="textinput" + placeholder="profile name" + value={(*profile_name).clone()} + oninput={on_profile_name} + /> + <div class="row gap"> + <button onclick={on_profile_save}>{ "Save" }</button> + <button onclick={on_profile_load}>{ "Load" }</button> + </div> + if !profiles.is_empty() { + <select class="textinput" onchange={on_profile_select}> + <option value="" selected={true}>{ "saved profiles…" }</option> + { + profiles.iter().map(|n| html! { + <option value={n.clone()} key={n.clone()}>{ n.clone() }</option> + }).collect::<Html>() + } + </select> + } + <div class="section">{ "Display" }</div> + <label class="row"> + <input type="checkbox" checked={*show_hidden} onchange={on_show_hidden} /> + { "Show hidden peaks" } + </label> + <label class="row"> + <input type="checkbox" checked={*peak_labels} onchange={on_peak_labels} /> + { "Show peak labels" } + </label> + <SliderItem label="Visibility" display={format!("{:.0} %", (vp.vis - 0.01) / 0.09 * 100.0)} + value={vp.vis} min={0.01} max={0.1} step={0.001} onchange={on_vis} /> + <SliderItem label="Label size" display={format!("{:.0} px", vp.label_font)} + value={vp.label_font as f64} min={8.0} max={28.0} step={1.0} onchange={on_font} /> + <p class="hint">{ format!("{n_markers} markers · zoom {zoom_pct:.0} %") }</p> + if !fit_info.is_empty() { + <p class="fitinfo">{ (*fit_info).clone() }</p> + } + <div class="section">{ "Track" }</div> + <button onclick={open_track_picker}>{ "Load GPX Track…" }</button> + if !track.is_empty() { + <SliderItem label="Track width" display={format!("{:.0} m", *track_width)} + value={*track_width} min={50.0} max={1000.0} step={10.0} + onchange={on_track_width} /> + } + // deliberately below the track controls: the + // default database is loaded automatically, this + // is only an optional replacement + <button class="secondary" onclick={open_db_picker}> + { "Load alternative hill database…" } + </button> + <input + type="file" + class="hidden-file" + accept=".dat,.gz,.gzip,application/gzip" + ref={db_file_ref} + onchange={on_db_file_change} + /> + // last so revealing it on hover cannot shift any + // control above it (the bottom-pinned infofoot + // absorbs the height change) + if let Some(h) = hover.as_ref() { + <p class="hover">{ h.clone() }</p> + } + </> + } + <div class="infofoot"> + <p class="hint dim">{ format!("gipfel {} · build {}", env!("CARGO_PKG_VERSION"), BUILD_STAMP) }</p> + <p class="hint"> + { "Hover a dot to see the peak · click to mark it (or pick from the list) · drag to adjust · right-click to remove." } + </p> + <p class="hint dim"> + { "The view is fitted as soon as markers are placed; more markers improve the fit." } + </p> + </div> + </aside> + <main class="main"> + <div class="canvaswrap"> + if !*nav_open { + <button class="nav-toggle" title="Show controls" + onclick={expand_cb}>{ "☰" }</button> + } + <div class="canvasstatus">{ (*status).clone() }</div> + <CanvasView + bitmap={bitmap.as_ref().cloned()} + view={(*view).clone()} + {callbacks} + canvas_ref={canvas_ref.clone()} + tick={*tick} + markers={marker_views} + track={track_views} + candidates={candidates} + peak_labels={*peak_labels} + label_font={vp.label_font} + /> + { findpeak_popup.clone() } + if bitmap.is_some() { + <div class="zoomctrl"> + <button onclick={zoom_in} title="Zoom in" aria-label="Zoom in">{"+"}</button> + <button onclick={zoom_out} title="Zoom out" aria-label="Zoom out">{"\u{2212}"}</button> + </div> + } + </div> + if bitmap.is_some() { + <Compass data={compass_data} tick={*tick} on_change={compass_change} /> + } + </main> + </div> + } +} diff --git a/crates/gipfel/src/bridge.rs b/crates/gipfel/src/bridge.rs new file mode 100644 index 0000000..2a23c46 --- /dev/null +++ b/crates/gipfel/src/bridge.rs @@ -0,0 +1,119 @@ +//! 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<ImageBitmap, String> { + 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::<ImageBitmap>() + .map_err(|_| "decode produced non-bitmap".to_string()) +} + +/// Read a File/Blob fully into memory. +pub async fn read_blob(blob: &Blob) -> Result<Vec<u8>, String> { + let buf = JsFuture::from(blob.array_buffer()) + .await + .map_err(|e| format!("read failed: {e:?}"))?; + Ok(Uint8Array::new(&buf).to_vec()) +} + +/// Offer `bytes` as a browser download under the given file name. +pub fn download(filename: &str, bytes: &[u8], mime: &str) -> Result<(), String> { + let array = js_sys::Array::new(); + array.push(&Uint8Array::from(bytes).buffer()); + let opts = web_sys::BlobPropertyBag::new(); + opts.set_type(mime); + let blob = Blob::new_with_u8_array_sequence_and_options(&array, &opts) + .map_err(|_| "blob failed".to_string())?; + let url = web_sys::Url::create_object_url_with_blob(&blob) + .map_err(|_| "object url failed".to_string())?; + let doc = window().document().ok_or("no document")?; + let a = doc.create_element("a").map_err(|_| "no anchor".to_string())?; + a.set_attribute("href", &url).map_err(|_| "href".to_string())?; + a.set_attribute("download", filename).map_err(|_| "download".to_string())?; + if let Ok(el) = a.dyn_into::<web_sys::HtmlElement>() { + el.click(); + } + let _ = web_sys::Url::revoke_object_url(&url); + Ok(()) +} + +/// localStorage read (None when unavailable or unset). +pub fn store_get(key: &str) -> Option<String> { + let store = window().local_storage().ok()??; + store.get_item(key).ok().flatten() +} + +/// localStorage write. +pub fn store_set(key: &str, value: &str) -> Result<(), String> { + let store = window() + .local_storage() + .map_err(|_| "no localStorage")? + .ok_or("no localStorage")?; + store + .set_item(key, value) + .map_err(|_| "localStorage denied or full".to_string()) +} + +/// Fetch a URL (same-origin) into memory. +pub async fn fetch_bytes(url: &str) -> Result<Vec<u8>, 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<CanvasRenderingContext2d> { + canvas + .get_context("2d") + .ok() + .flatten() + .and_then(|c| c.dyn_into::<CanvasRenderingContext2d>().ok()) +} + +/// Read a CSS custom property from :root (follows the active +/// prefers-color-scheme), with a fallback when unavailable. +pub fn css_var(name: &str, fallback: &str) -> String { + window() + .document() + .and_then(|d| window().get_computed_style(&d.document_element()?).ok().flatten()) + .and_then(|s| s.get_property_value(name).ok()) + .map(|v| v.trim().to_string()) + .filter(|v| !v.is_empty()) + .unwrap_or_else(|| fallback.to_string()) +} diff --git a/crates/gipfel/src/canvas_view.rs b/crates/gipfel/src/canvas_view.rs new file mode 100644 index 0000000..df46b5c --- /dev/null +++ b/crates/gipfel/src/canvas_view.rs @@ -0,0 +1,686 @@ +//! 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 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, +} + +/// One GPS track point in center-relative image coordinates; `width` is +/// the projected stroke width in image pixels (C: scale*width/(dist_m*10)). +#[derive(Clone, Debug, PartialEq)] +pub struct TrackView { + pub x: f64, + pub y: f64, + pub hidden: bool, + pub width: 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)>, + /// 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<()>, + /// two-finger pinch: (center x, center y, factor, pan dx, pan dy). + /// Zoom and pan must land in ONE state update: two consecutive + /// read-modify-writes clobber each other, because a UseStateHandle + /// cloned into a callback derefs to its render-time snapshot. + pub pinch: Callback<(f64, f64, f64, f64, f64)>, +} + +#[derive(Properties, PartialEq)] +pub struct Props { + pub bitmap: Option<ImageBitmap>, + pub view: ViewState, + pub callbacks: ViewCallbacks, + pub canvas_ref: NodeRef, + /// bumped on window resize to force a redraw + pub tick: u32, + pub markers: Vec<MarkerView>, + /// GPS track points in file order + pub track: Vec<TrackView>, + /// guide dots for all visible hills + pub candidates: Vec<DotView>, + /// draw name labels for unmarked visible peaks too + pub peak_labels: 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<DragMode>, + last: (f64, f64), + start: (f64, f64), + moved: bool, + /// all active pointers (id, client position); >1 while pinching + pts: Vec<(i32, (f64, f64))>, + /// pinch geometry: (distance, center x, center y), canvas-relative + pinch: Option<(f64, f64, f64)>, +} + +#[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, + pts: Vec::new(), + pinch: None, + }); + // 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 track = props.track.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(), + track.clone(), + candidates.clone(), + label_font, + peak_labels, + ), + move |(bitmap, view, _tick, markers, track, candidates, label_font, peak_labels)| { + let Some(canvas) = canvas_ref.cast::<HtmlCanvasElement>() 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); + // transparent clear: the CSS background of .canvaswrap + // (a theme variable) shows through + ctx.clear_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; + + // GPS track: consecutive points joined with round-cap + // strokes scaled by distance (desktop parity: red, or + // blue where the point is hidden by terrain) + for w in track.windows(2) { + let (a, b) = (&w[0], &w[1]); + let color = if a.hidden { "rgb(51, 102, 255)" } else { "rgb(255, 51, 51)" }; + #[allow(deprecated)] + ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str(color)); + ctx.set_line_width((a.width * view.scale).max(1.0)); + ctx.set_line_cap("round"); + ctx.begin_path(); + ctx.move_to(sx(a.x), sy(a.y)); + ctx.line_to(sx(b.x), sy(b.y)); + ctx.stroke(); + } + ctx.set_line_cap("butt"); + + // 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 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; + } + ctx.begin_path(); + let _ = ctx.arc(px, py, 4.5, 0.0, std::f64::consts::TAU); + ctx.fill(); + } + 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 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(); + let _ = ctx.arc(px, py, 2.5, 0.0, std::f64::consts::TAU); + ctx.fill(); + } + + // 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<Item> = 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 + // 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<usize> = (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[b].x).total_cmp(&sx(items[a].x))); + let xs: Vec<f32> = order.iter().map(|&i| sx(items[i].x) as f32).collect(); + let ys: Vec<f32> = order.iter().map(|&i| sy(items[i].y) as f32).collect(); + let widths: Vec<f32> = order + .iter() + .map(|&i| { + ctx.measure_text(&items[i].name) + .map(|m| m.width() as f32) + .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: 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() { + 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(); + 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); + 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 { + 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); + ctx.move_to(px, py - 5.0); + ctx.line_to(px, py + 5.0); + ctx.stroke(); + } + // 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 items[i].name.is_empty() { + 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 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(&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(color)); + ctx.fill_text(&items[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::<HtmlCanvasElement>() + .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(); + let rect = canvas_ref + .cast::<HtmlCanvasElement>() + .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 n = { + let mut d = drag.borrow_mut(); + d.pts.retain(|(id, _)| *id != e.pointer_id()); + d.pts.push((e.pointer_id(), pos)); + let n = d.pts.len(); + if n >= 2 { + // second finger: switch to pinch, cancel any pan/marker + // drag so the view does not jump + d.mode = None; + d.pinch = None; + d.moved = true; + } else { + d.mode = Some(mode); + d.last = pos; + d.start = pos; + d.moved = false; + } + n + }; + // capture only the primary pointer; capturing every finger + // confuses some mobile browsers + if n == 1 { + if let Some(c) = canvas_ref.cast::<HtmlCanvasElement>() { + let _ = c.set_pointer_capture(e.pointer_id()); + } + } + }) + }; + + let on_pointermove = { + let drag = drag.clone(); + let pan_cb = props.callbacks.pan.clone(); + let pinch_cb = props.callbacks.pinch.clone(); + let marker_drag = props.callbacks.marker_drag.clone(); + let hover = props.callbacks.hover.clone(); + let to_img = to_img.clone(); + let canvas_ref = props.canvas_ref.clone(); + let scale = props.view.scale; + Callback::from(move |e: PointerEvent| { + // update the pointer table and handle two-finger pinch + let pinch_ev = { + let mut d = drag.borrow_mut(); + let pos = (e.client_x() as f64, e.client_y() as f64); + match d.pts.iter_mut().find(|(id, _)| *id == e.pointer_id()) { + Some(p) => p.1 = pos, + // a touch pointermove for a pointer we never saw go + // down (lost pointerdown, e.g. swallowed by the + // browser) — join it so pinch still works + None if e.pointer_type() == "touch" && e.buttons() != 0 => { + d.pts.push((e.pointer_id(), pos)); + } + None => {} + } + if d.pts.len() >= 2 { + let (x1, y1) = d.pts[0].1; + let (x2, y2) = d.pts[1].1; + let rect = canvas_ref + .cast::<HtmlCanvasElement>() + .map(|c| c.get_bounding_client_rect()); + let (rl, rt) = match rect { + Some(r) => (r.left(), r.top()), + None => (0.0, 0.0), + }; + let dist = ((x2 - x1).powi(2) + (y2 - y1).powi(2)).sqrt(); + let cx = (x1 + x2) / 2.0 - rl; + let cy = (y1 + y2) / 2.0 - rt; + let ev = match d.pinch { + Some((od, ocx, ocy)) if od > 1.0 && dist > 1.0 => { + Some((dist / od, cx, cy, cx - ocx, cy - ocy)) + } + _ => None, + }; + d.pinch = Some((dist, cx, cy)); + d.moved = true; + (ev, true) + } else { + (None, false) + } + }; + let in_pinch = pinch_ev.1; + if in_pinch { + if let Some((factor, cx, cy, dx, dy)) = pinch_ev.0 { + pinch_cb.emit((cx, cy, factor, dx, dy)); + } + return; + } + 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, moved) = { + let mut d = drag.borrow_mut(); + d.pts.retain(|(id, _)| *id != e.pointer_id()); + if d.pts.len() < 2 { + d.pinch = None; + } + let mode = d.mode.take(); + let moved = d.moved; + if d.pts.len() == 1 { + // one finger left after pinch: resume panning from + // there, never treat it as a click + d.mode = Some(DragMode::Pan); + d.last = d.pts[0].1; + d.moved = true; + } + (mode, moved) + }; + if let Some(c) = canvas_ref.cast::<HtmlCanvasElement>() { + let _ = c.release_pointer_capture(e.pointer_id()); + } + 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 |e: PointerEvent| { + let mut d = drag.borrow_mut(); + // do NOT clear the whole table: when a mobile browser + // "cancels" the first finger as the second arrives, a + // blanket clear would make a pinch impossible to form + d.pts.retain(|(id, _)| *id != e.pointer_id()); + if d.pts.len() < 2 { + d.pinch = None; + } + if d.pts.is_empty() { + d.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::<HtmlCanvasElement>() + .map(|c| c.get_bounding_client_rect().left()) + .unwrap_or(0.0); + let cy = e.client_y() as f64 + - canvas_ref + .cast::<HtmlCanvasElement>() + .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! { + <canvas + ref={props.canvas_ref.clone()} + class="viewport" + onpointerdown={on_pointerdown} + onpointermove={on_pointermove} + onpointerup={on_pointerup} + onpointercancel={on_pointercancel} + onpointerleave={on_pointerleave} + oncontextmenu={on_contextmenu} + onwheel={on_wheel} + /> + } +} + +/// 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<usize> = 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/src/compass.rs b/crates/gipfel/src/compass.rs new file mode 100644 index 0000000..5e91c9a --- /dev/null +++ b/crates/gipfel/src/compass.rs @@ -0,0 +1,351 @@ +//! 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<f64>, + 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<f64>, +} + +#[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::<HtmlCanvasElement>() 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); + + // theme colors come from the CSS variables, so the strip + // follows light/dark preference like the rest of the UI + let on = bridge::css_var("--compass-fg", "rgb(217, 217, 217)"); + let bg = bridge::css_var("--compass-bg", "rgb(41, 41, 41)"); + let divider = bridge::css_var("--compass-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(÷r, 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::<HtmlCanvasElement>() + .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::<HtmlCanvasElement>() { + 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::<HtmlCanvasElement>() { + let _ = c.release_pointer_capture(e.pointer_id()); + } + }) + }; + + html! { + <canvas + ref={canvas_ref} + class="compass" + style={format!("height: {}px", STRIP_H)} + onpointerdown={on_pointerdown} + onpointermove={on_pointermove} + onpointerup={on_pointerup.clone()} + onpointercancel={on_pointerup} + /> + } +} + +#[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/src/main.rs b/crates/gipfel/src/main.rs new file mode 100644 index 0000000..741393b --- /dev/null +++ b/crates/gipfel/src/main.rs @@ -0,0 +1,10 @@ +mod app; +mod bridge; +mod canvas_view; +mod compass; +mod markers; +mod widgets; + +fn main() { + yew::Renderer::<app::App>::new().render(); +} diff --git a/crates/gipfel/src/markers.rs b/crates/gipfel/src/markers.rs new file mode 100644 index 0000000..b8c00aa --- /dev/null +++ b/crates/gipfel/src/markers.rs @@ -0,0 +1,66 @@ +//! 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<Hill> = 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<usize> = (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<usize> { + let mut best = None; + let mut best_d = max_dist; + for &i in &pan.visible { + let flags = pan.hills[i].flags; + if flags & gipfel_core::hill::FLAG_DUPLIC != 0 + || flags & gipfel_core::hill::FLAG_TRACK_POINT != 0 + { + continue; + } + if !show_hidden && 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/src/widgets.rs b/crates/gipfel/src/widgets.rs new file mode 100644 index 0000000..93e2cdc --- /dev/null +++ b/crates/gipfel/src/widgets.rs @@ -0,0 +1,106 @@ +//! 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<f64>, +} + +#[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::<f64>() { + onchange.emit(v); + } + }) + }; + html! { + <div class="slider"> + <div class="sliderhead"> + <span>{ p.label.as_ref().to_string() }</span> + <span class="val">{ p.display.as_ref().to_string() }</span> + </div> + <input + type="range" + min={p.min.to_string()} + max={p.max.to_string()} + step={p.step.to_string()} + value={p.value.to_string()} + {oninput} + /> + </div> + } +} + +/// single-line text row (e.g. paste a GPS string) +#[derive(Properties, PartialEq)] +pub struct TextProps { + pub label: AttrValue, + pub placeholder: AttrValue, + pub onchange: Callback<String>, +} + +#[function_component(TextItem)] +pub fn text_item(p: &TextProps) -> Html { + let onchange = { + let onchange = p.onchange.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + onchange.emit(input.value()); + }) + }; + html! { + <label class="numrow"> + <span>{ p.label.as_ref().to_string() }</span> + <input + type="text" + placeholder={p.placeholder.as_ref().to_string()} + {onchange} + /> + </label> + } +} + +#[derive(Properties, PartialEq)] +pub struct NumProps { + pub label: AttrValue, + pub value: f64, + pub step: f64, + #[prop_or(2)] + pub decimals: usize, + pub onchange: Callback<f64>, +} + +#[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::<f64>() { + onchange.emit(v); + } + }) + }; + let display = format!("{:.*}", p.decimals, p.value); + html! { + <label class="numrow"> + <span>{ p.label.as_ref().to_string() }</span> + <input type="number" step={p.step.to_string()} value={display} {onchange} /> + </label> + } +} diff --git a/crates/gipfel/www/index.html b/crates/gipfel/www/index.html new file mode 100644 index 0000000..3356815 --- /dev/null +++ b/crates/gipfel/www/index.html @@ -0,0 +1,24 @@ +<!doctype html> +<html lang="en"> + <head> + <meta charset="utf-8" /> + <!-- + Content-Security-Policy (ships with the page so it applies on any + static host). Scripts only from this origin, no inline JS; wasm + compilation is the one scoped exception. Inline style *attributes* + are used by the Yew views, hence style-src unsafe-inline. + --> + <meta + http-equiv="Content-Security-Policy" + content="default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; img-src 'self' blob: data:; connect-src 'self' blob: data:; style-src 'self' 'unsafe-inline'" + /> + <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> + <meta name="theme-color" content="#101014" media="(prefers-color-scheme: dark)" /> + <meta name="theme-color" content="#e9eaf0" media="(prefers-color-scheme: light)" /> + <title>gipfel — Photogrammetry for Mountain Images</title> + <link rel="stylesheet" href="style.css" /> + </head> + <body> + <script type="module" src="loader.js"></script> + </body> +</html> diff --git a/crates/gipfel/www/loader.js b/crates/gipfel/www/loader.js new file mode 100644 index 0000000..5fbd558 --- /dev/null +++ b/crates/gipfel/www/loader.js @@ -0,0 +1,4 @@ +// External loader so the page needs no inline <script>, keeping +// `script-src 'self'` in the Content-Security-Policy sufficient. +import init from './gipfel.js'; +init(); diff --git a/crates/gipfel/www/style.css b/crates/gipfel/www/style.css new file mode 100644 index 0000000..942c569 --- /dev/null +++ b/crates/gipfel/www/style.css @@ -0,0 +1,407 @@ +* { + box-sizing: border-box; +} +:root { + /* dark is the default theme; the light block below overrides for + users whose OS/browser prefers light */ + --bg: #101014; + --panel: #1a1a20; + --panel-border: #2c2c34; + --text: #e8e8ea; + --text-dim: #c8c8d0; + --text-faint: #8a8a94; + --input-bg: #24242c; + --input-border: #34343e; + --chip-bg: #2c2c34; + --chip-hover: #3b3b46; + --btn: #3b6fd4; + --btn-hover: #4a7ee4; + --accent: #7fa5e8; + --fitinfo: #9fd09f; + --canvas-bg: #101014; + --compass-bg: rgb(41, 41, 41); + --compass-fg: rgb(217, 217, 217); + --compass-divider: rgb(82, 82, 82); + --popover-bg: #1e1e26; + --popover-border: #3a3a46; + --popover-shadow: rgba(0, 0, 0, 0.5); +} +@media (prefers-color-scheme: light) { + :root { + --bg: #e9eaf0; + --panel: #ffffff; + --panel-border: #d6d8de; + --text: #1e1e26; + --text-dim: #44464e; + --text-faint: #7c7e88; + --input-bg: #f0f1f5; + --input-border: #c9ccd4; + --chip-bg: #e2e3e9; + --chip-hover: #d0d2da; + --btn: #3b6fd4; + --btn-hover: #2f5fbd; + --accent: #2b5cb8; + --fitinfo: #2e7d32; + --canvas-bg: #d9dbe2; + --compass-bg: rgb(240, 241, 245); + --compass-fg: rgb(40, 40, 48); + --compass-divider: rgb(170, 173, 182); + --popover-bg: #ffffff; + --popover-border: #c9ccd4; + --popover-shadow: rgba(40, 40, 60, 0.25); + } +} +html, +body { + margin: 0; + height: 100%; + font-family: system-ui, sans-serif; +} +.app { + display: flex; + height: 100vh; + /* dynamic viewport height: on mobile browsers 100vh includes the + area behind the collapsing URL bar, pushing the compass below the + fold; dvh tracks the actually visible area */ + height: 100dvh; + background: var(--bg); + color: var(--text); +} +.sidebar { + width: 300px; + padding: 16px; + background: var(--panel); + border-right: 1px solid var(--panel-border); + display: flex; + flex-direction: column; + gap: 8px; + overflow-y: auto; + position: relative; +} +.sidebar.collapsed { + display: none; +} +.sidebar .collapse-btn { + position: absolute; + top: 10px; + right: 10px; + width: 28px; + height: 28px; + padding: 0; + background: var(--chip-bg); + color: var(--text); + font-size: 12px; + border-radius: 5px; +} +.sidebar .collapse-btn:hover { + background: var(--chip-hover); +} +.nav-toggle { + position: absolute; + top: 10px; + left: 10px; + z-index: 5; + width: 36px; + height: 36px; + padding: 0; + background: rgba(26, 26, 32, 0.85); + color: #e8e8ea; + border: 1px solid #2c2c34; + border-radius: 6px; + font-size: 16px; + cursor: pointer; +} +.nav-toggle:hover { + background: rgba(59, 111, 212, 0.9); +} +/* sits on top of the photo, so it stays dark in both themes */ +.canvasstatus { + position: absolute; + bottom: 6px; + left: 8px; + right: 8px; + /* do NOT let long status text widen the flex container (that + stretched the canvas and re-anchored the fit on every update) */ + width: min-content; + max-width: calc(100% - 16px); + font-size: 11px; + color: #e8e8ea; + background: rgba(16, 16, 20, 0.7); + padding: 3px 8px; + border-radius: 5px; + pointer-events: none; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} +.sidebar h1 { + margin: 0; + font-size: 22px; +} +.tag { + display: block; + margin: 0 0 12px; + color: var(--text-faint); + font-size: 12px; + text-transform: uppercase; + letter-spacing: 1px; + text-decoration: none; +} +.tag:hover { + color: var(--accent); + text-decoration: underline; +} +.sidebar button { + padding: 8px 12px; + background: var(--btn); + color: #fff; + border: 0; + border-radius: 6px; + font-size: 14px; + cursor: pointer; +} +.sidebar button:hover { + background: var(--btn-hover); +} +.sidebar button.secondary { + background: var(--chip-bg); + color: var(--text); + font-size: 13px; + padding: 6px 10px; +} +.sidebar button.secondary:hover { + background: var(--chip-hover); +} +.status { + font-size: 13px; + color: var(--text-dim); + word-break: break-word; +} +.hint { + font-size: 12px; + color: var(--text-faint); +} +.row { + display: flex; + gap: 6px; + align-items: center; + font-size: 13px; + cursor: pointer; +} +.fitinfo { + font-size: 12px; + color: var(--fitinfo); + font-variant-numeric: tabular-nums; +} +.hover { + font-size: 14px; + font-weight: 600; + color: var(--text); +} +.dim { + opacity: 0.6; +} +.hidden-file { + display: none; +} +.infofoot { + /* pins the info texts to the bottom of the sidebar */ + margin-top: auto; +} +.main { + flex: 1; + min-width: 0; + display: flex; + flex-direction: column; +} +.canvaswrap { + flex: 1; + position: relative; + min-height: 0; + background: var(--canvas-bg); +} +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: var(--text-faint); + border-bottom: 1px solid var(--panel-border); + 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: var(--text-dim); +} +.slider input[type="range"] { + width: 100%; + accent-color: var(--btn); +} +.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: var(--input-bg); + color: var(--text); + border: 1px solid var(--input-border); + border-radius: 4px; +} +.numrow input[type="text"] { + width: 150px; +} +.fpbackdrop { + position: absolute; + inset: 0; + z-index: 9; +} +.findpeak { + position: absolute; + z-index: 10; + width: 280px; + background: var(--popover-bg); + border: 1px solid var(--popover-border); + border-radius: 6px; + box-shadow: 0 8px 24px var(--popover-shadow); + display: flex; + flex-direction: column; +} +.fpsearch { + padding: 8px; + border-bottom: 1px solid var(--panel-border); +} +.fpsearch input { + width: 100%; + padding: 5px 8px; + background: var(--input-bg); + border: 1px solid var(--popover-border); + border-radius: 4px; + color: var(--text); + font-size: 13px; +} +.fplist { + max-height: 320px; + overflow-y: auto; +} +.fpempty { + padding: 8px 10px; + font-size: 13px; + color: var(--text-faint); + margin: 0; +} +.fpfoot { + padding: 6px 8px; + border-top: 1px solid var(--panel-border); + text-align: right; +} +.fpcancel { + padding: 4px 12px; + background: var(--chip-bg); + color: var(--text); + border: 0; + border-radius: 4px; + font-size: 12px; + cursor: pointer; +} +.fphead { + padding: 6px 10px; + font-size: 11px; + text-transform: uppercase; + letter-spacing: 1px; + color: var(--text-faint); + border-bottom: 1px solid var(--panel-border); +} +.fpitem { + display: block; + width: 100%; + text-align: left; + padding: 6px 10px; + background: none; + border: 0; + color: var(--text); + font-size: 13px; + cursor: pointer; +} +.fpitem:hover { + background: var(--btn); + color: #fff; +} +.subsection { + margin-top: 10px; + font-size: 12px; + color: var(--text-dim); +} +.textinput { + width: 100%; + box-sizing: border-box; + padding: 6px 8px; + background: var(--btn); + color: var(--text); + border: 1px solid var(--panel-border); + border-radius: 6px; + font-size: 13px; +} +select.textinput { + margin-top: 6px; +} +.row.gap { + margin-top: 6px; +} +/* Google-Maps-style zoom control, bottom right above the status line */ +.zoomctrl { + position: absolute; + right: 12px; + bottom: 34px; + display: flex; + flex-direction: column; + border-radius: 8px; + overflow: hidden; + box-shadow: 0 1px 5px rgba(0, 0, 0, 0.45); + z-index: 6; +} +.zoomctrl button { + width: 38px; + height: 38px; + padding: 0; + font-size: 21px; + line-height: 1; + background: rgba(26, 26, 32, 0.85); + color: #fff; + border: 0; + cursor: pointer; +} +.zoomctrl button:hover { + background: rgba(59, 111, 212, 0.9); +} +.zoomctrl button + button { + border-top: 1px solid rgba(255, 255, 255, 0.15); +} |
