Draw the actual plot.
196114
def _plot(self):
        

        w = self
        kbos = self.kbos
        re_string = w.FilterVar.get()
        vlist = []
        for name in kbos:
            if not re.search(re_string, name):
                continue
            vlist.append(name)
            fill = None
            is_colossos_target = False
            for cname in parameters.COLOSSOS:
                if cname in name:
                    is_colossos_target = True
                    print "ColOSSOS: ", cname
                    break
            is_terminated = False
            for cname in tracking_termination:
                if cname in name:
                    is_terminated = True
                    print "Terminated", cname
                    break
            is_double = False
            for cname in doubles:
                if cname in name:
                    is_double = True
                    print 'Needs double:', cname
                    break
            if type(kbos[name]) == type(ephem.EllipticalBody()):
                try:
                    kbos[name].compute(w.date.get())
                except Exception as e:
                    logging.error("Failed to compute KBO position. {}".format(name))
                    continue
                ra = kbos[name].ra
                dec = kbos[name].dec
                a = math.radians(10.0 / 3600.0)
                b = a
                ang = 0.0
                point_size = 1
                yoffset = +10
                xoffset = +10
            elif isinstance(kbos[name], orbfit.Orbfit):
                yoffset = -10
                xoffset = -10
                kbo = kbos[name]
                pointing_date = mpc.Time(w.date.get(), scale='utc').jd
                trail_mid_point = 0
                for days in range(trail_mid_point * 2 + 1):
                    point_size = days == trail_mid_point and 5 or 1
                    today = mpc.Time(pointing_date - trail_mid_point + days, scale='utc', format='jd')
                    kbo.predict(today, 568)
                    ra = kbo.coordinate.ra.radian
                    dec = kbo.coordinate.dec.radian
                    from astropy import units
                    a = kbo.dra.to(units.radian).value
                    b = kbo.ddec.to(units.radian).value
                    ang = kbo.pa.to(units.radian).value
                    lost = False
                    if a > math.radians(0.3):
                        lost = True

                fill_colour = (lost and "red") or "grey"
                fill_colour = (is_double and "magenta") or fill_colour
                fill_colour = (is_colossos_target and "blue") or fill_colour
                point_colour = (is_terminated and "red") or "black"
                w.create_point(ra, dec, size=point_size, color=point_colour, fill=fill_colour)
                if w.show_ellipse.get() == 1 and days == trail_mid_point:
                    if a < math.radians(5.0):
                        w.create_ellipse(ra,
                                         dec,
                                         a,
                                         b,
                                         ang)
                    if w.show_labels.get() == 1:
                        w.label(ra, dec, name, offset=[xoffset, yoffset])
            else:
                ra = kbos[name]['RA']
                dec = kbos[name]['DEC']
                w.create_point(ra, dec, size=4, color='cyan')
                w.label(ra, dec, name[-2:], offset=[-15, +15])  # truncate object name for plot clutter clarity

        vlist.sort()
        for v in vlist:
            w.objList.insert(END, v)
        w.plot_pointings()
914933
def draw(self, milliseconds, surface, cell):
        """"""
        # print self.cells[cell]
        self.source = self.cells[cell].copy()
        # Find the current scale of the image in relation to its original scale.
        current_scale = Vector2()
        current_scale.X = self.rect.width / float(self.untransformed_image.get_width())
        current_scale.Y = self.rect.height / float(self.untransformed_image.get_height())
        # self.source.x *= self.scale.X
        # self.source.y *= self.scale.Y
        self.source.width *= current_scale.X
        self.source.height *= current_scale.Y
        super(SpriteSheet, self).draw(milliseconds, surface)
854174
def plot(self,x,y,panel=None,**kws):
        
        if panel is None:
            panel = self.current_panel
        opts = {}
        opts.update(self.default_panelopts)
        opts.update(kws)
        self.panels[panel].plot(x ,y, **opts)
368213
public void draw() {
		//=================================================================
		//Now plot the STP with the Utility.PlotSTPTemporalModule class
		//=================================================================
		PlotSTPTemporalModule view;
		Toolkit tk = Toolkit.getDefaultToolkit();
		int xSize = ((int) tk.getScreenSize().getWidth());
		int ySize = ((int) tk.getScreenSize().getHeight());
		//int ySize = 500;

		//GIVE tm TO VISIUALIZER		
		view = new PlotSTPTemporalModule(this, xSize, ySize);
		JFrame myFrame = new JFrame("Simple Temporal Network");

		Container pane = myFrame.getContentPane();
		pane.setLayout(new BorderLayout());
		pane.add(view, BorderLayout.NORTH);
		myFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

		myFrame.setSize(xSize,ySize);

		myFrame.pack();
		myFrame.setVisible(true);

		view.touchLBUBNodes();
		//=================================================================
		//End STP plotting
		//=================================================================
	}
108369
def draw(self):
        
        pos = np.arange(self.scores_.shape[0]) + 0.5

        self.ax.barh(pos, self.scores_)

        # Set the labels for the bars
        self.ax.set_yticks(pos)
        self.ax.set_yticklabels(self.features_)

        return self.ax
672990
def _draw_lines(self, bg, colour, extent, line, xo, yo):
        """"""
        coords = [self._scale_coords(x, y, extent, xo, yo) for x, y in line]
        self._draw_lines_internal(coords, colour, bg)
22421
def show(self, *args, **kwargs):
        
        plt = self.get_pourbaix_plot(*args, **kwargs)
        plt.show()
1266916
def plot(self, **kwds):
        """
        plo = self.lx.plot(dist_to_center=3, **kwds)
        plo += self.ly.plot(dist_to_center=3, **kwds)
        plo += self.lz.plot(dist_to_center=3, **kwds)
        plo += self.lx_r.plot(dist_to_center=3, **kwds)
        plo += self.ly_r.plot(dist_to_center=3, **kwds)
        plo += self.lz_r.plot(dist_to_center=3, **kwds)
        return plo
194051
def _plot(self):
        """"""
        for serie in self.series[::-1 if self.stack_from_top else 1]:
            self.line(serie)
        for serie in self.secondary_series[::-1 if self.stack_from_top else 1]:
            self.line(serie, True)
657361
def plot(self, x, y, **kw):
        
        self.panel.plot(x, y, **kw)
1245191
def draw_figure(self,data_for_color=None, data_for_size=None, data_for_clouds=None, rot_bonds=None, color_for_clouds="Blues", color_type_color="viridis"):
        
        self.molecule = Molecule(self.topol_data)

        self.draw = Draw(self.topol_data,self.molecule,self.hbonds,self.pistacking,self.salt_bridges,self.lig_descr)
        self.draw.draw_molecule(data_for_color, data_for_size, data_for_clouds, rot_bonds, color_for_clouds, color_type_color)

        self.figure = Figure(self.molecule,self.topol_data,self.draw)
        self.figure.add_bigger_box()
        self.figure.manage_the_plots()
        self.figure.draw_white_circles()
        self.figure.put_everything_together()
        self.figure.write_final_draw_file(self.output_name)
117289
def draw(self):
        '''
        
        '''
        return np.random.normal(loc=self.__mu, scale=self.__sigma, size=self.__output_shape)
806848
def draw(self):
        """"""
        if not self.visible:
            return

        self.window.blit(self.textImage, self.loc)
1360699
def plot(self, size=1):
        
        n = len(self)
        fig, ax = plt.subplots(1, 1, figsize=(n * size, size))
        ax.imshow(np.arange(n).reshape(1,n),
                  cmap=mpl.colors.ListedColormap(list(self)),
                  interpolation="nearest", aspect="auto")
        ax.set_xticks(np.arange(n) - .5)
        ax.set_yticks([-.5, .5])
        ax.set_xticklabels([])
        ax.set_yticklabels([])
588887
def plot(self, x, y, **kw):
        
        return self.frame.plot(x,y,**kw)
998460
def plot(self, figsize=None, ax=None, **kwargs):
        '''
        
        '''
        if ax is None:
            fig, ax = plt.subplots(figsize=figsize)
        ax.set_aspect('equal')
        ax.matshow(self.raster, **kwargs)
        plt.draw()
        return ax
598743
def plotIndividual(self):
		'''
		
		'''
		pl.plot(self.x_int, self.y_int)
		pl.grid(True)
		pl.show()