def _compute(self):
# Approximatively the same code as in XY.
# The only difference is the transformation of dates to numbers
# (beginning) and the reversed transformation to dates (end)
self._offset = min([val[0]
for serie in self.series
for val in serie.values
if val[0] is not None]
or [datetime.datetime.fromtimestamp(0)])
for serie in self.all_series:
serie.values = [(self._tonumber(v[0]), v[1]) for v in serie.values]
xvals = [val[0]
for serie in self.series
for val in serie.values
if val[0] is not None]
yvals = [val[1]
for serie in self.series
for val in serie.values
if val[1] is not None]
if xvals:
xmin = min(xvals)
xmax = max(xvals)
rng = (xmax - xmin)
else:
rng = None
for serie in self.all_series:
serie.points = serie.values
if self.interpolate and rng:
vals = list(zip(*sorted(
[t for t in serie.points if None not in t],
key=lambda x: x[0])))
serie.interpolated = self._interpolate(vals[0], vals[1])
if self.interpolate and rng:
xvals = [val[0]
for serie in self.all_series
for val in serie.interpolated]
yvals = [val[1]
for serie in self.all_series
for val in serie.interpolated]
if xvals:
xmin = min(xvals)
xmax = max(xvals)
rng = (xmax - xmin)
else:
rng = None
if rng:
self._box.xmin, self._box.xmax = min(xvals), max(xvals)
self._box.ymin, self._box.ymax = min(yvals), max(yvals)
x_pos = compute_scale(
self._box.xmin, self._box.xmax, self.logarithmic, self.order_min)
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min)
self._x_labels = list(zip(list(map(self._todate, x_pos)), x_pos))
self._y_labels = list(zip(list(map(self._format, y_pos)), y_pos))
def _compute(self):
if self.xvals:
xmin = min(self.xvals)
xmax = max(self.xvals)
xrng = (xmax - xmin)
else:
xrng = None
if self.yvals:
ymin = min(min(self.yvals), self.zero)
ymax = max(max(self.yvals), self.zero)
yrng = (ymax - ymin)
else:
yrng = None
for serie in self.all_series:
serie.points = serie.values
if xrng:
self._box.xmin, self._box.xmax = xmin, xmax
if yrng:
self._box.ymin, self._box.ymax = ymin, ymax
x_pos = compute_scale(self._box.xmin, self._box.xmax, self.logarithmic,
self.order_min)
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min)
self._x_labels = list(zip(map(self._format, x_pos), x_pos))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
if self.xvals:
xmin = min(self.xvals)
xmax = max(self.xvals)
xrng = (xmax - xmin)
else:
xrng = None
if self.yvals:
ymin = min(min(self.yvals), self.zero)
ymax = max(max(self.yvals), self.zero)
yrng = (ymax - ymin)
else:
yrng = None
for serie in self.all_series:
serie.points = serie.values
if xrng:
self._box.xmin, self._box.xmax = xmin, xmax
if yrng:
self._box.ymin, self._box.ymax = ymin, ymax
x_pos = compute_scale(
self._box.xmin, self._box.xmax, self.logarithmic, self.order_min)
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min)
self._x_labels = list(zip(map(self._format, x_pos), x_pos))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
if self.xvals:
xmin = min(self.xvals)
xmax = max(self.xvals)
xrng = (xmax - xmin)
else:
xrng = None
if self.yvals:
ymin = self._min
ymax = self._max
if self.include_x_axis:
ymin = min(ymin or 0, 0)
ymax = max(ymax or 0, 0)
yrng = (ymax - ymin)
else:
yrng = None
for serie in self.all_series:
serie.points = serie.values
if self.interpolate and xrng:
vals = list(
zip(*sorted(filter(lambda t: None not in t, serie.points),
key=lambda x: x[0])))
serie.interpolated = self._interpolate(vals[0], vals[1])
if self.interpolate and xrng:
self.xvals = [
val[0] for serie in self.all_series
for val in serie.interpolated
]
self.yvals = [
val[1] for serie in self.series for val in serie.interpolated
]
if self.xvals:
xmin = min(self.xvals)
xmax = max(self.xvals)
xrng = (xmax - xmin)
else:
xrng = None
if xrng:
self._box.xmin, self._box.xmax = xmin, xmax
if yrng:
self._box.ymin, self._box.ymax = ymin, ymax
x_pos = compute_scale(self._box.xmin, self._box.xmax, self.logarithmic,
self.order_min)
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min)
self._x_labels = list(zip(map(self._format, x_pos), x_pos))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
if self.xvals:
xmin = min(self.xvals)
xmax = max(self.xvals)
xrng = (xmax - xmin)
else:
xrng = None
if self.yvals:
ymin = self._min
ymax = self._max
if self.include_x_axis:
ymin = min(ymin or 0, 0)
ymax = max(ymax or 0, 0)
yrng = (ymax - ymin)
else:
yrng = None
for serie in self.all_series:
serie.points = serie.values
if self.interpolate and xrng:
vals = list(zip(*sorted(
filter(lambda t: None not in t,
serie.points), key=lambda x: x[0])))
serie.interpolated = self._interpolate(vals[0], vals[1])
if self.interpolate and xrng:
self.xvals = [val[0]
for serie in self.all_series
for val in serie.interpolated]
self.yvals = [val[1]
for serie in self.series
for val in serie.interpolated]
if self.xvals:
xmin = min(self.xvals)
xmax = max(self.xvals)
xrng = (xmax - xmin)
else:
xrng = None
if xrng:
self._box.xmin, self._box.xmax = xmin, xmax
if yrng:
self._box.ymin, self._box.ymax = ymin, ymax
x_pos = compute_scale(
self._box.xmin, self._box.xmax, self.logarithmic, self.order_min)
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min)
self._x_labels = list(zip(map(self._format, x_pos), x_pos))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
xvals = [val[0]
for serie in self.series
for val in serie.values
if val[0] is not None]
yvals = [val[1]
for serie in self.series
for val in serie.values
if val[1] is not None]
if xvals:
xmin = min(xvals)
xmax = max(xvals)
rng = (xmax - xmin)
else:
rng = None
for serie in self.series:
serie.points = serie.values
if self.interpolate and rng:
vals = zip(*sorted(
filter(lambda t: None not in t,
serie.points), key=lambda x: x[0]))
serie.interpolated = self._interpolate(
vals[1], vals[0], xy=True, xy_xmin=xmin, xy_rng=rng)
if self.interpolate and rng:
xvals = [val[0]
for serie in self.series
for val in serie.interpolated]
yvals = [val[1]
for serie in self.series
for val in serie.interpolated]
if xvals:
xmin = min(xvals)
xmax = max(xvals)
rng = (xmax - xmin)
else:
rng = None
if rng:
self._box.xmin, self._box.xmax = min(xvals), max(xvals)
self._box.ymin, self._box.ymax = min(yvals), max(yvals)
x_pos = compute_scale(
self._box.xmin, self._box.xmax, self.logarithmic, self.order_min)
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min)
self._x_labels = zip(map(self._format, x_pos), x_pos)
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
"""
This method was taken from Pygal.XY class, with my minor changes. It's
licensed under GPL v3 or greater.
"""
for serie in self.series:
for metadata in serie.metadata:
if not hasattr(metadata.value, '__iter__'):
metadata.value = (metadata.value, self.zero)
xvals = [val[0]
for serie in self.series
for val in serie.values
if val[0] is not None]
yvals = [val[1]
for serie in self.series
for val in serie.values
if val[1] is not None]
xmin = min(xvals)
xmax = max(xvals)
rng = (xmax - xmin)
for serie in self.series:
serie.points = serie.values
if self.interpolate:
vals = zip(*sorted(serie.points, key=lambda x: x[0]))
serie.interpolated = self._interpolate(
vals[1], vals[0], xy=True, xy_xmin=xmin, xy_rng=rng)
if not serie.interpolated:
serie.interpolated = serie.values
if self.interpolate:
xvals = [val[0]
for serie in self.series
for val in serie.interpolated]
yvals = [val[1]
for serie in self.series
for val in serie.interpolated]
self._box.xmin, self._box.xmax = min(xvals), max(xvals)
self._box.ymin, self._box.ymax = min(yvals), max(yvals)
x_pos = compute_scale(self._box.xmin, self._box.xmax, self.logarithmic,
self.order_min)
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min)
self._x_labels = zip(map(self._format_x, x_pos), x_pos)
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
transposed = zip(*[serie.values for serie in self.series])
positive_vals = [sum([
val if val is not None and val > self.zero else self.zero
for val in vals]) - self.zero
for vals in transposed]
negative_vals = [sum([
val - self.zero
if val is not None and val < self.zero else self.zero
for val in vals]) + self.zero
for vals in transposed]
self._box.ymin, self._box.ymax = (
min(min(negative_vals), self.zero),
max(max(positive_vals), self.zero))
x_pos = [
x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min
) if not self.y_labels else map(float, self.y_labels)
self._x_ranges = zip(x_pos, x_pos[1:])
self._x_labels = self.x_labels and zip(self.x_labels, [
sum(x_range) / 2 for x_range in self._x_ranges])
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
x_pos = [x / (self._len - 1) for x in range(self._len)
] if self._len != 1 else [.5] # Center if only one value
for serie in self.series:
if not hasattr(serie, 'points'):
serie.points = [
(x_pos[i], v)
for i, v in enumerate(serie.values)]
if self.interpolate:
serie.interpolated = self._interpolate(serie.values, x_pos)
if self.include_x_axis:
self._box.ymin = min(self._min, 0)
self._box.ymax = max(self._max, 0)
else:
self._box.ymin = self._min
self._box.ymax = self._max
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min
) if not self.y_labels else map(float, self.y_labels)
self._x_labels = self.x_labels and zip(self.x_labels, x_pos)
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
xlen = len(self.series)
x_pos = [(x + 1) / xlen for x in range(xlen)
] if xlen != 1 else [.5] # Center if only one value
previous = [[0, 0] for i in range(self._len)]
for i, serie in enumerate(self.series):
y_height = - sum(serie.values) / 2
all_x_pos = [0] + x_pos
serie.points = []
for j, value in enumerate(serie.values):
poly = []
poly.append((all_x_pos[i], previous[j][0]))
poly.append((all_x_pos[i], previous[j][1]))
previous[j][0] = y_height
y_height = previous[j][1] = y_height + value
poly.append((all_x_pos[i + 1], previous[j][1]))
poly.append((all_x_pos[i + 1], previous[j][0]))
serie.points.append(poly)
val_max = max(map(sum, cut(self.series, 'values')))
self._box.ymin = -val_max
self._box.ymax = val_max
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min
) if not self.y_labels else map(float, self.y_labels)
self._x_labels = zip(cut(self.series, 'title'),
map(lambda x: x - 1 / (2 * xlen), x_pos))
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
x_pos = [x / (self._len - 1) for x in range(self._len)] if self._len != 1 else [0.5] # Center if only one value
self._points(x_pos)
if self.include_x_axis:
self._box.ymin = min(self._min, 0)
self._box.ymax = max(self._max, 0)
else:
self._box.ymin = self._min
self._box.ymax = self._max
y_pos = (
compute_scale(self._box.ymin, self._box.ymax, self.logarithmic, self.order_min)
if not self.y_labels
else map(float, self.y_labels)
)
x_labels = zip(self.x_labels, x_pos)
if self.x_labels_num_limit and len(x_labels) > self.x_labels_num_limit:
step = (len(x_labels) - 1) / (self.x_labels_num_limit - 1)
x_labels = list(x_labels[int(i * step)] for i in range(self.x_labels_num_limit))
self._x_labels = self.x_labels and x_labels
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
delta = 2 * pi / self._len if self._len else 0
x_pos = [0.5 * pi + i * delta for i in range(self._len + 1)]
for serie in self.series:
serie.points = [(v, x_pos[i]) for i, v in enumerate(serie.values)]
if self.interpolate:
extend = 2
extended_x_pos = (
[0.5 * pi + i * delta for i in range(-extend, 0)]
+ x_pos
+ [0.5 * pi + i * delta for i in range(self._len + 1, self._len + 1 + extend)]
)
extended_vals = serie.values[-extend:] + serie.values + serie.values[:extend]
serie.interpolated = self._interpolate(extended_vals, extended_x_pos, polar=True)
# x labels space
self._box.margin *= 2
self._rmin = self.zero
self._rmax = self._max or 1
self._box.set_polar_box(self._rmin, self._rmax)
y_pos = (
compute_scale(self._rmin, self._rmax, self.logarithmic, self.order_min, max_scale=8)
if not self.y_labels
else list(map(int, self.y_labels))
)
self._x_labels = self.x_labels and list(zip(self.x_labels, x_pos))
self._y_labels = list(zip(list(map(self._format, y_pos)), y_pos))
self.x_pos = x_pos
self._self_close = True
def _compute(self):
positive_vals, negative_vals = self._get_separated_values()
self._compute_box(positive_vals, negative_vals)
if self.logarithmic:
positive_vals = list(filter(lambda x: x > 0, positive_vals))
negative_vals = list(filter(lambda x: x > 0, negative_vals))
positive_vals = positive_vals or [self.zero]
negative_vals = negative_vals or [self.zero]
x_pos = [
x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
self._points(x_pos)
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min
) if not self.y_labels else list(map(float, self.y_labels))
self._x_ranges = zip(x_pos, x_pos[1:])
self._x_labels = self.x_labels and list(zip(self.x_labels, [
sum(x_range) / 2 for x_range in self._x_ranges]))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
self.negative_cumulation = [0] * self._len
self.positive_cumulation = [0] * self._len
if self.secondary_series:
positive_vals, negative_vals = self._get_separated_values(True)
positive_vals = positive_vals or [self.zero]
negative_vals = negative_vals or [self.zero]
self.secondary_negative_cumulation = [0] * self._len
self.secondary_positive_cumulation = [0] * self._len
self._pre_compute_secondary(positive_vals, negative_vals)
def _compute(self):
# X Labels
x_pos = [
x / (self._len - 1) for x in range(self._len)
] if self._len != 1 else [.5] # Center if only one value
self._points(x_pos)
if self.x_labels:
label_len = len(self.x_labels)
if label_len != self._len:
label_pos = [0.5] if label_len == 1 else [
x / (label_len - 1) for x in range(label_len)
]
self._x_labels = list(zip(self.x_labels, label_pos))
else:
self._x_labels = list(zip(self.x_labels, x_pos))
else:
self._x_labels = None
if self.include_x_axis:
# Y Label
self._box.ymin = min(self._min or 0, 0)
self._box.ymax = max(self._max or 0, 0)
else:
self._box.ymin = self._min
self._box.ymax = self._max
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min
) if not self.y_labels else list(map(float, self.y_labels))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
x_pos = [(x + 1) / self._order for x in range(self._order)
] if self._order != 1 else [.5] # Center if only one value
previous = [[self.zero, self.zero] for i in range(self._len)]
for i, serie in enumerate(self.series):
y_height = -sum(serie.safe_values) / 2
all_x_pos = [0] + x_pos
serie.points = []
for j, value in enumerate(serie.values):
poly = []
poly.append((all_x_pos[i], previous[j][0]))
poly.append((all_x_pos[i], previous[j][1]))
previous[j][0] = y_height
y_height = previous[j][1] = y_height + value
poly.append((all_x_pos[i + 1], previous[j][1]))
poly.append((all_x_pos[i + 1], previous[j][0]))
serie.points.append(poly)
val_max = max(list(map(sum, cut(self.series, 'values'))) + [self.zero])
self._box.ymin = -val_max
self._box.ymax = val_max
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min) if not self.y_labels else map(
float, self.y_labels)
self._x_labels = list(
zip(cut(self.series, 'title'),
map(lambda x: x - 1 / (2 * self._order), x_pos)))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
ymin = self.y_label_min if self.y_label_min is not None else self._min
ymax = self.y_label_max if self.y_label_max is not None else self._max
if ymin:
self._box.ymin = min(ymin, self.zero)
if ymax:
self._box.ymax = max(ymax, self.zero)
x_pos = [
x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
self._points(x_pos)
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min
) if not self.y_labels else map(float, self.y_labels)
if self.y_labels_descriptions:
y_pos.extend([key for key in self.y_labels_descriptions.keys() if key >= self._box.ymin and key <= self._box.ymax])
y_pos.sort()
self._x_labels = self.x_labels and zip(self.x_labels, [
(i + .5) / self._len for i in range(self._len)])
format = functools.partial(self._describe_label, self._format)
self._y_labels = zip(map(format, y_pos), y_pos)
def _compute(self):
delta = 2 * pi / self._len if self._len else 0
x_pos = [.5 * pi + i * delta for i in range(self._len + 1)]
for serie in self.all_series:
serie.points = [(v, x_pos[i]) for i, v in enumerate(serie.values)]
if self.interpolate:
extended_x_pos = ([.5 * pi - delta] + x_pos)
extended_vals = (serie.values[-1:] + serie.values)
serie.interpolated = list(
map(
tuple,
map(reversed,
self._interpolate(extended_x_pos, extended_vals))))
# x labels space
self._box.margin *= 2
self._rmin = self.zero
self._rmax = self._max or 1
self._box.set_polar_box(self._rmin, self._rmax)
y_pos = compute_scale(self._rmin,
self._rmax,
self.logarithmic,
self.order_min,
max_scale=8) if not self.y_labels else list(
map(int, self.y_labels))
self._x_labels = self.x_labels and list(zip(self.x_labels, x_pos))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
self.x_pos = x_pos
self._self_close = True
def _compute(self):
x_pos = [
(x + 1) / self._order for x in range(self._order)
] if self._order != 1 else [.5] # Center if only one value
previous = [[self.zero, self.zero] for i in range(self._len)]
for i, serie in enumerate(self.series):
y_height = - sum(serie.safe_values) / 2
all_x_pos = [0] + x_pos
serie.points = []
for j, value in enumerate(serie.values):
poly = []
poly.append((all_x_pos[i], previous[j][0]))
poly.append((all_x_pos[i], previous[j][1]))
previous[j][0] = y_height
y_height = previous[j][1] = y_height + value
poly.append((all_x_pos[i + 1], previous[j][1]))
poly.append((all_x_pos[i + 1], previous[j][0]))
serie.points.append(poly)
val_max = max(list(map(sum, cut(self.series, 'values'))) + [self.zero])
self._box.ymin = -val_max
self._box.ymax = val_max
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min,
self.min_scale, self.max_scale
) if not self.y_labels else list(map(float, self.y_labels))
self._x_labels = list(
zip(cut(self.series, 'title'),
map(lambda x: x - 1 / (2 * self._order), x_pos)))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
"""
Compute parameters necessary for later steps
within the rendering process
"""
for serie in self.series:
serie.values, serie.outliers = \
self._box_points(serie.values, self.box_mode)
if self._min:
self._box.ymin = min(self._min, self.zero)
if self._max:
self._box.ymax = max(self._max, self.zero)
x_pos = [
x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
self._points(x_pos)
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min,
self.min_scale, self.max_scale
) if not self.y_labels else list(map(float, self.y_labels))
self._x_labels = self.x_labels and list(zip(self.x_labels, [
(i + .5) / self._order for i in range(self._order)]))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute_y_labels(self):
y_pos = compute_scale(
self.min_, self.max_, self.logarithmic,
self.order_min, self.min_scale, self.max_scale
)
if self.y_labels:
self._y_labels = []
for i, y_label in enumerate(self.y_labels):
if isinstance(y_label, dict):
pos = self._adapt(y_label.get('value'))
title = y_label.get('label', self._y_format(pos))
elif is_str(y_label):
pos = self._adapt(y_pos[i])
title = y_label
else:
pos = self._adapt(y_label)
title = self._y_format(pos)
self._y_labels.append((title, pos))
self.min_ = min(self.min_, min(cut(self._y_labels, 1)))
self.max_ = max(self.max_, max(cut(self._y_labels, 1)))
self._box.set_polar_box(
0, 1,
self.min_,
self.max_)
else:
self._y_labels = list(zip(map(self._y_format, y_pos), y_pos))
def _compute(self):
positive_vals = zip(*[serie.safe_values
for index, serie in enumerate(self.series)
if index % 2])
negative_vals = zip(*[serie.safe_values
for index, serie in enumerate(self.series)
if not index % 2])
positive_sum = map(sum, positive_vals) or [0]
negative_sum = map(sum, negative_vals) or [0]
self._box.ymax = max(max(positive_sum), max(negative_sum))
self._box.ymin = - self._box.ymax
x_pos = [
x / self._len
for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min
) if not self.y_labels else map(float, self.y_labels)
self._x_ranges = zip(x_pos, x_pos[1:])
self._x_labels = self.x_labels and zip(self.x_labels, [
sum(x_range) / 2 for x_range in self._x_ranges])
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute_y_labels(self):
y_pos = compute_scale(
self.min_, self.max_, self.logarithmic,
self.order_min, self.min_scale, self.max_scale
)
if self.y_labels:
self._y_labels = []
for i, y_label in enumerate(self.y_labels):
if isinstance(y_label, dict):
pos = self._adapt(y_label.get('value'))
title = y_label.get('label', self._y_format(pos))
elif is_str(y_label):
pos = self._adapt(y_pos[i])
title = y_label
else:
pos = self._adapt(y_label)
title = self._y_format(pos)
self._y_labels.append((title, pos))
self.min_ = min(self.min_, min(cut(self._y_labels, 1)))
self.max_ = max(self.max_, max(cut(self._y_labels, 1)))
self._box.set_polar_box(
0, 1,
self.min_,
self.max_)
else:
self._y_labels = list(zip(map(self._y_format, y_pos), y_pos))
def _compute(self):
positive_vals, negative_vals = self._get_separated_values()
self._compute_box(positive_vals, negative_vals)
if self.logarithmic:
positive_vals = list(filter(lambda x: x > 0, positive_vals))
negative_vals = list(filter(lambda x: x > 0, negative_vals))
positive_vals = positive_vals or [self.zero]
negative_vals = negative_vals or [self.zero]
x_pos = [x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
self._points(x_pos)
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min) if not self.y_labels else list(
map(float, self.y_labels))
self._x_ranges = zip(x_pos, x_pos[1:])
self._x_labels = self.x_labels and list(
zip(self.x_labels,
[sum(x_range) / 2 for x_range in self._x_ranges]))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
self.negative_cumulation = [0] * self._len
self.positive_cumulation = [0] * self._len
if self.secondary_series:
positive_vals, negative_vals = self._get_separated_values(True)
positive_vals = positive_vals or [self.zero]
negative_vals = negative_vals or [self.zero]
self.secondary_negative_cumulation = [0] * self._len
self.secondary_positive_cumulation = [0] * self._len
self._pre_compute_secondary(positive_vals, negative_vals)
def _compute(self):
positive_vals = zip(*[
serie.safe_values for index, serie in enumerate(self.series)
if index % 2
])
negative_vals = zip(*[
serie.safe_values for index, serie in enumerate(self.series)
if not index % 2
])
positive_sum = map(sum, positive_vals) or [0]
negative_sum = map(sum, negative_vals) or [0]
self._box.ymax = max(max(positive_sum), max(negative_sum))
self._box.ymin = -self._box.ymax
x_pos = [x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min) if not self.y_labels else map(
float, self.y_labels)
self._x_ranges = zip(x_pos, x_pos[1:])
self._x_labels = self.x_labels and zip(
self.x_labels, [sum(x_range) / 2 for x_range in self._x_ranges])
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
delta = 2 * pi / self._len if self._len else 0
x_pos = [.5 * pi + i * delta for i in range(self._len + 1)]
for serie in self.all_series:
serie.points = [
(v, x_pos[i])
for i, v in enumerate(serie.values)]
if self.interpolate:
extended_x_pos = (
[.5 * pi - delta] + x_pos)
extended_vals = (serie.values[-1:] +
serie.values)
serie.interpolated = list(
map(tuple,
map(reversed,
self._interpolate(
extended_x_pos, extended_vals))))
# x labels space
self._box.margin *= 2
self._rmin = self.zero
self._rmax = self._max or 1
self._box.set_polar_box(self._rmin, self._rmax)
y_pos = compute_scale(
self._rmin, self._rmax, self.logarithmic, self.order_min,
max_scale=8
) if not self.y_labels else list(map(int, self.y_labels))
self._x_labels = self.x_labels and list(zip(self.x_labels, x_pos))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
self.x_pos = x_pos
self._self_close = True
def _compute(self):
delta = 2 * pi / self._len
x_pos = [.5 * pi + i * delta for i in range(self._len + 1)]
for serie in self.series:
serie.points = [(v, x_pos[i]) for i, v in enumerate(serie.values)]
if self.interpolate:
extend = 2
extended_x_pos = (
[.5 * pi + i * delta
for i in range(-extend, 0)] + x_pos + [
.5 * pi + i * delta
for i in range(self._len + 1, self._len + 1 + extend)
])
extended_vals = (serie.values[-extend:] + serie.values +
serie.values[:extend])
serie.interpolated = self._interpolate(extended_vals,
extended_x_pos,
polar=True)
self._box.margin *= 2
self._box.xmin = self._box.ymin = -self._max
self._box.xmax = self._box.ymax = self._rmax = self._max
y_pos = compute_scale(
0, self._box.ymax, self.logarithmic, self.order_min,
max_scale=8) if not self.y_labels else map(int, self.y_labels)
self._x_labels = self.x_labels and zip(self.x_labels, x_pos)
self._y_labels = zip(map(self._format, y_pos), y_pos)
self.x_pos = x_pos
self._self_close = True
def _compute(self):
"""
Compute parameters necessary for later steps
within the rendering process
"""
for serie in self.series:
serie.values = self._box_points(serie.values, self.mode)
if self._min:
self._box.ymin = min(self._min, self.zero)
if self._max:
self._box.ymax = max(self._max, self.zero)
x_pos = [x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
self._points(x_pos)
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min) if not self.y_labels else list(
map(float, self.y_labels))
self._x_labels = self.x_labels and list(
zip(self.x_labels, [(i + .5) / self._order
for i in range(self._order)]))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
delta = 2 * pi / self._len
x_pos = [.5 * pi + i * delta for i in range(self._len + 1)]
for serie in self.series:
serie.points = [
(v, x_pos[i])
for i, v in enumerate(serie.values)]
if self.interpolate:
extend = 2
extended_x_pos = (
[.5 * pi + i * delta for i in range(-extend, 0)] +
x_pos +
[.5 * pi + i * delta for i in range(
self._len + 1, self._len + 1 + extend)])
extended_vals = (serie.values[-extend:] +
serie.values +
serie.values[:extend])
serie.interpolated = self._interpolate(
extended_vals, extended_x_pos, polar=True)
self._box.margin *= 2
self._box.xmin = self._box.ymin = - self._max
self._box.xmax = self._box.ymax = self._rmax = self._max
y_pos = compute_scale(
0, self._box.ymax, self.logarithmic, self.order_min, max_scale=8
) if not self.y_labels else map(int, self.y_labels)
self._x_labels = self.x_labels and zip(self.x_labels, x_pos)
self._y_labels = zip(map(self._format, y_pos), y_pos)
self.x_pos = x_pos
self._self_close = True
def _compute(self):
# X Labels
x_pos = [x / (self._len - 1) for x in range(self._len)
] if self._len != 1 else [.5] # Center if only one value
self._points(x_pos)
if self.x_labels:
label_len = len(self.x_labels)
if label_len != self._len:
label_pos = [0.5] if label_len == 1 else [
x / (label_len - 1) for x in range(label_len)
]
self._x_labels = list(zip(self.x_labels, label_pos))
else:
self._x_labels = list(zip(self.x_labels, x_pos))
else:
self._x_labels = None
if self.include_x_axis:
# Y Label
self._box.ymin = min(self._min or 0, 0)
self._box.ymax = max(self._max or 0, 0)
else:
self._box.ymin = self._min
self._box.ymax = self._max
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min) if not self.y_labels else list(
map(float, self.y_labels))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
for serie in self.series:
for metadata in serie.metadata:
if not hasattr(metadata.value, '__iter__'):
metadata.value = (metadata.value, self.zero)
xvals = [val[0]
for serie in self.series
for val in serie.values
if val[0] != None]
yvals = [val[1]
for serie in self.series
for val in serie.values
if val[1] != None]
xmin = min(xvals)
xmax = max(xvals)
rng = (xmax - xmin)
for serie in self.series:
serie.points = serie.values
if self.interpolate:
vals = zip(*sorted(serie.points, key=lambda x: x[0]))
serie.interpolated = self._interpolate(
vals[1], vals[0], xy=True, xy_xmin=xmin, xy_rng=rng)
if not serie.interpolated:
serie.interpolated = serie.values
if self.interpolate:
xvals = [val[0]
for serie in self.series
for val in serie.interpolated]
yvals = [val[1]
for serie in self.series
for val in serie.interpolated]
self._box.xmin, self._box.xmax = min(xvals), max(xvals)
self._box.ymin, self._box.ymax = min(yvals), max(yvals)
x_pos = compute_scale(
self._box.xmin, self._box.xmax, self.logarithmic, self.order_min)
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min)
self._x_labels = zip(map(self._format, x_pos), x_pos)
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
self.min_ = self._min or 0
self.max_ = self._max or 0
if self.max_ - self.min_ == 0:
self.min_ -= 1
self.max_ += 1
self._box.set_polar_box(0, 1, self.min_, self.max_)
x_pos = compute_scale(self.min_, self.max_, self.logarithmic,
self.order_min)
self._x_labels = list(zip(map(self._format, x_pos), x_pos))
def _compute(self):
self._box.ymin = min(self._min, self.zero)
self._box.ymax = max(self._max, self.zero)
x_pos = [x / self._len for x in range(self._len + 1)] if self._len > 1 else [0, 1] # Center if only one value
y_pos = (
compute_scale(self._box.ymin, self._box.ymax, self.logarithmic, self.order_min)
if not self.y_labels
else map(float, self.y_labels)
)
self._x_ranges = zip(x_pos, x_pos[1:])
self._x_labels = self.x_labels and zip(self.x_labels, [sum(x_range) / 2 for x_range in self._x_ranges])
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
self._box.xmin = -1
self._box.ymin = -1
self.min_ = self._min
self.max_ = self._max
if self.max_ - self.min_ == 0:
self.min_ -= 1
self.max_ += 1
x_pos = compute_scale(self.min_, self.max_, self.logarithmic,
self.order_min)
self._x_labels = zip(map(self._format, x_pos), x_pos)
def _compute(self):
self._box.ymin = min(self._min, self.zero)
self._box.ymax = max(self._max, self.zero)
x_pos = [x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min) if not self.y_labels else map(
float, self.y_labels)
self._x_ranges = zip(x_pos, x_pos[1:])
self._x_labels = self.x_labels and zip(
self.x_labels, [sum(x_range) / 2 for x_range in self._x_ranges])
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
self._box.xmin = -1
self._box.ymin = -1
self.min_ = self._min
self.max_ = self._max
if self.max_ - self.min_ == 0:
self.min_ -= 1
self.max_ += 1
x_pos = compute_scale(
self.min_, self.max_, self.logarithmic, self.order_min
)
self._x_labels = zip(map(self._format, x_pos), x_pos)
def _compute(self):
self.min_ = self._min or 0
self.max_ = self._max or 0
if self.max_ - self.min_ == 0:
self.min_ -= 1
self.max_ += 1
self._box.set_polar_box(
0, 1,
self.min_,
self.max_)
x_pos = compute_scale(
self.min_, self.max_, self.logarithmic, self.order_min
)
self._x_labels = list(zip(map(self._format, x_pos), x_pos))
def _compute(self):
self.min_ = self._min or 0
self.max_ = self._max or 0
if self.max_ - self.min_ == 0:
self.min_ -= 1
self.max_ += 1
self._box.set_polar_box(
0, 1,
self.min_,
self.max_)
y_pos = compute_scale(
self.min_, self.max_, self.logarithmic, self.order_min,
self.min_scale, self.max_scale
) if not self.y_labels else list(map(float, self.y_labels))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
if self._min:
self._box.ymin = min(self._min, self.zero)
if self._max:
self._box.ymax = max(self._max, self.zero)
x_pos = [x / self._len for x in range(self._len + 1)] if self._len > 1 else [0, 1] # Center if only one value
self._points(x_pos)
y_pos = (
compute_scale(self._box.ymin, self._box.ymax, self.logarithmic, self.order_min)
if not self.y_labels
else list(map(float, self.y_labels))
)
self._x_labels = self.x_labels and list(zip(self.x_labels, [(i + 0.5) / self._len for i in range(self._len)]))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
def _compute(self):
if self._min:
self._box.ymin = min(self._min, self.zero)
if self._max:
self._box.ymax = max(self._max, self.zero)
x_pos = [x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
self._points(x_pos)
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min) if not self.y_labels else map(
float, self.y_labels)
self._x_labels = self.x_labels and zip(
self.x_labels, [(i + .5) / self._len for i in range(self._len)])
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
x_pos = [x / (self._len - 1) for x in range(self._len)
] if self._len != 1 else [.5] # Center if only one value
self._points(x_pos)
if self.include_x_axis:
self._box.ymin = min(self._min, 0)
self._box.ymax = max(self._max, 0)
else:
self._box.ymin = self._min
self._box.ymax = self._max
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min) if not self.y_labels else map(
float, self.y_labels)
self._x_labels = self.x_labels and zip(self.x_labels, x_pos)
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
x_pos = [
x / (self._len - 1) for x in range(self._len)
] if self._len != 1 else [.5] # Center if only one value
self._points(x_pos)
if self.include_x_axis:
self._box.ymin = min(self._min, 0)
self._box.ymax = max(self._max, 0)
else:
self._box.ymin = self._min
self._box.ymax = self._max
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min
) if not self.y_labels else map(float, self.y_labels)
self._x_labels = self.x_labels and zip(self.x_labels, x_pos)
self._y_labels = zip(map(self._format, y_pos), y_pos)
def _compute(self):
positive_vals, negative_vals = self._get_separated_values()
self._compute_box(positive_vals, negative_vals)
if self.logarithmic:
positive_vals = list(filter(lambda x: x > 0, positive_vals))
negative_vals = list(filter(lambda x: x > 0, negative_vals))
positive_vals = positive_vals or [self.zero]
negative_vals = negative_vals or [self.zero]
x_pos = [x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
self._points(x_pos)
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min) if not self.y_labels else map(
float, self.y_labels)
self._x_ranges = zip(x_pos, x_pos[1:])
self._x_labels = self.x_labels and list(
zip(self.x_labels,
[sum(x_range) / 2 for x_range in self._x_ranges]))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
self.negative_cumulation = [0] * self._len
self.positive_cumulation = [0] * self._len
if self.secondary_series:
positive_vals, negative_vals = self._get_separated_values(True)
self.secondary_negative_cumulation = [0] * self._len
self.secondary_positive_cumulation = [0] * self._len
# In case of pyramids
sum_ = lambda x: sum(x) if isinstance(x, tuple) else x
self._secondary_min = (negative_vals and min(
sum_(min(negative_vals)), self.zero)) or self.zero
self._secondary_max = (positive_vals and max(
sum_(max(positive_vals)), self.zero)) or self.zero
def _compute_x_labels(self):
x_pos = compute_scale(self._box.xmin, self._box.xmax, self.logarithmic,
self.order_min, self.min_scale, self.max_scale)
if self.x_labels:
self._x_labels = []
for i, x_label in enumerate(self.x_labels):
if isinstance(x_label, dict):
pos = self._x_adapt(x_label.get('value'))
title = x_label.get('label', self._x_format(pos))
elif is_str(x_label):
pos = self._x_adapt(x_pos[i % len(x_pos)])
title = x_label
else:
pos = self._x_adapt(x_label)
title = self._x_format(pos)
self._x_labels.append((title, pos))
self._box.xmin = min(self._box.xmin, min(cut(self._x_labels, 1)))
self._box.xmax = max(self._box.xmax, max(cut(self._x_labels, 1)))
else:
self._x_labels = list(zip(map(self._x_format, x_pos), x_pos))
def _compute(self):
positive_vals, negative_vals = self._get_separated_values()
self._compute_box(positive_vals, negative_vals)
if self.logarithmic:
positive_vals = list(filter(lambda x: x > 0, positive_vals))
negative_vals = list(filter(lambda x: x > 0, negative_vals))
positive_vals = positive_vals or [self.zero]
negative_vals = negative_vals or [self.zero]
x_pos = [
x / self._len for x in range(self._len + 1)
] if self._len > 1 else [0, 1] # Center if only one value
self._points(x_pos)
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min
) if not self.y_labels else map(float, self.y_labels)
self._x_ranges = zip(x_pos, x_pos[1:])
self._x_labels = self.x_labels and list(zip(self.x_labels, [
sum(x_range) / 2 for x_range in self._x_ranges]))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
self.negative_cumulation = [0] * self._len
self.positive_cumulation = [0] * self._len
if self.secondary_series:
positive_vals, negative_vals = self._get_separated_values(True)
self.secondary_negative_cumulation = [0] * self._len
self.secondary_positive_cumulation = [0] * self._len
# In case of pyramids
sum_ = lambda x: sum(x) if isinstance(x, tuple) else x
self._secondary_min = (negative_vals and min(
sum_(min(negative_vals)), self.zero)) or self.zero
self._secondary_max = (positive_vals and max(
sum_(max(positive_vals)), self.zero)) or self.zero
def _compute_x_labels(self):
x_pos = compute_scale(
self._box.xmin, self._box.xmax, self.logarithmic,
self.order_min, self.min_scale, self.max_scale
)
if self.x_labels:
self._x_labels = []
for i, x_label in enumerate(self.x_labels):
if isinstance(x_label, dict):
pos = self._x_adapt(x_label.get('value'))
title = x_label.get('label', self._x_format(pos))
elif is_str(x_label):
pos = self._x_adapt(x_pos[i % len(x_pos)])
title = x_label
else:
pos = self._x_adapt(x_label)
title = self._x_format(pos)
self._x_labels.append((title, pos))
self._box.xmin = min(self._box.xmin, min(cut(self._x_labels, 1)))
self._box.xmax = max(self._box.xmax, max(cut(self._x_labels, 1)))
else:
self._x_labels = list(zip(map(self._x_format, x_pos), x_pos))
def _compute(self):
# Approximatively the same code as in XY.
# The only difference is the transformation of dates to numbers
# (beginning) and the reversed transformation to dates (end)
self._offset = min(
[val[0] for serie in self.series for val in serie.values if val[0] is not None]
or [datetime.datetime.fromtimestamp(0)]
)
for serie in self.all_series:
serie.values = [(self._tonumber(v[0]), v[1]) for v in serie.values]
xvals = [val[0] for serie in self.series for val in serie.values if val[0] is not None]
yvals = [val[1] for serie in self.series for val in serie.values if val[1] is not None]
if xvals:
xmin = min(xvals)
xmax = max(xvals)
rng = xmax - xmin
else:
rng = None
if self.yvals:
ymin = self._min
ymax = self._max
if self.include_x_axis:
ymin = min(self._min or 0, 0)
ymax = max(self._max or 0, 0)
for serie in self.all_series:
serie.points = serie.values
if self.interpolate and rng:
vals = list(zip(*sorted([t for t in serie.points if None not in t], key=lambda x: x[0])))
serie.interpolated = self._interpolate(vals[0], vals[1])
if self.interpolate and rng:
xvals = [val[0] for serie in self.all_series for val in serie.interpolated]
yvals = [val[1] for serie in self.all_series for val in serie.interpolated]
if xvals:
xmin = min(xvals)
xmax = max(xvals)
rng = xmax - xmin
else:
rng = None
# Calculate/prcoess the x_labels
if self.x_labels:
# Process the given x_labels
x_labels_num = []
for label in self.x_labels:
x_labels_num.append(self._tonumber(label))
x_pos = x_labels_num
# Update the xmin/xmax to fit all of the x_labels and the data
xmin = min(xmin, min(x_pos))
xmax = max(xmax, max(x_pos))
self._box.xmin, self._box.xmax = xmin, xmax
self._box.ymin, self._box.ymax = ymin, ymax
else:
# Automatically generate the x_labels
if rng:
self._box.xmin, self._box.xmax = xmin, xmax
self._box.ymin, self._box.ymax = ymin, ymax
x_pos = compute_scale(self._box.xmin, self._box.xmax, self.logarithmic, self.order_min)
# Always auto-generate the y labels
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic, self.order_min)
self._x_labels = list(zip(list(map(self._todate, x_pos)), x_pos))
self._y_labels = list(zip(list(map(self._format, y_pos)), y_pos))
def _compute(self):
# Approximatively the same code as in XY.
# The only difference is the transformation of dates to numbers
# (beginning) and the reversed transformation to dates (end)
self._offset = min([
val[0] for serie in self.series
for val in serie.values if val[0] is not None
] or [datetime.datetime.fromtimestamp(0)])
for serie in self.all_series:
serie.values = [(self._tonumber(v[0]), v[1]) for v in serie.values]
if self.xvals:
xmin = min(self.xvals)
xmax = max(self.xvals)
rng = (xmax - xmin)
else:
rng = None
if self.yvals:
ymin = self._min
ymax = self._max
if self.include_x_axis:
ymin = min(self._min or 0, 0)
ymax = max(self._max or 0, 0)
for serie in self.all_series:
serie.points = serie.values
if self.interpolate and rng:
vals = list(
zip(*sorted([t for t in serie.points if None not in t],
key=lambda x: x[0])))
serie.interpolated = self._interpolate(vals[0], vals[1])
if self.interpolate and rng:
self.xvals = [
val[0] for serie in self.all_series
for val in serie.interpolated
]
self.yvals = [
val[1] for serie in self.all_series
for val in serie.interpolated
]
xmin = min(self.xvals)
xmax = max(self.xvals)
rng = (xmax - xmin)
# Calculate/prcoess the x_labels
if self.x_labels and all(
map(
lambda x: isinstance(x,
(datetime.datetime, datetime.date)),
self.x_labels)):
# Process the given x_labels
x_labels_num = []
for label in self.x_labels:
x_labels_num.append(self._tonumber(label))
x_pos = x_labels_num
# Update the xmin/xmax to fit all of the x_labels and the data
xmin = min(xmin, min(x_pos))
xmax = max(xmax, max(x_pos))
self._box.xmin, self._box.xmax = xmin, xmax
self._box.ymin, self._box.ymax = ymin, ymax
else:
# Automatically generate the x_labels
if rng:
self._box.xmin, self._box.xmax = xmin, xmax
self._box.ymin, self._box.ymax = ymin, ymax
x_pos = compute_scale(self._box.xmin, self._box.xmax,
self.logarithmic, self.order_min)
# Always auto-generate the y labels
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min)
self._x_labels = list(zip(list(map(self._todate, x_pos)), x_pos))
self._y_labels = list(zip(list(map(self._format, y_pos)), y_pos))
def _compute(self):
# Approximatively the same code as in XY.
# The only difference is the transformation of dates to numbers
# (beginning) and the reversed transforamtion to dates (end)
self._offset = min([
val[0] for serie in self.series for val in serie.values
if val[0] is not None
])
for serie in self.series:
serie.values = [(self._tonumber(v[0]), v[1]) for v in serie.values]
xvals = [
val[0] for serie in self.series for val in serie.values
if val[0] is not None
]
yvals = [
val[1] for serie in self.series for val in serie.values
if val[1] is not None
]
if xvals:
xmin = min(xvals)
xmax = max(xvals)
rng = (xmax - xmin)
else:
rng = None
for serie in self.series:
serie.points = serie.values
if self.interpolate and rng:
vals = list(
zip(*sorted([t for t in serie.points if None not in t],
key=lambda x: x[0])))
serie.interpolated = self._interpolate(vals[1],
vals[0],
xy=True,
xy_xmin=xmin,
xy_rng=rng)
if self.interpolate and rng:
xvals = [
val[0] for serie in self.series for val in serie.interpolated
]
yvals = [
val[1] for serie in self.series for val in serie.interpolated
]
if xvals:
xmin = min(xvals)
xmax = max(xvals)
rng = (xmax - xmin)
else:
rng = None
if rng:
self._box.xmin, self._box.xmax = min(xvals), max(xvals)
self._box.ymin, self._box.ymax = min(yvals), max(yvals)
x_pos = compute_scale(self._box.xmin, self._box.xmax, self.logarithmic,
self.order_min)
y_pos = compute_scale(self._box.ymin, self._box.ymax, self.logarithmic,
self.order_min)
self._x_labels = list(zip(list(map(self._todate, x_pos)), x_pos))
self._y_labels = list(zip(list(map(self._format, y_pos)), y_pos))
def _compute(self):
if self.xvals:
if self.xrange:
x_adapter = reduce(
compose, self._x_adapters) if getattr(
self, '_x_adapters', None) else ident
xmin = x_adapter(self.xrange[0])
xmax = x_adapter(self.xrange[1])
else:
xmin = min(self.xvals)
xmax = max(self.xvals)
xrng = (xmax - xmin)
else:
xrng = None
if self.yvals:
ymin = self._min
ymax = self._max
if self.include_x_axis:
ymin = min(ymin or 0, 0)
ymax = max(ymax or 0, 0)
yrng = (ymax - ymin)
else:
yrng = None
for serie in self.all_series:
serie.points = serie.values
if self.interpolate:
vals = list(zip(*sorted(
filter(lambda t: None not in t,
serie.points), key=lambda x: x[0])))
serie.interpolated = self._interpolate(vals[0], vals[1])
if self.interpolate:
self.xvals = [val[0]
for serie in self.all_series
for val in serie.interpolated]
self.yvals = [val[1]
for serie in self.series
for val in serie.interpolated]
if self.xvals:
xmin = min(self.xvals)
xmax = max(self.xvals)
xrng = (xmax - xmin)
else:
xrng = None
if xrng:
self._box.xmin, self._box.xmax = xmin, xmax
if self.x_labels:
self._box.xmin = min(self.x_labels)
self._box.xmax = max(self.x_labels)
if yrng:
self._box.ymin, self._box.ymax = ymin, ymax
if self.y_labels:
self._box.ymin = min(self.y_labels)
self._box.ymax = max(self.y_labels)
x_pos = compute_scale(
self._box.xmin, self._box.xmax, self.logarithmic, self.order_min,
self.min_scale, self.max_scale
) if not self.x_labels else list(map(float, self.x_labels))
y_pos = compute_scale(
self._box.ymin, self._box.ymax, self.logarithmic, self.order_min,
self.min_scale, self.max_scale
) if not self.y_labels else list(map(float, self.y_labels))
self._x_labels = list(zip(map(self._x_format, x_pos), x_pos))
self._y_labels = list(zip(map(self._format, y_pos), y_pos))
