Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

Geometry: a projective map at a small scale maps a far point without overflowing

dotCooCoob5885e35fa74
diff --git a/crates/geom/src/projective.rs b/crates/geom/src/projective.rs
index 9d4800626..070048f38 100644
--- a/crates/geom/src/projective.rs
+++ b/crates/geom/src/projective.rs
@@ -54,7 +54,7 @@ impl Homography {
/// magnitude in the map's `w` row, so the answer is the same at any scale of the map), or when
/// it does not map to a finite page point. The point is mapped through [`Self::upscaled`].
pub fn apply(&self, p: Point) -> Option<Point> {
- let m = self.upscaled();
+ let m = self.upscaled(p);
let x = m[0][0] * p.x + m[0][1] * p.y + m[0][2];
let y = m[1][0] * p.x + m[1][1] * p.y + m[1][2];
let w = m[2][0] * p.x + m[2][1] * p.y + m[2][2];
@@ -66,12 +66,15 @@ impl Homography {
q.is_finite().then_some(q)
}
- /// The entries, multiplied by the power of two that brings the largest magnitude to at least
- /// 1/2 and below 1 when every entry is below 1/2 in magnitude (an exact step that keeps a map
- /// at a tiny scale from losing precision to subnormal products), and unchanged otherwise.
- fn upscaled(&self) -> [[f64; 3]; 3] {
+ /// The entries for mapping `p`, multiplied by a power of two of at least 1 (an exact step that
+ /// keeps a map at a tiny scale from losing precision to subnormal products). When every entry
+ /// is below 1/2 in magnitude, the power brings the largest to at least 1/2 and below 1, divided
+ /// by the power of two of `p`'s larger coordinate magnitude when that is 1 or more, so that no
+ /// product of an entry and a coordinate reaches 1. Otherwise the entries are unchanged.
+ fn upscaled(&self, p: Point) -> [[f64; 3]; 3] {
let largest = self.0.iter().flatten().fold(0.0_f64, |k, v| k.max(v.abs()));
- let e = frexp(largest).1.min(0);
+ let e_p = frexp(p.x.abs().max(p.y.abs())).1.max(0);
+ let e = (frexp(largest).1.min(0) + e_p).min(0);
self.0.map(|row| row.map(|v| ldexp(v, -e)))
}
@@ -261,7 +264,7 @@ impl Homography {
/// The affine map that matches `self` to first order at `p` (its derivative there), `None`
/// beyond the horizon or when the derivative is not finite.
pub fn affine_at(&self, p: Point) -> Option<Affine> {
- let m = self.upscaled();
+ let m = self.upscaled(p);
let w = m[2][0] * p.x + m[2][1] * p.y + m[2][2];
let q = self.apply(p)?;
// d(x/w) = (dx − (x/w)·dw) / w, and the same for y.
@@ -584,6 +587,17 @@ mod tests {
}
}
+ #[test]
+ fn a_map_at_a_small_scale_maps_a_far_point() {
+ // Every product of an entry and a coordinate is finite, but the entries brought to 1/2 or
+ // more would overflow against this point.
+ let h = Homography([[1e-6, 1e-6, 0.0], [0.0, 1e-6, 0.0], [1e-6, 0.0, 1e-6]]);
+ let p = Point::new(1.75e308, 1.75e308);
+ let q = h.apply(p).unwrap_or_else(|| panic!("{p:?}"));
+ assert!((q.x - 2.0).abs() <= 1e-12 && (q.y - 1.0).abs() <= 1e-12, "{q:?}");
+ assert!(h.affine_at(p).is_some());
+ }
+
#[test]
fn a_product_that_overflows_is_none() {
// Each factor is finite and invertible, but the product's first entry is 1e400.