Mercurial > repos > non-riemannian-opt / changeset

--- a/src/cube.rs	Tue Oct 22 08:39:46 2024 -0500
+++ b/src/cube.rs	Tue Oct 22 09:34:12 2024 -0500
@@ -187,31 +187,63 @@
     /// Indicates whether an unfolded point `p` is on this face, i.e.,
     /// has coordinates in [0,1]².
     pub fn is_in_face(&self, p: &Point) -> bool {
-        p.iter().map(|t| t.abs()).all(|t| 0.0 <= t && t <= 1.0)
+        p.iter().all(|t| 0.0 <= *t && *t <= 1.0)
     }
 
-    /// Given an unfolded point `p`, possibly outside this face, finds
-    /// the edge, presented by an adjacent face, in whose direction it is.
+    /// Given an unfolded point `p` and a destination point `d` in unfolded coordinates,
+    /// but possibly outside this face, find the crossing point of the line between
+    /// `p` and `d` on an edge of (`self`). Return the point and the edge presented
+    /// by an adjacent face.
     ///
-    /// **TODO:** this does not correctly handle corners, i.e., when the point is not in
-    /// the direction of an adjacent face.
-    pub fn find_crossing(&self, p : &Point) -> Face {
+    /// Crossing at corners is decided arbitrarily.
+    pub fn find_crossing(&self, p :& Point, d : &Point) -> (Face, Point) {
+        //assert!(self.is_in_face(p));
+        
+        if self.is_in_face(d) {
+            return (*self, *p)
+        }
+
+        use std::cmp::Ordering::*;
+
         let &Loc([x, y]) = p;
-        use std::cmp::Ordering::*;
-        let crossing = |t| match (0.0 <= t, t<=1.0) {
+        let &Loc([xd, yd]) = d;
+        let tx = xd - x;
+        let ty = yd - y;
+
+        // Move towards tangent as (x + s tx, y + s ty) for the largest s<=1.0 for which
+        // both coordinates is within [0, 1].
+        let sx = match tx.partial_cmp(&0.0) {
+            Some(Less) =>  1.0f64.min(-x/tx),
+            Some(Greater) => 1.0f64.min((1.0-x)/tx),
+            _ => 1.0,
+        };
+        let sy = match ty.partial_cmp(&0.0) {
+            Some(Less) => 1.0f64.min(-y/ty),
+            Some(Greater) => 1.0f64.min((1.0-y)/ty),
+            _ => 1.0,
+        };
+        // We use the point where one coordinate comes within the range to decide on
+        // the edge.
+        let s = sx.max(sy);
+        // But move such that both coordinates are within the range.
+        let c = sx.min(sy);
+        let (cx, cy) = (x + c*tx, y + c*ty);
+
+        let crossing = |t| match (0.0 <= t, t <= 1.0) {
             (false, _) => Less,
             (_, false) => Greater,
             _ => Equal,
         };
 
         // TODO: how to properly handle corners? Just throw an error?
-        match (crossing(x), crossing(y)) {
+        let crossing = match (crossing(x + s*tx), crossing(y + s*ty)) {
             (Equal, Equal) => *self,
             (Less, _) => self.adjacent_faces()[0],
             (Greater, _) => self.adjacent_faces()[1],
             (Equal, Less) => self.adjacent_faces()[2],
             (Equal, Greater) => self.adjacent_faces()[3],
-        }
+        };
+        (crossing, Loc([cx, cy]))
     }
 
     /// Get embedded 3D coordinates
@@ -278,16 +310,18 @@
 
     fn exp(self, tangent : &Self::Tangent) -> Self {
         let mut face = self.face;
-        let mut point = self.point + tangent;
+        let mut point = self.point;
+        let mut dest = self.point + tangent;
         loop {
-            let next_face = face.find_crossing(&point);
+            let (next_face, cross) = face.find_crossing(&point, &dest);
             if next_face == face {
                 break
             }
-            point = next_face.convert_adjacent(face, &point).unwrap();
+            point = next_face.convert_adjacent(face, &cross).unwrap();
+            dest = next_face.convert_adjacent(face, &dest).unwrap();
             face = next_face;
         }
-        OnCube { face, point }
+        OnCube { face, point : dest }
     }
 
     fn log(&self, other : &Self) -> Self::Tangent {
@@ -311,8 +345,8 @@
     fn convert_adjacent() {
         let point = Loc([0.4, 0.6]);
 
-        for f1 in [F1, F2, F3, F4, F5, F6] {
-            for f2 in [F1, F2, F3, F4, F5, F6] {
+        for f1 in Face::all() {
+            for f2 in Face::all() {
                 println!("{:?}-{:?}", f1, f2);
                 match f1.convert_adjacent(f2, &point) {
                     None => assert_eq!(f2.opposing_face(), f1),
@@ -333,8 +367,8 @@
     // fn convert_paths() {
     //     let point = Loc([0.4, 0.6]);
 
-    //     for f1 in [F1, F2, F3, F4, F5, F6] {
-    //         for f2 in [F1, F2, F3, F4, F5, F6] {
+    //     for f1 in Face::all() {
+    //         for f2 in Face::all() {
     //             for p1 in f2.paths(f1) {
     //                 for p2 in f1.paths(f2) {
     //                     println!("{:?}-{:?}; {:?} {:?}", f1, f2, p1, p2);