dessin 0.8.23

Build complex drawing for PDF, SVG, Images or Dioxus
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use super::{BoundingBox, Curve, ShapeBoundingBox, UnParticular};
use crate::{
	prelude::Circle,
	shapes::{Shape, ShapeOp},
};
use nalgebra::{Point2, Scale2, Transform2, Vector2};

#[derive(Debug, Clone, PartialEq)]
///
pub struct EllipsePosition {
	///
	pub center: Point2<f32>,

	///
	pub semi_major_axis: f32,
	///
	pub semi_minor_axis: f32,

	///
	pub rotation: f32,
}

#[derive(Default, Debug, Clone, PartialEq)]
///
pub struct Ellipse {
	///
	pub local_transform: Transform2<f32>,
}

impl Ellipse {
	#[inline]
	///
	pub fn axis<S: Into<Scale2<f32>>>(&mut self, scale: S) -> &mut Self {
		self.scale(scale);
		self
	}

	#[inline]
	///
	pub fn with_axis<S: Into<Scale2<f32>>>(mut self, scale: S) -> Self {
		self.axis(scale);
		self
	}

	#[inline]
	///
	pub fn semi_major_axis(&mut self, value: f32) -> &mut Self {
		self.scale(Scale2::new(2. * value, 1.));
		self
	}

	#[inline]
	///
	pub fn with_semi_major_axis(mut self, value: f32) -> Self {
		self.semi_major_axis(value);
		self
	}

	#[inline]
	///
	pub fn semi_minor_axis(&mut self, value: f32) -> &mut Self {
		self.scale(Scale2::new(1., 2. * value));
		self
	}

	#[inline]
	///
	pub fn with_semi_minor_axis(mut self, value: f32) -> Self {
		self.semi_minor_axis(value);
		self
	}

	///
	pub fn position(&self, parent_transform: &Transform2<f32>) -> EllipsePosition {
		let transform = self.global_transform(parent_transform);

		let center = transform * Point2::origin();

		let semi_major_axis = transform * Vector2::new(0.5, 0.);
		let semi_minor_axis = transform * Vector2::new(0., 0.5);

		let rotation = semi_major_axis.y.atan2(semi_major_axis.x);

		EllipsePosition {
			center,
			semi_major_axis: semi_major_axis.magnitude(),
			semi_minor_axis: semi_minor_axis.magnitude(),
			rotation,
		}
	}
}

impl From<Ellipse> for Curve {
	#[inline]
	fn from(e: Ellipse) -> Self {
		Circle::from(e).into()
	}
}

impl From<Ellipse> for Shape {
	#[inline]
	fn from(v: Ellipse) -> Self {
		Shape::Ellipse(v)
	}
}

impl ShapeOp for Ellipse {
	#[inline]
	fn transform(&mut self, transform_matrix: Transform2<f32>) -> &mut Self {
		self.local_transform = transform_matrix * self.local_transform;
		self
	}

	#[inline]
	fn local_transform(&self) -> &Transform2<f32> {
		&self.local_transform
	}
}

impl ShapeBoundingBox for Ellipse {
	fn local_bounding_box(&self) -> BoundingBox<UnParticular> {
		BoundingBox::new(
			self.local_transform() * Point2::new(-0.5, 0.5),
			self.local_transform() * Point2::new(0.5, 0.5),
			self.local_transform() * Point2::new(0.5, -0.5),
			self.local_transform() * Point2::new(-0.5, -0.5),
		)
	}
}