@ -0,0 +1,796 @@
//! More preset outlines: line callouts, arrow callouts, curved and circular arrows, curved
//! ribbons, gears, tabs and chart markers. Like the rest of `preset`, every outline is our own
//! construction, fitted to how the shapes look and to what their adjust values mean.
use super ::* ;
/// Builds the presets this module knows; `None` for any other name.
pub ( super ) fn build ( name : & str , w : f64 , h : f64 , a : & dyn Fn ( usize ) -> f64 ) -> Option < Geometry > {
let ss = w . min ( h ) ;
let full = Rect ::new ( 0.0 , 0.0 , w , h ) ;
let mut b = Pb ::new ( ) ;
let g = match name {
" lineInv " = > {
let l = b . m ( 0.0 , h ) . l ( w , 0.0 ) . take ( ) ;
Geometry { paths : vec ! [ stroke_only ( l ) ] , text_rect : full , handles : vec ! [ ] , sites : vec ! [ Point ::new ( 0.0 , h ) , Point ::new ( w , 0.0 ) ] }
}
" nonIsoscelesTrapezoid " = > {
let max = 50000.0 * w / ss . max ( 1e-9 ) ;
let ( v1 , v2 ) = ( a ( 0 ) . clamp ( 0.0 , max ) , a ( 1 ) . clamp ( 0.0 , max ) ) ;
let ( d1 , d2 ) = ( ss * v1 / 1e5 , ss * v2 / 1e5 ) ;
let mut g = simple ( b . poly ( & [ ( 0.0 , h ) , ( d1 , 0.0 ) , ( w - d2 , 0.0 ) , ( w , h ) ] ) . take ( ) , Rect ::new ( d1 * 0.66 , h * 0.2 , w - d2 * 0.66 , h ) , w , h ) ;
g . handles . push ( Handle ::new ( 0 , Point ::ZERO , Vec2 ::new ( ss / 1e5 , 0.0 ) , v1 , 0.0 , max ) ) ;
g . handles . push ( Handle ::new ( 1 , Point ::new ( w , 0.0 ) , Vec2 ::new ( - ss / 1e5 , 0.0 ) , v2 , 0.0 , max ) ) ;
g
}
" pieWedge " = > {
b . m ( 0.0 , h ) . arc ( w , h , 180.0 , 90.0 ) . l ( w , h ) . z ( ) ;
simple ( b . take ( ) , Rect ::new ( w * 0.29289 , h * 0.29289 , w , h ) , w , h )
}
" flowChartOfflineStorage " = > {
let tri = b . poly ( & [ ( 0.0 , 0.0 ) , ( w , 0.0 ) , ( w / 2.0 , h ) ] ) . take ( ) ;
let bar = Pb ::new ( ) . m ( w * 0.4 , h * 0.8 ) . l ( w * 0.6 , h * 0.8 ) . take ( ) ;
Geometry {
paths : vec ! [ fill ( tri ) , stroke_only ( bar ) ] ,
text_rect : Rect ::new ( w / 4.0 , 0.0 , w * 0.75 , h * 0.8 ) ,
handles : vec ! [ ] ,
sites : vec ! [ Point ::new ( w / 2.0 , 0.0 ) , Point ::new ( w / 4.0 , h / 2.0 ) , Point ::new ( w / 2.0 , h ) , Point ::new ( w * 0.75 , h / 2.0 ) ] ,
}
}
" chartX " | " chartStar " | " chartPlus " = > {
let body = corner_rect ( w , h , [ Corner ::Square ; 4 ] ) ;
let mut l = Pb ::new ( ) ;
if name ! = " chartPlus " {
l . m ( 0.0 , 0.0 ) . l ( w , h ) . m ( 0.0 , h ) . l ( w , 0.0 ) ;
}
if name ! = " chartX " {
l . m ( w / 2.0 , 0.0 ) . l ( w / 2.0 , h ) ;
}
if name = = " chartPlus " {
l . m ( 0.0 , h / 2.0 ) . l ( w , h / 2.0 ) ;
}
Geometry { paths : vec ! [ fill_only ( body ) , stroke_only ( l . take ( ) ) ] , text_rect : full , handles : vec ! [ ] , sites : mid_sites ( w , h ) }
}
" cornerTabs " | " squareTabs " | " plaqueTabs " = > {
// Each tab's size is a twentieth of the diagonal.
let d = ( w . hypot ( h ) / 20.0 ) . min ( w / 2.0 ) . min ( h / 2.0 ) ;
match name {
" cornerTabs " = > {
b . poly ( & [ ( 0.0 , 0.0 ) , ( d , 0.0 ) , ( 0.0 , d ) ] ) ;
b . poly ( & [ ( w - d , 0.0 ) , ( w , 0.0 ) , ( w , d ) ] ) ;
b . poly ( & [ ( w , h - d ) , ( w , h ) , ( w - d , h ) ] ) ;
b . poly ( & [ ( 0.0 , h - d ) , ( d , h ) , ( 0.0 , h ) ] ) ;
}
" squareTabs " = > {
b . poly ( & [ ( 0.0 , 0.0 ) , ( d , 0.0 ) , ( d , d ) , ( 0.0 , d ) ] ) ;
b . poly ( & [ ( w - d , 0.0 ) , ( w , 0.0 ) , ( w , d ) , ( w - d , d ) ] ) ;
b . poly ( & [ ( w - d , h - d ) , ( w , h - d ) , ( w , h ) , ( w - d , h ) ] ) ;
b . poly ( & [ ( 0.0 , h - d ) , ( d , h - d ) , ( d , h ) , ( 0.0 , h ) ] ) ;
}
_ = > {
if d > 0.0 {
b . m ( 0.0 , 0.0 ) . l ( d , 0.0 ) . arc ( d , d , 0.0 , 90.0 ) . z ( ) ;
b . m ( w , 0.0 ) . l ( w , d ) . arc ( d , d , 90.0 , 90.0 ) . z ( ) ;
b . m ( w , h ) . l ( w - d , h ) . arc ( d , d , 180.0 , 90.0 ) . z ( ) ;
b . m ( 0.0 , h ) . l ( 0.0 , h - d ) . arc ( d , d , 270.0 , 90.0 ) . z ( ) ;
} else {
b . m ( 0.0 , 0.0 ) . z ( ) ;
}
}
}
Geometry { paths : vec ! [ fill ( b . take ( ) ) ] , text_rect : full . inset ( - d ) , handles : vec ! [ ] , sites : mid_sites ( w , h ) }
}
" callout1 "
| " callout2 "
| " callout3 "
| " accentCallout1 "
| " accentCallout2 "
| " accentCallout3 "
| " borderCallout2 "
| " borderCallout3 "
| " accentBorderCallout1 "
| " accentBorderCallout2 "
| " accentBorderCallout3 " = > {
let n = match name . chars ( ) . last ( ) {
Some ( '2' ) = > 2 ,
Some ( '3' ) = > 3 ,
_ = > 1 ,
} ;
line_callout ( w , h , a , n + 1 , name . starts_with ( " accent " ) , name . contains ( " order " ) )
}
" leftRightArrowCallout " | " upDownArrowCallout " = > {
let vertical = name = = " upDownArrowCallout " ;
let ( l , t ) = if vertical { ( h , w ) } else { ( w , h ) } ;
let ss = l . min ( t ) ;
let head = ( ss * a ( 1 ) . max ( 0.0 ) / 1e5 ) . min ( t / 2.0 ) ;
let shaft = ( ss * a ( 0 ) . max ( 0.0 ) / 1e5 ) . min ( head * 2.0 ) ;
let hl = ( ss * a ( 2 ) . max ( 0.0 ) / 1e5 ) . min ( l / 2.0 ) ;
let boxl = ( l * a ( 3 ) . max ( 0.0 ) / 1e5 ) . min ( l - 2.0 * hl ) ;
let ( c , b0 , b1 ) = ( t / 2.0 , ( l - boxl ) / 2.0 , ( l + boxl ) / 2.0 ) ;
let pts = [
( 0.0 , c ) ,
( hl , c - head ) ,
( hl , c - shaft / 2.0 ) ,
( b0 , c - shaft / 2.0 ) ,
( b0 , 0.0 ) ,
( b1 , 0.0 ) ,
( b1 , c - shaft / 2.0 ) ,
( l - hl , c - shaft / 2.0 ) ,
( l - hl , c - head ) ,
( l , c ) ,
( l - hl , c + head ) ,
( l - hl , c + shaft / 2.0 ) ,
( b1 , c + shaft / 2.0 ) ,
( b1 , t ) ,
( b0 , t ) ,
( b0 , c + shaft / 2.0 ) ,
( hl , c + shaft / 2.0 ) ,
( hl , c + head ) ,
] ;
let d = if vertical { Dir ::Down } else { Dir ::Right } ;
let pts = orient ( d , w , h , & pts ) ;
let tr = orient ( d , w , h , & [ ( b0 , 0.0 ) , ( b1 , t ) ] ) ;
simple ( b . poly ( & pts ) . take ( ) , Rect ::from_points ( Point ::new ( tr [ 0 ] . 0 , tr [ 0 ] . 1 ) , Point ::new ( tr [ 1 ] . 0 , tr [ 1 ] . 1 ) ) . abs ( ) , w , h )
}
" quadArrowCallout " = > {
let head = ( ss * a ( 1 ) . max ( 0.0 ) / 1e5 ) . min ( ss / 2.0 ) ;
let shaft = ( ss * a ( 0 ) . max ( 0.0 ) / 1e5 ) . min ( head * 2.0 ) ;
let hl = ( ss * a ( 2 ) . max ( 0.0 ) / 1e5 ) . min ( ss / 2.0 ) ;
let k = a ( 3 ) . clamp ( 0.0 , 100000.0 ) / 1e5 ;
let ( bw , bh ) = ( ( w * k ) . min ( w - 2.0 * hl ) . max ( shaft ) , ( h * k ) . min ( h - 2.0 * hl ) . max ( shaft ) ) ;
let ( cx , cy ) = ( w / 2.0 , h / 2.0 ) ;
let ( bx0 , bx1 , by0 , by1 ) = ( cx - bw / 2.0 , cx + bw / 2.0 , cy - bh / 2.0 , cy + bh / 2.0 ) ;
let ( s2 , hd ) = ( shaft / 2.0 , head ) ;
let pts = [
( 0.0 , cy ) ,
( hl , cy - hd ) ,
( hl , cy - s2 ) ,
( bx0 , cy - s2 ) ,
( bx0 , by0 ) ,
( cx - s2 , by0 ) ,
( cx - s2 , hl ) ,
( cx - hd , hl ) ,
( cx , 0.0 ) ,
( cx + hd , hl ) ,
( cx + s2 , hl ) ,
( cx + s2 , by0 ) ,
( bx1 , by0 ) ,
( bx1 , cy - s2 ) ,
( w - hl , cy - s2 ) ,
( w - hl , cy - hd ) ,
( w , cy ) ,
( w - hl , cy + hd ) ,
( w - hl , cy + s2 ) ,
( bx1 , cy + s2 ) ,
( bx1 , by1 ) ,
( cx + s2 , by1 ) ,
( cx + s2 , h - hl ) ,
( cx + hd , h - hl ) ,
( cx , h ) ,
( cx - hd , h - hl ) ,
( cx - s2 , h - hl ) ,
( cx - s2 , by1 ) ,
( bx0 , by1 ) ,
( bx0 , cy + s2 ) ,
( hl , cy + s2 ) ,
( hl , cy + hd ) ,
] ;
simple ( b . poly ( & pts ) . take ( ) , Rect ::new ( bx0 , by0 , bx1 , by1 ) , w , h )
}
" curvedRightArrow " | " curvedLeftArrow " | " curvedUpArrow " | " curvedDownArrow " = > curved_arrow ( name , w , h , a ( 0 ) , a ( 1 ) , a ( 2 ) ) ,
" swooshArrow " = > swoosh ( w , h , a ( 0 ) , a ( 1 ) ) ,
" ellipseRibbon " | " ellipseRibbon2 " = > ellipse_ribbon ( name = = " ellipseRibbon2 " , w , h , a ( 0 ) , a ( 1 ) , a ( 2 ) ) ,
" leftRightRibbon " = > left_right_ribbon ( w , h , a ( 0 ) , a ( 1 ) , a ( 2 ) ) ,
" gear6 " | " gear9 " = > gear ( if name = = " gear6 " { 6 } else { 9 } , w , h , a ( 0 ) , a ( 1 ) ) ,
" funnel " = > funnel ( w , h ) ,
" circularArrow " | " leftCircularArrow " | " leftRightCircularArrow " = > circular_arrow ( name , w , h , [ a ( 0 ) , a ( 1 ) , a ( 2 ) , a ( 3 ) , a ( 4 ) ] ) ,
_ = > return None ,
} ;
Some ( g )
}
/// An ellipse-centred frame for the circular arrows: the band's middle runs on the ellipse
/// `(rx, ry)`, its edges `th/2` either side.
struct Ring {
c : Point ,
rx : f64 ,
ry : f64 ,
th : f64 ,
hw : f64 ,
}
impl Ring {
/// The point at visual angle `deg` on the ellipse grown by `d`.
fn at ( & self , deg : f64 , d : f64 ) -> Point {
let ( ax , ay ) = ( ( self . rx + d ) . max ( 0.0 ) , ( self . ry + d ) . max ( 0.0 ) ) ;
let t = vis ( deg , ax , ay ) . to_radians ( ) ;
Point ::new ( self . c . x + ax * t . cos ( ) , self . c . y + ay * t . sin ( ) )
}
/// Parametric angle (degrees) of `p` on the ellipse grown by `d`.
fn param ( & self , p : Point , d : f64 ) -> f64 {
let ( ax , ay ) = ( ( self . rx + d ) . max ( 1e-9 ) , ( self . ry + d ) . max ( 1e-9 ) ) ;
( ( p . y - self . c . y ) / ay ) . atan2 ( ( p . x - self . c . x ) / ax ) . to_degrees ( )
}
/// Where the line `b + s·u` meets the ellipse grown by `d`, taking the crossing nearest `b`
/// on the side `sign` (+1 outwards, −
fn cross ( & self , b : Point , u : Vec2 , d : f64 , sign : f64 ) -> Point {
let ( ax , ay ) = ( ( self . rx + d ) . max ( 1e-9 ) , ( self . ry + d ) . max ( 1e-9 ) ) ;
let ( px , py ) = ( ( b . x - self . c . x ) / ax , ( b . y - self . c . y ) / ay ) ;
let ( ux , uy ) = ( u . x / ax , u . y / ay ) ;
let qa = ux * ux + uy * uy ;
let qb = 2.0 * ( px * ux + py * uy ) ;
let qc = px * px + py * py - 1.0 ;
let disc = qb * qb - 4.0 * qa * qc ;
if qa < 1e-18 | | disc < 0.0 {
// The line misses (a long head on a thin ring): the edge then carries on from the
// base centre itself, as the reference does.
return b ;
}
let r = disc . sqrt ( ) ;
let ( s0 , s1 ) = ( ( - qb - r ) / ( 2.0 * qa ) , ( - qb + r ) / ( 2.0 * qa ) ) ;
let s = if sign > 0.0 {
if s0 > = 0.0 { s0 } else { s1 }
} else if s1 < = 0.0 {
s1
} else {
s0
} ;
b + u * s
}
/// An arrow head whose base centre sits on the middle ellipse at `base` degrees and whose tip
/// sits there at `base + sweep`. The base runs along the line from the centre to the tip.
/// Returns (band outer edge, outer wing, tip, inner wing, band inner edge).
fn head ( & self , base : f64 , sweep : f64 ) -> [ Point ; 5 ] {
let b = self . at ( base , 0.0 ) ;
let tip = self . at ( base + sweep , 0.0 ) ;
let d = tip - self . c ;
let u = if d . hypot ( ) > 1e-12 { d / d . hypot ( ) } else { Vec2 ::new ( 1.0 , 0.0 ) } ;
let half = self . th / 2.0 ;
[ self . cross ( b , u , half , 1.0 ) , b + u * self . hw , tip , b - u * self . hw , self . cross ( b , u , - half , - 1.0 ) ]
}
}
/// Sweep (degrees) from `a` to `b` turning one way: positive when `dir > 0`.
fn turn ( a : f64 , b : f64 , dir : f64 ) -> f64 {
if dir > 0.0 { ( b - a ) . rem_euclid ( 360.0 ) } else { - ( a - b ) . rem_euclid ( 360.0 ) }
}
/// The circular arrows: a band along an ellipse with one head (`circularArrow` clockwise,
/// `leftCircularArrow` anticlockwise) or a head at each end (`leftRightCircularArrow`).
/// Adjusts: band thickness, head sweep (degrees), end angle, start angle, head half-width.
fn circular_arrow ( name : & str , w : f64 , h : f64 , a : [ f64 ; 5 ] ) -> Geometry {
let ss = w . min ( h ) ;
if ss < = 0.0 {
return simple ( corner_rect ( w , h , [ Corner ::Square ; 4 ] ) , Rect ::new ( 0.0 , 0.0 , w , h ) , w , h ) ;
}
let a5 = a [ 4 ] . clamp ( 0.0 , 25000.0 ) ;
let hw = ss * a5 / 1e5 ;
let th = ss * a [ 0 ] . clamp ( 0.0 , 2.0 * a5 ) / 1e5 ;
let ring = Ring { c : Point ::new ( w / 2.0 , h / 2.0 ) , rx : ( w / 2.0 - hw ) . max ( th / 2.0 ) , ry : ( h / 2.0 - hw ) . max ( th / 2.0 ) , th , hw } ;
let deg = | v : f64 | ( v / 60000.0 ) % 360.0 ;
let ( sweep , end , start ) = ( deg ( a [ 1 ] ) , deg ( a [ 2 ] ) , deg ( a [ 3 ] ) ) ;
let half = th / 2.0 ;
let mut b = Pb ::new ( ) ;
// Arcs of the ellipse grown by `d`, drawn on from the current point (which is on it except in
// the degenerate case above, where the arc shifts with it like the reference's).
let edge_arc = | b : & mut Pb , from : Point , to : Point , d : f64 , dir : f64 | {
let ( ax , ay ) = ( ( ring . rx + d ) . max ( 0.0 ) , ( ring . ry + d ) . max ( 0.0 ) ) ;
let ( s , e ) = ( ring . param ( from , d ) , ring . param ( to , d ) ) ;
b . arc ( ax , ay , s , turn ( s , e , dir ) ) ;
} ;
let outer_arc = | b : & mut Pb , from : Point , to : Point , dir : f64 | edge_arc ( b , from , to , half , dir ) ;
let inner_arc = | b : & mut Pb , from : Point , to : Point , dir : f64 | edge_arc ( b , from , to , - half , dir ) ;
if name = = " leftRightCircularArrow " {
let hs = ring . head ( start , - sweep ) ;
let he = ring . head ( end , sweep ) ;
b . m ( hs [ 0 ] . x , hs [ 0 ] . y ) ;
outer_arc ( & mut b , hs [ 0 ] , he [ 0 ] , 1.0 ) ;
b . l ( he [ 1 ] . x , he [ 1 ] . y ) . l ( he [ 2 ] . x , he [ 2 ] . y ) . l ( he [ 3 ] . x , he [ 3 ] . y ) . l ( he [ 4 ] . x , he [ 4 ] . y ) ;
inner_arc ( & mut b , he [ 4 ] , hs [ 4 ] , - 1.0 ) ;
b . l ( hs [ 3 ] . x , hs [ 3 ] . y ) . l ( hs [ 2 ] . x , hs [ 2 ] . y ) . l ( hs [ 1 ] . x , hs [ 1 ] . y ) . z ( ) ;
} else {
let dir = if name = = " circularArrow " { 1.0 } else { - 1.0 } ;
let he = ring . head ( end , sweep ) ;
let ( o0 , i0 ) = ( ring . at ( start , half ) , ring . at ( start , - half ) ) ;
b . m ( o0 . x , o0 . y ) ;
outer_arc ( & mut b , o0 , he [ 0 ] , dir ) ;
b . l ( he [ 1 ] . x , he [ 1 ] . y ) . l ( he [ 2 ] . x , he [ 2 ] . y ) . l ( he [ 3 ] . x , he [ 3 ] . y ) . l ( he [ 4 ] . x , he [ 4 ] . y ) ;
inner_arc ( & mut b , he [ 4 ] , i0 , - dir ) ;
b . z ( ) ;
}
simple ( b . take ( ) , Rect ::new ( 0.0 , 0.0 , w , h ) , w , h )
}
/// A funnel: an elliptical rim (with an open mouth) across the top quarter, and straight sides
/// down to a small rounded spout. The side lines leave the rim and meet the spout at fixed
/// angles, fitted to the reference look.
fn funnel ( w : f64 , h : f64 ) -> Geometry {
const RIM : f64 = 173.0 ; // where the left side leaves the rim, degrees on the rim ellipse
const SPOUT : f64 = 163.4 ; // where it meets the spout, degrees on the spout ellipse
let ss = w . min ( h ) ;
let ( cx , rim_y ) = ( w / 2.0 , h / 4.0 ) ;
let ( sx , sy ) = ( w / 8.0 , h / 15.0 ) ;
let spout_y = h - sy ;
let at = | rx : f64 , ry : f64 , cy : f64 , deg : f64 | {
let t = deg . to_radians ( ) ;
Point ::new ( cx + rx * t . cos ( ) , cy + ry * t . sin ( ) )
} ;
let p0 = at ( cx , rim_y , rim_y , RIM ) ;
let p1 = at ( sx , sy , spout_y , 180.0 - SPOUT ) ;
let mut b = Pb ::new ( ) ;
b . m ( p0 . x , p0 . y ) . arc ( cx , rim_y , RIM , 540.0 - 2.0 * RIM ) ;
b . l ( p1 . x , p1 . y ) . arc ( sx , sy , 180.0 - SPOUT , 2.0 * SPOUT - 180.0 ) . z ( ) ;
let d = ss / 20.0 ;
b . ellipse ( cx , rim_y , ( cx - d ) . max ( 0.0 ) , ( rim_y - d ) . max ( 0.0 ) ) ;
Geometry { paths : vec ! [ fill_eo ( b . take ( ) ) ] , text_rect : Rect ::new ( w / 4.0 , h / 2.0 , w * 0.75 , h - sy ) , handles : vec ! [ ] , sites : mid_sites ( w , h ) }
}
/// A gear: an elliptical body with `n` teeth, the first pointing straight up. Each tooth leaves
/// the body at two points an equal angle either side of its centre, and its tip corners sit a
/// tooth height further out along the body's normal and a flank lean further in.
fn gear ( n : usize , w : f64 , h : f64 , a0 : f64 , a1 : f64 ) -> Geometry {
let ss = w . min ( h ) ;
let th = ss * a0 . clamp ( 0.0 , 20000.0 ) / 1e5 ; // tooth height
let lean_max = if n = = 6 { 5380.0 } else { 2730.0 } ;
let l = ss * a1 . clamp ( 0.0 , a0 . clamp ( 0.0 , 20000.0 ) . min ( lean_max ) ) / 1e5 ; // flank lean
let ( cx , cy ) = ( w / 2.0 , h / 2.0 ) ;
let ( rx , ry ) = ( ( cx - th ) . max ( 0.0 ) , ( cy - th ) . max ( 0.0 ) ) ;
let r = ( ss / 2.0 - th ) . max ( 1e-9 ) ;
let half = ( ( th + l ) / 2.0 / r ) . atan ( ) ;
let step = std ::f64 ::consts ::TAU / n as f64 ;
let on_body = | t : f64 | Point ::new ( cx + rx * t . cos ( ) , cy + ry * t . sin ( ) ) ;
let mut b = Pb ::new ( ) ;
for k in 0 .. n {
let t = - std ::f64 ::consts ::FRAC_PI_2 + step * k as f64 ;
// The tooth stands along the body's normal at its centre.
let nrm = Vec2 ::new ( t . cos ( ) * ry , t . sin ( ) * rx ) ;
let u = if nrm . hypot ( ) > 1e-12 { nrm / nrm . hypot ( ) } else { Vec2 ::new ( t . cos ( ) , t . sin ( ) ) } ;
let v = Vec2 ::new ( - u . y , u . x ) ;
let ( r0 , r1 ) = ( on_body ( t - half ) , on_body ( t + half ) ) ;
let ( c0 , c1 ) = ( r0 + u * th + v * l , r1 + u * th - v * l ) ;
if k = = 0 {
b . m ( r0 . x , r0 . y ) ;
} else {
b . arc ( rx , ry , ( t - step + half ) . to_degrees ( ) , ( step - 2.0 * half ) . to_degrees ( ) ) ;
}
b . l ( c0 . x , c0 . y ) . l ( c1 . x , c1 . y ) . l ( r1 . x , r1 . y ) ;
}
let t_last = - std ::f64 ::consts ::FRAC_PI_2 + step * ( n - 1 ) as f64 ;
b . arc ( rx , ry , ( t_last + half ) . to_degrees ( ) , ( step - 2.0 * half ) . to_degrees ( ) ) . z ( ) ;
let k = std ::f64 ::consts ::FRAC_1_SQRT_2 ;
let text = Rect ::new ( cx - rx * k , cy - ry * k , cx + rx * k , cy + ry * k ) ;
simple ( b . take ( ) , text , w , h )
}
/// Two arrows on a band that steps down in the middle: the left arrow sits high, the right one low,
/// and the band rolls over between them in a shaded half-ellipse curl.
fn left_right_ribbon ( w : f64 , h : f64 , a0 : f64 , a1 : f64 , a2 : f64 ) -> Geometry {
let ss = w . min ( h ) ;
let sh = h * a2 . clamp ( 0.0 , 33333.0 ) / 1e5 ; // step between the two halves
let bt = ( h * a0 . max ( 0.0 ) / 1e5 ) . min ( h - sh ) ; // band thickness
let cx = w / 2.0 ;
let ( rx , ry ) = ( w / 32.0 , ( sh / 4.0 ) . min ( w / 24.0 ) ) ;
let hb = ( ss * a1 . max ( 0.0 ) / 1e5 ) . min ( cx - rx ) ; // head length
let yc = ( h - sh ) / 2.0 ;
let ( lt , lb ) = ( yc - bt / 2.0 , yc + bt / 2.0 ) ;
let ( rt , rb ) = ( lt + sh , lb + sh ) ;
// The left half: filled as a closed outline, stroked only where it can show.
let mut edge = Pb ::new ( ) ;
edge . m ( cx - rx , lb ) . l ( hb , lb ) . l ( hb , h - sh ) . l ( 0.0 , yc ) . l ( hb , 0.0 ) . l ( hb , lt ) . l ( cx , lt ) ;
edge . arc ( rx , ry , 270.0 , 180.0 ) . arc ( rx , ry , 270.0 , - 90.0 ) ;
let edge = edge . take ( ) ;
let mut left = Pb ::new ( ) ;
left . m ( 0.0 , yc ) . l ( hb , 0.0 ) . l ( hb , lt ) . l ( cx , lt ) . arc ( rx , ry , 270.0 , 180.0 ) . arc ( rx , ry , 270.0 , - 180.0 ) ;
left . l ( cx , lb . max ( lt + 4.0 * ry ) ) . l ( hb , lb ) . l ( hb , h - sh ) . z ( ) ;
let left = left . take ( ) ;
let mut curl = Pb ::new ( ) ;
curl . m ( cx + rx , lt + ry ) . l ( cx + rx , rt ) . l ( cx , lt + 4.0 * ry ) . arc ( rx , ry , 90.0 , 180.0 ) . arc ( rx , ry , 90.0 , - 90.0 ) . z ( ) ;
let mut right = Pb ::new ( ) ;
right . m ( w , yc + sh ) . l ( w - hb , h ) . l ( w - hb , rb ) . l ( cx , rb ) . arc ( rx , ry , 90.0 , 90.0 ) . l ( cx - rx , rt - ry ) . arc ( rx , ry , 180.0 , - 90.0 ) ;
right . l ( w - hb , rt ) . l ( w - hb , sh ) . z ( ) ;
Geometry {
paths : vec ! [ fill_only ( left ) , stroke_only ( edge ) , shade ( curl . take ( ) , FillMode ::DarkenLess ) , fill ( right . take ( ) ) ] ,
text_rect : Rect ::new ( hb . min ( cx - rx ) , rt , ( w - hb ) . max ( cx + rx ) , lb . max ( rt ) ) ,
handles : vec ! [ ] ,
sites : vec ! [ Point ::new ( 0.0 , yc ) , Point ::new ( cx , rt ) , Point ::new ( w , yc + sh ) , Point ::new ( cx , lb ) ] ,
}
}
/// Adds a piece of the parabola `y = y0 + d·(1 − −
/// `xa`) to `xb`, as one quadratic curve.
fn sag ( b : & mut Pb , w : f64 , d : f64 , y0 : f64 , xa : f64 , xb : f64 ) {
let hw = ( w / 2.0 ) . max ( 1e-9 ) ;
let f = | x : f64 | y0 + d * ( 1.0 - ( ( x - hw ) / hw ) . powi ( 2 ) ) ;
let slope = - 2.0 * d * ( xa - hw ) / ( hw * hw ) ;
b . q ( ( xa + xb ) / 2.0 , f ( xa ) + slope * ( xb - xa ) / 2.0 , xb , f ( xb ) ) ;
}
/// A ribbon whose edges sag along one parabola: a front band in the middle and two notched ends
/// behind it, joined by shaded folds. Built sagging downwards; `up` mirrors it vertically.
fn ellipse_ribbon ( up : bool , w : f64 , h : f64 , a0 : f64 , a1 : f64 , a2 : f64 ) -> Geometry {
let th = h * a0 . clamp ( 0.0 , 100000.0 ) / 1e5 ; // band drop at the centre
// Sag of every edge: never more than the drop, never so little that the band would rise
// above the ends by more than half their height.
let d = ( h * a2 . max ( 0.0 ) / 1e5 ) . max ( th - ( h - th ) / 2.0 ) . clamp ( 0.0 , th ) ;
let bw = w * a1 . clamp ( 25000.0 , 75000.0 ) / 1e5 ;
let ( x0 , x1 ) = ( ( w - bw ) / 2.0 , ( w + bw ) / 2.0 ) ;
let ear = w / 8.0 ;
let ( xf , xg ) = ( x0 + ear , x1 - ear ) ;
let e = h - th ; // band height
let off = th - d ; // band top below the ends' top
let t = | x : f64 | {
let hw = ( w / 2.0 ) . max ( 1e-9 ) ;
d * ( 1.0 - ( ( x - hw ) / hw ) . powi ( 2 ) )
} ;
let mut ends = Pb ::new ( ) ;
ends . m ( 0.0 , 0.0 ) ;
sag ( & mut ends , w , d , 0.0 , 0.0 , xf ) ;
ends . l ( xf , t ( xf ) + off ) . l ( x0 , t ( x0 ) + off ) . l ( x0 , t ( x0 ) + e ) ;
sag ( & mut ends , w , d , e , x0 , 0.0 ) ;
ends . l ( ear , t ( ear ) + e / 2.0 ) . z ( ) ;
ends . m ( w , 0.0 ) . l ( w - ear , t ( w - ear ) + e / 2.0 ) . l ( w , e ) ;
sag ( & mut ends , w , d , e , w , x1 ) ;
ends . l ( x1 , t ( x1 ) + off ) . l ( xg , t ( xg ) + off ) . l ( xg , t ( xg ) ) ;
sag ( & mut ends , w , d , 0.0 , xg , w ) ;
ends . z ( ) ;
let mut folds = Pb ::new ( ) ;
folds . poly ( & [ ( x0 , t ( x0 ) + off ) , ( xf , t ( xf ) ) , ( xf , t ( xf ) + off ) ] ) ;
folds . poly ( & [ ( x1 , t ( x1 ) + off ) , ( xg , t ( xg ) ) , ( xg , t ( xg ) + off ) ] ) ;
let mut band = Pb ::new ( ) ;
band . m ( x0 , t ( x0 ) + off ) ;
sag ( & mut band , w , d , off , x0 , x1 ) ;
band . l ( x1 , t ( x1 ) + off + e ) ;
sag ( & mut band , w , d , off + e , x1 , x0 ) ;
band . z ( ) ;
let mut paths = vec! [ fill ( ends . take ( ) ) , shade ( folds . take ( ) , FillMode ::DarkenLess ) , fill ( band . take ( ) ) ] ;
let mut text = Rect ::new ( x0 , th , x1 , t ( x0 ) + off + e ) ;
if up {
let m = kurbo ::Affine ::new ( [ 1.0 , 0.0 , 0.0 , - 1.0 , 0.0 , h ] ) ;
for p in & mut paths {
p . path . apply_affine ( m ) ;
}
text = m . transform_rect_bbox ( text ) ;
}
Geometry { paths , text_rect : text , handles : vec ! [ ] , sites : mid_sites ( w , h ) }
}
/// A sweeping arrow rising from the bottom-left corner. The band's two edges are quadratic curves
/// from the corner; the head's base leans slightly forward and reaches one eighth of the shorter
/// side above and below the band. The tilt and the tip's lift were fitted to the reference look.
fn swoosh ( w : f64 , h : f64 , a0 : f64 , a1 : f64 ) -> Geometry {
const TILT : f64 = 0.1126 ; // tan of the head base's lean from vertical
const LIFT : f64 = 0.051 ; // tip height above the band's centre, per unit of height
let ss = w . min ( h ) ;
let e = ss / 8.0 ;
let th = ( h * a0 . max ( 0.0 ) / 1e5 ) . min ( ( h - 2.0 * e ) . max ( 0.0 ) ) ;
// The head is at least long enough to keep its leaning base inside the frame.
let hl = ( ss * a1 . max ( 0.0 ) / 1e5 ) . max ( ( e + th ) * TILT ) . min ( ( w - e * TILT ) . max ( 0.0 ) ) ;
let qx = w - hl ;
let mut b = Pb ::new ( ) ;
b . m ( 0.0 , h )
. q ( w / 6.0 , h / 3.0 , qx , e )
. l ( qx - e * TILT , 0.0 )
. l ( w , ( e + th / 2.0 - LIFT * h ) . clamp ( 0.0 , 2.0 * e + th ) )
. l ( ( qx + ( e + th ) * TILT ) . min ( w ) , 2.0 * e + th )
. l ( ( qx + th * TILT ) . min ( w ) , e + th )
. q ( w / 4.0 , ( th + h / 12.0 + e ) . min ( h ) , 0.0 , h )
. z ( ) ;
simple ( b . take ( ) , Rect ::new ( 0.0 , 0.0 , w , h ) , w , h )
}
/// A band that sweeps around half an ellipse and ends in an arrow head. Built pointing right
/// (`curvedRightArrow`) in a `cw`×
///
/// Both halves of the band hang off one ellipse touching the far side: its centre sits on the
/// head side's edge, its horizontal radius is the full length, and the band has a constant
/// vertical thickness. The back half (shaded) starts flat against the head side; the front half
/// runs to the head, centred on the band where it ends.
fn curved_arrow ( name : & str , w : f64 , h : f64 , a0 : f64 , a1 : f64 , a2 : f64 ) -> Geometry {
let along_x = matches! ( name , " curvedRightArrow " | " curvedLeftArrow " ) ;
let ( cw , ch ) = if along_x { ( w , h ) } else { ( h , w ) } ;
let ss = cw . min ( ch ) ;
let head = ( ss * a1 . max ( 0.0 ) / 1e5 ) . min ( ch / 2.0 ) ;
let th = ( ss * a0 . max ( 0.0 ) / 1e5 ) . min ( head ) ;
let hl = ( ss * a2 . max ( 0.0 ) / 1e5 ) . min ( cw ) ;
let hh = head / 2.0 ;
// The band's centre line, carried on to the head side, ends at the tip, which sits half a
// head width above the bottom.
let r = ( ( ch - hh - th / 2.0 ) / 2.0 ) . max ( 0.0 ) ;
// Parametric angle where the front band reaches the head base.
let te = if cw > 0.0 { ( - ( hl / cw ) ) . clamp ( - 1.0 , 1.0 ) . acos ( ) . to_degrees ( ) } else { 90.0 } ;
let mut back = Pb ::new ( ) ;
back . m ( cw , 0.0 ) . arc ( cw , r , 270.0 , - 90.0 ) . l ( 0.0 , r + th ) . arc ( cw , r , 180.0 , 90.0 ) . z ( ) ;
let mut front = Pb ::new ( ) ;
front . m ( 0.0 , r ) . arc ( cw , r , 180.0 , te - 180.0 ) ;
let yb = front . cur . y ;
let yc = yb + th / 2.0 ;
front . l ( cw - hl , yc - hh ) . l ( cw , 2.0 * r + th / 2.0 ) . l ( cw - hl , yc + hh ) . l ( cw - hl , yb + th ) . arc ( cw , r , te , 180.0 - te ) . z ( ) ;
let m = match name {
" curvedLeftArrow " = > kurbo ::Affine ::new ( [ - 1.0 , 0.0 , 0.0 , 1.0 , w , 0.0 ] ) ,
" curvedUpArrow " = > kurbo ::Affine ::new ( [ 0.0 , - 1.0 , 1.0 , 0.0 , 0.0 , h ] ) ,
" curvedDownArrow " = > kurbo ::Affine ::new ( [ 0.0 , 1.0 , 1.0 , 0.0 , 0.0 , 0.0 ] ) ,
_ = > kurbo ::Affine ::IDENTITY ,
} ;
let ( mut back , mut front ) = ( back . take ( ) , front . take ( ) ) ;
back . apply_affine ( m ) ;
front . apply_affine ( m ) ;
Geometry {
paths : vec ! [ shade ( back , FillMode ::DarkenLess ) , fill ( front ) ] ,
text_rect : Rect ::new ( 0.0 , 0.0 , w , h ) ,
handles : vec ! [ ] ,
sites : mid_sites ( w , h ) ,
}
}
/// A rectangle with a callout leader through `pts` points (`(y, x)` adjust pairs in 1/100 000 of
/// the height and width), optionally with an accent bar at the first point's x and a border.
fn line_callout ( w : f64 , h : f64 , a : & dyn Fn ( usize ) -> f64 , pts : usize , accent : bool , border : bool ) -> Geometry {
let body = corner_rect ( w , h , [ Corner ::Square ; 4 ] ) ;
// Leaders may reach well outside the box, but not without bound.
let pt = | i : usize | ( w * a ( 2 * i + 1 ) . clamp ( - 1e7 , 1e7 ) / 1e5 , h * a ( 2 * i ) . clamp ( - 1e7 , 1e7 ) / 1e5 ) ;
let mut l = Pb ::new ( ) ;
let ( x0 , y0 ) = pt ( 0 ) ;
l . m ( x0 , y0 ) ;
for i in 1 .. pts {
let ( x , y ) = pt ( i ) ;
l . l ( x , y ) ;
}
let mut paths = vec! [ if border { fill ( body ) } else { fill_only ( body ) } ] ;
if accent {
paths . push ( stroke_only ( Pb ::new ( ) . m ( x0 , 0.0 ) . l ( x0 , h ) . take ( ) ) ) ;
}
paths . push ( stroke_only ( l . take ( ) ) ) ;
Geometry { paths , text_rect : Rect ::new ( 0.0 , 0.0 , w , h ) , handles : vec ! [ ] , sites : mid_sites ( w , h ) }
}
#[ cfg(test) ]
mod tests {
use super ::super ::{ CATALOG , FillMode , build , info } ;
use kurbo ::{ BezPath , PathEl , Point , Shape } ;
const NEW : [ & str ; 38 ] = [
" lineInv " ,
" nonIsoscelesTrapezoid " ,
" pieWedge " ,
" leftRightArrowCallout " ,
" upDownArrowCallout " ,
" quadArrowCallout " ,
" circularArrow " ,
" leftCircularArrow " ,
" leftRightCircularArrow " ,
" curvedRightArrow " ,
" curvedLeftArrow " ,
" curvedUpArrow " ,
" curvedDownArrow " ,
" swooshArrow " ,
" callout1 " ,
" callout2 " ,
" callout3 " ,
" accentCallout1 " ,
" accentCallout2 " ,
" accentCallout3 " ,
" borderCallout2 " ,
" borderCallout3 " ,
" accentBorderCallout1 " ,
" accentBorderCallout2 " ,
" accentBorderCallout3 " ,
" ellipseRibbon " ,
" ellipseRibbon2 " ,
" leftRightRibbon " ,
" flowChartOfflineStorage " ,
" gear6 " ,
" gear9 " ,
" funnel " ,
" cornerTabs " ,
" squareTabs " ,
" plaqueTabs " ,
" chartX " ,
" chartStar " ,
" chartPlus " ,
] ;
fn outline ( name : & str , w : f64 , h : f64 , adj : & [ f64 ] ) -> BezPath {
build ( name , w , h , adj ) . map ( | g | g . outline ( ) ) . unwrap_or_default ( )
}
/// Distance from `p` to the nearest point of the (flattened) outline.
fn dist ( path : & BezPath , p : Point ) -> f64 {
let mut best = f64 ::MAX ;
let mut prev = Point ::ZERO ;
let mut start = Point ::ZERO ;
kurbo ::flatten ( path . iter ( ) , 0.01 , | el | {
let ( a , b ) = match el {
PathEl ::MoveTo ( q ) = > {
prev = q ;
start = q ;
return ;
}
PathEl ::LineTo ( q ) = > ( prev , q ) ,
PathEl ::ClosePath = > ( prev , start ) ,
_ = > return ,
} ;
let d = b - a ;
let t = if d . hypot2 ( ) > 0.0 { ( ( p - a ) . dot ( d ) / d . hypot2 ( ) ) . clamp ( 0.0 , 1.0 ) } else { 0.0 } ;
best = best . min ( ( a + d * t - p ) . hypot ( ) ) ;
prev = b ;
} ) ;
best
}
/// Asserts every point lies within 1pt of the outline.
fn on ( name : & str , w : f64 , h : f64 , adj : & [ f64 ] , pts : & [ ( f64 , f64 ) ] ) {
let path = outline ( name , w , h , adj ) ;
for & ( x , y ) in pts {
let d = dist ( & path , Point ::new ( x , y ) ) ;
assert! ( d < 1.0 , " {name} {w}x{h} {adj:?}: ({x}, {y}) is {d:.2} from the outline " ) ;
}
}
#[ test ]
fn new_presets_are_in_the_catalog ( ) {
for n in NEW {
let i = info ( n ) . unwrap_or_else ( | | panic! ( " {n} missing from the catalog " ) ) ;
assert! ( ! i . label . is_empty ( ) ) ;
}
assert! ( CATALOG . len ( ) > = 183 ) ;
}
#[ test ]
fn new_presets_build_within_bounds_at_many_sizes_and_adjusts ( ) {
let sizes = [ ( 480.0 , 300.0 ) , ( 300.0 , 300.0 ) , ( 200.0 , 460.0 ) , ( 100.0 , 460.0 ) , ( 1.0 , 1.0 ) , ( 0.0 , 0.0 ) , ( 0.0 , 50.0 ) , ( 60.0 , 0.0 ) ] ;
let adjusts : [ & [ f64 ] ; 8 ] = [
& [ ] ,
& [ 0.0 ; 8 ] ,
& [ 100000.0 ; 8 ] ,
& [ - 50000.0 ; 8 ] ,
& [ 1e12 , - 1e12 , 1e12 , - 1e12 , 1e12 , - 1e12 , 1e12 , - 1e12 ] ,
& [ f64 ::MAX , f64 ::MIN , f64 ::MAX , f64 ::MIN , f64 ::MAX , f64 ::MIN , f64 ::MAX , f64 ::MIN ] ,
& [ f64 ::NAN , f64 ::INFINITY , f64 ::NEG_INFINITY , f64 ::NAN , 5.0 , 6.0 , 7.0 , 8.0 ] ,
& [ 30000.0 , 60000.0 , 20000.0 , 9000000.0 , 20000.0 , 40000.0 , 120000.0 , - 30000.0 ] ,
] ;
for n in NEW {
// Line callouts' leaders may reach anywhere, by design.
let callout = n . contains ( " allout " ) & & ! n . contains ( " Arrow " ) ;
for ( w , h ) in sizes {
for adj in adjusts {
let g = build ( n , w , h , adj ) . unwrap_or_else ( | | panic! ( " {n} did not build " ) ) ;
assert! ( ! g . paths . is_empty ( ) , " {n} has no paths " ) ;
for s in & g . paths {
let bb = s . path . bounding_box ( ) ;
assert! ( bb . x0 . is_finite ( ) & & bb . y0 . is_finite ( ) & & bb . x1 . is_finite ( ) & & bb . y1 . is_finite ( ) , " {n} {w}x{h} {adj:?}: {bb:?} " ) ;
if ! callout {
// Circular arrows with a head longer than their ring can hold carry the
// inner edge on from the head, as the reference does, so may spill.
let spill = if n . contains ( " ircular " ) { 0.5 } else { 0.01 } ;
let tol = 0.5 + w . max ( h ) * spill ;
assert! (
bb . x0 > = - tol & & bb . y0 > = - tol & & bb . x1 < = w + tol & & bb . y1 < = h + tol ,
" {n} {w}x{h} {adj:?} out of bounds: {bb:?} "
) ;
}
}
let t = g . text_rect ;
assert! ( t . x0 . is_finite ( ) & & t . y0 . is_finite ( ) & & t . x1 . is_finite ( ) & & t . y1 . is_finite ( ) , " {n} text rect {t:?} " ) ;
}
}
let g = build ( n , 480.0 , 300.0 , & [ ] ) . unwrap_or_else ( | | panic! ( " {n} " ) ) ;
assert! ( g . outline ( ) . elements ( ) . len ( ) > = 2 , " {n} default outline is empty " ) ;
}
}
// The spot checks below are outline points measured on reference renders.
#[ test ]
fn simple_new_presets_match_reference_points ( ) {
on ( " lineInv " , 480.0 , 300.0 , & [ ] , & [ ( 0.0 , 300.0 ) , ( 480.0 , 0.0 ) ] ) ;
on ( " nonIsoscelesTrapezoid " , 480.0 , 300.0 , & [ ] , & [ ( 75.0 , 0.0 ) , ( 405.0 , 0.0 ) , ( 0.0 , 300.0 ) ] ) ;
on ( " nonIsoscelesTrapezoid " , 200.0 , 460.0 , & [ 80000.0 , 20000.0 ] , & [ ( 100.0 , 0.0 ) , ( 160.0 , 0.0 ) ] ) ;
on ( " pieWedge " , 480.0 , 300.0 , & [ ] , & [ ( 64.3 , 150.0 ) , ( 0.0 , 300.0 ) , ( 480.0 , 0.0 ) ] ) ;
on ( " flowChartOfflineStorage " , 480.0 , 300.0 , & [ ] , & [ ( 240.0 , 300.0 ) , ( 192.0 , 240.0 ) , ( 288.0 , 240.0 ) ] ) ;
on ( " squareTabs " , 480.0 , 300.0 , & [ ] , & [ ( 28.3 , 28.3 ) , ( 451.7 , 271.7 ) ] ) ;
on ( " cornerTabs " , 480.0 , 300.0 , & [ ] , & [ ( 23.3 , 5.0 ) ] ) ;
on ( " plaqueTabs " , 480.0 , 300.0 , & [ ] , & [ ( 27.85 , 5.0 ) ] ) ;
on ( " chartStar " , 480.0 , 300.0 , & [ ] , & [ ( 240.0 , 0.0 ) , ( 240.0 , 300.0 ) , ( 48.0 , 30.0 ) ] ) ;
on ( " chartPlus " , 480.0 , 300.0 , & [ ] , & [ ( 0.0 , 150.0 ) , ( 240.0 , 0.0 ) ] ) ;
// Chart markers and plain callouts leave the box unstroked.
for n in [ " chartX " , " callout1 " , " accentCallout2 " ] {
let g = build ( n , 100.0 , 100.0 , & [ ] ) . unwrap_or_else ( | | panic! ( " {n} " ) ) ;
assert! ( ! g . paths [ 0 ] . stroke , " {n} " ) ;
}
}
#[ test ]
fn line_callouts_follow_their_adjusts ( ) {
on ( " callout3 " , 480.0 , 300.0 , & [ ] , & [ ( - 40.0 , 56.25 ) , ( - 80.0 , 56.25 ) , ( - 80.0 , 300.0 ) , ( - 40.0 , 338.9 ) ] ) ;
let adj = [ 50000.0 , 110000.0 , 20000.0 , 120000.0 , - 20000.0 , 80000.0 , 30000.0 , 40000.0 ] ;
let g = build ( " accentBorderCallout3 " , 480.0 , 300.0 , & adj ) . unwrap_or_else ( | | panic! ( " accentBorderCallout3 " ) ) ;
assert_eq! ( g . paths . len ( ) , 3 ) ;
assert! ( g . paths [ 0 ] . stroke ) ;
let accent = g . paths [ 1 ] . path . bounding_box ( ) ;
assert! ( ( accent . x0 - 528.0 ) . abs ( ) < 1e-6 & & accent . y0 = = 0.0 & & accent . y1 = = 300.0 , " {accent:?} " ) ;
on ( " accentBorderCallout3 " , 480.0 , 300.0 , & adj , & [ ( 576.0 , 60.0 ) , ( 384.0 , - 60.0 ) , ( 192.0 , 90.0 ) ] ) ;
}
#[ test ]
fn arrow_callouts_match_reference_points ( ) {
on ( " leftRightArrowCallout " , 480.0 , 300.0 , & [ ] , & [ ( 0.0 , 150.0 ) , ( 75.0 , 75.0 ) , ( 124.5 , 0.0 ) , ( 355.5 , 300.0 ) , ( 480.0 , 150.0 ) ] ) ;
on ( " leftRightArrowCallout " , 200.0 , 460.0 , & [ ] , & [ ( 50.0 , 180.0 ) , ( 52.0 , 0.0 ) , ( 148.0 , 460.0 ) ] ) ;
on ( " upDownArrowCallout " , 480.0 , 300.0 , & [ ] , & [ ( 240.0 , 0.0 ) , ( 0.0 , 77.8 ) , ( 480.0 , 222.2 ) , ( 240.0 , 300.0 ) ] ) ;
on ( " quadArrowCallout " , 480.0 , 300.0 , & [ ] , & [ ( 0.0 , 150.0 ) , ( 124.5 , 77.8 ) , ( 240.0 , 0.0 ) , ( 480.0 , 150.0 ) , ( 240.0 , 300.0 ) ] ) ;
}
#[ test ]
fn curved_arrows_match_reference_points ( ) {
on (
" curvedRightArrow " ,
480.0 ,
300.0 ,
& [ ] ,
& [ ( 480.0 , 0.0 ) , ( 480.0 , 75.0 ) , ( 480.0 , 225.0 ) , ( 405.0 , 149.0 ) , ( 405.0 , 299.0 ) , ( 100.0 , 151.5 ) , ( 300.0 , 6.7 ) ] ,
) ;
on ( " curvedRightArrow " , 200.0 , 460.0 , & [ 30000.0 , 60000.0 , 40000.0 ] , & [ ( 200.0 , 400.0 ) , ( 120.0 , 324.5 ) , ( 120.0 , 443.5 ) , ( 200.0 , 60.0 ) ] ) ;
// The band never outgrows the head; the head never outgrows half the frame.
on ( " curvedRightArrow " , 200.0 , 460.0 , & [ 60000.0 , 30000.0 , 80000.0 ] , & [ ( 200.0 , 60.0 ) ] ) ;
on ( " curvedLeftArrow " , 480.0 , 300.0 , & [ ] , & [ ( 0.0 , 225.0 ) , ( 0.0 , 0.0 ) ] ) ;
on ( " curvedUpArrow " , 480.0 , 300.0 , & [ ] , & [ ( 405.0 , 0.0 ) , ( 0.0 , 0.0 ) , ( 75.0 , 0.0 ) ] ) ;
on ( " curvedDownArrow " , 480.0 , 300.0 , & [ ] , & [ ( 405.0 , 300.0 ) , ( 0.0 , 300.0 ) ] ) ;
let g = build ( " curvedRightArrow " , 480.0 , 300.0 , & [ ] ) . unwrap_or_else ( | | panic! ( " curvedRightArrow " ) ) ;
assert_eq! ( g . paths [ 0 ] . fill , FillMode ::DarkenLess ) ;
}
#[ test ]
fn swoosh_matches_reference_points ( ) {
on ( " swooshArrow " , 480.0 , 300.0 , & [ ] , & [ ( 0.0 , 300.0 ) , ( 425.8 , 0.0 ) , ( 480.0 , 59.7 ) , ( 442.8 , 150.0 ) , ( 202.0 , 105.5 ) , ( 202.0 , 159.0 ) ] ) ;
on ( " swooshArrow " , 480.0 , 300.0 , & [ 40000.0 , 16667.0 ] , & [ ( 480.0 , 82.2 ) , ( 447.8 , 195.0 ) ] ) ;
on ( " swooshArrow " , 200.0 , 460.0 , & [ ] , & [ ( 163.9 , 0.0 ) , ( 200.0 , 59.4 ) ] ) ;
}
#[ test ]
fn ribbons_match_reference_points ( ) {
on (
" ellipseRibbon " ,
480.0 ,
300.0 ,
& [ ] ,
& [ ( 0.0 , 0.0 ) , ( 120.0 , 28.1 ) , ( 60.0 , 128.9 ) , ( 240.0 , 300.0 ) , ( 120.0 , 66.1 ) , ( 180.0 , 72.2 ) , ( 180.0 , 35.2 ) ] ,
) ;
on ( " ellipseRibbon " , 480.0 , 300.0 , & [ 30000.0 , 60000.0 , 20000.0 ] , & [ ( 120.0 , 45.0 ) , ( 240.0 , 300.0 ) , ( 96.0 , 68.4 ) ] ) ;
on ( " ellipseRibbon " , 480.0 , 300.0 , & [ 80000.0 , 20000.0 , 60000.0 ] , & [ ( 240.0 , 240.0 ) , ( 1.0 , 61.75 ) ] ) ;
on ( " ellipseRibbon2 " , 480.0 , 300.0 , & [ ] , & [ ( 0.0 , 300.0 ) , ( 240.0 , 0.0 ) ] ) ;
on (
" leftRightRibbon " ,
480.0 ,
300.0 ,
& [ ] ,
& [ ( 0.0 , 125.0 ) , ( 150.0 , 0.0 ) , ( 150.0 , 50.0 ) , ( 255.0 , 62.5 ) , ( 225.0 , 87.5 ) , ( 480.0 , 175.0 ) , ( 330.0 , 300.0 ) ] ,
) ;
on ( " leftRightRibbon " , 480.0 , 300.0 , & [ 90000.0 , 10000.0 , 60000.0 ] , & [ ( 0.0 , 100.0 ) , ( 480.0 , 200.0 ) , ( 240.0 , 300.0 ) ] ) ;
}
#[ test ]
fn gears_and_funnel_match_reference_points ( ) {
// Square gear6: body radius 105, top tooth tip 3.5 inside the frame, tip half-width ~16.3.
on ( " gear6 " , 300.0 , 300.0 , & [ ] , & [ ( 150.0 , 3.5 ) , ( 133.7 , 3.5 ) , ( 166.3 , 3.5 ) , ( 45.0 , 150.0 ) ] ) ;
on ( " gear9 " , 300.0 , 300.0 , & [ ] , & [ ( 150.0 , 1.0 ) , ( 30.0 , 150.0 ) ] ) ;
on ( " gear6 " , 480.0 , 300.0 , & [ ] , & [ ( 240.0 , 3.5 ) , ( 201.0 , 3.5 ) ] ) ;
on ( " funnel " , 480.0 , 300.0 , & [ ] , & [ ( 240.0 , 0.0 ) , ( 0.0 , 75.0 ) , ( 240.0 , 15.0 ) , ( 15.0 , 75.0 ) , ( 240.0 , 300.0 ) , ( 60.5 , 150.0 ) ] ) ;
let g = build ( " funnel " , 480.0 , 300.0 , & [ ] ) . unwrap_or_else ( | | panic! ( " funnel " ) ) ;
assert! ( g . paths [ 0 ] . even_odd ) ;
}
#[ test ]
fn circular_arrows_match_reference_points ( ) {
on ( " circularArrow " , 300.0 , 300.0 , & [ ] , & [ ( 19.0 , 150.0 ) , ( 56.5 , 150.0 ) , ( 150.0 , 19.0 ) , ( 262.4 , 150.0 ) , ( 218.6 , 113.4 ) , ( 293.6 , 113.4 ) ] ) ;
on (
" circularArrow " ,
300.0 ,
300.0 ,
& [ 20000.0 , 1800000.0 , 18000000.0 , 5400000.0 , 20000.0 ] ,
& [ ( 150.0 , 270.0 ) , ( 150.0 , 210.0 ) , ( 247.0 , 42.1 ) , ( 143.0 , 102.1 ) , ( 227.9 , 105.0 ) ] ,
) ;
on ( " leftCircularArrow " , 300.0 , 300.0 , & [ ] , & [ ( 37.6 , 150.0 ) , ( 262.4 , 150.0 ) , ( 150.0 , 281.0 ) ] ) ;
on ( " leftRightCircularArrow " , 300.0 , 300.0 , & [ ] , & [ ( 262.4 , 150.0 ) , ( 37.6 , 150.0 ) , ( 150.0 , 19.0 ) ] ) ;
// The band never grows past twice the head's half-width.
on ( " circularArrow " , 300.0 , 300.0 , & [ 25000.0 , 1142319.0 , 20457681.0 , 10800000.0 , 5000.0 ] , & [ ( 0.0 , 150.0 ) , ( 30.0 , 150.0 ) ] ) ;
}
}
Brandon Thomas