Redraw the series after an update in the axes.
1173
function () {
            var series = this,
              chart = series.chart,
              wasDirtyData = series.isDirtyData, // cache it here as it is set to false in render, but used after
              group = series.group,
              xAxis = series.xAxis,
              yAxis = series.yAxis;

            // reposition on resize
            if (group) {
                if (chart.inverted) {
                    group.attr({
                        width: chart.plotWidth,
                        height: chart.plotHeight
                    });
                }

                group.animate({
                    translateX: pick(xAxis && xAxis.left, chart.plotLeft),
                    translateY: pick(yAxis && yAxis.top, chart.plotTop)
                });
            }

            series.translate();
            if (series.setTooltipPoints) {
                series.setTooltipPoints(true);
            }
            series.render();

            if (wasDirtyData) {
                fireEvent(series, 'updatedData');
            }
        }
1198104
function(after) {

    var
      context = this.ctx,
      i;

    E.fire(this.el, 'flotr:beforedraw', [this.series, this]);

    if (this.series.length) {

      context.save();
      context.translate(this.plotOffset.left, this.plotOffset.top);

      for (i = 0; i < this.series.length; i++) {
        if (!this.series[i].hide) this.drawSeries(this.series[i]);
      }

      context.restore();
      this.clip();
    }

    E.fire(this.el, 'flotr:afterdraw', [this.series, this]);
    if (after) after();
  }
1230317
function(series){
    var _self = this,
      yAxis = series.get('yAxis');
    if(!series.get('visible')){
      series.show();
      if(yAxis){
        _self._resetAxis(yAxis);
        _self._resetSeries();
      }
    }
  }
708146
def update(self, figure):
        

        if hasattr(self, "figure_canvas"):
            self.figure_canvas.Destroy()

        self.figure_canvas = self._get_figure_canvas(figure)

        self.figure_canvas.SetSize(self.GetSize())
        figure.subplots_adjust()

        self.main_sizer.Add(self.figure_canvas, 1,
                            wx.EXPAND | wx.FIXED_MINSIZE, 0)

        self.Layout()
        self.figure_canvas.draw()
159636
def _redraw(self):
        
        for row in self._rows:
            for widget in row:
                widget.grid_forget()

        offset = 0 if not self.headers else 1
        for i, row in enumerate(self._rows):
            for j, widget in enumerate(row):
                widget.grid(row=i+offset, column=j)
1233679
function () {
		var series = this,
			options = series.options,
			yAxis = series.yAxis,
			len,
			i,
			points,
			point,
			shapeArgs,
			stack,
			y,
			yValue,
			previousY,
			previousIntermediate,
			range,
			threshold = options.threshold,
			stacking = options.stacking,
			tooltipY;

		// run column series translate
		seriesTypes.column.prototype.translate.apply(this);

		previousY = previousIntermediate = threshold;
		points = series.points;

		for (i = 0, len = points.length; i < len; i++) {
			// cache current point object
			point = points[i];
			yValue = this.processedYData[i];
			shapeArgs = point.shapeArgs;

			// get current stack
			stack = stacking && yAxis.stacks[(series.negStacks && yValue < threshold ? '-' : '') + series.stackKey];
			range = stack ? 
				stack[point.x].points[series.index + ',' + i] :
				[0, yValue];

			// override point value for sums
			// #3710 Update point does not propagate to sum
			if (point.isSum) {
				point.y = yValue;
			} else if (point.isIntermediateSum) {
				point.y = yValue - previousIntermediate; // #3840
			}
			// up points
			y = mathMax(previousY, previousY + point.y) + range[0];
			shapeArgs.y = yAxis.translate(y, 0, 1);


			// sum points
			if (point.isSum) {
				shapeArgs.y = yAxis.translate(range[1], 0, 1);
				shapeArgs.height = yAxis.translate(range[0], 0, 1) - shapeArgs.y;

			} else if (point.isIntermediateSum) {
				shapeArgs.y = yAxis.translate(range[1], 0, 1);
				shapeArgs.height = yAxis.translate(previousIntermediate, 0, 1) - shapeArgs.y;
				previousIntermediate = range[1];

			// If it's not the sum point, update previous stack end position and get 
			// shape height (#3886)
			} else {
				if (previousY !== 0) { // Not the first point
					shapeArgs.height = yValue > 0 ? 
						yAxis.translate(previousY, 0, 1) - shapeArgs.y :
						yAxis.translate(previousY, 0, 1) - yAxis.translate(previousY - yValue, 0, 1);
				}
				previousY += yValue;
			}
			// #3952 Negative sum or intermediate sum not rendered correctly
			if (shapeArgs.height < 0) {
				shapeArgs.y += shapeArgs.height;
				shapeArgs.height *= -1;
			}

			point.plotY = shapeArgs.y = mathRound(shapeArgs.y) - (series.borderWidth % 2) / 2;
			shapeArgs.height = mathMax(mathRound(shapeArgs.height), 0.001); // #3151
			point.yBottom = shapeArgs.y + shapeArgs.height;

			// Correct tooltip placement (#3014)
			tooltipY = point.plotY + (point.negative ? shapeArgs.height : 0);
			if (series.chart.inverted) {
				point.tooltipPos[0] = yAxis.len - tooltipY;
			} else {
				point.tooltipPos[1] = tooltipY;
			}

		}
	}
198255
def rebin(a, newshape):
    """"""

    slices = [slice(0, old, float(old)/new)
              for old, new in zip(a.shape, newshape)]
    coordinates = numpy.mgrid[slices]
    # choose the biggest smaller integer index
    indices = coordinates.astype('i')
    return a[tuple(indices)]
412651
def _reassigned_axes_event(event, ax):
    """"""
    event = copy.copy(event)
    event.xdata, event.ydata = (
        ax.transData.inverted().transform_point((event.x, event.y)))
    return event
653453
def reshape(self, newshape, order='C'):
        
        oldshape = self.shape
        ar = np.asarray(self).reshape(newshape, order=order)
        if (newshape is -1 and len(oldshape) is 1 or
                (isinstance(newshape, numbers.Integral) and 
                    newshape == oldshape[0]) or 
                (isinstance(newshape, Sequence) and
                    (newshape[0] == oldshape[0] or
                     (newshape[0] is -1 and np.array(oldshape[1:]).prod() ==
                                            np.array(newshape[1:]).prod())))):
            # then axis 0 is unaffected by the reshape
            newlabels = [None] * ar.ndim
            i = 1
            while i < ar.ndim and i < self.ndim and ar.shape[i] == oldshape[i]:
                newlabels[i] = self.labels[i]
                i += 1
            return Timeseries(ar, self.tspan, newlabels)
        else:
            return ar
615349
def redraw_data(self, whence=0):
        
        if not self._imgwin_set:
            # window has not been realized yet
            return

        if not self._self_scaling:
            rgbobj = self.get_rgb_object(whence=whence)
            self.renderer.render_image(rgbobj, self._dst_x, self._dst_y)

        self.private_canvas.draw(self)

        self.make_callback('redraw', whence)

        if whence < 2:
            self.check_cursor_location()
955867
protected void redraw() {

        if (isAttached()) {
            int outerHeight = getElement().getOffsetHeight();
            int innerHeight = m_containerElement.getOffsetHeight();
            if (outerHeight >= innerHeight) {
                setScrollbarVisible(false);
            } else {
                setScrollbarVisible(true);
                adjustKnobHeight(outerHeight, innerHeight);
                setKnobPosition(m_currentValue);
            }
        }
        if (m_slidingMouse) {
            m_mouseSlidingStartY = m_lastMouseY;
            m_mouseSlidingStartValue = m_currentValue;
        }
    }
1006618
public void updateScale() {
        scaleX = targetPpiX / Gdx.graphics.getPpiX();
        scaleY = targetPpiY / Gdx.graphics.getPpiY();
    }
1362463
function () {
			var series = this,
				yAxis = series.yAxis,
				plotHigh;

			colProto.translate.apply(series);

			// Set plotLow and plotHigh
			each(series.points, function (point) {
				var shapeArgs = point.shapeArgs,
					minPointLength = series.options.minPointLength,
					heightDifference,
					height,
					y;

				point.tooltipPos = null; // don't inherit from column
				point.plotHigh = plotHigh = yAxis.translate(point.high, 0, 1, 0, 1);
				point.plotLow = point.plotY;

				// adjust shape
				y = plotHigh;
				height = point.plotY - plotHigh;

				if (height < minPointLength) {
					heightDifference = (minPointLength - height);
					height += heightDifference;
					y -= heightDifference / 2;
				}
				shapeArgs.height = height;
				shapeArgs.y = y;
			});
		}
427028
public void redraw() {
        Layers mapOverlays = clusterManager.getMapView().getLayerManager().getLayers();
        if (clusterMarker != null && !clusterManager.getCurBounds().contains(center)
                && mapOverlays.contains(clusterMarker)) {
            mapOverlays.remove(clusterMarker);
            return;
        }
        if (clusterMarker != null
                && mapOverlays.size() > 0
                && !mapOverlays.contains(clusterMarker)
                && !clusterManager.isClustering) {
            mapOverlays.add(1, clusterMarker);
        }
    }
531808
function () {

            // render the axis
            this.render();

            // move plot lines and bands
            each(this.plotLinesAndBands, function (plotLine) {
                plotLine.render();
            });

            // mark associated series as dirty and ready for redraw
            each(this.series, function (series) {
                series.isDirty = true;
            });

        }
1307786
def redraw(self):
        

        # Check if the refresh time lapse has elapsed and if a change requires to redraw
        lapse_since_last_refresh = millis() - self.refresh_timer
        if not lapse_since_last_refresh > self.redraw_frequency_millis or not self.changes_made:
            return
        # If yes, then reset change indicator and chrono
        self.changes_made = False
        self.refresh_timer = millis()

        # Clear the system console
        os.system(self.os_flush_command)

        # For each task, check if it has complete. If so, start its chrono
        # Once the chrono has reached the maximum timeout time, delete the task
        # For the other tasks that have not completed yet, redraw them

        # Delete tasks that have been marked for deletion
        if len(self.to_delete) > 0:
            for task_id in self.to_delete:
                del self.tasks[task_id]
            self.to_delete = []
            # If a task has been deleted, recalculate the maximum prefix length to keep progress bars aligned
            self.longest_bar_prefix_size = self.longest_bar_prefix_value()

        for task_id, task in self.tasks.items():

            # If a task has completed, force its value to its maximum to prevent progress bar overflow
            # Then start its timeout chrono
            if task.progress >= task.total and not task.keep_alive:
                # Prevent bar overflow
                task.progress = task.total

                # Start task's timeout chrono
                if not task.timeout_chrono:
                    task.timeout_chrono = millis()
                # If task's chrono has reached the maximum timeout time, mark it for deletion
                elif millis() - task.timeout_chrono >= self.task_millis_to_removal:
                    self.to_delete.append(task_id)

            # Redraw the task's progress bar through standard output
            self.print_progress_bar(task=task)

        # Keep space for future tasks if needed
        slots = self.permanent_progressbar_slots - len(self.tasks)
        if slots > 0:
            for i in range(slots):
                sys.stdout.write('\n\t\t---\n')

        # Draw some space between bars and messages
        if len(self.messages) > 0:
            if self.permanent_progressbar_slots > 0 or len(self.tasks) > 0:
                sys.stdout.write('\n\n')

            # Print all the last log messages through standard output
            for m in self.messages:
                sys.stdout.write(m)

        # Draw some space between messages and exceptions
        if len(self.exceptions) > 0:
            if len(self.messages) > 0:
                sys.stdout.write('\n\n')

            # Print all the exceptions through error output
            for ex in self.exceptions:
                sys.stderr.write(ex)
698570
def refresh_styles(self):
        """"""
        import matplotlib.pyplot as plt

        self.colours = {}
        for style in plt.style.available:
            try:
                style_colours = plt.style.library[style]['axes.prop_cycle']
                self.colours[style] = [c['color'] for c in list(style_colours)]
            except KeyError:
                continue

        self.colours['km3pipe'] = [
            "#ff7869", "#4babe1", "#96ad3e", "#e4823d", "#5d72b2", "#e2a3c2",
            "#fd9844", "#e480e7"
        ]