ggplot_rs/render/

plotters_backend.rs

use std::collections::HashSet;
use std::sync::{Mutex, OnceLock};

use plotters::prelude::*;
use plotters::style::FontStyle;

use super::backend::{
    DrawBackend, LineStyle, PointShape, PointStyle, RectStyle, TextAnchor, TextStyle,
};
use super::{Rect, RenderError};

/// A font bundled into the binary so text renders in a headless container with
/// no system fonts / fontconfig. DejaVu Sans (Bitstream Vera–derived license,
/// freely redistributable) — broad glyph coverage keeps labels tofu-free.
const SANS: &[u8] = include_bytes!("../../assets/fonts/DejaVuSans.ttf");
const SANS_BOLD: &[u8] = include_bytes!("../../assets/fonts/DejaVuSans-Bold.ttf");
const SANS_OBLIQUE: &[u8] = include_bytes!("../../assets/fonts/DejaVuSans-Oblique.ttf");
const SERIF: &[u8] = include_bytes!("../../assets/fonts/DejaVuSerif.ttf");
const SERIF_BOLD: &[u8] = include_bytes!("../../assets/fonts/DejaVuSerif-Bold.ttf");
const SERIF_ITALIC: &[u8] = include_bytes!("../../assets/fonts/DejaVuSerif-Italic.ttf");
const MONO: &[u8] = include_bytes!("../../assets/fonts/DejaVuSansMono.ttf");
const MONO_BOLD: &[u8] = include_bytes!("../../assets/fonts/DejaVuSansMono-Bold.ttf");

/// Pick the DejaVu face set (per style) that matches a requested family name, so
/// `family = "serif"` / `"monospace"` render with real serif/mono glyphs — not
/// just the SVG attribute — headlessly.
fn faces_for(family: &str) -> [(FontStyle, &'static [u8]); 4] {
    let f = family.to_lowercase();
    if f.contains("mono") || f.contains("courier") {
        [
            (FontStyle::Normal, MONO),
            (FontStyle::Bold, MONO_BOLD),
            (FontStyle::Italic, MONO),
            (FontStyle::Oblique, MONO),
        ]
    } else if f == "serif" || f.contains("times") || (f.contains("serif") && !f.contains("sans")) {
        [
            (FontStyle::Normal, SERIF),
            (FontStyle::Bold, SERIF_BOLD),
            (FontStyle::Italic, SERIF_ITALIC),
            (FontStyle::Oblique, SERIF_ITALIC),
        ]
    } else {
        [
            (FontStyle::Normal, SANS),
            (FontStyle::Bold, SANS_BOLD),
            (FontStyle::Italic, SANS_OBLIQUE),
            (FontStyle::Oblique, SANS_OBLIQUE),
        ]
    }
}

fn registered_families() -> &'static Mutex<HashSet<String>> {
    static REGISTERED: OnceLock<Mutex<HashSet<String>>> = OnceLock::new();
    REGISTERED.get_or_init(|| Mutex::new(HashSet::new()))
}

/// Ensure the bundled font is registered under `family` (idempotent).
///
/// With plotters' `ab_glyph` backend there is no system-font lookup: every
/// family used for layout must be registered first. We map *all* requested
/// families to the one bundled font, so any family name lays out correctly
/// headlessly; SVG output still carries the requested family name for browsers.
fn ensure_font(family: &str) {
    let mut set = registered_families().lock().unwrap();
    if set.insert(family.to_string()) {
        // Register the matching DejaVu family + face per style so serif/mono and
        // bold/italic actually render (not just carry the SVG attribute).
        for (style, bytes) in faces_for(family) {
            // Ignore the result: a malformed font would surface as a draw error.
            let _ = plotters::style::register_font(family, style, bytes);
        }
    }
}

/// Adapter from plotters' DrawingArea to our DrawBackend trait.
pub struct PlottersAdapter<'a, DB: DrawingBackend> {
    area: &'a DrawingArea<DB, plotters::coord::Shift>,
    plot_area: Rect,
    total_area: Rect,
    /// #273: panel-corner boxes claimed so far this render pass — see
    /// [`DrawBackend::corner_claims`]/[`DrawBackend::claim_corner_box`].
    corner_claims: Vec<Rect>,
    /// Clip lines / points / clip-flagged rects to the panel (data marks);
    /// off while legends draw (#410), whose keys sit outside it.
    clip: bool,
    /// The renderer's clip groups ([`DrawBackend::begin_clip`]): a zoomed
    /// panel's rect, which marks are clipped to while it's open (#493).
    clips: Vec<Rect>,
}

impl<'a, DB: DrawingBackend> PlottersAdapter<'a, DB> {
    pub fn new(area: &'a DrawingArea<DB, plotters::coord::Shift>, plot_area: Rect) -> Self {
        let (w, h) = area.dim_in_pixel();
        PlottersAdapter {
            area,
            plot_area,
            total_area: Rect {
                x: 0.0,
                y: 0.0,
                width: w as f64,
                height: h as f64,
            },
            corner_claims: Vec::new(),
            clip: true,
            clips: Vec::new(),
        }
    }
}

fn to_rgba(color: (u8, u8, u8), alpha: f64) -> RGBAColor {
    RGBAColor(color.0, color.1, color.2, alpha)
}

/// Clip a point to the given rectangle bounds. Returns None if fully outside.
fn clip_point(x: f64, y: f64, rect: &Rect) -> (f64, f64) {
    (
        x.clamp(rect.x, rect.x + rect.width),
        y.clamp(rect.y, rect.y + rect.height),
    )
}

/// Check if a point is inside the rectangle (with small margin).
fn point_in_rect(x: f64, y: f64, rect: &Rect) -> bool {
    let margin = 2.0;
    x >= rect.x - margin
        && x <= rect.x + rect.width + margin
        && y >= rect.y - margin
        && y <= rect.y + rect.height + margin
}

/// Sutherland–Hodgman: `points` (a polygon) cut to `rect`.
fn clip_polygon(points: &[(f64, f64)], rect: &Rect) -> Vec<(f64, f64)> {
    let (x0, y0) = (rect.x, rect.y);
    let (x1, y1) = (rect.x + rect.width, rect.y + rect.height);
    // (inside?, intersection with the edge) per side
    type Side = (fn(&(f64, f64), f64) -> bool, bool, f64);
    let sides: [Side; 4] = [
        (|p, v| p.0 >= v, true, x0),
        (|p, v| p.0 <= v, true, x1),
        (|p, v| p.1 >= v, false, y0),
        (|p, v| p.1 <= v, false, y1),
    ];
    let mut out: Vec<(f64, f64)> = points.to_vec();
    for (inside, vertical, v) in sides {
        let input = std::mem::take(&mut out);
        let Some(&last) = input.last() else {
            break;
        };
        let cross = |a: (f64, f64), b: (f64, f64)| {
            if vertical {
                let t = (v - a.0) / (b.0 - a.0);
                (v, a.1 + t * (b.1 - a.1))
            } else {
                let t = (v - a.1) / (b.1 - a.1);
                (a.0 + t * (b.0 - a.0), v)
            }
        };
        let mut prev = last;
        for &cur in &input {
            match (inside(&cur, v), inside(&prev, v)) {
                (true, true) => out.push(cur),
                (true, false) => {
                    out.push(cross(prev, cur));
                    out.push(cur);
                }
                (false, true) => out.push(cross(prev, cur)),
                (false, false) => {}
            }
            prev = cur;
        }
    }
    out
}

/// Cohen-Sutherland line clipping. Returns clipped line segment or None if fully outside.
fn clip_line_segment(
    mut x0: f64,
    mut y0: f64,
    mut x1: f64,
    mut y1: f64,
    rect: &Rect,
) -> Option<((f64, f64), (f64, f64))> {
    let xmin = rect.x;
    let xmax = rect.x + rect.width;
    let ymin = rect.y;
    let ymax = rect.y + rect.height;

    const INSIDE: u8 = 0;
    const LEFT: u8 = 1;
    const RIGHT: u8 = 2;
    const BOTTOM: u8 = 4;
    const TOP: u8 = 8;

    let outcode = |x: f64, y: f64| -> u8 {
        let mut code = INSIDE;
        if x < xmin {
            code |= LEFT;
        } else if x > xmax {
            code |= RIGHT;
        }
        if y < ymin {
            code |= TOP;
        } else if y > ymax {
            code |= BOTTOM;
        }
        code
    };

    let mut code0 = outcode(x0, y0);
    let mut code1 = outcode(x1, y1);

    for _ in 0..20 {
        if (code0 | code1) == 0 {
            return Some(((x0, y0), (x1, y1)));
        }
        if (code0 & code1) != 0 {
            return None;
        }

        let code_out = if code0 != 0 { code0 } else { code1 };
        let (x, y);

        if code_out & TOP != 0 {
            x = x0 + (x1 - x0) * (ymin - y0) / (y1 - y0);
            y = ymin;
        } else if code_out & BOTTOM != 0 {
            x = x0 + (x1 - x0) * (ymax - y0) / (y1 - y0);
            y = ymax;
        } else if code_out & RIGHT != 0 {
            y = y0 + (y1 - y0) * (xmax - x0) / (x1 - x0);
            x = xmax;
        } else {
            y = y0 + (y1 - y0) * (xmin - x0) / (x1 - x0);
            x = xmin;
        }

        if code_out == code0 {
            x0 = x;
            y0 = y;
            code0 = outcode(x0, y0);
        } else {
            x1 = x;
            y1 = y;
            code1 = outcode(x1, y1);
        }
    }

    None
}

fn map_err<E: std::fmt::Debug>(e: E) -> RenderError {
    RenderError::BackendError(format!("{:?}", e))
}

/// Segment a polyline according to a dash pattern, returning visible sub-paths.
fn segment_dashed(points: &[(f64, f64)], pattern: &[(f64, f64)]) -> Vec<Vec<(f64, f64)>> {
    if pattern.is_empty() || points.len() < 2 {
        return vec![points.to_vec()];
    }

    let mut segments: Vec<Vec<(f64, f64)>> = Vec::new();
    let mut current_seg: Vec<(f64, f64)> = Vec::new();
    let mut drawing = true;
    let mut pat_idx = 0;
    let mut remaining_in_pat = pattern[0].0; // start with draw phase

    for window in points.windows(2) {
        let (x0, y0) = window[0];
        let (x1, y1) = window[1];
        let dx = x1 - x0;
        let dy = y1 - y0;
        let seg_len = (dx * dx + dy * dy).sqrt();
        if seg_len < 0.001 {
            continue;
        }
        let ux = dx / seg_len;
        let uy = dy / seg_len;
        let mut consumed = 0.0;

        while consumed < seg_len - 0.001 {
            let available = seg_len - consumed;
            let step = remaining_in_pat.min(available);
            let px = x0 + ux * (consumed + step);
            let py = y0 + uy * (consumed + step);

            if drawing {
                if current_seg.is_empty() {
                    current_seg.push((x0 + ux * consumed, y0 + uy * consumed));
                }
                current_seg.push((px, py));
            }

            consumed += step;
            remaining_in_pat -= step;

            if remaining_in_pat < 0.001 {
                if drawing {
                    if current_seg.len() >= 2 {
                        segments.push(std::mem::take(&mut current_seg));
                    } else {
                        current_seg.clear();
                    }
                    drawing = false;
                    remaining_in_pat = pattern[pat_idx].1; // gap
                } else {
                    drawing = true;
                    pat_idx = (pat_idx + 1) % pattern.len();
                    remaining_in_pat = pattern[pat_idx].0; // draw
                }
            }
        }
    }

    if drawing && current_seg.len() >= 2 {
        segments.push(current_seg);
    }

    segments
}

impl<DB: DrawingBackend> PlottersAdapter<'_, DB> {
    /// The rect marks are clipped to: the panel, or the canvas when off.
    fn clip_area(&self) -> Rect {
        match (self.clip, self.clips.last()) {
            (true, Some(r)) => r.clone(),
            (true, None) => self.plot_area.clone(),
            (false, _) => self.total_area.clone(),
        }
    }

    /// The open clip group's rect, while clipping is on.
    fn clip_group(&self) -> Option<Rect> {
        self.clip.then(|| self.clips.last().cloned()).flatten()
    }
}

impl<'a, DB: DrawingBackend> DrawBackend for PlottersAdapter<'a, DB> {
    fn set_clipping(&mut self, on: bool) {
        self.clip = on;
    }

    fn begin_clip(&mut self, rect: &Rect) {
        self.clips.push(rect.clone());
    }

    fn end_clip(&mut self) {
        self.clips.pop();
    }

    fn draw_circle(
        &mut self,
        center: (f64, f64),
        radius: f64,
        style: &PointStyle,
    ) -> Result<(), RenderError> {
        // Clip: skip points entirely outside the plot area
        if !point_in_rect(center.0, center.1, &self.clip_area()) {
            return Ok(());
        }
        let color = to_rgba(style.color, style.alpha);
        if style.filled {
            self.area
                .draw(&Circle::new(
                    (center.0 as i32, center.1 as i32),
                    radius as i32,
                    color.filled(),
                ))
                .map_err(map_err)?;
        } else {
            self.area
                .draw(&Circle::new(
                    (center.0 as i32, center.1 as i32),
                    radius as i32,
                    color.stroke_width(1),
                ))
                .map_err(map_err)?;
        }
        Ok(())
    }

    fn draw_line(&mut self, points: &[(f64, f64)], style: &LineStyle) -> Result<(), RenderError> {
        if points.len() < 2 {
            return Ok(());
        }
        // Simulate sub-pixel line widths: render as 1px with reduced opacity
        let (pixel_width, alpha) = if style.width >= 1.0 {
            (style.width as u32, style.alpha)
        } else if style.width > 0.0 {
            (1, style.alpha * style.width)
        } else {
            (0, style.alpha)
        };
        let color = to_rgba(style.color, alpha);
        let stroke = color.stroke_width(pixel_width);

        let pattern = style.linetype.dash_pattern();
        let sub_paths = segment_dashed(points, &pattern);

        for path in &sub_paths {
            for window in path.windows(2) {
                // Clip each line segment to plot area
                if let Some((p1, p2)) = clip_line_segment(
                    window[0].0,
                    window[0].1,
                    window[1].0,
                    window[1].1,
                    &self.clip_area(),
                ) {
                    self.area
                        .draw(&PathElement::new(
                            vec![(p1.0 as i32, p1.1 as i32), (p2.0 as i32, p2.1 as i32)],
                            stroke,
                        ))
                        .map_err(map_err)?;
                }
            }
        }
        Ok(())
    }

    fn draw_rect(
        &mut self,
        top_left: (f64, f64),
        bottom_right: (f64, f64),
        style: &RectStyle,
    ) -> Result<(), RenderError> {
        let (tl, br) = if style.clip {
            // Clamp rect to plot area (data elements only)
            let area = self.clip_area();
            let clamped_tl = clip_point(top_left.0, top_left.1, &area);
            let clamped_br = clip_point(bottom_right.0, bottom_right.1, &area);

            // Skip if fully collapsed after clamping
            if (clamped_tl.0 - clamped_br.0).abs() < 0.5
                && (clamped_tl.1 - clamped_br.1).abs() < 0.5
            {
                // But don't skip if original rect was already small (it's a real data rect)
                if (top_left.0 - bottom_right.0).abs() > 1.0
                    || (top_left.1 - bottom_right.1).abs() > 1.0
                {
                    return Ok(());
                }
            }

            (
                (clamped_tl.0 as i32, clamped_tl.1 as i32),
                (clamped_br.0 as i32, clamped_br.1 as i32),
            )
        } else {
            // No clipping — backgrounds, strips, legends
            (
                (top_left.0 as i32, top_left.1 as i32),
                (bottom_right.0 as i32, bottom_right.1 as i32),
            )
        };

        if style.corner_radius > 0.0 {
            // plotters has no native rounded-rect primitive: approximate with
            // the same polygon the pixel backend uses. Note this clips the
            // bounding box above, not each rounded corner individually — a
            // rounded rect that straddles the clip edge gets a straight cut.
            let pts = super::backend::rounded_rect_points(
                tl.0 as f64,
                tl.1 as f64,
                br.0 as f64,
                br.1 as f64,
                style.corner_radius,
            );
            let int_pts: Vec<(i32, i32)> =
                pts.iter().map(|(x, y)| (*x as i32, *y as i32)).collect();
            if let Some(fill) = style.fill {
                let fill_color = to_rgba(fill, style.alpha);
                self.area
                    .draw(&Polygon::new(int_pts.clone(), fill_color.filled()))
                    .map_err(map_err)?;
            }
            if let Some(stroke) = style.stroke {
                let stroke_color = to_rgba(stroke, style.alpha);
                let width = if style.stroke_width > 0.0 {
                    (style.stroke_width as u32).max(1)
                } else {
                    0
                };
                let mut loop_pts = int_pts;
                if let Some(first) = loop_pts.first().copied() {
                    loop_pts.push(first);
                }
                self.area
                    .draw(&PathElement::new(
                        loop_pts,
                        stroke_color.stroke_width(width),
                    ))
                    .map_err(map_err)?;
            }
            return Ok(());
        }

        if let Some(fill) = style.fill {
            let fill_color = to_rgba(fill, style.alpha);
            self.area
                .draw(&plotters::prelude::Rectangle::new(
                    [tl, br],
                    fill_color.filled(),
                ))
                .map_err(map_err)?;
        }

        if let Some(stroke) = style.stroke {
            let stroke_color = to_rgba(stroke, style.alpha);
            self.area
                .draw(&plotters::prelude::Rectangle::new(
                    [tl, br],
                    stroke_color.stroke_width(if style.stroke_width > 0.0 {
                        (style.stroke_width as u32).max(1)
                    } else {
                        0
                    }),
                ))
                .map_err(map_err)?;
        }

        Ok(())
    }

    fn draw_text(
        &mut self,
        text: &str,
        pos: (f64, f64),
        style: &TextStyle,
    ) -> Result<(), RenderError> {
        let color = to_rgba(style.color, 1.0);
        let family = style.family.as_deref().unwrap_or("sans-serif");
        ensure_font(family);
        let font_style = match style.face {
            crate::render::backend::FontFace::Plain => FontStyle::Normal,
            crate::render::backend::FontFace::Bold => FontStyle::Bold,
            crate::render::backend::FontFace::Italic => FontStyle::Italic,
        };
        let angle_i = style.angle.round() as i32;

        // #229: a text halo — this backend has no native stroke-text, so
        // approximate the SVG `stroke`/`paint-order="stroke"` outline by
        // drawing the same text at 8 offsets around the radius, in
        // `bg_colour`, before the normal pass. `bg_colour: None` (the
        // default) skips this entirely, so existing output is unchanged.
        if let Some(bg) = style.bg_colour {
            let r = if style.bg_r.is_finite() {
                style.bg_r
            } else {
                0.0
            };
            if r > 0.0 {
                let halo_color = to_rgba(bg, 1.0);
                for i in 0..8 {
                    let theta = i as f64 * std::f64::consts::FRAC_PI_4;
                    let offset = (pos.0 + r * theta.cos(), pos.1 + r * theta.sin());
                    self.draw_text_pass(
                        text,
                        offset,
                        style.anchor.clone(),
                        family,
                        style.size,
                        font_style,
                        angle_i,
                        halo_color,
                    )?;
                }
            }
        }

        self.draw_text_pass(
            text,
            pos,
            style.anchor.clone(),
            family,
            style.size,
            font_style,
            angle_i,
            color,
        )?;
        Ok(())
    }

    fn draw_polygon(
        &mut self,
        points: &[(f64, f64)],
        style: &RectStyle,
    ) -> Result<(), RenderError> {
        if points.len() < 3 {
            return Ok(());
        }
        // #493: inside a clip group (a zoomed panel), the fill is cut to the
        // panel and the outline drawn as clipped segments, so the cut adds
        // no edge of its own.
        if let Some(rect) = self.clip_group() {
            let clipped = clip_polygon(points, &rect);
            if let (Some(fill), true) = (style.fill, clipped.len() >= 3) {
                let pts: Vec<(i32, i32)> = clipped
                    .iter()
                    .map(|(x, y)| (*x as i32, *y as i32))
                    .collect();
                self.area
                    .draw(&Polygon::new(pts, to_rgba(fill, style.alpha).filled()))
                    .map_err(map_err)?;
            }
            if let (Some(stroke), true) = (style.stroke, style.stroke_width > 0.0) {
                let width = (style.stroke_width as u32).max(1);
                let n = points.len();
                for i in 0..n {
                    let (a, b) = (points[i], points[(i + 1) % n]);
                    if let Some((p, q)) = clip_line_segment(a.0, a.1, b.0, b.1, &rect) {
                        self.area
                            .draw(&PathElement::new(
                                vec![(p.0 as i32, p.1 as i32), (q.0 as i32, q.1 as i32)],
                                to_rgba(stroke, style.alpha).stroke_width(width),
                            ))
                            .map_err(map_err)?;
                    }
                }
            }
            return Ok(());
        }
        let int_points: Vec<(i32, i32)> =
            points.iter().map(|(x, y)| (*x as i32, *y as i32)).collect();

        if let Some(fill) = style.fill {
            let fill_color = to_rgba(fill, style.alpha);
            self.area
                .draw(&Polygon::new(int_points.clone(), fill_color.filled()))
                .map_err(map_err)?;
        }
        // Outline, as the native SVG backend draws it (it was never stroked
        // here, so violins / polygons / notched boxes lost their border in
        // PNG output).
        if let (Some(stroke), true) = (style.stroke, style.stroke_width > 0.0) {
            let mut pts = int_points;
            pts.push(pts[0]);
            let width = (style.stroke_width as u32).max(1);
            self.area
                .draw(&PathElement::new(
                    pts,
                    to_rgba(stroke, style.alpha).stroke_width(width),
                ))
                .map_err(map_err)?;
        }

        Ok(())
    }

    /// Even-odd fill across every ring at once (`geom_sf`'s polygon holes,
    /// #178) — plotters' own `Polygon` element has no hole support, so the
    /// fill is a per-pixel scanline (as the `canvas` backend's own
    /// `fill_polygon_rings` does), then each ring is stroked the same way
    /// (plotters' [`PathElement`], one closed path per ring).
    fn draw_polygon_rings(
        &mut self,
        rings: &[Vec<(f64, f64)>],
        style: &RectStyle,
    ) -> Result<(), RenderError> {
        if let Some(fill) = style.fill {
            let color = to_rgba(fill, style.alpha);
            let (mut y0, mut y1) = (f64::INFINITY, f64::NEG_INFINITY);
            for ring in rings {
                if ring.len() < 3 {
                    continue;
                }
                for p in ring {
                    y0 = y0.min(p.1);
                    y1 = y1.max(p.1);
                }
            }
            if y0.is_finite() && y1.is_finite() {
                let (y0, y1) = (y0.floor() as i32, y1.ceil() as i32);
                for y in y0..=y1 {
                    let yc = y as f64 + 0.5;
                    let mut xs: Vec<f64> = Vec::new();
                    for ring in rings {
                        let n = ring.len();
                        if n < 3 {
                            continue;
                        }
                        for i in 0..n {
                            let (ax, ay) = ring[i];
                            let (bx, by) = ring[(i + 1) % n];
                            if (ay <= yc && by > yc) || (by <= yc && ay > yc) {
                                xs.push(ax + (yc - ay) / (by - ay) * (bx - ax));
                            }
                        }
                    }
                    xs.sort_by(|p, q| p.total_cmp(q));
                    for span in xs.chunks(2) {
                        if let [xa, xb] = span {
                            for x in xa.round() as i32..=xb.round() as i32 {
                                self.area.draw_pixel((x, y), &color).map_err(map_err)?;
                            }
                        }
                    }
                }
            }
        }
        if let Some(stroke) = style.stroke {
            let stroke_color = to_rgba(stroke, style.alpha);
            let width = if style.stroke_width > 0.0 {
                (style.stroke_width as u32).max(1)
            } else {
                0
            };
            if width > 0 {
                for ring in rings {
                    if ring.len() < 3 {
                        continue;
                    }
                    let mut pts: Vec<(i32, i32)> =
                        ring.iter().map(|(x, y)| (*x as i32, *y as i32)).collect();
                    pts.push(pts[0]);
                    self.area
                        .draw(&PathElement::new(pts, stroke_color.stroke_width(width)))
                        .map_err(map_err)?;
                }
            }
        }
        Ok(())
    }

    fn draw_shape(
        &mut self,
        center: (f64, f64),
        radius: f64,
        style: &PointStyle,
    ) -> Result<(), RenderError> {
        // Clip: skip shapes entirely outside the plot area
        if !point_in_rect(center.0, center.1, &self.clip_area()) {
            return Ok(());
        }
        let color = to_rgba(style.color, style.alpha);
        let (cx, cy) = (center.0 as i32, center.1 as i32);
        let r = radius as i32;

        match style.shape {
            PointShape::Circle => self.draw_circle(center, radius, style),
            PointShape::Square => {
                let tl = (cx - r, cy - r);
                let br = (cx + r, cy + r);
                if style.filled {
                    self.area
                        .draw(&plotters::prelude::Rectangle::new([tl, br], color.filled()))
                        .map_err(map_err)?;
                } else {
                    self.area
                        .draw(&plotters::prelude::Rectangle::new(
                            [tl, br],
                            color.stroke_width(1),
                        ))
                        .map_err(map_err)?;
                }
                Ok(())
            }
            PointShape::Triangle => {
                let pts = vec![(cx, cy - r), (cx - r, cy + r), (cx + r, cy + r)];
                if style.filled {
                    self.area
                        .draw(&Polygon::new(pts, color.filled()))
                        .map_err(map_err)?;
                } else {
                    let outline = vec![
                        (cx, cy - r),
                        (cx - r, cy + r),
                        (cx + r, cy + r),
                        (cx, cy - r),
                    ];
                    self.area
                        .draw(&PathElement::new(outline, color.stroke_width(1)))
                        .map_err(map_err)?;
                }
                Ok(())
            }
            PointShape::Diamond => {
                let pts = vec![(cx, cy - r), (cx + r, cy), (cx, cy + r), (cx - r, cy)];
                if style.filled {
                    self.area
                        .draw(&Polygon::new(pts, color.filled()))
                        .map_err(map_err)?;
                } else {
                    let outline = vec![
                        (cx, cy - r),
                        (cx + r, cy),
                        (cx, cy + r),
                        (cx - r, cy),
                        (cx, cy - r),
                    ];
                    self.area
                        .draw(&PathElement::new(outline, color.stroke_width(1)))
                        .map_err(map_err)?;
                }
                Ok(())
            }
            PointShape::Cross => {
                // X shape
                self.area
                    .draw(&PathElement::new(
                        vec![(cx - r, cy - r), (cx + r, cy + r)],
                        color.stroke_width(1),
                    ))
                    .map_err(map_err)?;
                self.area
                    .draw(&PathElement::new(
                        vec![(cx - r, cy + r), (cx + r, cy - r)],
                        color.stroke_width(1),
                    ))
                    .map_err(map_err)?;
                Ok(())
            }
            PointShape::Plus => {
                // + shape
                self.area
                    .draw(&PathElement::new(
                        vec![(cx - r, cy), (cx + r, cy)],
                        color.stroke_width(1),
                    ))
                    .map_err(map_err)?;
                self.area
                    .draw(&PathElement::new(
                        vec![(cx, cy - r), (cx, cy + r)],
                        color.stroke_width(1),
                    ))
                    .map_err(map_err)?;
                Ok(())
            }
        }
    }

    /// #325: the visible part, scaled, as one bitmap element (an `<image>`
    /// in plotters' SVG output). Opaque: plotters bitmaps carry no alpha.
    fn draw_image(
        &mut self,
        bytes: &[u8],
        rect: &Rect,
        clip: &Rect,
        _alpha: f64,
    ) -> Result<(), RenderError> {
        let (w, h) = self.area.dim_in_pixel();
        let Some((pos, img)) = crate::render::raster::decode_visible(bytes, rect, clip, w, h)
        else {
            return Ok(());
        };
        let rgb = image::DynamicImage::ImageRgba8(img).to_rgb8();
        let element: plotters::element::BitMapElement<(i32, i32)> =
            (pos, image::DynamicImage::ImageRgb8(rgb)).into();
        self.area.draw(&element).map_err(map_err)?;
        Ok(())
    }

    fn plot_area(&self) -> Rect {
        self.plot_area.clone()
    }

    fn total_area(&self) -> Rect {
        self.total_area.clone()
    }

    fn corner_claims(&self) -> Vec<Rect> {
        self.corner_claims.clone()
    }
    fn claim_corner_box(&mut self, rect: Rect) {
        self.corner_claims.push(rect);
    }
    fn clear_corner_claims(&mut self) {
        self.corner_claims.clear();
    }
}

impl<'a, DB: DrawingBackend> PlottersAdapter<'a, DB> {
    /// One pass of `text` in `color` at `pos` — factored out of
    /// `draw_text` so #229's halo can run it several times (once per
    /// offset, in `bg_colour`) before the normal pass.
    ///
    /// (Kept in its own inherent `impl` block: a trait `impl` can't be
    /// split across two blocks, so this can't live inside
    /// `impl DrawBackend for PlottersAdapter` alongside the trait's own
    /// methods.)
    #[allow(clippy::too_many_arguments)]
    fn draw_text_pass(
        &mut self,
        text: &str,
        pos: (f64, f64),
        anchor: TextAnchor,
        family: &str,
        size: f64,
        font_style: FontStyle,
        angle_i: i32,
        color: RGBAColor,
    ) -> Result<(), RenderError> {
        let font = (family, size).into_font().style(font_style);

        let pos_adj = match anchor {
            TextAnchor::Start => plotters::style::text_anchor::Pos::new(
                plotters::style::text_anchor::HPos::Left,
                plotters::style::text_anchor::VPos::Center,
            ),
            TextAnchor::Middle => plotters::style::text_anchor::Pos::new(
                plotters::style::text_anchor::HPos::Center,
                plotters::style::text_anchor::VPos::Center,
            ),
            TextAnchor::End => plotters::style::text_anchor::Pos::new(
                plotters::style::text_anchor::HPos::Right,
                plotters::style::text_anchor::VPos::Center,
            ),
        };

        if angle_i != 0 {
            let (font_transform, rotated_pos) = match angle_i.rem_euclid(360) {
                80..=100 => (
                    FontTransform::Rotate90,
                    plotters::style::text_anchor::Pos::new(
                        plotters::style::text_anchor::HPos::Center,
                        plotters::style::text_anchor::VPos::Center,
                    ),
                ),
                170..=190 => (
                    FontTransform::Rotate180,
                    plotters::style::text_anchor::Pos::new(
                        plotters::style::text_anchor::HPos::Center,
                        plotters::style::text_anchor::VPos::Center,
                    ),
                ),
                // 270° or -90° or 45° approximation (common ggplot2 x-axis rotation)
                _ => (
                    FontTransform::Rotate270,
                    plotters::style::text_anchor::Pos::new(
                        plotters::style::text_anchor::HPos::Right,
                        plotters::style::text_anchor::VPos::Center,
                    ),
                ),
            };

            let text_style = plotters::prelude::TextStyle::from((family, size).into_font())
                .color(&color)
                .transform(font_transform)
                .pos(rotated_pos);

            self.area
                .draw_text(text, &text_style, (pos.0 as i32, pos.1 as i32))
                .map_err(map_err)?;
        } else {
            let text_style = plotters::prelude::TextStyle::from(font)
                .color(&color)
                .pos(pos_adj);
            self.area
                .draw_text(text, &text_style, (pos.0 as i32, pos.1 as i32))
                .map_err(map_err)?;
        }

        Ok(())
    }
}

#[cfg(test)]
mod clip_polygon_tests {
    use super::*;

    fn rect() -> Rect {
        Rect {
            x: 0.0,
            y: 0.0,
            width: 10.0,
            height: 10.0,
        }
    }

    /// #493: a polygon reaching past the panel is cut at its edge.
    #[test]
    fn cuts_a_polygon_at_the_rect() {
        let tri = [(2.0, 2.0), (8.0, 2.0), (5.0, -6.0)];
        let out = clip_polygon(&tri, &rect());
        assert!(out.len() >= 3);
        assert!(out
            .iter()
            .all(|&(x, y)| (0.0..=10.0).contains(&x) && (0.0..=10.0).contains(&y)));
        assert!(out.iter().any(|&(_, y)| y == 0.0), "{out:?}");
    }

    #[test]
    fn keeps_an_inside_polygon_and_drops_an_outside_one() {
        let inside = [(1.0, 1.0), (4.0, 1.0), (4.0, 4.0)];
        assert_eq!(clip_polygon(&inside, &rect()), inside.to_vec());
        let outside = [(20.0, 20.0), (30.0, 20.0), (30.0, 30.0)];
        assert!(clip_polygon(&outside, &rect()).is_empty());
    }
}