`68f2023`

Adjust graph rendering behavior and formatting

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 months ago

SHA: 68f20234b699d8fecde6850cadb3a6221f11af4d
Parents: acc0efc
Tree: fea30ce

4 changed files

Status	File	+	-
M	`garcalc-geometry/src/lib.rs`	22	5
M	`garcalc-graph/src/lib.rs`	26	6
M	`garcalc-graph/src/plot2d.rs`	114	22
M	`garcalc-graph/src/plot3d.rs`	64	28

garcalc-geometry/src/lib.rsmodified

  #[derive(Debug, Clone, Serialize, Deserialize)]
  pub enum Shape {
      Point(Point2D),
--    Line { p1: Point2D, p2: Point2D },
++    Line {
--    Segment { p1: Point2D, p2: Point2D },
++        p1: Point2D,
--    Ray { origin: Point2D, direction: Point2D },
++        p2: Point2D,
--    Circle { center: Point2D, radius: f64 },
++    },
--    Arc { center: Point2D, radius: f64, start_angle: f64, end_angle: f64 },
++    Segment {
++        p1: Point2D,
++        p2: Point2D,
++    },
++    Ray {
++        origin: Point2D,
++        direction: Point2D,
++    },
++    Circle {
++        center: Point2D,
++        radius: f64,
++    },
++    Arc {
++        center: Point2D,
++        radius: f64,
++        start_angle: f64,
++        end_angle: f64,
++    },
      Polygon(Vec<Point2D>),
+ }

garcalc-graph/src/lib.rsmodified

  pub mod plot2d;
  pub mod plot3d;
--pub use plot2d::{Graph2D, PlotConfig, CURVE_COLORS};
++pub use plot2d::{CURVE_COLORS, Graph2D, PlotConfig};
--pub use plot3d::{Graph3D, Plot3DConfig, Camera3D, Viewport3D, Colormap, RenderMode};
++pub use plot3d::{Camera3D, Colormap, Graph3D, Plot3DConfig, RenderMode, Viewport3D};
  use garcalc_cas::Expr;
  use serde::{Deserialize, Serialize};
+ }
  impl Color {
--    pub const RED: Self = Self { r: 255, g: 0, b: 0, a: 255 };
++    pub const RED: Self = Self {
--    pub const BLUE: Self = Self { r: 0, g: 0, b: 255, a: 255 };
++        r: 255,
--    pub const GREEN: Self = Self { r: 0, g: 128, b: 0, a: 255 };
++        g: 0,
--    pub const BLACK: Self = Self { r: 0, g: 0, b: 0, a: 255 };
++        b: 0,
++        a: 255,
++    };
++    pub const BLUE: Self = Self {
++        r: 0,
++        g: 0,
++        b: 255,
++        a: 255,
++    };
++    pub const GREEN: Self = Self {
++        r: 0,
++        g: 128,
++        b: 0,
++        a: 255,
++    };
++    pub const BLACK: Self = Self {
++        r: 0,
++        g: 0,
++        b: 0,
++        a: 255,
++    };
+ }
  /// Line style for curves

garcalc-graph/src/plot2d.rsmodified

  impl Default for PlotConfig {
      fn default() -> Self {
          Self {
--            background: Color { r: 30, g: 30, b: 46, a: 255 },
++            background: Color {
--            axis_color: Color { r: 166, g: 173, b: 200, a: 255 },
++                r: 30,
--            grid_color: Color { r: 69, g: 71, b: 90, a: 255 },
++                g: 30,
--            label_color: Color { r: 166, g: 173, b: 200, a: 255 },
++                b: 46,
++                a: 255,
++            },
++            axis_color: Color {
++                r: 166,
++                g: 173,
++                b: 200,
++                a: 255,
++            },
++            grid_color: Color {
++                r: 69,
++                g: 71,
++                b: 90,
++                a: 255,
++            },
++            label_color: Color {
++                r: 166,
++                g: 173,
++                b: 200,
++                a: 255,
++            },
              show_grid: true,
              show_labels: true,
              curve_width: 2.0,
  /// Default curve colors (catppuccin palette)
  pub const CURVE_COLORS: [Color; 6] = [
--    Color { r: 137, g: 180, b: 250, a: 255 }, // blue
++    Color {
--    Color { r: 166, g: 227, b: 161, a: 255 }, // green
++        r: 137,
--    Color { r: 249, g: 226, b: 175, a: 255 }, // yellow
++        g: 180,
--    Color { r: 243, g: 139, b: 168, a: 255 }, // red
++        b: 250,
--    Color { r: 203, g: 166, b: 247, a: 255 }, // mauve
++        a: 255,
--    Color { r: 148, g: 226, b: 213, a: 255 }, // teal
++    }, // blue
++    Color {
++        r: 166,
++        g: 227,
++        b: 161,
++        a: 255,
++    }, // green
++    Color {
++        r: 249,
++        g: 226,
++        b: 175,
++        a: 255,
++    }, // yellow
++    Color {
++        r: 243,
++        g: 139,
++        b: 168,
++        a: 255,
++    }, // red
++    Color {
++        r: 203,
++        g: 166,
++        b: 247,
++        a: 255,
++    }, // mauve
++    Color {
++        r: 148,
++        g: 226,
++        b: 213,
++        a: 255,
++    }, // teal
  ];
  /// 2D graph state and renderer
      fn draw_function(&self, ctx: &Context, func: &Plottable, width: u32, height: u32) {
          match func {
--            Plottable::Explicit2D { expr, x_var, color, style } => {
++            Plottable::Explicit2D {
++                expr,
++                x_var,
++                color,
++                style,
++            } => {
                  self.draw_explicit(ctx, expr, x_var, *color, *style, width, height);
+             }
--            Plottable::Implicit2D { expr, x_var, y_var, color } => {
++            Plottable::Implicit2D {
++                expr,
++                x_var,
++                y_var,
++                color,
++            } => {
                  self.draw_implicit(ctx, expr, x_var, y_var, *color, width, height);
+             }
--            Plottable::Parametric2D { x_expr, y_expr, t_var, t_range, color } => {
++            Plottable::Parametric2D {
++                x_expr,
++                y_expr,
++                t_var,
++                t_range,
++                color,
++            } => {
                  self.draw_parametric(ctx, x_expr, y_expr, t_var, *t_range, *color, width, height);
+             }
              _ => {}
              if let Ok(result) = evaluator.eval(expr) {
                  if let Ok(math_y) = expr_to_f64(&result) {
--                    if math_y.is_finite() && math_y >= self.viewport.y_min - x_range
++                    if math_y.is_finite()
++                        && math_y >= self.viewport.y_min - x_range
                          && math_y <= self.viewport.y_max + x_range
+                     {
                          let (sx, sy) = self.math_to_screen(math_x, math_y, width, height);
                  let s11 = v11 >= 0.0;
                  // Build case index (4-bit)
--                let case = (s00 as u8) | ((s10 as u8) << 1) | ((s01 as u8) << 2) | ((s11 as u8) << 3);
++                let case =
++                    (s00 as u8) | ((s10 as u8) << 1) | ((s01 as u8) << 2) | ((s11 as u8) << 3);
                  // Linear interpolation to find zero crossing on an edge
                  let interp = |va: f64, vb: f64| -> f64 {
--                    if (va - vb).abs() < 1e-15 { 0.5 } else { va / (va - vb) }
++                    if (va - vb).abs() < 1e-15 {
++                        0.5
++                    } else {
++                        va / (va - vb)
++                    }
                  };
                  // Edge midpoints where contour crosses
--                let e_bottom = || { let t = interp(v00, v10); (x0 + t * dx, y0) };
++                let e_bottom = || {
--                let e_top = || { let t = interp(v01, v11); (x0 + t * dx, y1) };
++                    let t = interp(v00, v10);
--                let e_left = || { let t = interp(v00, v01); (x0, y0 + t * dy) };
++                    (x0 + t * dx, y0)
--                let e_right = || { let t = interp(v10, v11); (x1, y0 + t * dy) };
++                };
++                let e_top = || {
++                    let t = interp(v01, v11);
++                    (x0 + t * dx, y1)
++                };
++                let e_left = || {
++                    let t = interp(v00, v01);
++                    (x0, y0 + t * dy)
++                };
++                let e_right = || {
++                    let t = interp(v10, v11);
++                    (x1, y0 + t * dy)
++                };
                  // Draw line segments based on marching squares case
                  let draw_line = |p1: (f64, f64), p2: (f64, f64)| {
          ctx.set_dash(&[], 0.0);
          // Coordinate display
--        set_color(ctx, Color { r: 30, g: 30, b: 46, a: 200 });
++        set_color(
++            ctx,
++            Color {
++                r: 30,
++                g: 30,
++                b: 46,
++                a: 200,
++            },
++        );
          let label = format!("({:.4}, {:.4})", mx, my);
          let label_w = label.len() as f64 * 7.0 + 8.0;
          let label_h = 18.0;
      let nice = if frac < 1.5 {
 .0
--    } else if frac < 3.0 {
++    } else if frac <= 3.0 {
 .0
      } else if frac < 7.0 {
 .0

garcalc-graph/src/plot3d.rsmodified

      /// Rotate the camera by delta angles
      pub fn rotate(&mut self, d_azimuth: f64, d_elevation: f64) {
          self.azimuth += d_azimuth;
--        self.elevation = (self.elevation + d_elevation)
++        self.elevation =
--            .clamp(-89.0_f64.to_radians(), 89.0_f64.to_radians());
++            (self.elevation + d_elevation).clamp(-89.0_f64.to_radians(), 89.0_f64.to_radians());
+     }
      /// Zoom by a factor
              Colormap::Coolwarm => coolwarm(t),
              Colormap::Grayscale => {
                  let v = (t * 255.0) as u8;
--                Color { r: v, g: v, b: v, a: 255 }
++                Color {
++                    r: v,
++                    g: v,
++                    b: v,
++                    a: 255,
++                }
+             }
+         }
+     }
  impl Default for Plot3DConfig {
      fn default() -> Self {
          Self {
--            background: Color { r: 30, g: 30, b: 46, a: 255 },
++            background: Color {
--            axis_color: Color { r: 166, g: 173, b: 200, a: 255 },
++                r: 30,
--            wireframe_color: Color { r: 100, g: 100, b: 120, a: 255 },
++                g: 30,
++                b: 46,
++                a: 255,
++            },
++            axis_color: Color {
++                r: 166,
++                g: 173,
++                b: 200,
++                a: 255,
++            },
++            wireframe_color: Color {
++                r: 100,
++                g: 100,
++                b: 120,
++                a: 255,
++            },
              colormap: Colormap::Viridis,
              render_mode: RenderMode::FilledWithWireframe,
              grid_lines: 40,
              forward.0 * world_up.1 - forward.1 * world_up.0,
          );
          let right_len = (right.0 * right.0 + right.1 * right.1 + right.2 * right.2).sqrt();
--        let right = (right.0 / right_len, right.1 / right_len, right.2 / right_len);
++        let right = (
++            right.0 / right_len,
++            right.1 / right_len,
++            right.2 / right_len,
++        );
          // Actual up = right x forward
          let up = (
              Surface3D::Explicit { expr, x_var, y_var } => {
                  self.draw_explicit_surface(ctx, expr, x_var, y_var, width, height);
+             }
--            Surface3D::Parametric { x_expr, y_expr, z_expr, u_var, v_var, u_range, v_range } => {
++            Surface3D::Parametric {
++                x_expr,
++                y_expr,
++                z_expr,
++                u_var,
++                v_var,
++                u_range,
++                v_range,
++            } => {
                  self.draw_parametric_surface(
--                    ctx, x_expr, y_expr, z_expr, u_var, v_var, *u_range, *v_range, width, height
++                    ctx, x_expr, y_expr, z_expr, u_var, v_var, *u_range, *v_range, width, height,
                  );
+             }
+         }
                      let cy = (p00.1 + p10.1 + p11.1 + p01.1) / 4.0;
                      let cz = (p00.2 + p10.2 + p11.2 + p01.2) / 4.0;
                      let depth = (cx - cam_pos.0).powi(2)
--                              + (cy - cam_pos.1).powi(2)
++                        + (cy - cam_pos.1).powi(2)
--                              + (cz - cam_pos.2).powi(2);
++                        + (cz - cam_pos.2).powi(2);
                      quads.push(Quad {
                          corners: [p00, p10, p11, p01],
+         }
          // Sort by depth (painter's algorithm - far to near)
--        quads.sort_by(|a, b| b.depth.partial_cmp(&a.depth).unwrap_or(std::cmp::Ordering::Equal));
++        quads.sort_by(|a, b| {
++            b.depth
++                .partial_cmp(&a.depth)
++                .unwrap_or(std::cmp::Ordering::Equal)
++        });
          // Draw quads
          for quad in &quads {
--            let corners: Vec<(f64, f64)> = quad.corners
++            let corners: Vec<(f64, f64)> = quad
++                .corners
                  .iter()
                  .map(|p| self.project(p.0, p.1, p.2, width, height))
                  .collect();
                  let z_result = evaluator.eval(z_expr);
                  if let (Ok(xr), Ok(yr), Ok(zr)) = (x_result, y_result, z_result) {
--                    if let (Ok(x), Ok(y), Ok(z)) = (expr_to_f64(&xr), expr_to_f64(&yr), expr_to_f64(&zr)) {
++                    if let (Ok(x), Ok(y), Ok(z)) =
++                        (expr_to_f64(&xr), expr_to_f64(&yr), expr_to_f64(&zr))
++                    {
                          if x.is_finite() && y.is_finite() && z.is_finite() {
                              z_min = z_min.min(z);
                              z_max = z_max.max(z);
                      let cy = (p00.1 + p10.1 + p11.1 + p01.1) / 4.0;
                      let cz = (p00.2 + p10.2 + p11.2 + p01.2) / 4.0;
                      let depth = (cx - cam_pos.0).powi(2)
--                              + (cy - cam_pos.1).powi(2)
++                        + (cy - cam_pos.1).powi(2)
--                              + (cz - cam_pos.2).powi(2);
++                        + (cz - cam_pos.2).powi(2);
                      quads.push(Quad {
                          corners: [p00, p10, p11, p01],
+             }
+         }
--        quads.sort_by(|a, b| b.depth.partial_cmp(&a.depth).unwrap_or(std::cmp::Ordering::Equal));
++        quads.sort_by(|a, b| {
++            b.depth
++                .partial_cmp(&a.depth)
++                .unwrap_or(std::cmp::Ordering::Equal)
++        });
          for quad in &quads {
--            let corners: Vec<(f64, f64)> = quad.corners
++            let corners: Vec<(f64, f64)> = quad
++                .corners
                  .iter()
                  .map(|p| self.project(p.0, p.1, p.2, width, height))
                  .collect();
  fn coolwarm(t: f64) -> Color {
      // Blue (cool) to red (warm)
--    let r = if t < 0.5 {
++    let r = if t < 0.5 { 0.2 + t * 1.6 } else { 1.0 };
--        0.2 + t * 1.6
--    } else {
--        1.0
--    };
      let g = if t < 0.5 {
 .2 + t * 1.2
      } else {
 .8 - (t - 0.5) * 1.6
      };
--    let b = if t < 0.5 {
++    let b = if t < 0.5 { 1.0 } else { 1.0 - (t - 0.5) * 1.6 };
--        1.0
--    } else {
--        1.0 - (t - 0.5) * 1.6
--    };
      Color {
          r: (r.clamp(0.0, 1.0) * 255.0) as u8,
          g: (g.clamp(0.0, 1.0) * 255.0) as u8,