reduce to easel3d-xcb demo program

 [package]
-name = "xcb-test"
+name = "easel3d-xcb"
 version = "0.1.0"
 authors = ["Georg Hopp <georg@steffers.org>"]
 edition = "2018"
 
 [dependencies]
+easel3d = { path = "../easel3d" }
 libc = "0.2"
-gl = "0.5.2"
-x11 = { version = "2.3", features = ["glx"] }
 xcb = { version = "0.8", features = ["dri2", "randr", "thread", "xlib_xcb", "shm"] }

-# Rust playground
+# Easel3D-XCB
 
-Things I have recently done while learning the Rust programming language.
+X windows demo application using Easel3D...
 
 ## Synopsis
 
-Change in one of the toplevel subdirectories and try `cargo build` or
-`cargo run`. Maybe not everything is working oob. Feel free to fix whatever
-you want.
+Checkout this repository as well as the _easel3d_ repository to the same
+destination directory.
 
-## Description
-
-Various small examples I have tried while learning rust. The biggest and
-currently most active project is **fractional** which started as an
-implamentation of a rational number data type and then switched to a 3D
-math playground visualizing using **XCB** (in future it might also use
-a **HTML5 Canvas** for drawing as WebAssembly application.
-Using fractions with 3D math has several drawbacks:
+In the root of this repository call `cargo run`.
 
-1. A huge part of 3D math is non rational, like sin, cos, tan and sqrt.
-2. The numerator and denominator tend to become very huge while nearing to non
-   rational numbers and reduction is difficult and time consuming.
-3. Because of 2 it is way slower than the floating point calculation (at least
-   with a decent coprocessor).
+## Description
 
-Anyway, implementing the vector math stuff for both fractions and floating
-point was a nice playground for generics and traits. In future I might add
-another data type which implements the math as done by David Braben for the
-elite computer game.
+A demo application using easel3d to draw in an X-Window.
 
 ## Requirements
 
-### Always
-
 - A recent version of the Rust programming language as well as tooling.
   Currently I use Rust 1.39.0.
+- X11 (xcb, x11-shm)
 
-### For fractional
+## Dependencies
 
-- A running X Server with **XCB** and **X11-SHM** extentions
+### Rust crates.
 
-## Dependencies
+- easel3d (from parent directory)
+- libc >=0.2
+- xcb >=0.8
 
-...
+Along with the dependencies of the xcb crate. `cargo build` should take care
+of having them available.
 
 ## Contributing
 

-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "branches"
-version = "0.1.0"
-

-[package]
-name = "branches"
-version = "0.1.0"
-authors = ["Georg Hopp <georg@steffers.org>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]

-//
-// Control Flow Examples
-//
-// Georg Hopp <georg@steffers.org>
-//
-// Copyright © 2019 Georg Hopp
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-fn main() {
-    let condition = true;
-    let number = if condition {
-        5
-    } else {
-        6
-    };
-
-    println!("The value of number is: {}", number);
-}

-[package]
-name = "fractional"
-version = "0.1.0"
-authors = ["Georg Hopp <georg@steffers.org>"]
-edition = "2018"
-
-[dependencies]
-lazy_static = "1.4.0"
-libc = "0.2"
-gl = "0.5.2"
-x11 = { version = "2.3", features = ["glx"] }
-xcb = { version = "0.8", features = ["dri2", "randr", "thread", "xlib_xcb", "shm"] }

-http://www.jongware.com/galaxy1.html

-I really would like to see a HTML5 canvas as canvas for the 3D code.
-
-Some URLs:
-- https://stackoverflow.com/questions/42806037/modify-canvas-from-wasm
-- https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.HtmlCanvasElement.html
-- https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.CanvasRenderingContext2d.html
-- https://stackoverflow.com/questions/49935207/editing-canvas-pixel-data-in-webassembly-rust

-https://www.themathpage.com/Alg/reciprocals.htm

-https://en.wikipedia.org/wiki/Texture_mapping
-http://www.gamers.org/dEngine/quake/papers/checker_texmap.html
-https://www.cs.uic.edu/~jbell/CourseNotes/ComputerGraphics/TextureMapping.html
-http://www.decew.net/OSS/References/chapter_2_texture_mapping.pdf
-
-# example affine texture mapping
-http://archive.gamedev.net/archive/reference/articles/article852.html
-
-
-http://www.lysator.liu.se/~mikaelk/doc/perspectivetexture/
-
-# Shader... This also describes z-Buffer... :)
-https://people.ece.cornell.edu/land/OldStudentProjects/cs490-95to96/GUO/report.html
-https://software.intel.com/en-us/articles/the-basics-of-the-art-of-lighting-part-3-lighting-and-shaders/
-https://docs.unity3d.com/Manual/Lighting.html

-//
-// A «continued fraction» is a representation of a fraction as a vector
-// of integrals… Irrational fractions will result in infinite most of the
-// time repetitive vectors. They can be used to get a resonable approximation
-// for sqrt on fractionals.
-//
-// Georg Hopp <georg@steffers.org>
-//
-// Copyright © 2019 Georg Hopp
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-use crate::Fractional;
-
-#[derive(Debug)]
-pub struct Continuous (Vec<i64>);
-
-impl Continuous {
-    // calculate a sqrt as continued fraction sequence. Taken from:
-    // https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#
-    //  Continued_fraction_expansion
-    pub fn sqrt(x :i64, a0 :i64) -> Self {
-        fn inner(v :&mut [i64], x :i64, a0 :i64, mn :i64, dn :i64, an :i64) {
-            let mn_1 = dn * an - mn;
-            let dn_1 = (x - mn_1 * mn_1) / dn;
-            let an_1 = (a0 + mn_1) / dn_1;
-
-            v[0] = an;
-            // The convergence criteria „an_1 == 2 * a0“ is not good for
-            // very small x thus I decided to break the iteration at constant
-            // time. Which is the 5 below.
-            if v.len() > 1 {
-                inner(&mut v[1..], x, a0, mn_1, dn_1, an_1);
-            }
-        }
-
-        let mut v :Vec<i64> = vec!(0; 5);
-        inner(&mut v, x, a0, 0, 1, a0);
-        Continuous(v)
-    }
-
-    // general continous fraction form of a fractional...
-    pub fn from_prec(f :&Fractional, prec :Option<usize>) -> Self {
-        fn inner(v :&mut Vec<i64>, f :Fractional, prec :Option<usize>) {
-            let mut process = |prec :Option<usize>| {
-                let Fractional(n, d)   = f;
-                let a                  = n / d;
-                let Fractional(_n, _d) = f.noreduce_sub(a.into());
-
-                v.push(a);
-                match _n {
-                    1 => v.push(_d),
-                    0 => {},
-                    _ => inner(v, Fractional(_d, _n), prec),
-                }
-            };
-
-            match prec {
-                Some(0) => {},
-                None    => process(None),
-                Some(p) => process(Some(p - 1)),
-            }
-        }
-
-        let mut v = match prec {
-            None    => Vec::with_capacity(100),
-            Some(p) => Vec::with_capacity(p + 1),
-        };
-
-        inner(&mut v, *f, prec);
-        Continuous(v)
-    }
-
-    pub fn into_prec(&self, prec :Option<usize>) -> Fractional {
-        let Continuous(c) = self;
-        let             p = match prec {
-            Some(p) => if p <= c.len() { p } else { c.len() },
-            None    => c.len(),
-        };
-
-        let to_frac = |acc :Fractional, x :&i64| {
-            let Fractional(an, ad) = acc.noreduce_add((*x).into());
-            Fractional(ad, an)
-        };
-
-        let Fractional(n, d) = c[..p]
-                             . into_iter()
-                             . rev()
-                             . fold(Fractional(0, 1), to_frac);
-        Fractional(d, n)
-    }
-}
-
-impl From<&Fractional> for Continuous {
-    fn from(x :&Fractional) -> Self {
-        Self::from_prec(x, None)
-    }
-}
-
-impl Into<Fractional> for &Continuous {
-    fn into(self) -> Fractional {
-        (&self).into_prec(None)
-    }
-}

-//
-// This is an abstraction over a drawing environment.
-// Future note: z-Buffer is described here:
-// https://www.scratchapixel.com/lessons/3d-basic-rendering/rasterization-practical-implementation/perspective-correct-interpolation-vertex-attributes
-//
-// Georg Hopp <georg@steffers.org>
-//
-// Copyright © 2019 Georg Hopp
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-use std::cmp;
-use std::fmt::{Formatter, Debug, Display, Result};
-use std::ops::{Add, Sub, Div};
-use std::sync::mpsc;
-
-pub trait Easel {
-    //fn canvas(&mut self, width :u16, height :u16) -> Option<&dyn Canvas>;
-}
-
-pub trait Canvas<T> {
-    fn init_events(&self);
-    fn start_events(&self, tx :mpsc::Sender<i32>);
-
-    fn width(&self) -> u16;
-    fn height(&self) -> u16;
-
-    fn clear(&mut self);
-    fn draw(&mut self, c :&dyn Drawable<T>, ofs :Coordinate<T>, color :u32);
-    fn put_text(&self, ofs :Coordinate<T>, s :&str);
-    fn set_pixel(&mut self, c :Coordinate<T>, color :u32);
-    fn show(&self);
-}
-
-pub trait Drawable<T> {
-    fn plot(&self) -> Coordinates<T>;
-}
-
-pub trait Fillable<T>
-where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
-       + Debug + Copy + From<i32> {
-    fn fill(&self, canvas :&mut dyn Canvas<T>, color :u32);
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct Coordinate<T>(pub i32, pub i32, pub T);
-
-#[derive(Debug, Clone)]
-pub struct Coordinates<T>(pub Vec<Coordinate<T>>);
-
-#[derive(Debug, Clone, Copy)]
-pub struct LineIterator<T> where T: Debug {
-               a :Option<Coordinate<T>>
-    ,          b :Coordinate<T>
-    ,         dx :i32
-    ,         dy :i32
-    ,         dz :T
-    ,         sx :i32
-    ,         sy :i32
-    ,        err :i32
-    , only_edges :bool
-}
-
-impl<T> Iterator for LineIterator<T>
-where T: Add<Output = T> + Debug + Copy + From<i32> {
-    type Item = Coordinate<T>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.a {
-            None    => None,
-            Some(a) => {
-                let Coordinate(ax, ay, az) = a;
-                let Coordinate(bx, by,  _) = self.b;
-
-                if ax != bx || ay != by {
-                    match (2 * self.err >= self.dy, 2 * self.err <= self.dx ) {
-                        (true, false) => {
-                            let r    = self.a;
-                            self.a   = Some(Coordinate( ax + self.sx
-                                                      , ay
-                                                      , az + self.dz ));
-                            self.err = self.err + self.dy;
-                            if self.only_edges { self.next() } else { r }
-                        },
-                        (false, true) => {
-                            let r    = self.a;
-                            self.a   = Some(Coordinate( ax
-                                                      , ay + self.sy
-                                                      , az + self.dz ));
-                            self.err = self.err + self.dx;
-                            r
-                        },
-                        _             => {
-                            let r    = self.a;
-                            self.a   = Some(Coordinate( ax + self.sx
-                                                      , ay + self.sy
-                                                      , az + self.dz ));
-                            self.err = self.err + self.dx + self.dy;
-                            r
-                        },
-                    }
-                } else {
-                    self.a = None;
-                    Some(self.b)
-                }
-            }
-        }
-    }
-}
-
-impl<T> Coordinate<T>
-where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
-       + Debug + Clone + Copy + From<i32> {
-    fn iter(self, b :&Self, only_edges :bool) -> LineIterator<T> {
-        let Coordinate(ax, ay, az) = self;
-        let Coordinate(bx, by, bz) = *b;
-
-        let dx = (bx - ax).abs();
-        let dy = -(by - ay).abs();
-
-        LineIterator {    a: Some(self)
-                     ,    b: *b
-                     ,   dx: dx
-                     ,   dy: dy
-                     ,   dz: (bz - az) / cmp::max(dx, -dy).into()
-                     ,   sx: if ax < bx { 1 } else { -1 }
-                     ,   sy: if ay < by { 1 } else { -1 }
-                     , err: dx + dy
-                     , only_edges: only_edges
-        }
-    }
-
-    fn line_iter(self, b :&Self) -> LineIterator<T> {
-        self.iter(b, false)
-    }
-
-    fn line(self, b :&Self) -> Vec<Self> {
-        self.line_iter(b).collect()
-    }
-
-    fn edge_iter(self, b :&Self) -> LineIterator<T> {
-        self.iter(b, true)
-    }
-
-    fn edge(self, b :&Self) -> Vec<Self> {
-        self.edge_iter(b).collect()
-    }
-
-    fn face(edges :&[Self]) -> Vec<Self> {
-        edges.to_vec()
-    }
-}
-
-impl<T> Display for Coordinate<T> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        write!(f, "<{},{}>", self.0, self.1)
-    }
-}
-
-impl<T> Display for Coordinates<T> where T: Copy {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        let Coordinates(is) = self;
-
-        let c = match is[..] {
-            []  => String::from(""),
-            [a] => format!("{}", a),
-            _   => {
-                let mut a = format!("{}", is[0]);
-                for i in is[1..].iter() {
-                    a = a + &format!(",{}", i);
-                }
-                a
-            }
-        };
-
-        write!(f, "Coordinates[{}]", c)
-    }
-}
-
-
-#[derive(Debug, Clone, Copy)]
-pub struct Point<T>(pub Coordinate<T>);
-
-impl<T> Drawable<T> for Point<T> where T: Copy {
-    fn plot(&self) -> Coordinates<T> {
-        let Point(c) = *self;
-        Coordinates(vec!(c))
-    }
-}
-
-impl<T> Display for Point<T> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        let Point(p) = self;
-        write!(f, "Point[{}]", p)
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct Line<T>(pub Coordinate<T>, pub Coordinate<T>);
-
-impl<T> Drawable<T> for Line<T>
-where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
-       + Debug + Clone + Copy + From<i32> {
-    fn plot(&self) -> Coordinates<T> {
-        let Line(a, b) = *self;
-        Coordinates(a.line(&b))
-    }
-}
-
-impl<T> Display for Line<T> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        let Line(a, b) = self;
-        write!(f, "Line[{},{}]", a, b)
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct Polyline<T>(pub Coordinates<T>);
-
-impl<T> Drawable<T> for Polyline<T>
-where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
-       + Debug + Clone + Copy + From<i32> {
-    fn plot(&self) -> Coordinates<T> {
-        let Polyline(Coordinates(cs)) = self;
-
-        match cs[..] {
-            []     => Coordinates(Vec::<Coordinate<T>>::new()),
-            [a]    => Coordinates(vec!(a)),
-            [a, b] => Coordinates(a.line(&b)),
-            _      => {
-                let (a, b) = (cs[0], cs[1]);
-                let mut r = a.line(&b);
-                let mut i = b;
-                for j in cs[2..].iter() {
-                    r.append(&mut i.line(j)[1..].to_vec());
-                    i = *j;
-                }
-                Coordinates(r)
-            },
-        }
-    }
-}
-
-impl<T> Display for Polyline<T> where T: Copy {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        let Polyline(a) = self;
-        write!(f, "PLine[{}]", a)
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-enum Direction { Left, Right }
-
-#[derive(Debug, Clone)]
-pub struct Polygon<T>(pub Coordinates<T>);
-
-#[derive(Debug, Clone)]
-enum VertexIteratorMode { Vertex, Edge }
-#[derive(Debug, Clone)]
-pub struct VertexIterator<'a,T> where T: Debug {
-    p         :&'a Polygon<T>,
-    top       :usize,
-    current   :Option<usize>,
-    edge      :Option<LineIterator<T>>,
-    mode      :VertexIteratorMode,
-    direction :Direction,
-}
-
-impl<'a,T> VertexIterator<'a,T>
-where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
-       + Debug + Copy + From<i32> {
-    fn edge(p :&'a Polygon<T>, direction :Direction) -> Self {
-        let top  = p.vert_min(direction);
-        let next = p.next_y(top, direction);
-        let edge = match next {
-            None       => None,
-            Some(next) => Some(p.vertex(top).edge_iter(&p.vertex(next))),
-        };
-
-        VertexIterator { p:         p
-                       , top:       top
-                       , current:   next
-                       , edge:      edge
-                       , mode:      VertexIteratorMode::Edge
-                       , direction: direction }
-    }
-
-    fn vertex(p :&'a Polygon<T>, direction :Direction) -> Self {
-        let top  = p.vert_min(direction);
-        let next = p.next_y(top, direction);
-
-        VertexIterator { p:         p
-                       , top:       top
-                       , current:   next
-                       , edge:      None
-                       , mode:      VertexIteratorMode::Vertex
-                       , direction: direction }
-    }
-
-    // if this yields "None" we are finished.
-    fn next_edge(&mut self) -> Option<LineIterator<T>> {
-        let current  = self.current?;
-        let next     = self.p.next_y(current, self.direction)?;
-        let mut edge = self.p.vertex(current).edge_iter(&self.p.vertex(next));
-
-        match edge.next() {
-            // It should be impossible that a new edge iterator has no values
-            // at all… anyway, just in case I handle it here.
-            None    => self.next_edge(),
-            Some(_) => {
-                self.current = Some(next);
-                self.edge    = Some(edge);
-                self.edge
-            },
-        }
-    }
-}
-
-impl<'a,T> Iterator for VertexIterator<'a,T>
-where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
-       + Debug + Copy + From<i32> {
-    type Item = Coordinate<T>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.mode {
-            VertexIteratorMode::Edge => {
-                // if for whatever reason edge is "None" finish this iterator.
-                let next = self.edge.as_mut()?.next();
-
-                match next {
-                    Some(_) => next,
-                    None    => {
-                        self.next_edge()?;
-                        self.next()
-                    },
-                }
-            },
-            VertexIteratorMode::Vertex => {
-                let current  = self.current?;
-                self.current = self.p.next_y(current, self.direction);
-                Some(self.p.vertex(current))
-            },
-        }
-    }
-}
-
-impl<T> Polygon<T>
-where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
-       + Copy + Debug + From<i32> {
-    #[inline]
-    fn vertex(&self, v :usize) -> Coordinate<T> {
-        let Polygon(Coordinates(cs)) = self;
-        cs[v]
-    }
-
-    fn vert_min<'a>(&'a self, d :Direction) -> usize {
-        let Polygon(Coordinates(cs)) = self;
-
-        type ICoord<'a,T> = (usize, &'a Coordinate<T>);
-
-        // TODO I guess the problem here is that it does not account for the
-        //      same y vertex on the beggining and the end. So i guess correct
-        //      would be finding the first one and then dependings on the
-        //      given direction either search left or right for same y's.
-        let fold = |acc :Option<ICoord<'a,T>>, x :ICoord<'a,T>|
-            match acc {
-                None    => Some(x),
-                Some(a) => {
-                    let Coordinate(_, ay, _) = a.1;
-                    let Coordinate(_, xy, _) = x.1;
-                    if xy < ay {Some(x)} else {Some(a)}
-                },
-            };
-
-        let mut  min = cs.iter().enumerate().fold(None, fold).unwrap().0;
-        let mut next = self.step(min, d);
-
-        while self.vertex(min).1 == self.vertex(next).1 {
-            min = next;
-            next = self.step(min, d);
-        }
-
-        min
-    }
-
-    fn left_edge(&self) -> VertexIterator<T> {
-        VertexIterator::edge(self, Direction::Left)
-    }
-
-    fn right_edge(&self) -> VertexIterator<T> {
-        VertexIterator::edge(self, Direction::Right)
-    }
-
-    fn left_vertices(&self) -> VertexIterator<T> {
-        VertexIterator::vertex(self, Direction::Left)
-    }
-
-    fn right_vertices(&self) -> VertexIterator<T> {
-        VertexIterator::vertex(self, Direction::Right)
-    }
-
-    fn left(&self, v :usize) -> usize {
-        let Polygon(Coordinates(cs)) = self;
-
-        match v {
-            0 => cs.len() - 1,
-            _ => v - 1,
-        }
-    }
-
-    fn right(&self, v :usize) -> usize {
-        let Polygon(Coordinates(cs)) = self;
-
-        (v + 1) % cs.len()
-    }
-
-    fn step(&self, v :usize, d :Direction) -> usize {
-        match d {
-            Direction::Left  => self.left(v),
-            Direction::Right => self.right(v),
-        }
-    }
-
-    fn next_y(&self, c :usize, d :Direction) -> Option<usize> {
-        fn inner<T>( p :&Polygon<T>
-                   , c :usize
-                   , n :usize
-                   , d :Direction) -> Option<usize>
-        where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
-               + Copy + Debug + From<i32> {
-            if c == n {
-                None
-            } else {
-                let Coordinate(_, cy, _) = p.vertex(c);
-                let Coordinate(_, ny, _) = p.vertex(n);
-
-                if ny < cy { None } else { Some(n) }
-            }
-        }
-
-        inner(self, c, self.step(c, d), d)
-    }
-
-    pub fn debug(&self) {
-        let mut left  = self.left_vertices();
-        let mut right = self.right_vertices();
-
-        if left.find(|l| right.find(|r| l.0 == r.0).is_some()).is_some() {
-            let left  :Vec<Coordinate<T>> = self.left_vertices().collect();
-            let right :Vec<Coordinate<T>> = self.right_vertices().collect();
-
-            println!("===");
-            println!("==  poly : {:?}", self);
-            println!("==  ltop : {:?}", self.vert_min(Direction::Left));
-            println!("==  rtop : {:?}", self.vert_min(Direction::Right));
-            println!("==  left : {:?}", left);
-            println!("== right : {:?}", right);
-            println!("===");
-        }
-    }
-}
-
-impl<T> Drawable<T> for Polygon<T>
-where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
-       + Debug + Clone + Copy + From<i32> {
-    fn plot(&self) -> Coordinates<T> {
-        let Polygon(Coordinates(cs)) = self;
-
-        match cs[..] {
-            []     => Coordinates(Vec::<Coordinate<T>>::new()),
-            [a]    => Coordinates(vec!(a)),
-            [a, b] => Coordinates(a.line(&b)),
-            _      => {
-                let (a, b) = (cs[0], cs[1]);
-                let mut r = a.line(&b);
-                let mut i = b;
-                for j in cs[2..].iter() {
-                    r.append(&mut i.line(j)[1..].to_vec());
-                    i = *j;
-                }
-                let mut j = a.line(&i);
-                let     l = j.len();
-                if l > 1 {
-                    r.append(&mut j[1..l-1].to_vec());
-                }
-                Coordinates(r)
-            },
-        }
-    }
-}
-
-impl<T> Fillable<T> for Polygon<T>
-where T: Add<Output = T> + Sub<Output = T> + Div<Output = T>
-       + Debug + Clone + Copy + From<i32> {
-    fn fill(&self, canvas :&mut dyn Canvas<T>, color :u32) {
-        let scanlines = self.left_edge().zip(self.right_edge());
-
-        for l in scanlines.flat_map(|(l, r)| l.line_iter(&r)) {
-            canvas.set_pixel(l, color);
-        }
-    }
-}
-
-impl<T> Display for Polygon<T> where T: Copy {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        let Polygon(a) = self;
-        write!(f, "Poly[{}]", a)
-    }
-}

-//
-// Some code to support fractional numbers for full precision rational number
-// calculations. (At least for the standard operations.)
-// This also implements a sqrt on fractional numbers, which can not be precise
-// because of the irrational nature of most sqare roots.
-// Fractions can only represent rational numbers precise.
-//
-// Georg Hopp <georg@steffers.org>
-//
-// Copyright © 2019 Georg Hopp
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-use std::cmp::Ordering;
-use std::convert::{TryFrom, TryInto};
-use std::fmt::{Formatter, Display};
-use std::num::TryFromIntError;
-use std::ops::{Add,Sub,Neg,Mul,Div};
-
-use crate::continuous::Continuous;
-
-#[derive(Debug, Eq, Clone, Copy)]
-pub struct Fractional (pub i64, pub i64);
-
-#[inline]
-fn hcf(x :i64, y :i64) -> i64 {
-    match y {
-        0 => x,
-        _ => hcf(y, x % y),
-    }
-}
-
-pub fn from_vector(xs: &Vec<i64>) -> Vec<Fractional> {
-    xs.iter().map(|x| Fractional(*x, 1)).collect()
-}
-
-impl Fractional {
-    #[inline]
-    pub fn gcd(self, other: Self) -> i64 {
-        let Fractional(_, d1) = self;
-        let Fractional(_, d2) = other;
-        (d1 * d2) / hcf(d1, d2)
-    }
-
-    #[inline]
-    pub fn reduce(self) -> Self {
-        let Fractional(n, d) = self;
-        let (_n, _d) = if n > d { (n, d) } else { (d, n) };
-
-        // if the difference from _n % _d to _n is very big we are close to
-        // a whole number and can ignore the fractional part... this reduces
-        // the precision but ensures smaller numbers for numerator and
-        // denominator.
-        if _d > 1 && (_n % _d) * 10000000 < _n {
-            if n == _n {
-                Self(_n / _d, 1)
-            } else {
-                Self(1, _n / _d)
-            }
-        } else {
-            // Self(n / hcf(n, d), d / hcf(n, d))
-            // The above reduces prcisely but results in very large numerator
-            // or denominator occasionally. The below is less precise but
-            // keeps the numbers small… the bad point is, that it is not very
-            // fast.
-            let cont = Continuous::from_prec(&self, Some(5));
-            (&cont).into()
-        }
-    }
-
-    pub fn noreduce_add(self, other: Self) -> Self {
-        let Fractional(n1, d1) = self;
-        let Fractional(n2, d2) = other;
-        let n = n1 * (self.gcd(other) / d1) + n2 * (self.gcd(other) / d2);
-        Self(n, self.gcd(other))
-    }
-
-    pub fn noreduce_sub(self, other: Self) -> Self {
-        self.noreduce_add(other.noreduce_neg())
-    }
-
-    pub fn noreduce_neg(self) -> Self {
-        let Fractional(n, d) = self;
-        Self(-n, d)
-    }
-}
-
-impl From<i64> for Fractional {
-    fn from(x: i64) -> Self {
-        Self(x, 1)
-    }
-}
-
-impl From<i32> for Fractional {
-    fn from(x: i32) -> Self {
-        Self(x as i64, 1)
-    }
-}
-
-impl TryFrom<usize> for Fractional {
-    type Error = &'static str;
-
-    fn try_from(x: usize) -> Result<Self, Self::Error> {
-        let v = i64::try_from(x);
-        match v {
-            Err(_) => Err("Conversion from usize to i32 failed"),
-            Ok(_v) => Ok(Self(_v, 1)),
-        }
-    }
-}
-
-impl TryInto<f64> for Fractional {
-    type Error = TryFromIntError;
-
-    fn try_into(self) -> Result<f64, Self::Error> {
-        let n :i32 = self.0.try_into()?;
-        let d :i32 = self.1.try_into()?;
-        Ok(f64::from(n) / f64::from(d))
-    }
-}
-
-impl TryInto<(i32, i32)> for Fractional {
-    type Error = TryFromIntError;
-
-    fn try_into(self) -> Result<(i32, i32), Self::Error> {
-        let a :i32 = (self.0 / self.1).try_into()?;
-        let b :i32 = (self.0 % self.1).try_into()?;
-        Ok((a, b))
-    }
-}
-
-impl Display for Fractional {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "({}/{})", self.0, self.1)
-    }
-}
-
-impl PartialEq for Fractional {
-    fn eq(&self, other: &Self) -> bool {
-        let Fractional(n1, d1) = self;
-        let Fractional(n2, d2) = other;
-        n1 * (self.gcd(*other) / d1) == n2 * (self.gcd(*other) / d2)
-    }
-}
-
-impl PartialOrd for Fractional {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for Fractional {
-    fn cmp(&self, other: &Self) -> Ordering {
-        let Fractional(n1, d1) = self;
-        let Fractional(n2, d2) = other;
-        let x = n1 * (self.gcd(*other) / d1);
-        let y = n2 * (self.gcd(*other) / d2);
-        x.cmp(&y)
-    }
-}
-
-impl Add for Fractional {
-    type Output = Self;
-
-    fn add(self, other: Self) -> Self {
-        self.noreduce_add(other).reduce()
-    }
-}
-
-impl Sub for Fractional {
-    type Output = Self;
-
-    fn sub(self, other: Self) -> Self {
-        self + -other
-    }
-}
-
-impl Neg for Fractional {
-    type Output = Self;
-
-    fn neg(self) -> Self {
-        let Fractional(n, d) = self;
-        Self(-n, d)
-    }
-}
-
-impl Mul for Fractional {
-    type Output = Self;
-
-    fn mul(self, other :Self) -> Self {
-        let Fractional(n1, d1) = self;
-        let Fractional(n2, d2) = other;
-        Self(n1 * n2, d1 * d2).reduce()
-    }
-}
-
-impl Div for Fractional {
-    type Output = Self;
-
-    fn div(self, other: Self) -> Self {
-        let Fractional(n, d) = other;
-        self * Fractional(d, n)
-    }
-}
-
-    /* some stuff that could be tested...
-    let x = Fractional(1, 3);
-    let y = Fractional(1, 6);
-
-    println!(
-        "Greatest common denominator of {} and {}: {}", x, y, x.gcd(y));
-    println!("Numerator of {}: {}", x, x.numerator());
-    println!("Denominator of {}: {}", x, x.denominator());
-    assert_eq!(Fractional(1, 3), Fractional(2, 6));
-    assert_eq!(Fractional(1, 3), Fractional(1, 3));
-    assert_eq!(y < x, true);
-    assert_eq!(y > x, false);
-    assert_eq!(x == y, false);
-    assert_eq!(x == x, true);
-    assert_eq!(x + y, Fractional(1, 2));
-    println!("{} + {} = {}", x, y, x + y);
-    assert_eq!(x - y, Fractional(1, 6));
-    println!("{} - {} = {}", x, y, x - y);
-    assert_eq!(y - x, Fractional(-1, 6));
-    println!("{} - {} = {}", y, x, y - x);
-    assert_eq!(-x, Fractional(-1, 3));
-    println!("-{} = {}", x, -x);
-    assert_eq!(x * y, Fractional(1, 18));
-    println!("{} * {} = {}", x, y, x * y);
-    assert_eq!(x / y, Fractional(2, 1));
-    println!("{} / {} = {}", x, y, x / y);
-    assert_eq!(y / x, Fractional(1, 2));
-    println!("{} / {} = {}", y, x, y / x);
-
-    println!("Fractional from 3: {}", Fractional::from(3));
-    let z :f64 = Fractional::into(x);
-    println!("Floating point of {}: {}", x, z);
-    let (d, r) = Fractional::into(x);
-    println!("(div, rest) of {}: ({}, {})", x, d, r);
-    */
-

-//
-// Basic geometric things...
-//
-// Georg Hopp <georg@steffers.org>
-//
-// Copyright © 2019 Georg Hopp
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-use std::convert::{From, Into};
-use std::ops::{Add,Sub,Neg,Mul,Div};
-use std::fmt::Debug;
-
-use crate::easel::{Canvas, Coordinate, Coordinates, Polygon};
-use crate::transform::{TMatrix, Transformable};
-use crate::trigonometry::Trig;
-use crate::vector::Vector;
-
-#[derive(Debug, Clone)]
-pub struct Face<T>
-where T: Add + Sub + Neg + Mul + Div + Copy + Trig {
-    corners :Vec<usize>,
-    normal  :Option<Vector<T>>,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub struct Point<T>(pub Vector<T>, T)
-    where T: Add + Sub + Neg + Mul + Div + PartialEq + Copy + Trig;
-
-impl<T> Point<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + PartialEq + Trig + Copy + From<i32> {
-    pub fn new(x :T, y :T, z :T) -> Self {
-        Self(Vector(x, y, z), 1.into())
-    }
-}
-
-impl<T> Add for Point<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + PartialEq + Trig + Copy {
-    type Output = Self;
-
-    fn add(self, other :Self) -> Self {
-        let Point(v1, w1) = self;
-        let Point(v2, w2) = other;
-        Self(v1 + v2, w1 + w2)
-    }
-}
-
-impl<T> Neg for Point<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + PartialEq + Trig + Copy {
-    type Output = Self;
-
-    fn neg(self) -> Self {
-        let Point(v, w) = self;
-        Self(-v, -w)
-    }
-}
-
-impl<T> Sub for Point<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + PartialEq + Trig + Copy {
-    type Output = Self;
-
-    fn sub(self, other :Self) -> Self {
-        self + -other
-    }
-}
-
-impl<T> Mul for Point<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + PartialEq + Trig + Copy + From<i32> {
-    type Output = Self;
-
-    fn mul(self, other :Self) -> Self {
-        let a :Vector<T> = self.into();
-        let b :Vector<T> = other.into();
-
-        Point(a * b, 1.into())
-    }
-}
-
-impl<T> From<Vector<T>> for Point<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + PartialEq + Trig + Copy + From<i32> {
-    fn from(v :Vector<T>) -> Self {
-        Point(v, 1.into())
-    }
-}
-
-impl<T> Into<Vector<T>> for Point<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + PartialEq + Trig + Copy + From<i32> {
-    fn into(self) -> Vector<T> {
-        let Point(v, w) = self;
-
-        if w == 0.into() {
-            v
-        } else {
-            v.mul(&w.recip())
-        }
-    }
-}
-
-impl<T> Transformable<T> for Point<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + PartialEq + Debug + Trig + Copy + From<i32> {
-    fn transform(&self, m :&TMatrix<T>) -> Self {
-        let Point(v, w) = *self;
-        let (v, w)      = m.apply(&v, w);
-
-        if w == 0.into() {
-            v.into()
-        } else {
-            v.mul(&w.recip()).into()
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Polyeder<T>
-where T: Add + Sub + Neg + Mul + Div + PartialEq + Copy + Trig {
-    points :Vec<Point<T>>,
-    faces  :Vec<Face<T>>,
-}
-
-pub trait Primitives<T>
-where T: Add + Sub + Neg + Mul + Div + Debug + Copy + Trig + From<i32> {
-    fn transform(&self, m :&TMatrix<T>) -> Self;
-    fn project( &self
-              , camera :&Camera<T>
-              , light :&DirectLight<T>
-              , col :u32 ) -> Vec<(Polygon<T>, u32)>;
-}
-
-pub struct Camera<T>
-where T: Add + Sub + Neg + Mul + Div + Debug + Copy + Trig + From<i32> {
-    width    :T,
-    height   :T,
-    distance :T,
-    project  :TMatrix<T>,
-}
-
-pub struct DirectLight<T>
-where T: Add + Sub + Neg + Mul + Div + Debug + Copy + Trig + From<i32> {
-    direction: Vector<T>,
-}
-
-impl<T> Camera<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + PartialEq + Debug + Copy + Trig + From<i32> {
-    // This code assumes that the size of the viewport is always
-    // equal to the size of the physical screen… e.g. window/canvas thus some
-    // effects can't be done. See book for examples with different viewport
-    // and screen sizes.
-    pub fn new(c :&dyn Canvas<T>, angle :i32) -> Self {
-        let  width :T = (c.width() as i32).into();
-        let height :T = (c.height() as i32).into();
-        let      d :T = 1.into();
-        let    fov    = T::cot(angle) * width;
-        let     wh    = width / 2.into();
-        let     hh    = height / 2.into();
-
-        Camera { width:    width
-               , height:   height
-               , distance: d
-               , project:  TMatrix::new(
-                     (     fov, 0.into(),       wh, 0.into())
-                   , (0.into(),      fov,       hh, 0.into())
-                   , (0.into(), 0.into(),        d, 1.into())
-                   , (0.into(), 0.into(), 1.into(), 0.into()) ) }
-    }
-
-    pub fn get_distance(&self) -> T {
-        self.distance
-    }
-
-    pub fn get_projection(&self) -> TMatrix<T> {
-        self.project
-    }
-
-    pub fn project(&self, p :Point<T>) -> Point<T> {
-        p.transform(&self.project)
-    }
-}
-
-impl<T> DirectLight<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + Debug + Copy + Trig + From<i32> {
-    pub fn new(v :Vector<T>) -> Self {
-        DirectLight{ direction: v }
-    }
-
-    pub fn dir(&self) -> Vector<T> {
-        self.direction
-    }
-}
-
-impl<T> Face<T>
-where T: Add<Output = T> + Sub<Output = T> + Neg<Output = T>
-       + Mul<Output = T> + Div<Output = T>
-       + PartialEq + Debug + Copy + Trig + From<i32> {
-    fn new(corners :Vec<usize>, ps :&[Point<T>]) -> Self {
-        let mut f = Face{ corners: corners, normal: None };
-        f.update_normal(ps);
-        f
-    }
-
-    fn update_normal(&mut self, ps :&[Point<T>]) {
-        let edge10 :Vector<T> = (ps[self.corners[1]] - ps[self.corners[0]]).into();