1use std::{
2 f64::consts::{FRAC_PI_2, PI},
3 iter::once,
4};
5
6use ab_glyph::FontArc;
7use anchor2d::{Anchor2D, HorizontalAnchor, VerticalAnchorContext, VerticalAnchorValue};
8use glam::{DVec2, IVec2, dvec2, ivec2};
9use image::{
10 Rgba, RgbaImage,
11 imageops::{FilterType, overlay, resize},
12};
13use imageproc::{
14 drawing::{
15 draw_filled_circle_mut, draw_filled_rect_mut, draw_polygon_mut, draw_text_mut, text_size,
16 },
17 point::Point,
18 rect::Rect,
19};
20use itertools::Itertools;
21use palette::Srgba;
22
23use crate::Renderer;
24
25fn srgba_to_rgba8(color: Srgba) -> Rgba<u8> {
26 let red = (color.red * 255.0).round().clamp(0.0, 255.0) as u8;
27 let green = (color.green * 255.0).round().clamp(0.0, 255.0) as u8;
28 let blue = (color.blue * 255.0).round().clamp(0.0, 255.0) as u8;
29 let alpha = (color.alpha * 255.0).round().clamp(0.0, 255.0) as u8;
30 Rgba([red, green, blue, alpha])
31}
32
33#[derive(Clone)]
34pub struct ImageRenderer {
35 virtual_width: u32,
36 virtual_height: u32,
37 image: RgbaImage,
38 scale: f64,
39 scaling_target: DVec2,
40 supersampling: u32,
41 font: FontArc,
42}
43
44impl ImageRenderer {
45 pub fn new(
46 width: u32,
47 height: u32,
48 scale: f64,
49 scaling_target: DVec2,
50 supersampling: u32,
51 font: FontArc,
52 ) -> Self {
53 Self {
54 virtual_width: width,
55 virtual_height: height,
56 image: RgbaImage::new(width * supersampling, height * supersampling),
57 scale,
58 scaling_target,
59 supersampling,
60 font,
61 }
62 }
63
64 pub fn get_font(&self) -> &FontArc {
65 &self.font
66 }
67
68 pub fn set_font(&mut self, font: FontArc) {
69 self.font = font;
70 }
71
72 fn get_supersampled_width(&self) -> u32 {
73 self.virtual_width * self.supersampling
74 }
75
76 fn get_supersampled_height(&self) -> u32 {
77 self.virtual_height * self.supersampling
78 }
79
80 fn map_value(&self, value: f64) -> f64 {
81 value * self.scale * self.supersampling as f64
82 }
83
84 fn map_x(&self, x: f64) -> f64 {
85 let target_x = self.get_supersampled_width() as f64 * self.scaling_target.x;
86 (x * self.supersampling as f64 - target_x) * self.scale + target_x
87 }
88
89 fn map_y(&self, y: f64) -> f64 {
90 let target_y = self.get_supersampled_height() as f64 * self.scaling_target.y;
91 (y * self.supersampling as f64 - target_y) * self.scale + target_y
92 }
93
94 fn map_dvec2(&self, v: DVec2) -> DVec2 {
95 dvec2(self.map_x(v.x), self.map_y(v.y))
96 }
97
98 pub fn reset(&mut self) {
99 self.image = self.transparent();
100 }
101
102 pub fn get_image(&self) -> &RgbaImage {
103 &self.image
104 }
105
106 pub fn render_image_onto(&self, mut image: RgbaImage) -> RgbaImage {
107 overlay(&mut image, &self.image, 0, 0);
108
109 resize(
110 &image,
111 self.virtual_width,
112 self.virtual_height,
113 FilterType::Lanczos3,
114 )
115 }
116
117 pub fn transparent(&self) -> RgbaImage {
118 RgbaImage::new(
119 self.get_supersampled_width(),
120 self.get_supersampled_height(),
121 )
122 }
123
124 pub fn black(&self) -> RgbaImage {
125 RgbaImage::from_pixel(
126 self.get_supersampled_width(),
127 self.get_supersampled_height(),
128 Rgba([0, 0, 0, 255]),
129 )
130 }
131
132 fn get_base_points(&self, position: DVec2, width: f64, height: f64) -> Vec<DVec2> {
133 vec![
134 position,
135 position + DVec2::X * width,
136 position + DVec2::X * width + DVec2::Y * height,
137 position + DVec2::Y * height,
138 ]
139 }
140
141 fn get_offset_vec(&self, width: f64, height: f64, offset: DVec2) -> DVec2 {
142 let offset_width = width * offset.x;
143 let offset_height = height * offset.y;
144
145 dvec2(offset_width, offset_height)
146 }
147
148 fn get_offset_points(&self, points: &[DVec2], offset_vec: DVec2) -> Vec<DVec2> {
149 points
150 .iter()
151 .copied()
152 .map(|base_point| base_point - offset_vec)
153 .collect::<Vec<DVec2>>()
154 }
155
156 fn get_rotated_points(&self, points: &[DVec2], axis: DVec2, rotation: f64) -> Vec<DVec2> {
157 points
158 .iter()
159 .copied()
160 .map(|point| rotate_point_around(point, axis, rotation))
161 .collect::<Vec<DVec2>>()
162 }
163
164 fn get_unique_integer_points(&self, points: &[DVec2]) -> Vec<IVec2> {
165 points
166 .iter()
167 .map(|point| point.round().as_ivec2())
168 .unique()
169 .collect::<Vec<IVec2>>()
170 }
171}
172
173impl Renderer for ImageRenderer {
174 fn render_point(&mut self, position: DVec2, color: Srgba) {
175 let position = self.map_dvec2(position);
176 let width = self.map_value(1.0);
177 let height = self.map_value(1.0);
178
179 let integer_position = position.round().as_ivec2();
180
181 draw_filled_rect_mut(
182 &mut self.image,
183 Rect::at(integer_position.x, integer_position.y)
184 .of_size(width.round() as u32, height.round() as u32),
185 srgba_to_rgba8(color),
186 );
187 }
188
189 fn render_line(&mut self, start: DVec2, end: DVec2, thickness: f64, color: Srgba) {
190 let start = self.map_dvec2(start);
191 let end = self.map_dvec2(end);
192
193 let thickness = self.map_value(thickness);
194 let offset = thickness / 2.0;
195 let normal = DVec2::from_angle((end - start).to_angle() + FRAC_PI_2);
196
197 let points = vec![
198 start + normal * offset,
199 start - normal * offset,
200 end - normal * offset,
201 end + normal * offset,
202 ];
203
204 let integer_points = self
205 .get_unique_integer_points(&points)
206 .iter()
207 .map(|integer_point| Point::new(integer_point.x, integer_point.y))
208 .collect::<Vec<Point<i32>>>();
209
210 if integer_points.len() == 1 {
211 let integer_point = integer_points.first().unwrap();
212
213 self.render_point(dvec2(integer_point.x as f64, integer_point.y as f64), color);
214 } else {
215 draw_polygon_mut(&mut self.image, &integer_points, srgba_to_rgba8(color));
216 }
217 }
218
219 fn render_circle(&mut self, position: DVec2, radius: f64, color: Srgba) {
220 let position = self.map_dvec2(position).round().as_ivec2();
221 let radius = self.map_value(radius).round() as u32;
222
223 draw_filled_circle_mut(
224 &mut self.image,
225 position.into(),
226 radius as i32,
227 srgba_to_rgba8(color),
228 );
229 }
230
231 fn render_circle_lines(&mut self, position: DVec2, radius: f64, thickness: f64, color: Srgba) {
232 let position = self.map_dvec2(position).round().as_ivec2();
233 let radius = self.map_value(radius).round();
234 let thickness = self.map_value(thickness).round();
235
236 let mut circle_renderer = ImageRenderer::new(
237 2 * radius as u32 + 1,
238 2 * radius as u32 + 1,
239 self.scale,
240 self.scaling_target,
241 self.supersampling,
242 self.font.clone(),
243 );
244
245 circle_renderer.render_circle(dvec2(radius, radius), radius, color);
246
247 circle_renderer.render_circle(
248 dvec2(radius, radius),
249 radius - thickness,
250 Srgba::new(0.0, 0.0, 0.0, 0.0),
251 );
252
253 overlay(
254 &mut self.image,
255 &circle_renderer.render_image_onto(circle_renderer.transparent()),
256 (position.x - radius as i32) as i64,
257 (position.y - radius as i32) as i64,
258 );
259 }
260
261 fn render_arc(&mut self, position: DVec2, radius: f64, rotation: f64, arc: f64, color: Srgba) {
262 let position = self.map_dvec2(position);
263 let radius = self.map_value(radius);
264
265 let points =
266 once(position)
267 .chain((0..32).map(|i| {
268 position + radius * DVec2::from_angle(rotation + arc * i as f64 / 31.0)
269 }))
270 .collect::<Vec<DVec2>>();
271
272 let integer_points = self
273 .get_unique_integer_points(&points)
274 .iter()
275 .map(|integer_point| Point::new(integer_point.x, integer_point.y))
276 .collect::<Vec<Point<i32>>>();
277
278 if integer_points.len() == 1 {
279 let integer_point = integer_points.first().unwrap();
280
281 self.render_point(dvec2(integer_point.x as f64, integer_point.y as f64), color);
282 } else {
283 draw_polygon_mut(&mut self.image, &integer_points, srgba_to_rgba8(color));
284 }
285 }
286
287 fn render_arc_lines(
288 &mut self,
289 position: DVec2,
290 radius: f64,
291 rotation: f64,
292 arc: f64,
293 thickness: f64,
294 color: Srgba,
295 ) {
296 let position = self.map_dvec2(position).round().as_ivec2();
297 let radius = self.map_value(radius).round();
298 let thickness = self.map_value(thickness).round();
299
300 let mut circle_renderer = ImageRenderer::new(
301 2 * radius as u32 + 1,
302 2 * radius as u32 + 1,
303 self.scale,
304 self.scaling_target,
305 self.supersampling,
306 self.font.clone(),
307 );
308
309 circle_renderer.render_arc(dvec2(radius, radius), radius, rotation, arc, color);
310
311 circle_renderer.render_circle(
312 dvec2(radius, radius),
313 radius - thickness,
314 Srgba::new(0.0, 0.0, 0.0, 0.0),
315 );
316
317 overlay(
318 &mut self.image,
319 &circle_renderer.render_image_onto(circle_renderer.transparent()),
320 (position.x - radius as i32) as i64,
321 (position.y - radius as i32) as i64,
322 );
323 }
324
325 fn render_text(
326 &mut self,
327 text: &str,
328 position: DVec2,
329 anchor: Anchor2D,
330 size: f64,
331 color: Srgba,
332 ) {
333 let position = self.map_dvec2(position);
334 let size = self.map_value(size);
335
336 let (text_width, _) = text_size(size as f32, &self.font, text);
337
338 let x = match anchor.get_horizontal() {
339 HorizontalAnchor::Left => position.x,
340 HorizontalAnchor::Center => position.x - text_width as f64 / 2.0,
341 HorizontalAnchor::Right => position.x - text_width as f64,
342 };
343
344 let vertical_anchor = anchor.get_vertical();
345
346 let y = match (vertical_anchor.get_context(), vertical_anchor.get_value()) {
347 (VerticalAnchorContext::Graphics, VerticalAnchorValue::Bottom) => {
348 position.y - size / 1.25
349 }
350 (VerticalAnchorContext::Math, VerticalAnchorValue::Bottom) => position.y,
351 (_, VerticalAnchorValue::Center) => position.y - size / 1.25 / 2.0,
352 (VerticalAnchorContext::Graphics, VerticalAnchorValue::Top) => position.y,
353 (VerticalAnchorContext::Math, VerticalAnchorValue::Top) => position.y - size / 1.25,
354 };
355
356 draw_text_mut(
357 &mut self.image,
358 srgba_to_rgba8(color),
359 x as i32,
360 y as i32,
361 size as f32,
362 &self.font,
363 text,
364 );
365 }
366
367 fn render_text_outline(
368 &mut self,
369 text: &str,
370 position: DVec2,
371 anchor: Anchor2D,
372 size: f64,
373 outline_thickness: f64,
374 color: Srgba,
375 outline_color: Srgba,
376 ) {
377 let position = self.map_dvec2(position);
378 let size = self.map_value(size);
379 let outline_thickness = self.map_value(outline_thickness);
380
381 let (text_width, _) = text_size(size as f32, &self.font, text);
382
383 let x = match anchor.get_horizontal() {
384 HorizontalAnchor::Left => position.x,
385 HorizontalAnchor::Center => position.x - text_width as f64 / 2.0,
386 HorizontalAnchor::Right => position.x - text_width as f64,
387 };
388
389 let vertical_anchor = anchor.get_vertical();
390
391 let y = match (vertical_anchor.get_context(), vertical_anchor.get_value()) {
392 (VerticalAnchorContext::Graphics, VerticalAnchorValue::Bottom) => {
393 position.y - size / 1.25
394 }
395 (VerticalAnchorContext::Math, VerticalAnchorValue::Bottom) => position.y,
396 (_, VerticalAnchorValue::Center) => position.y - size / 1.25 / 2.0,
397 (VerticalAnchorContext::Graphics, VerticalAnchorValue::Top) => position.y,
398 (VerticalAnchorContext::Math, VerticalAnchorValue::Top) => position.y - size / 1.25,
399 };
400
401 for i in -1..=1 {
402 for j in -1..=1 {
403 if i != 0 || j != 0 {
404 draw_text_mut(
405 &mut self.image,
406 srgba_to_rgba8(outline_color),
407 (x - i as f64 * outline_thickness).round() as i32,
408 (y - j as f64 * outline_thickness).round() as i32,
409 size as f32,
410 &self.font,
411 text,
412 );
413 }
414 }
415 }
416
417 draw_text_mut(
418 &mut self.image,
419 srgba_to_rgba8(color),
420 x as i32,
421 y as i32,
422 size as f32,
423 &self.font,
424 text,
425 );
426 }
427
428 fn render_rectangle(
429 &mut self,
430 position: DVec2,
431 width: f64,
432 height: f64,
433 offset: DVec2,
434 rotation: f64,
435 color: Srgba,
436 ) {
437 let position = self.map_dvec2(position);
438 let width = self.map_value(width) - 1.0;
439 let height = self.map_value(height) - 1.0;
440
441 let base_points = self.get_base_points(position, width, height);
442 let offset_vec = self.get_offset_vec(width, height, offset);
443 let offset_points = self.get_offset_points(&base_points, offset_vec);
444 let rotated_points = self.get_rotated_points(&offset_points, position, rotation);
445
446 let integer_points = self
447 .get_unique_integer_points(&rotated_points)
448 .iter()
449 .map(|integer_point| Point::new(integer_point.x, integer_point.y))
450 .collect::<Vec<Point<i32>>>();
451
452 if integer_points.len() == 1 {
453 let integer_point = integer_points.first().unwrap();
454
455 self.render_point(dvec2(integer_point.x as f64, integer_point.y as f64), color);
456 } else {
457 draw_polygon_mut(&mut self.image, &integer_points, srgba_to_rgba8(color));
458 }
459 }
460
461 fn render_rectangle_lines(
462 &mut self,
463 position: DVec2,
464 width: f64,
465 height: f64,
466 offset: DVec2,
467 rotation: f64,
468 thickness: f64,
469 color: Srgba,
470 ) {
471 let position = self.map_dvec2(position);
472 let width = self.map_value(width) - 1.0;
473 let height = self.map_value(height) - 1.0;
474 let thickness = self.map_value(thickness);
475
476 let base_points = self.get_base_points(position, width, height);
477 let offset_vec = self.get_offset_vec(width, height, offset);
478 let offset_points = self.get_offset_points(&base_points, offset_vec);
479 let rotated_points = self.get_rotated_points(&offset_points, position, rotation);
480
481 let integer_points = self
482 .get_unique_integer_points(&rotated_points)
483 .iter()
484 .map(|integer_point| Point::new(integer_point.x, integer_point.y))
485 .collect::<Vec<Point<i32>>>();
486
487 let min_x = integer_points
488 .iter()
489 .map(|integer_point| integer_point.x)
490 .min()
491 .unwrap();
492 let max_x = integer_points
493 .iter()
494 .map(|integer_point| integer_point.x)
495 .max()
496 .unwrap();
497
498 let min_y = integer_points
499 .iter()
500 .map(|integer_point| integer_point.y)
501 .min()
502 .unwrap();
503 let max_y = integer_points
504 .iter()
505 .map(|integer_point| integer_point.y)
506 .max()
507 .unwrap();
508
509 let min_vec = ivec2(min_x, min_y).as_dvec2();
510
511 let renderer_width = max_x - min_x + 1;
512 let renderer_height = max_y - min_y + 1;
513
514 let mut rectangle_renderer = ImageRenderer::new(
515 renderer_width as u32,
516 renderer_height as u32,
517 1.0,
518 DVec2::ZERO,
519 1,
520 self.font.clone(),
521 );
522
523 rectangle_renderer.render_rectangle(
524 position - min_vec,
525 width + 1.0,
526 height + 1.0,
527 offset,
528 rotation,
529 color,
530 );
531
532 let midpoint = rotated_points
533 .iter()
534 .copied()
535 .map(|rotated_point| rotated_point - min_vec)
536 .sum::<DVec2>()
537 / 4.0;
538
539 rectangle_renderer.render_rectangle(
540 midpoint,
541 width + 1.0 - 2.0 * thickness,
542 height + 1.0 - 2.0 * thickness,
543 DVec2::splat(0.5),
544 rotation,
545 Srgba::new(0.0, 0.0, 0.0, 0.0),
546 );
547
548 overlay(
549 &mut self.image,
550 &rectangle_renderer.render_image_onto(rectangle_renderer.transparent()),
551 min_x as i64,
552 min_y as i64,
553 );
554 }
555
556 fn render_equilateral_triangle(
557 &mut self,
558 position: DVec2,
559 radius: f64,
560 rotation: f64,
561 color: Srgba,
562 ) {
563 let position = self.map_dvec2(position);
564 let radius = self.map_value(radius);
565
566 let points = (0..3)
567 .map(|i| position + radius * DVec2::from_angle(i as f64 * 2.0 * PI / 3.0 + rotation))
568 .collect::<Vec<DVec2>>();
569
570 let integer_points = self
571 .get_unique_integer_points(&points)
572 .iter()
573 .map(|integer_point| Point::new(integer_point.x, integer_point.y))
574 .collect::<Vec<Point<i32>>>();
575
576 if integer_points.len() == 1 {
577 let integer_point = integer_points.first().unwrap();
578
579 self.render_point(dvec2(integer_point.x as f64, integer_point.y as f64), color);
580 } else {
581 draw_polygon_mut(&mut self.image, &integer_points, srgba_to_rgba8(color));
582 }
583 }
584
585 fn render_equilateral_triangle_lines(
586 &mut self,
587 position: DVec2,
588 radius: f64,
589 rotation: f64,
590 thickness: f64,
591 color: Srgba,
592 ) {
593 let position = self.map_dvec2(position);
594 let radius = self.map_value(radius);
595 let thickness = self.map_value(thickness);
596
597 let points = (0..3)
598 .map(|i| position + radius * DVec2::from_angle(i as f64 * 2.0 * PI / 3.0 + rotation))
599 .collect::<Vec<DVec2>>();
600
601 let integer_points = self
602 .get_unique_integer_points(&points)
603 .iter()
604 .map(|integer_point| Point::new(integer_point.x, integer_point.y))
605 .collect::<Vec<Point<i32>>>();
606
607 let min_x = integer_points
608 .iter()
609 .map(|integer_point| integer_point.x)
610 .min()
611 .expect("triangles have more than 0 points");
612 let max_x = integer_points
613 .iter()
614 .map(|integer_point| integer_point.x)
615 .max()
616 .expect("triangles have more than 0 points");
617 let min_y = integer_points
618 .iter()
619 .map(|integer_point| integer_point.y)
620 .min()
621 .expect("triangles have more than 0 points");
622 let max_y = integer_points
623 .iter()
624 .map(|integer_point| integer_point.y)
625 .max()
626 .expect("triangles have more than 0 points");
627
628 let min_point = ivec2(min_x, min_y);
629
630 let renderer_width = (max_x - min_x + 1) as u32;
631 let renderer_height = (max_y - min_y + 1) as u32;
632
633 let mut triangle_renderer = ImageRenderer::new(
634 renderer_width,
635 renderer_height,
636 1.0,
637 DVec2::ZERO,
638 1,
639 self.font.clone(),
640 );
641
642 triangle_renderer.render_equilateral_triangle(
643 (position - min_point.as_dvec2()).round(),
644 radius,
645 rotation,
646 color,
647 );
648
649 triangle_renderer.render_equilateral_triangle(
650 (position - min_point.as_dvec2()).round(),
651 radius - thickness,
652 rotation,
653 Srgba::new(0.0, 0.0, 0.0, 0.0),
654 );
655
656 overlay(
657 &mut self.image,
658 &triangle_renderer.render_image_onto(triangle_renderer.transparent()),
659 min_x as i64,
660 min_y as i64,
661 );
662 }
663}
664
665fn rotate_point_around(point: DVec2, axis: DVec2, theta: f64) -> DVec2 {
666 if theta == 0.0 {
667 return point;
668 }
669
670 let relative = point - axis;
671 let relative_theta = relative.to_angle();
672 let new_relative_theta = relative_theta + theta;
673 let new_relative = DVec2::from_angle(new_relative_theta) * relative.length();
674 new_relative + axis
675}