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 = (radius * self.scale * self.supersampling as f64).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 = (radius * self.scale * self.supersampling as f64).round();
234 let thickness = (thickness * self.scale * self.supersampling as f64).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 = (radius * self.scale * self.supersampling as f64).round();
298 let thickness = (thickness * self.scale * self.supersampling as f64).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 = size * self.scale * self.supersampling as f64;
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_rectangle(
368 &mut self,
369 position: DVec2,
370 width: f64,
371 height: f64,
372 offset: DVec2,
373 rotation: f64,
374 color: Srgba,
375 ) {
376 let position = self.map_dvec2(position);
377 let width = self.map_value(width) - 1.0;
378 let height = self.map_value(height) - 1.0;
379
380 let base_points = self.get_base_points(position, width, height);
381 let offset_vec = self.get_offset_vec(width, height, offset);
382 let offset_points = self.get_offset_points(&base_points, offset_vec);
383 let rotated_points = self.get_rotated_points(&offset_points, position, rotation);
384
385 let integer_points = self
386 .get_unique_integer_points(&rotated_points)
387 .iter()
388 .map(|integer_point| Point::new(integer_point.x, integer_point.y))
389 .collect::<Vec<Point<i32>>>();
390
391 if integer_points.len() == 1 {
392 let integer_point = integer_points.first().unwrap();
393
394 self.render_point(dvec2(integer_point.x as f64, integer_point.y as f64), color);
395 } else {
396 draw_polygon_mut(&mut self.image, &integer_points, srgba_to_rgba8(color));
397 }
398 }
399
400 fn render_rectangle_lines(
401 &mut self,
402 position: DVec2,
403 width: f64,
404 height: f64,
405 offset: DVec2,
406 rotation: f64,
407 thickness: f64,
408 color: Srgba,
409 ) {
410 let position = self.map_dvec2(position);
411 let width = self.map_value(width) - 1.0;
412 let height = self.map_value(height) - 1.0;
413 let thickness = self.map_value(thickness);
414
415 let base_points = self.get_base_points(position, width, height);
416 let offset_vec = self.get_offset_vec(width, height, offset);
417 let offset_points = self.get_offset_points(&base_points, offset_vec);
418 let rotated_points = self.get_rotated_points(&offset_points, position, rotation);
419
420 let integer_points = self
421 .get_unique_integer_points(&rotated_points)
422 .iter()
423 .map(|integer_point| Point::new(integer_point.x, integer_point.y))
424 .collect::<Vec<Point<i32>>>();
425
426 let min_x = integer_points
427 .iter()
428 .map(|integer_point| integer_point.x)
429 .min()
430 .unwrap();
431 let max_x = integer_points
432 .iter()
433 .map(|integer_point| integer_point.x)
434 .max()
435 .unwrap();
436
437 let min_y = integer_points
438 .iter()
439 .map(|integer_point| integer_point.y)
440 .min()
441 .unwrap();
442 let max_y = integer_points
443 .iter()
444 .map(|integer_point| integer_point.y)
445 .max()
446 .unwrap();
447
448 let min_vec = ivec2(min_x, min_y).as_dvec2();
449
450 let renderer_width = max_x - min_x + 1;
451 let renderer_height = max_y - min_y + 1;
452
453 let mut rectangle_renderer = ImageRenderer::new(
454 renderer_width as u32,
455 renderer_height as u32,
456 1.0,
457 DVec2::ZERO,
458 1,
459 self.font.clone(),
460 );
461
462 rectangle_renderer.render_rectangle(
463 position - min_vec,
464 width + 1.0,
465 height + 1.0,
466 offset,
467 rotation,
468 color,
469 );
470
471 let midpoint = rotated_points
472 .iter()
473 .copied()
474 .map(|rotated_point| rotated_point - min_vec)
475 .sum::<DVec2>()
476 / 4.0;
477
478 rectangle_renderer.render_rectangle(
479 midpoint,
480 width + 1.0 - 2.0 * thickness,
481 height + 1.0 - 2.0 * thickness,
482 DVec2::splat(0.5),
483 rotation,
484 Srgba::new(0.0, 0.0, 0.0, 0.0),
485 );
486
487 overlay(
488 &mut self.image,
489 &rectangle_renderer.render_image_onto(rectangle_renderer.transparent()),
490 min_x as i64,
491 min_y as i64,
492 );
493 }
494
495 fn render_equilateral_triangle(
496 &mut self,
497 position: DVec2,
498 radius: f64,
499 rotation: f64,
500 color: Srgba,
501 ) {
502 let position = self.map_dvec2(position);
503 let radius = self.map_value(radius);
504
505 let points = (0..3)
506 .map(|i| position + radius * DVec2::from_angle(i as f64 * 2.0 * PI / 3.0 + rotation))
507 .collect::<Vec<DVec2>>();
508
509 let integer_points = self
510 .get_unique_integer_points(&points)
511 .iter()
512 .map(|integer_point| Point::new(integer_point.x, integer_point.y))
513 .collect::<Vec<Point<i32>>>();
514
515 if integer_points.len() == 1 {
516 let integer_point = integer_points.first().unwrap();
517
518 self.render_point(dvec2(integer_point.x as f64, integer_point.y as f64), color);
519 } else {
520 draw_polygon_mut(&mut self.image, &integer_points, srgba_to_rgba8(color));
521 }
522 }
523
524 fn render_equilateral_triangle_lines(
525 &mut self,
526 position: DVec2,
527 radius: f64,
528 rotation: f64,
529 thickness: f64,
530 color: Srgba,
531 ) {
532 let position = self.map_dvec2(position);
533 let radius = self.map_value(radius);
534 let thickness = self.map_value(thickness);
535
536 let points = (0..3)
537 .map(|i| position + radius * DVec2::from_angle(i as f64 * 2.0 * PI / 3.0 + rotation))
538 .collect::<Vec<DVec2>>();
539
540 let integer_points = self
541 .get_unique_integer_points(&points)
542 .iter()
543 .map(|integer_point| Point::new(integer_point.x, integer_point.y))
544 .collect::<Vec<Point<i32>>>();
545
546 let min_x = integer_points
547 .iter()
548 .map(|integer_point| integer_point.x)
549 .min()
550 .expect("triangles have more than 0 points");
551 let max_x = integer_points
552 .iter()
553 .map(|integer_point| integer_point.x)
554 .max()
555 .expect("triangles have more than 0 points");
556 let min_y = integer_points
557 .iter()
558 .map(|integer_point| integer_point.y)
559 .min()
560 .expect("triangles have more than 0 points");
561 let max_y = integer_points
562 .iter()
563 .map(|integer_point| integer_point.y)
564 .max()
565 .expect("triangles have more than 0 points");
566
567 let min_point = ivec2(min_x, min_y);
568
569 let renderer_width = (max_x - min_x + 1) as u32;
570 let renderer_height = (max_y - min_y + 1) as u32;
571
572 let mut triangle_renderer = ImageRenderer::new(
573 renderer_width,
574 renderer_height,
575 1.0,
576 DVec2::ZERO,
577 1,
578 self.font.clone(),
579 );
580
581 triangle_renderer.render_equilateral_triangle(
582 (position - min_point.as_dvec2()).round(),
583 radius,
584 rotation,
585 color,
586 );
587
588 triangle_renderer.render_equilateral_triangle(
589 (position - min_point.as_dvec2()).round(),
590 radius - thickness,
591 rotation,
592 Srgba::new(0.0, 0.0, 0.0, 0.0),
593 );
594
595 overlay(
596 &mut self.image,
597 &triangle_renderer.render_image_onto(triangle_renderer.transparent()),
598 min_x as i64,
599 min_y as i64,
600 );
601 }
602}
603
604fn rotate_point_around(point: DVec2, axis: DVec2, theta: f64) -> DVec2 {
605 if theta == 0.0 {
606 return point;
607 }
608
609 let relative = point - axis;
610 let relative_theta = relative.to_angle();
611 let new_relative_theta = relative_theta + theta;
612 let new_relative = DVec2::from_angle(new_relative_theta) * relative.length();
613 new_relative + axis
614}