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(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))