New graph style (#115)

* Add graph_style option and config

* Implement angular style graph

* Fix graph/image tests

* Add integrated graph tests

* Update README

* Update config.schema.json

* Extract geometric helper functions

* Add comments

Author: lusingander

README.md

@@ -105,6 +105,7 @@ Options:
   -p, --protocol <TYPE>           Image protocol to render graph [default: auto] [possible values: auto, iterm, kitty]
   -o, --order <TYPE>              Commit ordering algorithm [default: chrono] [possible values: chrono, topo]
   -g, --graph-width <TYPE>        Commit graph image cell width [default: auto] [possible values: auto, double, single]
+  -s, --graph-style <TYPE>        Commit graph image edge style [default: rounded] [possible values: rounded, angular]
   -i, --initial-selection <TYPE>  Initial selection of commit [default: latest] [possible values: latest, head]
       --preload                   Preload all graph images
   -h, --help                      Print help
@@ -155,6 +156,23 @@ If not specified or `auto` is specified, `double` will be used automatically if
 
 </details>
 
+#### -s, --graph-style \<TYPE\>
+
+The commit graph image edge style.
+
+`--graph-style rounded` will use rounded edges for the graph lines.
+
+`--graph-style angular` will use angular edges for the graph lines.
+
+<details>
+<summary>Screenshots</summary>
+
+<img src="./img/style-angular.png" width=300>
+
+`--graph-style angular`
+
+</details>
+
 #### -i, --initial-selection \<TYPE\>
 
 The initial selection of commit when starting the application.

config.schema.json

@@ -41,6 +41,15 @@
               ],
               "default": "auto"
             },
+            "graph_style": {
+              "type": "string",
+              "description": "The commit graph image edge style. The value specified in the command line argument takes precedence.",
+              "enum": [
+                "rounded",
+                "angular"
+              ],
+              "default": "rounded"
+            },
             "initial_selection": {
               "type": "string",
               "description": "The initial selection of commit when starting the application. The value specified in the command line argument takes precedence.",

img/style-angular.png

@@ -11,7 +11,7 @@ use umbra::optional;
 use crate::{
     color::{ColorTheme, OptionalColorTheme},
     keybind::KeyBind,
-    CommitOrderType, GraphWidthType, ImageProtocolType, InitialSelection, Result,
+    CommitOrderType, GraphStyle, GraphWidthType, ImageProtocolType, InitialSelection, Result,
 };
 
 const XDG_CONFIG_HOME_ENV_NAME: &str = "XDG_CONFIG_HOME";
@@ -111,6 +111,7 @@ pub struct CoreOptionConfig {
     pub protocol: Option<ImageProtocolType>,
     pub order: Option<CommitOrderType>,
     pub graph_width: Option<GraphWidthType>,
+    pub graph_style: Option<GraphStyle>,
     pub initial_selection: Option<InitialSelection>,
 }
 
@@ -332,6 +333,7 @@ mod tests {
                     protocol: None,
                     order: None,
                     graph_width: None,
+                    graph_style: None,
                     initial_selection: None,
                 },
                 search: CoreSearchConfig {
@@ -405,6 +407,7 @@ mod tests {
             protocol = "kitty"
             order = "topo"
             graph_width = "single"
+            graph_style = "angular"
             initial_selection = "head"
             [core.search]
             ignore_case = true
@@ -442,6 +445,7 @@ mod tests {
                     protocol: Some(ImageProtocolType::Kitty),
                     order: Some(CommitOrderType::Topo),
                     graph_width: Some(GraphWidthType::Single),
+                    graph_style: Some(GraphStyle::Angular),
                     initial_selection: Some(InitialSelection::Head),
                 },
                 search: CoreSearchConfig {
@@ -528,6 +532,7 @@ mod tests {
                     protocol: None,
                     order: None,
                     graph_width: None,
+                    graph_style: None,
                     initial_selection: None,
                 },
                 search: CoreSearchConfig {

src/config.rs

@@ -1,4 +1,5 @@
 mod calc;
+mod geometry;
 mod image;
 
 pub use calc::*;

src/graph.rs

@@ -43,6 +43,12 @@ pub enum EdgeType {
     LeftBottom,  // ╰
 }
 
+impl EdgeType {
+    pub fn is_vertically_related(&self) -> bool {
+        matches!(self, EdgeType::Vertical | EdgeType::Up | EdgeType::Down)
+    }
+}
+
 pub fn calc_graph(repository: &Repository) -> Graph<'_> {
     let commits = repository.all_commits();
 

src/graph/calc.rs

@@ -0,0 +1,198 @@
+use std::ops::{Add, AddAssign, Div, Mul, Sub, SubAssign};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Point {
+    pub x: f64,
+    pub y: f64,
+}
+
+impl Point {
+    pub fn new(x: f64, y: f64) -> Self {
+        Self { x, y }
+    }
+
+    pub fn is_inside_polygon(&self, vertices: &[Point]) -> bool {
+        if vertices.len() < 3 {
+            return false;
+        }
+
+        let signs = vertices
+            .iter()
+            .zip(vertices.iter().cycle().skip(1))
+            .map(|(&a, &b)| {
+                let edge_vector = b - a;
+                let point_vector = *self - a;
+                edge_vector.cross(point_vector).signum()
+            })
+            .collect::<Vec<_>>();
+
+        let first_sign = signs[0];
+        if first_sign == 0.0 {
+            return true;
+        }
+
+        signs.iter().all(|&s| s == 0.0 || s == first_sign)
+    }
+}
+
+impl Add<Vector> for Point {
+    type Output = Point;
+
+    fn add(self, rhs: Vector) -> Self::Output {
+        Point {
+            x: self.x + rhs.x,
+            y: self.y + rhs.y,
+        }
+    }
+}
+
+impl Sub for Point {
+    type Output = Vector;
+
+    fn sub(self, rhs: Point) -> Self::Output {
+        Vector {
+            x: self.x - rhs.x,
+            y: self.y - rhs.y,
+        }
+    }
+}
+
+impl Sub<Vector> for Point {
+    type Output = Point;
+
+    fn sub(self, rhs: Vector) -> Self::Output {
+        Point {
+            x: self.x - rhs.x,
+            y: self.y - rhs.y,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Vector {
+    pub x: f64,
+    pub y: f64,
+}
+
+impl Vector {
+    pub fn new(x: f64, y: f64) -> Self {
+        Self { x, y }
+    }
+
+    pub fn length(&self) -> f64 {
+        (self.x.powi(2) + self.y.powi(2)).sqrt()
+    }
+
+    pub fn zero() -> Self {
+        Self { x: 0.0, y: 0.0 }
+    }
+
+    pub fn normalize(&self) -> Vector {
+        let len = self.length();
+        if len == 0.0 {
+            Vector::zero()
+        } else {
+            *self / len
+        }
+    }
+
+    pub fn perpendicular(&self) -> Vector {
+        Vector::new(-self.y, self.x)
+    }
+
+    pub fn dot(&self, other: Vector) -> f64 {
+        self.x * other.x + self.y * other.y
+    }
+
+    pub fn cross(&self, other: Vector) -> f64 {
+        self.x * other.y - self.y * other.x
+    }
+}
+
+impl Add for Vector {
+    type Output = Vector;
+
+    fn add(self, rhs: Vector) -> Self::Output {
+        Vector {
+            x: self.x + rhs.x,
+            y: self.y + rhs.y,
+        }
+    }
+}
+
+impl AddAssign for Vector {
+    fn add_assign(&mut self, rhs: Self) {
+        self.x += rhs.x;
+        self.y += rhs.y;
+    }
+}
+
+impl Sub for Vector {
+    type Output = Vector;
+
+    fn sub(self, rhs: Vector) -> Self::Output {
+        Vector {
+            x: self.x - rhs.x,
+            y: self.y - rhs.y,
+        }
+    }
+}
+
+impl SubAssign for Vector {
+    fn sub_assign(&mut self, rhs: Self) {
+        self.x -= rhs.x;
+        self.y -= rhs.y;
+    }
+}
+
+impl Mul<f64> for Vector {
+    type Output = Vector;
+
+    fn mul(self, rhs: f64) -> Self::Output {
+        Vector {
+            x: self.x * rhs,
+            y: self.y * rhs,
+        }
+    }
+}
+
+impl Mul<Vector> for f64 {
+    type Output = Vector;
+
+    fn mul(self, rhs: Vector) -> Self::Output {
+        rhs * self
+    }
+}
+
+impl Div<f64> for Vector {
+    type Output = Vector;
+
+    fn div(self, rhs: f64) -> Self::Output {
+        Vector {
+            x: self.x / rhs,
+            y: self.y / rhs,
+        }
+    }
+}
+
+pub fn bounding_box_u32(points: &[Point]) -> (u32, u32, u32, u32) {
+    let (mut min_x, mut min_y) = (f64::INFINITY, f64::INFINITY);
+    let (mut max_x, mut max_y) = (f64::NEG_INFINITY, f64::NEG_INFINITY);
+
+    for point in points {
+        if point.x < min_x {
+            min_x = point.x;
+        }
+        if point.y < min_y {
+            min_y = point.y;
+        }
+        if point.x > max_x {
+            max_x = point.x;
+        }
+        if point.y > max_y {
+            max_y = point.y;
+        }
+    }
+
+    (min_x as u32, min_y as u32, max_x as u32, max_y as u32)
+}