fast image operations
Diffstat (limited to 'src/drawing/poly.rs')
| -rw-r--r-- | src/drawing/poly.rs | 186 |
1 files changed, 186 insertions, 0 deletions
diff --git a/src/drawing/poly.rs b/src/drawing/poly.rs new file mode 100644 index 0000000..5a67a07 --- /dev/null +++ b/src/drawing/poly.rs @@ -0,0 +1,186 @@ +//! draw polygons +use crate::Image; +use crate::math::{FExt, madd}; +use array_chunks::*; +use std::cmp::{max, min}; +use std::f32::consts::TAU; +use vecto::Vec2; + +impl<T: AsMut<[u8]> + AsRef<[u8]>, const CHANNELS: usize> Image<T, CHANNELS> { + /// Draws a filled polygon from a slice of points. Please close your poly. (first == last) + /// + /// Borrowed from [imageproc](https://docs.rs/imageproc/latest/src/imageproc/drawing/polygon.rs.html#31), modified for less allocations. + /// ``` + /// # use fimg::Image; + /// let mut i = Image::alloc(10, 10); + /// i.points(&[(1, 8), (3, 1), (8, 1), (6, 6), (8, 8), (1, 8)], [255]); + /// # assert_eq!(i.buffer(), b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\x00\x00\x00\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); + /// ``` + pub fn points(&mut self, poly: &[(i32, i32)], c: [u8; CHANNELS]) { + if poly.len() <= 1 { + return; + } + let (mut y_max, mut y_min) = poly[..poly.len() - 1] + .iter() + .fold((i32::MIN, i32::MAX), |(max, min), &(_, y)| { + (y.max(max), y.min(min)) + }); + y_min = max(0, min(y_min, self.height() as i32 - 1)); + y_max = max(0, min(y_max, self.height() as i32 - 1)); + let mut intersections = vec![]; + for y in y_min..=y_max { + for [p0, p1] in poly.array_windows::<2>() { + if p0.1 <= y && p1.1 >= y || p1.1 <= y && p0.1 >= y { + if p0.1 == p1.1 { + intersections.push(p0.0); + intersections.push(p1.0); + } else if p0.1 == y || p1.1 == y { + if p1.1 > y { + intersections.push(p0.0); + } + if p0.1 > y { + intersections.push(p1.0); + } + } else { + let fraction = (y - p0.1) as f32 / (p1.1 - p0.1) as f32; + let inter = madd(fraction, (p1.0 - p0.0) as f32, p0.0 as f32); + intersections.push(inter.round() as i32); + } + } + } + intersections.sort_unstable(); + for &[x, y_] in intersections.array_chunks::<2>() { + let mut from = min(x, self.width() as i32); + let mut to = min(y_, self.width() as i32 - 1); + if from < self.width() as i32 && to >= 0 { + // check bounds + from = max(0, from); + to = max(0, to); + + for x in from..=to { + // SAFETY: bounds are checked + unsafe { self.set_pixel(x as u32, y as u32, &c) }; + } + } + } + intersections.clear(); + } + + for &[(x1, y1), (x2, y2)] in poly.array_windows::<2>() { + self.line((x1, y1), (x2, y2), c); + } + } + + /// Draws a filled quadrilateral. + /// This currently just uses [`Image::points`], but in the future this may change. + pub fn quad( + &mut self, + a: (i32, i32), + b: (i32, i32), + c: (i32, i32), + d: (i32, i32), + col: [u8; CHANNELS], + ) { + self.points(&[a, b, c, d, a], col); + } + + /// Draws a regular convex polygon with a specified number of sides, a radius, and a rotation (radians). + /// Prefer [`Image::circle`] over `poly(.., 600, ..)`. + /// Calls into [`Image::tri`] and [`Image::quad`]. + /// ``` + /// # use fimg::Image; + /// let mut i = Image::alloc(300, 300); + /// // draw a enneagon + /// // at x150, y150 │ unrotated white + /// // with a radius of ─┼──╮ │ │ + /// i.poly((150., 150.), 9, 100.0, 0.0, [255]); + /// # assert_eq!(i.buffer(), include_bytes!("../../tdata/enneagon.imgbuf")); + /// ``` + pub fn poly( + &mut self, + pos: impl Into<Vec2>, + sides: usize, + radius: f32, + rotation: f32, + c: [u8; CHANNELS], + ) { + let pos = pos.into(); + let trans = |a: f32| Vec2::from_angle(a) * radius; + let r = |v: Vec2| (v.x.round() as i32, v.y.round() as i32); + match sides { + 3 => { + let space = TAU / 3.0; + self.tri::<f32>( + trans(space + rotation) + pos, + trans(rotation) + pos, + trans(madd(space, 2.0, rotation)) + pos, + c, + ); + } + _ => { + let space = TAU / sides as f32; + for i in (0..sides - 1).step_by(2).map(|i| i as f32) { + self.quad( + r(pos), + r(trans(madd(space, i, rotation)) + pos), + r(trans(madd(space, i + 1., rotation)) + pos), + r(trans(madd(space, i + 2., rotation)) + pos), + c, + ); + } + + if sides % 2 != 0 && sides > 4 { + let i = (sides - 1) as f32; + // the missing piece + self.tri::<f32>( + pos, + trans(madd(space, i, rotation)) + pos, + trans(madd(space, i + 1., rotation)) + pos, + c, + ); + } + } + } + } + + /// Draw a bordered polygon. + /// Prefer [`Image::border_circle`] to draw circles. + /// See also [`Image::poly`]. + /// ``` + /// let mut i = fimg::Image::alloc(100, 100); + /// i.border_poly((50., 50.), 5, 25., 0., 7., [255]); + /// # assert_eq!(i.buffer(), include_bytes!("../../tdata/border_pentagon.imgbuf")); + /// ``` + pub fn border_poly( + &mut self, + pos: impl Into<Vec2>, + sides: usize, + radius: f32, + rotation: f32, + stroke: f32, + c: [u8; CHANNELS], + ) { + let pos = pos.into(); + let space = TAU / sides as f32; + let step = stroke / 2.0 / (space / 2.0).cos(); + let r1 = radius - step; + let r2 = radius + step; + let r = |a: f32, b: f32| (a.round() as i32, b.round() as i32); + for i in 0..sides { + let a = space.madd(i as f32, rotation); + self.quad( + r(r1.madd(a.cos(), pos.x), r1.madd(a.sin(), pos.y)), + r( + r1.madd((a + space).cos(), pos.x), + r1.madd((a + space).sin(), pos.y), + ), + r( + r2.madd((a + space).cos(), pos.x), + r2.madd((a + space).sin(), pos.y), + ), + r(r2.madd(a.cos(), pos.x), r2.madd(a.sin(), pos.y)), + c, + ); + } + } +} |