use super::rough;
use super::{Rng, SketchKind, SketchOptions};
use crate::fit::{FitOptions, element_bounds, fit_scene};
use crate::geometry::{BezPath, Color, Vec2};
use crate::scene::{
Element, Fill, FillStrokeStyle, NodeKind, Scene, SceneNode, SketchFill, Stroke,
};
pub fn roughen_scene(scene: &mut Scene, opts: &SketchOptions) {
roughen_scene_where(scene, opts, None);
}
pub fn roughen_scene_if(
scene: &mut Scene,
opts: &SketchOptions,
filter: &dyn Fn(&SceneNode) -> bool,
) {
roughen_scene_where(scene, opts, Some(filter));
}
pub fn roughen_scene_fit(scene: &mut Scene, opts: &SketchOptions, margin: f64) {
roughen_scene_fit_where(scene, opts, margin, None);
}
pub fn roughen_scene_fit_if(
scene: &mut Scene,
opts: &SketchOptions,
margin: f64,
filter: &dyn Fn(&SceneNode) -> bool,
) {
roughen_scene_fit_where(scene, opts, margin, Some(filter));
}
fn roughen_scene_fit_where(
scene: &mut Scene,
opts: &SketchOptions,
margin: f64,
filter: Option<&dyn Fn(&SceneNode) -> bool>,
) {
roughen_scene_where(scene, opts, filter);
fit_scene(
scene,
FitOptions::new().with_margin(if margin > 0.0 { margin } else { 0.0 }),
);
}
fn roughen_scene_where(
scene: &mut Scene,
opts: &SketchOptions,
filter: Option<&dyn Fn(&SceneNode) -> bool>,
) {
let mut rng = match opts.seed {
Some(seed) => Rng::new(seed),
None => Rng::from_entropy(),
};
for nodes in scene.root_lists_mut() {
walk(nodes, &mut rng, opts, filter);
}
}
fn walk(
nodes: &mut [SceneNode],
rng: &mut Rng,
opts: &SketchOptions,
filter: Option<&dyn Fn(&SceneNode) -> bool>,
) {
for node in nodes.iter_mut() {
if !node.visible {
continue;
}
if let Some(f) = filter
&& !f(node)
{
continue;
}
if let Some(children) = node.children_mut() {
walk(children, rng, opts, filter);
continue;
}
let Some(element) = node.element() else {
continue;
};
let Some(kind) = SketchKind::of(element) else {
continue;
};
if !opts.kinds.contains(kind) {
continue;
}
if let Some(kind) = sketch_element(element, rng, opts) {
node.kind = kind;
}
}
}
pub fn roughen_element(el: &Element, rng: &mut Rng, opts: &SketchOptions) -> Vec<Element> {
let mut out = Vec::with_capacity(2);
let (fill, outline) = sketch_parts(el, rng, opts);
if let Some(fill) = fill {
out.push(fill);
}
if let Some(outline) = outline {
out.push(outline);
}
out
}
fn sketch_element(el: &Element, rng: &mut Rng, opts: &SketchOptions) -> Option<NodeKind> {
let (fill, outline) = sketch_parts(el, rng, opts);
match (fill, outline) {
(None, None) => None,
(Some(e), None) | (None, Some(e)) => Some(NodeKind::Draw(e)),
(Some(f), Some(o)) => Some(NodeKind::Group(vec![SceneNode::new(f), SceneNode::new(o)])),
}
}
fn sketch_parts(
el: &Element,
rng: &mut Rng,
opts: &SketchOptions,
) -> (Option<Element>, Option<Element>) {
let fill = fill_element(el, opts);
let outline = outline_element(el, fill.is_some(), rng, opts);
(fill, outline)
}
fn fill_element(el: &Element, opts: &SketchOptions) -> Option<Element> {
let style = opts.fill?;
if let Some(min) = opts.min_fill_area
&& let Some(b) = element_bounds(el)
&& b.width() * b.height() < min
{
return None;
}
let color = fill_color(el)?;
let sf = SketchFill::new(color)
.with_style(style)
.with_angle(opts.fill_angle)
.with_gap(floored_gap(el, opts))
.with_fill_weight(opts.fill_weight);
match el {
Element::GradientPath { path, .. } => Some(Element::Path {
path: path.clone(),
style: FillStrokeStyle {
fill: Some(Fill::Sketch(sf)),
stroke: None,
},
closed: true,
}),
_ => {
let mut out = el.clone();
let st = style_mut(&mut out)?;
st.fill = Some(Fill::Sketch(sf));
st.stroke = None;
Some(out)
}
}
}
fn outline_element(
el: &Element,
fill_taken: bool,
rng: &mut Rng,
opts: &SketchOptions,
) -> Option<Element> {
let stroke = match stroke_of(el) {
Some(s) => Some(s),
None if opts.outline_when_unstroked => {
Some(Stroke::new(fill_color(el)?, opts.outline_width))
}
None => None,
}?;
let path = outline_path(el, rng, opts)?;
Some(Element::Path {
path,
style: FillStrokeStyle {
fill: if fill_taken { None } else { original_fill(el) },
stroke: Some(stroke),
},
closed: false,
})
}
fn original_fill(el: &Element) -> Option<Fill> {
match el {
Element::GradientPath { gradient, .. } => Some(Fill::LinearGradient(gradient.clone())),
_ => style_of(el)?.fill.clone(),
}
}
fn outline_path(el: &Element, rng: &mut Rng, opts: &SketchOptions) -> Option<BezPath> {
let mut p = BezPath::new();
match el {
Element::Rect { rect, .. } => {
rough::polyline(rng, &mut p, &rough::rect_points(*rect), true, opts)
}
Element::RoundedRect { rect, radii, .. } => {
let pts = rough::rounded_rect_points(*rect, *radii, opts.curve_step);
rough::polyline(rng, &mut p, &pts, true, opts);
}
Element::Circle { center, radius, .. } => rough::ellipse(
rng,
&mut p,
*center,
Vec2::new(radius.abs(), radius.abs()),
0.0,
opts,
),
Element::Ellipse {
center,
radii,
rotation,
..
} => rough::ellipse(rng, &mut p, *center, *radii, *rotation, opts),
Element::Line { start, end, .. } => {
rough::polyline(rng, &mut p, &[*start, *end], false, opts)
}
Element::Polyline { points, .. } => rough::polyline(rng, &mut p, points, false, opts),
Element::Polygon { points, .. } => rough::polyline(rng, &mut p, points, true, opts),
Element::Arc {
center,
radii,
start_angle,
sweep_angle,
..
} => rough::arc(
rng,
&mut p,
*center,
*radii,
*start_angle,
*sweep_angle,
opts,
),
Element::Pie {
center,
radius,
start_angle,
sweep_angle,
..
} => {
let mut pts = vec![*center];
pts.extend(rough::sample_arc(
*center,
Vec2::new(radius.abs(), radius.abs()),
0.0,
*start_angle,
*sweep_angle,
opts.curve_step,
));
rough::polyline(rng, &mut p, &pts, true, opts);
}
Element::Path { path, closed, .. } => rough::path(rng, &mut p, path, *closed, opts),
Element::GradientPath { path, .. } => rough::path(rng, &mut p, path, true, opts),
_ => return None,
}
(!p.elements().is_empty()).then_some(p)
}
fn style_of(el: &Element) -> Option<&FillStrokeStyle> {
match el {
Element::Rect { style, .. }
| Element::Circle { style, .. }
| Element::Ellipse { style, .. }
| Element::RoundedRect { style, .. }
| Element::Polygon { style, .. }
| Element::Pie { style, .. }
| Element::Path { style, .. } => Some(style),
_ => None,
}
}
fn style_mut(el: &mut Element) -> Option<&mut FillStrokeStyle> {
match el {
Element::Rect { style, .. }
| Element::Circle { style, .. }
| Element::Ellipse { style, .. }
| Element::RoundedRect { style, .. }
| Element::Polygon { style, .. }
| Element::Pie { style, .. }
| Element::Path { style, .. } => Some(style),
_ => None,
}
}
fn stroke_of(el: &Element) -> Option<Stroke> {
match el {
Element::Line { style, .. }
| Element::Polyline { style, .. }
| Element::Arc { style, .. } => Some(style.clone()),
Element::GradientPath { stroke, .. } => stroke.clone(),
_ => style_of(el)?.stroke.clone(),
}
}
fn fill_color(el: &Element) -> Option<Color> {
match el {
Element::GradientPath { gradient, .. } => last_stop(&gradient.stops),
_ => match style_of(el)?.fill.as_ref()? {
Fill::Solid(c) => Some(*c),
Fill::LinearGradient(g) => last_stop(&g.stops),
Fill::RadialGradient(g) => last_stop(&g.stops),
Fill::SweepGradient(g) => last_stop(&g.stops),
Fill::Image(_) | Fill::Sketch(_) => None,
},
}
}
fn floored_gap(el: &Element, opts: &SketchOptions) -> f64 {
let gap = if opts.fill_gap.is_finite() && opts.fill_gap > 0.05 {
opts.fill_gap
} else {
4.0
};
let Some(bbox) = element_bounds(el) else {
return gap;
};
let t = opts.fill_angle.to_radians();
let along = (bbox.width() * t.sin()).abs() + (bbox.height() * t.cos()).abs();
let across = (bbox.width() * t.cos()).abs() + (bbox.height() * t.sin()).abs();
gap.max(along.max(across) / opts.max_fill_strokes.max(1) as f64)
}
fn last_stop(stops: &[crate::scene::GradientStop]) -> Option<Color> {
stops
.iter()
.max_by(|a, b| {
a.offset
.partial_cmp(&b.offset)
.unwrap_or(std::cmp::Ordering::Equal)
})
.map(|s| s.color)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::geometry::{Point, Rect, Vec2};
use crate::scene::{Clip, SketchFillStyle};
use crate::sketch::SketchKinds;
fn colored_rect() -> Element {
Element::rect(
Rect::new(0.0, 0.0, 100.0, 50.0),
FillStrokeStyle {
fill: Some(Fill::Solid(Color::rgb(0x33, 0x66, 0x99))),
stroke: Some(Stroke::new(Color::BLACK, 2.0)),
},
)
}
fn scene_with(nodes: Vec<SceneNode>) -> Scene {
let mut s = Scene::new(400.0, 300.0);
s.nodes = nodes;
s
}
#[test]
fn filled_and_stroked_shape_becomes_fill_plus_outline() {
let els = roughen_element(
&colored_rect(),
&mut Rng::new(1),
&SketchOptions {
fill: Some(SketchFillStyle::Hachure),
..Default::default()
},
);
assert_eq!(els.len(), 2, "填充 + 描边应拆成两个图元");
match &els[0] {
Element::Rect { style, .. } => {
assert!(matches!(style.fill, Some(Fill::Sketch(_))));
assert!(style.stroke.is_none(), "填充层不应再描边");
}
other => panic!("期望保留原几何做填充, got {other:?}"),
}
match &els[1] {
Element::Path { style, closed, .. } => {
assert!(style.fill.is_none());
assert!(style.stroke.is_some());
assert!(!closed, "描边是开放路径");
}
other => panic!("期望抖动后的描边路径, got {other:?}"),
}
}
#[test]
fn fill_only_shape_gets_a_synthesised_outline() {
let el = Element::rect(
Rect::new(0.0, 0.0, 10.0, 10.0),
FillStrokeStyle::fill(Color::rgb(0xff, 0x00, 0x00)),
);
let opts = SketchOptions {
fill: Some(SketchFillStyle::Hachure),
..Default::default()
};
let els = roughen_element(&el, &mut Rng::new(2), &opts);
assert_eq!(els.len(), 2);
if let Element::Path { style, .. } = &els[1] {
assert_eq!(
style.stroke.as_ref().unwrap().color,
Color::rgb(0xff, 0x00, 0x00),
"合成描边应取填充色"
);
} else {
panic!("期望合成描边");
}
let els = roughen_element(
&el,
&mut Rng::new(2),
&SketchOptions {
outline_when_unstroked: false,
..opts
},
);
assert_eq!(els.len(), 1);
}
#[test]
fn fill_is_untouched_when_no_style_is_requested() {
let els = roughen_element(&colored_rect(), &mut Rng::new(3), &SketchOptions::default());
assert_eq!(els.len(), 1, "未开启手绘填充时只输出描边");
match &els[0] {
Element::Path { style, .. } => {
assert_eq!(
style.fill,
Some(Fill::Solid(Color::rgb(0x33, 0x66, 0x99))),
"原填充应保留在描边路径上"
);
assert!(style.stroke.is_some());
}
other => panic!("期望抖动后的 Path, got {other:?}"),
}
}
#[test]
fn small_fills_keep_their_solid_ink() {
let opts = SketchOptions {
fill: Some(SketchFillStyle::Hachure),
min_fill_area: Some(1000.0),
..Default::default()
};
let tiny = Element::polygon(
vec![
Point::new(0.0, 0.0),
Point::new(10.0, 5.0),
Point::new(0.0, 10.0),
],
FillStrokeStyle::fill(Color::rgb(0x33, 0x33, 0x33)),
);
let els = roughen_element(&tiny, &mut Rng::new(6), &opts);
assert_eq!(els.len(), 1, "小填充不拆层");
if let Element::Path { style, .. } = &els[0] {
assert_eq!(
style.fill,
Some(Fill::Solid(Color::rgb(0x33, 0x33, 0x33))),
"实底应被继承"
);
} else {
panic!("期望带实底的抖动路径");
}
let big = Element::rect(
Rect::new(0.0, 0.0, 100.0, 100.0),
FillStrokeStyle::fill(Color::rgb(0x33, 0x66, 0x99)),
);
let els = roughen_element(&big, &mut Rng::new(6), &opts);
assert_eq!(els.len(), 2, "大填充仍应拆层");
assert!(matches!(els[0], Element::Rect { .. }));
}
#[test]
fn zero_min_fill_area_disables_the_guard() {
let opts = SketchOptions {
fill: Some(SketchFillStyle::Hachure),
min_fill_area: Some(0.0),
..Default::default()
};
let tiny = Element::polygon(
vec![
Point::new(0.0, 0.0),
Point::new(10.0, 5.0),
Point::new(0.0, 10.0),
],
FillStrokeStyle::fill(Color::rgb(0x33, 0x33, 0x33)),
);
let els = roughen_element(&tiny, &mut Rng::new(6), &opts);
assert_eq!(els.len(), 2, "关闭保护后小填充也拆层");
}
#[test]
fn text_and_image_are_never_sketched() {
let opts = SketchOptions {
fill: Some(SketchFillStyle::Hachure),
..Default::default()
};
let text = Element::text(
"hi",
Point::new(0.0, 0.0),
crate::text::TextStyle::new(Color::BLACK, 12.0, "sans-serif"),
);
assert!(roughen_element(&text, &mut Rng::new(4), &opts).is_empty());
}
#[test]
fn kinds_select_which_elements_are_sketched() {
let mut scene = scene_with(vec![
SceneNode::new(Element::rect(
Rect::new(0.0, 0.0, 10.0, 10.0),
FillStrokeStyle::stroke(Color::BLACK, 1.0),
)),
SceneNode::new(Element::circle(
Point::new(20.0, 20.0),
5.0,
FillStrokeStyle::stroke(Color::BLACK, 1.0),
)),
]);
roughen_scene(
&mut scene,
&SketchOptions {
seed: Some(1),
kinds: SketchKinds::only(&[SketchKind::Circle]),
..Default::default()
},
);
assert!(
matches!(scene.nodes[0].element(), Some(Element::Rect { .. })),
"矩形被排除"
);
assert!(
matches!(scene.nodes[1].element(), Some(Element::Path { .. })),
"圆被手绘化"
);
}
#[test]
fn predicate_skips_whole_subtrees() {
let child = SceneNode::new(Element::rect(
Rect::new(0.0, 0.0, 10.0, 10.0),
FillStrokeStyle::stroke(Color::BLACK, 1.0),
))
.with_name("keep");
let mut scene = scene_with(vec![SceneNode::group(vec![
child,
SceneNode::new(Element::rect(
Rect::new(0.0, 0.0, 10.0, 10.0),
FillStrokeStyle::stroke(Color::BLACK, 1.0),
))
.with_name("drop"),
])]);
roughen_scene_if(
&mut scene,
&SketchOptions {
seed: Some(1),
..Default::default()
},
&|n| n.name.as_deref() != Some("drop"),
);
let children = scene.nodes[0].children().expect("期望 Group");
assert!(
matches!(children[0].element(), Some(Element::Path { .. })),
"keep 应被手绘化"
);
assert!(
matches!(children[1].element(), Some(Element::Rect { .. })),
"drop 应被跳过"
);
}
#[test]
fn hidden_nodes_are_left_alone() {
let mut scene = scene_with(vec![
SceneNode::new(Element::rect(
Rect::new(0.0, 0.0, 10.0, 10.0),
FillStrokeStyle::stroke(Color::BLACK, 1.0),
))
.with_visible(false),
]);
roughen_scene(
&mut scene,
&SketchOptions {
seed: Some(1),
..Default::default()
},
);
assert!(matches!(
scene.nodes[0].element(),
Some(Element::Rect { .. })
));
}
#[test]
fn layers_are_visited_too() {
let mut scene = scene_with(vec![]);
let mut layer = crate::scene::Layer::new("grid");
layer.push(Element::rect(
Rect::new(0.0, 0.0, 10.0, 10.0),
FillStrokeStyle::stroke(Color::BLACK, 1.0),
));
scene.push_layer(layer);
roughen_scene(
&mut scene,
&SketchOptions {
seed: Some(1),
..Default::default()
},
);
assert!(matches!(
scene.layers[0].nodes[0].element(),
Some(Element::Path { .. })
));
}
#[test]
fn node_attributes_survive_the_pass() {
let mut scene = scene_with(vec![
SceneNode::new(Element::rect(
Rect::new(0.0, 0.0, 10.0, 10.0),
FillStrokeStyle {
fill: Some(Fill::Solid(Color::BLACK)),
stroke: Some(Stroke::new(Color::BLACK, 1.0)),
},
))
.with_transform(crate::geometry::Transform::translate(5.0, 5.0))
.with_opacity(0.5)
.with_name("node")
.with_clip(Clip::rect(Rect::new(0.0, 0.0, 40.0, 40.0))),
]);
roughen_scene(
&mut scene,
&SketchOptions {
seed: Some(1),
fill: Some(SketchFillStyle::Hachure),
..Default::default()
},
);
let n = &scene.nodes[0];
assert!(n.transform.is_some() && n.clip.is_some());
assert_eq!(n.opacity, 0.5);
assert_eq!(n.name.as_deref(), Some("node"));
assert!(n.is_group());
}
#[test]
fn whole_scene_is_deterministic() {
let build = || {
scene_with(vec![
SceneNode::new(Element::rect(
Rect::new(10.0, 10.0, 110.0, 60.0),
FillStrokeStyle {
fill: Some(Fill::Solid(Color::rgb(0xee, 0xee, 0xff))),
stroke: Some(Stroke::new(Color::BLACK, 1.5)),
},
)),
SceneNode::new(Element::circle(
Point::new(200.0, 40.0),
18.0,
FillStrokeStyle::stroke(Color::BLACK, 1.0),
)),
])
};
let opts = SketchOptions {
seed: Some(2024),
fill: Some(SketchFillStyle::Hachure),
..Default::default()
};
let mut a = build();
let mut b = build();
roughen_scene(&mut a, &opts);
roughen_scene(&mut b, &opts);
assert_eq!(format!("{:?}", a.nodes), format!("{:?}", b.nodes));
}
#[test]
fn different_seeds_produce_different_scenes() {
let build = || {
scene_with(vec![SceneNode::new(Element::rect(
Rect::new(0.0, 0.0, 100.0, 50.0),
FillStrokeStyle::stroke(Color::BLACK, 1.0),
))])
};
let mut a = build();
let mut b = build();
roughen_scene(
&mut a,
&SketchOptions {
seed: Some(1),
..Default::default()
},
);
roughen_scene(
&mut b,
&SketchOptions {
seed: Some(2),
..Default::default()
},
);
assert_ne!(format!("{:?}", a.nodes), format!("{:?}", b.nodes));
}
#[test]
fn roughened_bounds_stay_close_to_the_original() {
let mut scene = scene_with(vec![SceneNode::new(Element::rect(
Rect::new(10.0, 10.0, 110.0, 60.0),
FillStrokeStyle::stroke(Color::BLACK, 2.0),
))]);
let before = crate::fit::scene_bounds(&scene).unwrap();
roughen_scene(
&mut scene,
&SketchOptions {
seed: Some(7),
roughness: 2.0,
..Default::default()
},
);
let after = crate::fit::scene_bounds(&scene).unwrap();
assert!(after.min_x() < before.min_x() && after.max_x() > before.max_x());
assert!(
after.width() - before.width() < 12.0,
"抖动外扩应有界, got {}",
after.width() - before.width()
);
}
#[test]
fn refit_is_idempotent() {
let mut scene = scene_with(vec![SceneNode::new(Element::rect(
Rect::new(0.0, 0.0, 100.0, 50.0),
FillStrokeStyle {
fill: Some(Fill::Solid(Color::BLACK)),
stroke: Some(Stroke::new(Color::BLACK, 3.0)),
},
))]);
let opts = SketchOptions {
seed: Some(11),
roughness: 2.5,
..Default::default()
};
roughen_scene_fit(&mut scene, &opts, 8.0);
let (w, h) = (scene.width, scene.height);
let b1 = crate::fit::scene_bounds(&scene).unwrap();
crate::fit::fit_scene(&mut scene, FitOptions::new().with_margin(8.0));
assert!((scene.width - w).abs() < 1.0 && (scene.height - h).abs() < 1.0);
let b2 = crate::fit::scene_bounds(&scene).unwrap();
assert!((b1.width() - b2.width()).abs() < 1.0);
}
#[test]
fn gradient_degrades_to_its_last_stop() {
let g = crate::scene::LinearGradient::new(
Point::new(0.0, 0.0),
Point::new(10.0, 0.0),
vec![
crate::scene::GradientStop {
offset: 0.0,
color: Color::WHITE,
},
crate::scene::GradientStop {
offset: 1.0,
color: Color::rgb(0x12, 0x34, 0x56),
},
],
);
let el = Element::GradientPath {
path: BezPath::new(),
gradient: g,
stroke: None,
};
let els = roughen_element(
&el,
&mut Rng::new(1),
&SketchOptions {
fill: Some(SketchFillStyle::Hachure),
..Default::default()
},
);
match &els[0] {
Element::Path { style, .. } => match &style.fill {
Some(Fill::Sketch(sf)) => {
assert_eq!(sf.color, Color::rgb(0x12, 0x34, 0x56), "取末端色");
}
other => panic!("期望 Sketch 填充, got {other:?}"),
},
other => panic!("期望 Path, got {other:?}"),
}
}
#[test]
fn already_sketched_fill_is_not_reprocessed() {
let sf = SketchFill::new(Color::BLACK);
let el = Element::rect(
Rect::new(0.0, 0.0, 10.0, 10.0),
FillStrokeStyle {
fill: Some(Fill::Sketch(sf)),
stroke: Some(Stroke::new(Color::BLACK, 1.0)),
},
);
let els = roughen_element(
&el,
&mut Rng::new(1),
&SketchOptions {
fill: Some(SketchFillStyle::Hachure),
..Default::default()
},
);
assert_eq!(els.len(), 1, "只有描边被重画,填充保持原样");
assert!(matches!(els[0], Element::Path { .. }));
}
#[test]
fn ellipse_and_pie_and_arc_are_all_sketchable() {
let opts = SketchOptions {
seed: Some(5),
..Default::default()
};
for el in [
Element::ellipse(
Point::new(10.0, 10.0),
Vec2::new(20.0, 10.0),
0.3,
FillStrokeStyle::stroke(Color::BLACK, 1.0),
),
Element::pie(
Point::new(10.0, 10.0),
20.0,
0.0,
1.0,
FillStrokeStyle::stroke(Color::BLACK, 1.0),
),
Element::arc(
Point::new(10.0, 10.0),
Vec2::new(20.0, 20.0),
0.0,
1.0,
Stroke::new(Color::BLACK, 1.0),
),
Element::poly(
vec![
Point::new(0.0, 0.0),
Point::new(10.0, 5.0),
Point::new(4.0, 12.0),
],
Stroke::new(Color::BLACK, 1.0),
),
] {
let els = roughen_element(&el, &mut Rng::new(5), &opts);
assert_eq!(els.len(), 1, "{el:?} 应被手绘化");
assert!(matches!(els[0], Element::Path { .. }), "{el:?}");
}
}
}