hedgewars: comparison rust/integral-geometry/src/lib.rs

equal deleted inserted replaced

-:37c99587825d
+:3078123e84ea
 #[macro_use]
 extern crate fpnum;
 use fpnum::{distance, FPNum, FPPoint};
 use std::{
-cmp::max,
+cmp::{max, min},
-ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Range, RangeInclusive, Sub, SubAssign}
+ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Range, RangeInclusive, Sub, SubAssign},
 };
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
 pub struct Point {
 pub x: i32,
 self.dot(other.rotate90())
 }
 #[inline]
 pub fn clamp(self, rect: &Rect) -> Point {
-Point::new(
+Point::new(rect.x_range().clamp(self.x), rect.y_range().clamp(self.y))
-rect.x_range().clamp(self.x),
-rect.y_range().clamp(self.y)
-)
 }
 #[inline]
 pub fn line_to(self, end: Point) -> Line {
 Line::new(self, end)
 impl Rect {
 #[inline]
 pub fn new(top_left: Point, bottom_right: Point) -> Self {
 assert!(top_left.x <= bottom_right.x + 1);
 assert!(top_left.y <= bottom_right.y + 1);
-Self { top_left, bottom_right }
+Self {
+top_left,
+bottom_right,
+}
 }
 pub fn from_box(left: i32, right: i32, top: i32, bottom: i32) -> Self {
 Self::new(Point::new(left, top), Point::new(right, bottom))
 }
 pub fn from_size(top_left: Point, size: Size) -> Self {
 Self::new(
 top_left,
-top_left + Point::new(size.width as i32 - 1, size.height as i32 - 1)
+top_left + Point::new(size.width as i32 - 1, size.height as i32 - 1),
 )
 }
 pub fn from_size_coords(x: i32, y: i32, width: usize, height: usize) -> Self {
 Self::from_size(Point::new(x, y), Size::new(width, height))
 }
 #[inline]
 pub fn with_margin(&self, margin: i32) -> Self {
 let offset = Point::diag(margin);
-Self::new(
+Self::new(self.top_left() + offset, self.bottom_right() - offset)
-self.top_left() + offset,
-self.bottom_right() - offset
-)
 }
 #[inline]
 pub fn x_range(&self) -> RangeInclusive<i32> {
 self.left()..=self.right()
 ]
 }
 #[inline]
 pub fn quotient(self, x: usize, y: usize) -> Point {
-self.top_left() +
+self.top_left() + Point::new((x % self.width()) as i32, (y % self.height()) as i32)
-Point::new(
-(x % self.width()) as i32,
-(y % self.height()) as i32
-)
 }
 }
 trait RangeContains<T> {
 fn contains(&self, value: T) -> bool;
 }
-impl <T: Ord> RangeContains<T> for Range<T> {
+impl<T: Ord> RangeContains<T> for Range<T> {
 fn contains(&self, value: T) -> bool {
 value >= self.start && value < self.end
 }
 }
-impl <T: Ord> RangeContains<T> for RangeInclusive<T> {
+impl<T: Ord> RangeContains<T> for RangeInclusive<T> {
 fn contains(&self, value: T) -> bool {
 value >= *self.start() && value <= *self.end()
 }
 }
 trait RangeClamp<T> {
 fn clamp(&self, value: T) -> T;
 }
-impl <T: Ord + Copy> RangeClamp<T> for RangeInclusive<T> {
+impl<T: Ord + Copy> RangeClamp<T> for RangeInclusive<T> {
 fn clamp(&self, value: T) -> T {
 if value < *self.start() {
 *self.start()
 } else if value > *self.end() {
 *self.end()
 pub fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &mut Point> + 'a {
 let edges_count = self.edges_count();
 let start = self.vertices.as_mut_ptr();
 let end = unsafe { start.add(self.vertices.len()) };
-PolygonPointsIteratorMut { source: self, start, end }
+PolygonPointsIteratorMut {
+source: self,
+start,
+end,
+}
 }
 fn force_close(&mut self) {
 if !self.vertices.is_empty() {
 self.vertices[0] = self.vertices[self.vertices.len() - 1];
 (&self.vertices[0..self.edges_count()])
 .iter()
 .zip(&self.vertices[1..])
 .map(|(s, e)| Line::new(*s, *e))
 }
+pub fn bezierize(&mut self, segments_number: u32) {
+fn calc_point(p1: Point, p2: Point, p3: Point) -> FPPoint {
+let diff13 = (p1 - p3).to_fppoint();
+let diff13_norm = diff13.distance();
+if diff13_norm.is_zero() {
+diff13
+} else {
+let diff12_norm = (p1 - p2).to_fppoint().distance();
+let diff23_norm = (p2 - p3).to_fppoint().distance();
+let min_distance = min(diff13_norm, min(diff12_norm, diff23_norm));
+diff13 * min_distance / diff13_norm / 3
+}
+}
+if self.vertices.len() < 4 {
+return;
+}
+let delta = fp!(1 / segments_number);
+let mut bezierized_vertices = Vec::new();
+let mut pi = 0;
+let mut i = 1;
+let mut ni = 2;
+let mut right_point = calc_point(self.vertices[pi], self.vertices[i], self.vertices[ni]);
+let mut left_point;
+pi += 1;
+while pi != 0 {
+pi = i;
+i = ni;
+ni += 1;
+if ni >= self.vertices.len() {
+ni = 0;
+}
+left_point = right_point;
+right_point = calc_point(self.vertices[pi], self.vertices[i], self.vertices[ni]);
+bezierized_vertices.extend(BezierCurveSegments::new(
+Line::new(self.vertices[pi], self.vertices[i]),
+left_point,
+-right_point,
+delta,
+));
+}
+self.vertices = bezierized_vertices;
+}
 }
 struct PolygonPointsIteratorMut<'a> {
 source: &'a mut Polygon,
 start: *mut Point,
-end: *mut Point
+end: *mut Point,
 }
-impl <'a> Iterator for PolygonPointsIteratorMut<'a> {
+impl<'a> Iterator for PolygonPointsIteratorMut<'a> {
 type Item = &'a mut Point;
 fn next(&mut self) -> Option<<Self as Iterator>::Item> {
 if self.start == self.end {
 None
 }
 }
 }
 }
-impl <'a> Drop for PolygonPointsIteratorMut<'a> {
+impl<'a> Drop for PolygonPointsIteratorMut<'a> {
 fn drop(&mut self) {
 self.source.force_close();
 }
 }
 }
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
 pub struct Ray {
 pub start: Point,
-pub direction: Point
+pub direction: Point,
 }
 impl Ray {
 #[inline]
 pub fn new(start: Point, direction: Point) -> Ray {
 pub struct BezierCurveSegments {
 segment: Line,
 c1: FPPoint,
 c2: FPPoint,
 offset: FPNum,
+max_offset: FPNum,
 delta: FPNum,
+have_finished: bool,
 }
 impl BezierCurveSegments {
-pub fn new(segment: Line, p1: Point, p2: Point, delta: FPNum) -> Self {
+pub fn new(segment: Line, p1: FPPoint, p2: FPPoint, delta: FPNum) -> Self {
 Self {
 segment,
-c1: (segment.start - p1).to_fppoint(),
+c1: segment.start.to_fppoint() - p1,
-c2: (segment.end - p2).to_fppoint(),
+c2: segment.end.to_fppoint() - p2,
 offset: fp!(0),
+max_offset: fp!(4095 / 4096),
 delta,
+have_finished: false,
 }
 }
 }
 impl Iterator for BezierCurveSegments {
 type Item = Point;
 fn next(&mut self) -> Option<Self::Item> {
-if self.offset < fp!(1) {
+if self.offset < self.max_offset {
 let offset_sq = self.offset * self.offset;
 let offset_cub = offset_sq * self.offset;
 let r1 = fp!(1) - self.offset * 3 + offset_sq * 3 - offset_cub;
 let r2 = self.offset * 3 - offset_sq * 6 + offset_cub * 3;
 + offset_cub * self.segment.end.y;
 self.offset += self.delta;
 Some(Point::new(x.round(), y.round()))
+} else if !self.have_finished {
+self.have_finished = true;
+Some(self.segment.end)
 } else {
 None
 }
 }
 }

changeset 14140	3078123e84ea
parent 14139	37c99587825d
child 14141	477faa7b8a48