geopyv-dev 0.2.0__tar.gz → 0.2.2__tar.gz

{geopyv_dev-0.2.0 → geopyv_dev-0.2.2}/CLAUDE.md

@@ -34,13 +34,19 @@ pytest tests/python/mesh/test_mesh.py
 source .venv/bin/activate && python basictest.py
 ```
 
-### Build the GUI (separate binary crate)
+### Build the GUI
 
 ```bash
 cargo build -p geopyv-gui
 cargo run -p geopyv-gui
 ```
 
+`geopyv-gui` is a library (`geopyv_gui::run`) plus a thin binary. The Python
+extension links it and exposes `run_gui`; `pyproject.toml` installs a
+`geopyv-gui` console script (`geopyv_dev/gui.py`), so after `maturin develop`
+or `pip install geopyv-dev` users just run `geopyv-gui`. The GUI is a thin
+front-end: solving, defaults and derived quantities belong in the core.
+
 ### Publishing a release to PyPI
 
 The `.github/workflows/release.yml` workflow triggers **only on version tags** — pushing a branch does nothing. Steps:

{geopyv_dev-0.2.0 → geopyv_dev-0.2.2}/Cargo.lock

@@ -1531,7 +1531,7 @@ dependencies = [
 
 [[package]]
 name = "geopyv-dev"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "bincode",
  "image",
@@ -1550,9 +1550,10 @@ dependencies = [
 
 [[package]]
 name = "geopyv-dev-python"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "geopyv-dev",
+ "geopyv-gui",
  "ndarray",
  "numpy",
  "pyo3",
@@ -1560,7 +1561,7 @@ dependencies = [
 
 [[package]]
 name = "geopyv-gui"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "dirs",
  "eframe",

{geopyv_dev-0.2.0 → geopyv_dev-0.2.2}/Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
-members = [".", "python"]
+members = [".", "python", "geopyv-gui"]
 resolver = "2"
 
 [package]
 name = "geopyv-dev"
-version = "0.2.0"
+version = "0.2.2"
 edition = "2024"
 
 [dependencies]

{geopyv_dev-0.2.0 → geopyv_dev-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geopyv_dev
-Version: 0.2.0
+Version: 0.2.2
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)

{geopyv_dev-0.2.0 → geopyv_dev-0.2.2}/docs/tutorials/02_subset.rst

@@ -33,8 +33,9 @@ A ``Subset`` is defined by four things:
      - The patch's radius (circle) or half-width (square), set on the
        ``local_mask`` itself
    * - Order
-     - ``subset_order`` — 1 (affine) or 2 (quadratic); how complex a warp the
-       solver is allowed to fit (see *The warp function*, below)
+     - ``subset_order`` — 0 (translation), 1 (affine), or 2 (quadratic); how
+       complex a warp the solver is allowed to fit (see *The warp function*,
+       below). Default ``1``.
 
 .. image:: /_static/gifs/subset_shape_order.gif
    :alt: A circle and a square subset template growing and shrinking, then fixed
@@ -117,7 +118,12 @@ The warp function
 -------------------
 
 The DIC solver describes how a subset deforms using a **warp vector** ``p``. For
-**order 1** (affine, 6 parameters)::
+**order 0** (translation only, 2 parameters)::
+
+   u(x,y) = p[0]
+   v(x,y) = p[1]
+
+For **order 1** (affine, 6 parameters)::
 
    u(x,y) = p[0] + p[2]·Δx + p[4]·Δy
    v(x,y) = p[1] + p[3]·Δx + p[5]·Δy
@@ -130,7 +136,9 @@ ordering used by ``Speckle``'s ``comp`` array in :doc:`00_introduction` and
 
 For **order 2** (quadratic, 12 parameters), six second-order terms
 (``p[6..11]``) are added. Most analyses use order 1 for ``Subset`` and order 2
-for ``Mesh``/``Sequence``.
+for ``Mesh``/``Sequence``; order 0 is mainly useful as a deliberately
+under-specified baseline, e.g. for warp-adequacy diagnostics that compare a
+solve's residual against the modes a lower order couldn't fit.
 
 Solve
 ------

geopyv_dev-0.2.2/geopyv-gui/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "geopyv-gui"
+version = "0.2.2"
+edition = "2024"
+
+[lib]
+name = "geopyv_gui"
+path = "src/lib.rs"
+
+[[bin]]
+name = "geopyv-gui"
+path = "src/main.rs"
+
+[dependencies]
+geopyv-dev = { path = ".." }
+eframe = { version = "0.31", features = ["default"] }
+egui = "0.31"
+egui_plot = "0.31"
+rfd = "0.15"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+dirs = "6"
+image = { version = "0.25", default-features = false, features = ["jpeg", "png", "tiff"] }
+ndarray = "0.16"

geopyv_dev-0.2.2/geopyv-gui/src/app.rs

@@ -0,0 +1,287 @@
+use eframe::egui;
+
+use crate::main_window::MainWindow;
+use crate::project::Project;
+use crate::recent::RecentProjects;
+
+// ---------------------------------------------------------------------------
+// Top-level application state
+// ---------------------------------------------------------------------------
+
+pub struct GeopyvApp {
+    state: AppState,
+    recent: RecentProjects,
+    error: Option<String>,
+}
+
+enum AppState {
+    Startup,
+    ProjectOpen {
+        project: Project,
+        window: MainWindow,
+    },
+}
+
+impl GeopyvApp {
+    pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
+        configure_visuals(&cc.egui_ctx);
+        Self {
+            state: AppState::Startup,
+            recent: RecentProjects::load(),
+            error: None,
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Startup window
+    // -----------------------------------------------------------------------
+
+    fn show_startup(&mut self, ctx: &egui::Context) {
+        // Constrain the startup window to a compact size.
+        ctx.send_viewport_cmd(egui::ViewportCommand::MinInnerSize(egui::vec2(400.0, 260.0)));
+        ctx.send_viewport_cmd(egui::ViewportCommand::MaxInnerSize(egui::vec2(560.0, 600.0)));
+
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.vertical_centered(|ui| {
+                ui.add_space(40.0);
+
+                ui.heading(egui::RichText::new("geopyv").size(32.0).strong());
+                ui.add_space(4.0);
+                ui.label(
+                    egui::RichText::new("Digital Image Correlation")
+                        .size(16.0)
+                        .color(ui.visuals().weak_text_color()),
+                );
+
+                ui.add_space(32.0);
+
+                let btn_size = egui::vec2(180.0, 36.0);
+
+                if ui
+                    .add_sized(btn_size, egui::Button::new("New Project"))
+                    .clicked()
+                {
+                    self.action_new_project();
+                }
+
+                ui.add_space(8.0);
+
+                if ui
+                    .add_sized(btn_size, egui::Button::new("Open Project"))
+                    .clicked()
+                {
+                    self.action_open_project();
+                }
+
+                self.show_recent_list(ui);
+            });
+        });
+    }
+
+    fn show_recent_list(&mut self, ui: &mut egui::Ui) {
+        if self.recent.paths.is_empty() {
+            return;
+        }
+
+        ui.add_space(28.0);
+        ui.separator();
+        ui.add_space(8.0);
+        ui.label(
+            egui::RichText::new("Recent")
+                .size(14.0)
+                .color(ui.visuals().weak_text_color()),
+        );
+        ui.add_space(4.0);
+
+        let mut open_path: Option<std::path::PathBuf> = None;
+        let mut remove_path: Option<std::path::PathBuf> = None;
+
+        for path in &self.recent.paths {
+            let label = path
+                .file_name()
+                .map(|n| n.to_string_lossy().into_owned())
+                .unwrap_or_else(|| path.to_string_lossy().into_owned());
+
+            let exists = path.is_dir() && path.join("project.json").exists();
+
+            ui.horizontal(|ui| {
+                let resp = ui.add(
+                    egui::Button::new(
+                        egui::RichText::new(&label).size(15.0).color(if exists {
+                            ui.visuals().text_color()
+                        } else {
+                            ui.visuals().weak_text_color()
+                        }),
+                    )
+                    .frame(false),
+                );
+
+                if resp.clicked() {
+                    if exists {
+                        open_path = Some(path.clone());
+                    } else {
+                        remove_path = Some(path.clone());
+                    }
+                }
+
+                resp.on_hover_text(path.display().to_string());
+
+                if !exists {
+                    ui.label(
+                        egui::RichText::new("(missing)")
+                            .size(13.0)
+                            .color(ui.visuals().error_fg_color),
+                    );
+                }
+            });
+        }
+
+        if let Some(p) = open_path {
+            self.open_project_at(p);
+        }
+        if let Some(p) = remove_path {
+            self.recent.remove(&p);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Project open / create actions
+    // -----------------------------------------------------------------------
+
+    fn action_new_project(&mut self) {
+        let Some(folder) = rfd::FileDialog::new()
+            .set_title("Choose location for new project")
+            .pick_folder()
+        else {
+            return;
+        };
+
+        match Project::create(&folder) {
+            Ok(project) => self.load_project(project),
+            Err(e) => self.error = Some(format!("Could not create project: {e}")),
+        }
+    }
+
+    fn action_open_project(&mut self) {
+        let Some(folder) = rfd::FileDialog::new()
+            .set_title("Open project folder")
+            .pick_folder()
+        else {
+            return;
+        };
+
+        self.open_project_at(folder);
+    }
+
+    fn open_project_at(&mut self, path: std::path::PathBuf) {
+        match Project::open(&path) {
+            Ok(project) => self.load_project(project),
+            Err(e) => self.error = Some(format!("Could not open project: {e}")),
+        }
+    }
+
+    fn load_project(&mut self, project: Project) {
+        self.recent.push(&project.root);
+        // Restore the main window to full size.
+        // (MaxInnerSize from startup mode must be lifted.)
+        self.state = AppState::ProjectOpen {
+            project,
+            window: MainWindow::new(),
+        };
+    }
+
+    // -----------------------------------------------------------------------
+    // Main window
+    // -----------------------------------------------------------------------
+
+    fn show_main(&mut self, ctx: &egui::Context) {
+        // Lift the startup size constraints.
+        ctx.send_viewport_cmd(egui::ViewportCommand::MinInnerSize(egui::vec2(800.0, 500.0)));
+        ctx.send_viewport_cmd(egui::ViewportCommand::MaxInnerSize(egui::vec2(f32::INFINITY, f32::INFINITY)));
+
+        let AppState::ProjectOpen { project, window } = &mut self.state else {
+            return;
+        };
+
+        ctx.send_viewport_cmd(egui::ViewportCommand::Title(
+            format!("geopyv \u{2014} {}", project.meta.name),
+        ));
+
+        window.show(ctx, project);
+    }
+
+    // -----------------------------------------------------------------------
+    // Error modal
+    // -----------------------------------------------------------------------
+
+    fn show_error_modal(&mut self, ctx: &egui::Context) {
+        let Some(msg) = self.error.clone() else {
+            return;
+        };
+
+        let mut open = true;
+        egui::Window::new("Error")
+            .collapsible(false)
+            .resizable(false)
+            .anchor(egui::Align2::CENTER_CENTER, egui::vec2(0.0, 0.0))
+            .open(&mut open)
+            .show(ctx, |ui| {
+                ui.label(&msg);
+                ui.add_space(8.0);
+                if ui.button("OK").clicked() {
+                    self.error = None;
+                }
+            });
+
+        if !open {
+            self.error = None;
+        }
+    }
+}
+
+impl eframe::App for GeopyvApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        match &self.state {
+            AppState::Startup => self.show_startup(ctx),
+            AppState::ProjectOpen { .. } => self.show_main(ctx),
+        }
+
+        self.show_error_modal(ctx);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Theme
+// ---------------------------------------------------------------------------
+
+fn configure_visuals(ctx: &egui::Context) {
+    let mut visuals = egui::Visuals::dark();
+
+    visuals.window_fill = egui::Color32::from_rgb(22, 22, 24);
+    visuals.panel_fill = egui::Color32::from_rgb(22, 22, 24);
+    visuals.faint_bg_color = egui::Color32::from_rgb(30, 30, 32);
+
+    visuals.window_corner_radius = egui::CornerRadius::same(6);
+    visuals.menu_corner_radius = egui::CornerRadius::same(4);
+
+    visuals.widgets.inactive.bg_fill = egui::Color32::from_rgb(42, 42, 46);
+    visuals.widgets.hovered.bg_fill = egui::Color32::from_rgb(58, 58, 64);
+    visuals.widgets.active.bg_fill = egui::Color32::from_rgb(70, 70, 80);
+
+    ctx.set_visuals(visuals);
+
+    let mut style = (*ctx.style()).clone();
+    style.text_styles.insert(
+        egui::TextStyle::Body,
+        egui::FontId::new(16.0, egui::FontFamily::Proportional),
+    );
+    style.text_styles.insert(
+        egui::TextStyle::Button,
+        egui::FontId::new(16.0, egui::FontFamily::Proportional),
+    );
+    style.text_styles.insert(
+        egui::TextStyle::Heading,
+        egui::FontId::new(22.0, egui::FontFamily::Proportional),
+    );
+    ctx.set_style(style);
+}

geopyv_dev-0.2.2/geopyv-gui/src/colormap.rs

@@ -0,0 +1,107 @@
+use eframe::egui;
+
+// ---------------------------------------------------------------------------
+// Colormap type
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum ColormapType {
+    #[default]
+    Viridis,
+    Plasma,
+    Inferno,
+}
+
+impl ColormapType {
+    pub const ALL: &'static [ColormapType] = &[
+        ColormapType::Viridis,
+        ColormapType::Plasma,
+        ColormapType::Inferno,
+    ];
+
+    pub fn label(self) -> &'static str {
+        match self {
+            ColormapType::Viridis => "Viridis",
+            ColormapType::Plasma => "Plasma",
+            ColormapType::Inferno => "Inferno",
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// 9-keyframe LUTs (t = 0, 0.125, 0.25, ..., 1.0)
+// Values are (R, G, B) in [0, 255].
+// ---------------------------------------------------------------------------
+
+static VIRIDIS: [[u8; 3]; 9] = [
+    [68,   1,  84],
+    [71,  44, 122],
+    [59,  82, 139],
+    [44, 113, 142],
+    [32, 144, 140],
+    [35, 168, 132],
+    [93, 201,  99],
+    [161, 218, 62],
+    [253, 231, 37],
+];
+
+static PLASMA: [[u8; 3]; 9] = [
+    [ 13,   8, 135],
+    [ 84,   2, 163],
+    [139,  10, 165],
+    [185,  50, 137],
+    [219,  92, 104],
+    [244, 136,  73],
+    [253, 183,  45],
+    [249, 230,  51],
+    [240, 249,  33],
+];
+
+static INFERNO: [[u8; 3]; 9] = [
+    [  0,   0,   4],
+    [ 40,  11,  84],
+    [101,  21, 110],
+    [159,  42,  99],
+    [212,  72,  66],
+    [245, 125,  21],
+    [252, 185,  20],
+    [253, 236,  98],
+    [252, 255, 164],
+];
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/// Map `t ∈ [0, 1]` to an opaque colour via the chosen colormap.
+pub fn sample(t: f32, cmap: ColormapType) -> egui::Color32 {
+    let lut: &[[u8; 3]; 9] = match cmap {
+        ColormapType::Viridis => &VIRIDIS,
+        ColormapType::Plasma => &PLASMA,
+        ColormapType::Inferno => &INFERNO,
+    };
+
+    let t = t.clamp(0.0, 1.0);
+    let scaled = t * 8.0; // 9 keyframes → 8 segments
+    let lo = (scaled as usize).min(7);
+    let hi = lo + 1;
+    let frac = scaled - lo as f32;
+
+    let r = lerp_u8(lut[lo][0], lut[hi][0], frac);
+    let g = lerp_u8(lut[lo][1], lut[hi][1], frac);
+    let b = lerp_u8(lut[lo][2], lut[hi][2], frac);
+    egui::Color32::from_rgb(r, g, b)
+}
+
+/// Map a scalar value to a colour given a [vmin, vmax] range.
+pub fn map_value(v: f64, vmin: f64, vmax: f64, cmap: ColormapType) -> egui::Color32 {
+    if vmax <= vmin {
+        return sample(0.5, cmap);
+    }
+    let t = ((v - vmin) / (vmax - vmin)) as f32;
+    sample(t, cmap)
+}
+
+fn lerp_u8(a: u8, b: u8, t: f32) -> u8 {
+    (a as f32 + (b as f32 - a as f32) * t).round() as u8
+}