From f6883fa1d586a040bf228ab886b95ca64457fa34 Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 13:55:35 +0100 Subject: Rename web front end to wipfel MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 'gipfel web' is taken by an existing related project. The browser app is now wipfel — web based gipfel photogrammetry for mountain images: crate gipfel-web -> wipfel, updated titles, docs, plan and dev script. The shared engine crate stays gipfel-core. --- crates/wipfel/src/compass.rs | 349 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 349 insertions(+) create mode 100644 crates/wipfel/src/compass.rs (limited to 'crates/wipfel/src/compass.rs') diff --git a/crates/wipfel/src/compass.rs b/crates/wipfel/src/compass.rs new file mode 100644 index 0000000..b539e07 --- /dev/null +++ b/crates/wipfel/src/compass.rs @@ -0,0 +1,349 @@ +//! Compass strip (canvas port of the desktop `compass.rs`, Aligned style): +//! shares the image's horizontal transform so each direction sits above +//! its position in the image; drag horizontally to change the view azimuth. + +use web_sys::{HtmlCanvasElement, PointerEvent};use yew::prelude::*; + +use gipfel_core::projection::{projection_from_type, ProjArgs, Projection, ProjectionType, ViewParams}; + +use crate::bridge; + +pub const STRIP_H: f64 = 56.0; + +/// Damped, clamped Newton iteration for a scalar inverse projection: find +/// `a` such that `f(a) ≈ target` (identical to the desktop solver). +pub fn newton_inverse( + target: f64, + mut f: impl FnMut(f64) -> Option, + seed: f64, + lo: f64, + hi: f64, +) -> f64 { + let mut a = seed.clamp(lo, hi); + for _ in 0..6 { + let Some(y) = f(a) else { break }; + let resid = y - target; + let h = 1e-5; + let (Some(y1), Some(y2)) = (f(a + h), f(a - h)) else { + break; + }; + let d = (y1 - y2) / (2.0 * h); + if !d.is_finite() || d.abs() < 1e-9 { + break; + } + let step = (resid / d).clamp(-0.3, 0.3); + a = (a - step).clamp(lo, hi); + if step.abs() < 1e-10 { + break; + } + } + a +} + +/// azimuth whose image x is `x_img`, measured with `c_ref` as center angle +pub fn alph_at_img_x( + ptype: ProjectionType, + proj: &dyn Projection, + p: &ViewParams, + x_img: f64, + c_ref: f64, +) -> f64 { + let mut p = *p; + p.a_center = c_ref; + let seed = match ptype { + ProjectionType::Rectilinear => c_ref + (x_img / p.scale).atan(), + ProjectionType::Cylindrical => c_ref + x_img / p.scale, + }; + let (lo, hi) = match ptype { + ProjectionType::Rectilinear => (c_ref - 1.55, c_ref + 1.55), + ProjectionType::Cylindrical => (c_ref - 3.1, c_ref + 3.1), + }; + newton_inverse( + x_img, + |a| Some(proj.mac_x(ProjArgs::from_params(&p, a, 0.0))), + seed, + lo, + hi, + ) +} + +const DIRS: [(f64, &str); 8] = [ + (0.0, "N"), + (45.0, "NE"), + (90.0, "E"), + (135.0, "SE"), + (180.0, "S"), + (225.0, "SW"), + (270.0, "W"), + (315.0, "NW"), +]; + +/// everything the strip needs; all plain data so Yew can diff it +#[derive(Clone, Copy, PartialEq)] +pub struct CompassData { + pub ptype: ProjectionType, + pub parms: ViewParams, + pub center_deg: f64, + pub zoom: f64, + /// screen x of the image center (strip shares the image transform) + pub cx: f64, + /// lens FOV half-angle limit, radians (0 = none) + pub max_view_angle: f64, +} + +#[derive(Properties, PartialEq)] +pub struct Props { + pub data: CompassData, + /// bumped on window resize to force a redraw + pub tick: u32, + /// new azimuth in degrees while dragging + pub on_change: Callback, +} + +#[function_component(Compass)] +pub fn compass(props: &Props) -> Html { + let canvas_ref = use_node_ref(); + let drag = use_mut_ref(|| Option::<(f64, f64)>::None); // (press x, center_deg) + + let d = props.data; + + // draw + { + let canvas_ref = canvas_ref.clone(); + use_effect_with((d, props.tick), move |(d, _tick)| { + let Some(canvas) = canvas_ref.cast::() else { + return; + }; + let Some(ctx) = bridge::ctx2d(&canvas) else { + return; + }; + let dpr = bridge::window().device_pixel_ratio(); + let w = canvas.client_width() as f64; + let bw = (w * dpr).max(1.0) as u32; + let bh = (STRIP_H * dpr).max(1.0) as u32; + if canvas.width() != bw || canvas.height() != bh { + canvas.set_width(bw); + canvas.set_height(bh); + } + let _ = ctx.set_transform(dpr, 0.0, 0.0, dpr, 0.0, 0.0); + + let on = "rgb(217, 217, 217)"; + let bg = "rgb(41, 41, 41)"; + let divider = "rgb(82, 82, 82)"; + let red = "rgb(255, 102, 64)"; + + let fill = |c: &str| { + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str(c)); + }; + let stroke = |c: &str, width: f64| { + #[allow(deprecated)] + ctx.set_stroke_style(&wasm_bindgen::JsValue::from_str(c)); + ctx.set_line_width(width); + }; + + fill(bg); + ctx.fill_rect(0.0, 0.0, w, STRIP_H); + stroke(divider, 1.0); + ctx.begin_path(); + ctx.move_to(0.0, 0.5); + ctx.line_to(w, 0.5); + ctx.stroke(); + + let label_y = 17.0f64; // text baseline of the direction row + let y0 = (STRIP_H - 10.0).round(); // baseline of the ticks + let tri_y = 25.0f64; + let z = d.zoom; + let proj = projection_from_type(d.ptype); + let cx = d.cx; + let c = d.parms.a_center; + + let x_img_at = |alph: f64| proj.get_coordinates(alph, 0.0, &d.parms).0; + + // adaptive tick step: first that yields >= 6 px spacing + let ppd = ((x_img_at(c + 1f64.to_radians()) - x_img_at(c - 1f64.to_radians())) + * z + / 2.0) + .abs(); + let step = [1.0f64, 2.0, 5.0, 10.0, 15.0, 30.0, 45.0, 90.0] + .into_iter() + .find(|s| s * ppd >= 6.0) + .unwrap_or(90.0); + + let a_lo = alph_at_img_x(d.ptype, &*proj, &d.parms, -cx / z, c) + .min(c - std::f64::consts::PI); + let a_hi = alph_at_img_x(d.ptype, &*proj, &d.parms, (w - cx) / z, c) + .max(c + std::f64::consts::PI); + // rectilinear folds directions behind the camera onto the same + // pixels; also clamp to the lens FOV (distortion can fold + // out-of-view directions back onto the strip) + let mut fold = match d.ptype { + ProjectionType::Rectilinear => 1.535, + ProjectionType::Cylindrical => std::f64::consts::PI, + }; + if d.max_view_angle > 0.0 { + fold = fold.min(d.max_view_angle); + } + let a_lo = a_lo.max(c - fold); + let a_hi = a_hi.min(c + fold); + + // baseline + stroke(on, 1.0); + ctx.begin_path(); + ctx.move_to(0.0, y0 + 0.5); + ctx.line_to(w, y0 + 0.5); + ctx.stroke(); + + // ticks + let step_rad = step.to_radians(); + let mut a = (a_lo / step_rad).floor() * step_rad; + while a <= a_hi { + let x = cx + x_img_at(a) * z; + if x.is_finite() && x >= -1.0 && x <= w + 1.0 { + let rem = a.to_degrees().rem_euclid(45.0); + let major = rem.min(45.0 - rem) < step / 2.0; + let x = x.round(); + ctx.begin_path(); + ctx.move_to(x, y0); + ctx.line_to(x, y0 - if major { 12.0 } else { 6.0 }); + ctx.stroke(); + } + a += step_rad; + } + + // direction labels + ctx.set_font("13px system-ui, sans-serif"); + ctx.set_text_align("center"); + for (deg, name) in DIRS { + let alph = deg.to_radians(); + let rel = (alph - c + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) + - std::f64::consts::PI; + if rel.abs() > fold { + continue; + } + let x = cx + x_img_at(alph) * z; + if !x.is_finite() || x < -20.0 || x > w + 20.0 { + continue; + } + fill(if deg == 0.0 { red } else { on }); + ctx.fill_text(name, x, label_y).ok(); + } + ctx.set_text_align("start"); + + // center marker: triangle + hairline + azimuth readout + fill(red); + ctx.begin_path(); + ctx.move_to(cx - 6.0, tri_y); + ctx.line_to(cx + 6.0, tri_y); + ctx.line_to(cx, tri_y + 8.0); + ctx.close_path(); + ctx.fill(); + stroke(red, 1.0); + ctx.begin_path(); + ctx.move_to(cx.round(), tri_y + 8.0); + ctx.line_to(cx.round(), y0); + ctx.stroke(); + fill(red); + ctx.fill_text(&format!("{:05.1}°", d.center_deg.rem_euclid(360.0)), cx + 10.0, tri_y + 9.0) + .ok(); + }); + } + + let local_x = { + let canvas_ref = canvas_ref.clone(); + move |client_x: f64| { + client_x + - canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect().left()) + .unwrap_or(0.0) + } + }; + + let on_pointerdown = { + let drag = drag.clone(); + let canvas_ref = canvas_ref.clone(); + let center_deg = props.data.center_deg; + Callback::from(move |e: PointerEvent| { + e.prevent_default(); + if let Some(c) = canvas_ref.cast::() { + let _ = c.set_pointer_capture(e.pointer_id()); + } + *drag.borrow_mut() = Some((e.client_x() as f64, center_deg)); + }) + }; + let on_pointermove = { + let drag = drag.clone(); + let on_change = props.on_change.clone(); + let d = props.data; + Callback::from(move |e: PointerEvent| { + let Some((x0, c0_deg)) = *drag.borrow() else { + return; + }; + let proj = projection_from_type(d.ptype); + let c0 = c0_deg.to_radians(); + let lx0 = local_x(e.client_x() as f64); + let a0 = alph_at_img_x(d.ptype, &*proj, &d.parms, (x0 - d.cx) / d.zoom, c0); + let a1 = alph_at_img_x(d.ptype, &*proj, &d.parms, (lx0 - d.cx) / d.zoom, c0); + on_change.emit((c0 - (a1 - a0)).to_degrees()); + }) + }; + let on_pointerup = { + let drag = drag.clone(); + let canvas_ref = canvas_ref.clone(); + Callback::from(move |e: PointerEvent| { + *drag.borrow_mut() = None; + if let Some(c) = canvas_ref.cast::() { + let _ = c.release_pointer_capture(e.pointer_id()); + } + }) + }; + + html! { + + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn roundtrip(ptype: ProjectionType, k0: f64, k1: f64, x0: f64) { + let proj = projection_from_type(ptype); + let mut parms = ViewParams::new(); + parms.a_center = 0.3; + parms.scale = 3000.0; + parms.k0 = k0; + parms.k1 = k1; + parms.x0 = x0; + for x in [-2500.0, -800.0, -50.0, 0.0, 120.0, 900.0, 2400.0] { + let a = alph_at_img_x(ptype, &*proj, &parms, x, parms.a_center); + let (x2, _) = proj.get_coordinates(a, 0.0, &parms); + assert!( + (x2 - x).abs() < 1e-6, + "{ptype:?} x={x}: round-trips to {x2} (alph {a})" + ); + } + } + + #[test] + fn inverse_rectilinear() { + roundtrip(ProjectionType::Rectilinear, 0.0, 0.0, 0.0); + } + #[test] + fn inverse_rectilinear_distorted() { + roundtrip(ProjectionType::Rectilinear, 0.002, -0.0003, 0.01); + } + #[test] + fn inverse_cylindrical() { + roundtrip(ProjectionType::Cylindrical, 0.0, 0.0, 0.0); + } +} -- cgit v1.2.3