1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
use crate::Point; /// /// Default tension of curve between passed points. /// Will be used if not specified in [`SplineOpts`]. /// /// [`SplineOpts`]: struct.SplineOpts.html pub const DEFAULT_TENSION: f64 = 0.5; /// /// Default number of segments. /// Will be used if not specified in [`SplineOpts`]. /// /// [`SplineOpts`]: struct.SplineOpts.html pub const DEFAULT_SEGMENTS: u32 = 16; /// /// A list of options indicating how the spline should be calculated /// /// ``` /// use cubic_spline::SplineOpts; /// /// let o1 = SplineOpts::default(); /// /// let o2 = SplineOpts::new(); /// /// let o3 = SplineOpts::new() /// .tension(0.5) /// .num_of_segments(16); /// /// ``` /// Options list: /// * `tension` - /// Sets the bending strength of the curve. /// The usual value ranges from `0.0` (straight) to `1.0` (very rounded). /// If not specified [`DEFAULT_TENSION`] will be used. /// /// * `num_of_segments` - /// The number of points to be calculated between each two known points. /// If not specified [`DEFAULT_SEGMENTS`] will be used. /// /// * `hidden_point_at_start` - A point that will not be drawn, /// but the beginning of the graph will bend as if it is there. /// /// * `hidden_point_at_end` - Same as previous, but affects the end of the graph. /// /// [`DEFAULT_TENSION`]: constant.DEFAULT_TENSION.html /// [`DEFAULT_SEGMENTS`]: constant.DEFAULT_SEGMENTS.html #[derive(Clone)] pub struct SplineOpts { tension: f64, num_of_segments: u32, hidden_point_at_start: Option<Point>, hidden_point_at_end: Option<Point>, } impl SplineOpts { /// /// Creates new one with defaults. pub fn new() -> Self { SplineOpts::default() } /// /// Sets tension. pub fn tension(mut self, val: f64) -> Self { self.tension = val; self } /// /// Sets num_of_segments. pub fn num_of_segments(mut self, val: u32) -> Self { self.num_of_segments = val; self } /// /// Sets hidden_point_at_start. pub fn hidden_point_at_start<T: Into<Point>>(mut self, val: T) -> Self { self.hidden_point_at_start = Some(val.into()); self } /// /// Sets hidden_point_at_end. pub fn hidden_point_at_end<T: Into<Point>>(mut self, val: T) -> Self { self.hidden_point_at_end = Some(val.into()); self } // // Sets tension. pub fn get_tension(&self) -> f64 { self.tension } // // Sets num_of_segments. pub fn get_num_of_segments(&self) -> u32 { self.num_of_segments } // // Sets hidden_point_at_start. pub fn get_hidden_point_at_start(&self) -> Option<&Point> { self.hidden_point_at_start.as_ref() } // // Sets hidden_point_at_end. pub fn get_hidden_point_at_end(&self) -> Option<&Point> { self.hidden_point_at_end.as_ref() } } impl Default for SplineOpts { /// /// # Example /// ``` /// use cubic_spline::{SplineOpts}; /// let opts = SplineOpts::default(); /// /// assert_eq!(opts.get_num_of_segments(), cubic_spline::DEFAULT_SEGMENTS); /// assert!((opts.get_tension() - cubic_spline::DEFAULT_TENSION).abs() < 1e-9); /// assert!(opts.get_hidden_point_at_end().is_none()); /// /// ``` fn default() -> Self { SplineOpts { tension: DEFAULT_TENSION, num_of_segments: DEFAULT_SEGMENTS, hidden_point_at_start: None, hidden_point_at_end: None, } } }