non-riemannian-opt: comparison src/cube.rs

-:f67949050a32
+:d0f20c6cb49c
 }
 /// 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
+/// Given an unfolded point `p` and a destination point `d` in unfolded coordinates,
-/// the edge, presented by an adjacent face, in whose direction it is.
+/// 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
+/// Crossing at corners is decided arbitrarily.
-/// the direction of an adjacent face.
+pub fn find_crossing(&self, p :& Point, d : &Point) -> (Face, Point) {
-pub fn find_crossing(&self, p : &Point) -> Face {
+//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 &Loc([xd, yd]) = d;
-let crossing = |t| match (0.0 <= t, t<=1.0) {
+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
 pub fn embedded_coords(&self, p : &Point) -> Loc<f64, 3> {
 let &Loc([x, y]) = p;
 impl ManifoldPoint for OnCube {
 type Tangent = Point;
 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 {
 self.log_dist(other).0
 }
 #[test]
 fn convert_adjacent() {
 let point = Loc([0.4, 0.6]);
-for f1 in [F1, F2, F3, F4, F5, F6] {
+for f1 in Face::all() {
-for f2 in [F1, F2, F3, F4, F5, F6] {
+for f2 in Face::all() {
 println!("{:?}-{:?}", f1, f2);
 match f1.convert_adjacent(f2, &point) {
 None => assert_eq!(f2.opposing_face(), f1),
 Some(q) => {
 match f2.convert_adjacent(f1, &q) {
 // that a point outside the face will be returned to its point of origin.
 // #[test]
 // fn convert_paths() {
 //     let point = Loc([0.4, 0.6]);
-//     for f1 in [F1, F2, F3, F4, F5, F6] {
+//     for f1 in Face::all() {
-//         for f2 in [F1, F2, F3, F4, F5, F6] {
+//         for f2 in Face::all() {
 //             for p1 in f2.paths(f1) {
 //                 for p2 in f1.paths(f2) {
 //                     println!("{:?}-{:?}; {:?} {:?}", f1, f2, p1, p2);
 //                     let v = &f2.convert(&p1, &point);
 //                     let q = f1.convert(&p2, v);

Mercurial > repos > non-riemannian-opt / file comparison

comparison: src/cube.rs

src/cube.rs