let n = inputs.len();
inputs.retain(|input| !input.decode(series, &mut domains));
if n == inputs.len() {
- dbg!(&inputs);
todo!()
}
}
- //dbg!(&domains);
domains
}
mut csv_data: Option<IndexMap<String, DataSeries>>,
warn: &mut dyn FnMut(GraphWarning),
) -> Result<svg::Document, GraphError> {
- //dbg!(self.graph());
let _styles = self.decode_styles();
for delimited_source in self
.children
.as_ref()
.map_or(&EN, |lang| Locale::for_lang(lang));
let series = self.decode_series(locale, data, warn);
- /*
- for (name, series) in &series {
- dbg!(name, &series.values);
- }*/
- dbg!(&series);
let domains = self.decode_domains(&series, warn);
let _styles = self
.children
.map(|f| f.decode(&series))
.unwrap_or_default();
- dbg!(&faceting);
-
let x_facets = FacetIterator::new(&faceting[Axis2::X]);
let nx_facets = x_facets.len();
let y_facets = FacetIterator::new(&faceting[Axis2::Y]);
Graph(Graph),
LabelFrame(LabelFrame),
Container(Container),
+ StyleCycle(StyleCycle),
Style(Style),
Location(Location),
#[serde(other)]
}
CategoricalDomainChild::DomainReference(domain) => {
let Some(domain) = domains.get(domain.reference.as_str()) else {
- dbg!(&domain);
return false;
};
to: String,
}
+#[derive(Clone, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+struct StyleCycle {
+ #[serde(default)]
+ cycles: Vec<Cycle>,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+struct Cycle {
+ #[serde(default)]
+ styles: Vec<Style>,
+}
+
#[derive(Clone, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct Style {
variables[axis] = Some(series.clone());
}
}
- dbg!(&variables);
let mut ignore_minmax = EnumMap::default();
for statistic in &raw.statistics {
match statistic {
Statistic::BinStatistic(bin_statistic) => {
if let Some(x) = &mut variables[Axis3::X] {
- dbg!(&*x);
assert!(!x.categorical);
let mut min = None;
let mut max = None;
n += 1;
}
}
- dbg!((min, max, n));
if let Some(min) = min.copied()
&& let Some(max) = max.copied()
&& max > min
let bin_width =
bin_widths.entry(x.name.clone()).or_insert(binning.width);
*bin_width = bin_width.min(binning.width);
- dbg!(&binning);
for value in &mut x.values {
if let Datum::Number(Some(number)) = &value.value {
value.value = Datum::Number(binning.bin(*number));
}
Statistic::SummaryStatistic(summary_statistic) => {
if let Some(mut x) = variables[Axis3::X].take() {
- dbg!();
let mut frequencies = BTreeMap::<Datum<String>, f64>::new();
assert!(x.categorical);
for value in &x.values {
*frequencies.entry(value.value.clone()).or_default() += 1.0;
}
}
- dbg!(&frequencies);
if summary_statistic.convert_interval_to_single_value {
- dbg!();
x.values = frequencies
.keys()
.map(|value| SeriesValue {
let text = label_frame.text();
layout.set_text(&text);
let (w, h) = layout.size();
- println!("{text} => ({w},{h})");
enum_map! { Axis2::X => w as f64 / 1024.0, Axis2::Y => h as f64 / 1024.0}
}
FrameType::Legend(_) => enum_map! { Axis2::X => 100.0, Axis2::Y => 200.0 },
pub fn csv_data(&self) -> Result<Option<IndexMap<String, DataSeries>>, GraphError> {
if let Some(csv) = &self.csv {
- dbg!();
let mut reader = csv::Reader::from_reader(Cursor::new(&csv));
let headers = reader.headers().unwrap(); // XXX
let mut variables = vec![DataSeries::default(); headers.len()];
for row in reader.records() {
- dbg!(&row);
let row = row.unwrap(); // XXX
for (column, s) in row.iter().enumerate() {
let value = match s.parse::<f64>() {
.map(|series| series.data.len())
.max()
.unwrap_or_default();
- dbg!(&name);
- dbg!(rows);
let empty = Datum::String(String::new());
for row in 0..rows {
w.create_element("row").write_inner_content(|w| {
Ok(())
}
- eprintln!();
let mut reader = Reader::from_reader(self.xml.as_slice());
let mut writer = Writer::new(Vec::new());
loop {
(0.0..100.0, (0.0, 20.0, 6)),
] {
let expected = Scaling::new(base, interval, n_ticks);
- dbg!(&range, &expected);
let scaling = Scaling::for_range(&range);
assert_eq!(scaling, expected);
assert_eq!(scaling.ticks().count(), scaling.n_ticks);
(0.0..100.0, (0.0, 40.0 / 3.0, 8)),
] {
let expected = Binning::new(start, width, n);
- dbg!(&range, &expected);
let binning = Binning::for_range(&range, sturges_rule(50.0).unwrap());
assert_eq!(binning.start, expected.start);
assert_relative_eq!(binning.width, expected.width);
} else {
value
};
- println!("set {:?} {axis:?} {component:?} to {value:?}", &frame.id);
new_position[axis].set(component, value);
}
}
.as_ref()
.is_none_or(|location| location.is_size_to_content())
{
- println!("set {axis:?} default size");
position[axis].set_start(0.0);
position[axis].set_end(default);
}
while let n = self.missing_values()
&& n > 0
{
- println!();
- println!("round {n}");
- for frame in &self.frames {
- println!(
- "{:?}: X {:?} {:?} {:?}",
- &frame.id,
- &frame.position[Axis2::X].start(),
- &frame.position[Axis2::X].end(),
- &frame.position[Axis2::X].length()
- );
- println!(
- "{:?}: Y {:?} {:?} {:?}",
- &frame.id,
- &frame.position[Axis2::Y].start(),
- &frame.position[Axis2::Y].end(),
- &frame.position[Axis2::Y].length()
- );
- }
self.update_round();
if self.missing_values() == n {
- println!("no change");
- dbg!(strict);
if !strict {
break;
}
let size = self.preferred_size(&self.frames[0], false);
for (axis, position) in &mut self.frames[0].position {
if position.start().is_none() {
- println!("set {axis:?} start non-strict");
position.set_start(0.0);
}
if position.length().is_none() {
- println!("set {axis:?} length non-strict");
position.set_length(size[axis].unwrap_or_default());
}
}
let frame = &frames[index];
if self.start().is_some() && self.end().is_some() {
- println!("{:?}: known", &frame.id);
return;
}
let unknown_end = frame.locations[axis][Component::End].is_none();
let unknown_length =
frame.locations[axis][Component::Length].is_none() && self.length().is_none();
- println!(
- "{:?} {axis:?}: {unknown_start:?} {unknown_end:?} {unknown_length:?}",
- &frame.id
- );
match (unknown_start, unknown_end, unknown_length) {
(true, true, true) => {
- println!("{:?}: clone parent {axis:?}", &frame.id);
*self = parent.clone();
}
(true, true, false) => {
{
// We know where the parent starts, and another frame is
// attached to our end, so start us where our parent starts.
- println!(
- "set default {:?} {axis:?} start to {parent_start}",
- &frame.id
- );
self.set(Component::Start, parent_start);
} else if let Some(parent_end) = parent.end()
&& is_attached(frames, index, axis, Component::End)
{
// We know where the parent ends, and another frame is
// attached to our start, so end us where our parent ends.
- println!("set default {:?} {axis:?} end to {parent_end}", &frame.id);
self.set(Component::End, parent_end);
} else if let Some(length) = self.length()
&& let Some(parent_length) = parent.length()
{
// We have our parent's location, and no other frame is
// before or after us, so center us within the parent.
- println!("center {:?} {axis:?}", &frame.id);
self.set_start(parent_start + parent_length / 2.0 - length / 2.0);
}
}
(true, false, true) => {
if let Some(parent_start) = parent.start() {
- println!("set start {:?} {axis} to parent {parent_start}", &frame.id);
self.set(Component::Start, parent_start);
}
}
(false, true, true) => {
if let Some(parent_end) = parent.end() {
- println!("set end {:?} {axis} to parent {parent_end}", &frame.id);
self.set(Component::End, parent_end);
}
}
projects / pspp / commitdiff