implementing by-pixel color map for line segment

[DaMilyutin]

Hi all,

I decided to implement lines with some more advanced styles for lines.
By now with no width parameter (1pixel only).

With code on user side looking like this.

    let dashed = |t: f64| match (t as i32) % 13 {
        0..=6 => 1.0,
        9..=10 => 1.0,
        _ => 0.0,
    };

    let solid = |t: f64| 1.;
    use plotters::prelude::full_palette::*;

    let a = width as f64 / 2.0;
    let b = height as f64 / 2.0;

    root.backend_ops(|db| {
        use plotters::prelude::full_palette::*;
        let colors: Vec<BackendColor> = vec![RED, ORANGE, YELLOW, GREEN, CYAN, BLUE, PURPLE, RED]
            .into_iter()
            .map(|c| c.to_backend_color())
            .collect();
        let a = width as f64 / 2.0;
        let b = height as f64 / 2.0;
        let points = (0..=7)
            .map(|i| i as f64 * 2.0 * 2.0 * PI / 7.)
            .map(|t| (t.sin() * a * 0.9 + a, -t.cos() * b * 0.9 + b))
            .map(|p| (p.0 as i32, p.1 as i32));
        backend_line(
            db,
            points,
            &|t| {
                let idx = t.floor() as usize;
                if idx >= colors.len() - 1 {
                    return colors
                        .last()
                        .unwrap_or(&WHITE.to_backend_color())
                        .to_owned();
                }
                let t = t - t.floor();
                primitives::lcomb(1.0 - t, &colors[idx], t, &colors[idx + 1])
            },
            &dashed,
        )
    })
    .unwrap();

A little messy.... And I had to make backend_ops public.

[DaMilyutin]

    root.backend_ops(|db| {
        let a = width as f64 / 2.0;
        let b = height as f64 / 2.0;
        let points = (0..=10000)
            .map(|i| i as f64 * 7.0 * 2.0 * PI / 10000.0)
            .map(|t| (t.sin() * 5.0 * t + a, -t.cos() * 5.0 * t + b))
            .map(|p| (p.0 as i32, p.1 as i32));
        backend_line(
            db,
            points,
            &|t| {
                let t = t / 1000.;
                HSLColor(t - t.floor(), 1., 0.5).to_backend_color()
            },
            &dashed,
        )
    })
    .unwrap();

(and fixed some bug in impl)

[DaMilyutin]

just another color pattern (more nicer as for me) with insane number of points

    root.backend_ops(|db| {
        let a = width as f64 / 2.0;
        let b = height as f64 / 2.0;
        let points = (0..=100000)
            .map(|i| i as f64 * 7.0 * 2.0 * PI / 100000.0)
            .map(|t| (t.sin() * 5.0 * t + a, -t.cos() * 5.0 * t + b))
            .map(|p| (p.0 as i32, p.1 as i32));
        backend_line(
            db,
            points,
            &|t| {
                let t = 7. * t / 100000.;
                HSLColor(t - t.floor(), 1., 0.5).to_backend_color()
            },
            &dashed,
        )
    })
    .unwrap();