Allow creating Points from Tuples and Arrays (#32)

There's a lot of 2d vector/point types, and things like this simplify
interop.

Note: This is only fixed sized, 2-length arrays. &[f64] is not covered
and would need to be cast/copied into a [f64; 2] to work.

src/lib.rs

@@ -55,6 +55,30 @@ impl From<&Point> for robust::Coord<f64> {
     }
 }
 
+impl From<(f64, f64)> for Point {
+    fn from((x, y): (f64, f64)) -> Self {
+        Point { x, y }
+    }
+}
+
+impl From<[f64; 2]> for Point {
+    fn from([x, y]: [f64; 2]) -> Self {
+        Point { x, y }
+    }
+}
+
+impl From<Point> for (f64, f64) {
+    fn from(pt: Point) -> Self {
+        (pt.x, pt.y)
+    }
+}
+
+impl From<Point> for [f64; 2] {
+    fn from(pt: Point) -> Self {
+        [pt.x, pt.y]
+    }
+}
+
 impl Point {
     fn dist2(&self, p: &Self) -> f64 {
         let dx = self.x - p.x;

tests/tests.rs

@@ -177,6 +177,18 @@ fn invalid_nan_sequence() {
     triangulate(&points);
 }
 
+#[test]
+/// The test demonstrates and validates our tuple and array round tripping of `Point`
+fn tuple_array_conv() {
+    // Tuple/Array --> Point
+    assert_eq!(Into::<Point>::into((1., 2.)), Point { x: 1., y: 2. });
+    assert_eq!(Into::<Point>::into([1., 2.]), Point { x: 1., y: 2. });
+
+    // Point --> Tuple/Array
+    assert_eq!(Into::<(f64, f64)>::into(Point { x: 1., y: 2. }), (1., 2.));
+    assert_eq!(Into::<[f64; 2]>::into(Point { x: 1., y: 2. }), [1., 2.]);
+}
+
 fn scale_points(points: &[Point], scale: f64) -> Vec<Point> {
     let scaled: Vec<Point> = points
         .iter()