def __init__(self):
        """
        Class constructor
        """

        Figure.__init__(self, dpi=100)
        self.plot = self.add_subplot(111)
Exemplo n.º 2
0
    def __init__(self):
        Figure.__init__(self)
        self.subfigures = []
        palette = sns.color_palette("YlOrRd", 7)
        self.cmap = sns.blend_palette(palette, as_cmap=True)

        self.canvas = FigureCanvas
Exemplo n.º 3
0
    def __init__(self, *args, **kwargs):
        self.fig_args = {
            'values': kwargs.pop('values', []),
            'rows': kwargs.pop('rows', None),
            'columns': kwargs.pop('columns', None),
            'colors': kwargs.pop('colors', None),
            'labels': kwargs.pop('labels', None),
            'legend': kwargs.pop('legend', {}),
            'icon_legend': kwargs.pop('icon_legend', False),
            'interval_ratio_x': kwargs.pop('interval_ratio_x', 0.2),
            'interval_ratio_y': kwargs.pop('interval_ratio_y', 0.2),
            'block_aspect': kwargs.pop('block_aspect', 1),
            'cmap_name': kwargs.pop('cmap_name', 'Set2'),
            'title': kwargs.pop('title', None),
            'icons': kwargs.pop('icons', None),
            'icon_size': kwargs.pop('icon_size', None),
            'plot_anchor': kwargs.pop('plot_anchor', 'W'),
        }
        self.plots = kwargs.pop('plots', None)

        # If plots is empty, make a single waffle chart
        if self.plots is None:
            self.plots = {111: self.fig_args}

        Figure.__init__(self, *args, **kwargs)

        for loc, setting in self.plots.items():
            self._waffle(loc, **copy.deepcopy(setting))

        # Adjust the layout
        self.set_tight_layout(True)
Exemplo n.º 4
0
    def __init__(self, parent, *args, **kwargs):
        ##        QtCore.QThread.__init__(self, parent)
        ##        threading.Thread.__init__(self)
        Figure.__init__(self, *args, **kwargs)

        self.plot_data = list()
        self.figures = list()
Exemplo n.º 5
0
    def __init__(self, master, size, xlabel, ylabel, **kwargs):
        """Create empty plot and initialize options.

        Args:
            master (snr_gui.LayoutFrame): container frame widget
            size (tuple): width and height of plot in inches
            xlabel (str): x-axis title
            ylabel (str): y-axis title
            **kwargs: additional options for plot
        """

        Figure.__init__(self, figsize=size, facecolor="white")
        self.xlabel = xlabel
        self.ylabel = ylabel
        self.graph = self.add_subplot(111,
                                      xlabel=self.xlabel,
                                      ylabel=self.ylabel,
                                      **kwargs)
        self.ticker = mpl.ticker.ScalarFormatter(useMathText=True,
                                                 useOffset=False)
        self.graph.xaxis.set_major_formatter(self.ticker)
        self.graph.yaxis.set_major_formatter(self.ticker)
        self.graph.xaxis.get_major_formatter().set_powerlimits((-4, 4))
        self.graph.yaxis.get_major_formatter().set_powerlimits((-4, 4))
        self.graph.xaxis.labelpad = 2
        self.graph.yaxis.labelpad = 2
        self.canvas = FigureCanvasTkAgg(self, master=master)
        self.canvas.show()
        self.canvas.get_tk_widget().grid(column=0, row=0)
        # Remove scientific notation from edges of axes (will be added to axis titles when plot limits are known)
        self.graph.xaxis.offsetText.set_visible(False)
        self.graph.yaxis.offsetText.set_visible(False)
Exemplo n.º 6
0
 def __init__(self, *args, **kwargs):
     """
     custom kwarg figtitle is a figure title
     """
     figtitle = kwargs.pop('figtitle', 'hi mom')
     Figure.__init__(self, *args, **kwargs)
     self.text(0.5, 0.95, figtitle, ha='center')
    def __init__(self, player, mod):
        Figure.__init__(self, figsize=(5, 5), dpi=150)
        self.plot = self.add_subplot(111)

        with urllib.request.urlopen(
                "https://api.faforever.com/data/gamePlayerStats?"
                "filter=player.login=={0};"
                "game.featuredMod.technicalName=={1}"
                "&fields[gamePlayerStats]=afterMean,afterDeviation,faction,scoreTime"
                "&page[limit]=10000".format(player, mod)) as url:
            data = json.loads(url.read())
        # with open('/home/brett/Documents/Code/data/spocko.json', 'r') as infile:
        #     data = json.loads(infile.read())

        colors = ['#00486b', '#005119', '#801609', '#9a751d']
        time = []
        rating = []
        faction = []

        for i in data['data']:
            f = int((i['attributes']['faction']) - 1)
            if i['attributes']['scoreTime'] is not None and i['attributes'][
                    'afterMean'] is not None and f < 4:
                time.append(
                    datetime.datetime.strptime(i['attributes']['scoreTime'],
                                               '%Y-%m-%dT%H:%M:%SZ') -
                    datetime.timedelta(hours=8))
                rating.append(i['attributes']['afterMean'] -
                              3 * i['attributes']['afterDeviation'])
                faction.append(colors[f])

        self.plot.plot(time, rating, alpha=.5, c='black', linewidth=.8)
        self.plot.scatter(time, rating, color=faction, s=5)
Exemplo n.º 8
0
 def __init__(self, *args, **kwargs):
     """
     custom kwarg figtitle is a figure title
     """
     figtitle = kwargs.pop('figtitle', 'hi mom')
     Figure.__init__(self, *args, **kwargs)
     self.text(0.5, 0.95, figtitle, ha='center')
Exemplo n.º 9
0
    def __init__(self, sigs={}, fig=None):
        """ Instanciate a Figure.
        If a signal list is provided, add a graph with the signal list
        By default, create an empty list of graph and set the layout to horiz

        Parameters
        ----------
        sigs: dict of Signals
        If provided, the function instanciate the Figure with one Graph and
        insert the Signals

        fig: Not used

        Returns
        -------
        The figure instanciated and initialized
        """
        MplFig.__init__(self)

        self._layout = "horiz"
        self._MODES_NAMES_TO_OBJ = {'lin':LinGraph, 'polar':PolarGraph, 'smith':SmithChart, 'eye':EyeGraph}
        self._kid = None
        # FIXME: Slow way... Surely there exist something faster
        self._OBJ_TO_MODES_NAMES = {}
        for k, v in self._MODES_NAMES_TO_OBJ.items():
            self._OBJ_TO_MODES_NAMES[v] = k

        if not sigs:
            return
        elif isinstance(sigs, dict):
            self.add(sigs)
        else:
            print(sigs)
            assert 0, _("Bad type")
    def __init__(self, model: GraphPlotterModel, *args, **kwargs):
        Figure.__init__(self,
                        figsize=(1.5, 1),
                        facecolor=self.convertColor(model.faceColor),
                        edgecolor=self.convertColor(model.edgeColor),
                        *args,
                        **kwargs)
        View.__init__(self)

        # Data model references
        self.model = model

        # GraphPlotter view components
        self.graphViews = []
        self.axesViews = []
        self.legendView = None

        # Updating initial views
        for graphModel in self.model.graphModels:
            self.onGraphModelAdded(graphModel)
        for axesModel in self.model.axesModels:
            self.onAxesModelAdded(axesModel)

        # Signal and slot connection
        self.model.graphModelAdded.connect(self.onGraphModelAdded)
        self.model.graphModelRemoved.connect(self.onGraphModelRemoved)
        self.model.axesModelAdded.connect(self.onAxesModelAdded)
        self.model.axesModelRemoved.connect(self.onAxesModelRemoved)
        self.model.propertyChanged.connect(self.onPropertyChanged)
Exemplo n.º 11
0
    def __init__(self,
                 nb_lin,
                 nb_col,
                 height,
                 width,
                 projection=None,
                 **figure_properties):
        """
        Prepare a figure with a specified number axes

        Parameters
        ----------
        nb_lin, nb_lin      integer
                            Number of lines and number of columns

        height, width       float
                            Height and width of the figure in inches

        axes_properties:    set of axes properties
        """

        figure_properties['figsize'] = (width, height)

        Figure.__init__(self, **figure_properties)

        self.nb_lin = nb_lin
        self.nb_col = nb_col

        gs = gridspec.GridSpec(nb_lin, nb_col)
        self.ax = np.ndarray((nb_lin, nb_col), dtype=Axes)
        for row in range(gs._nrows):
            for col in range(gs._ncols):
                self.ax[row, col] = self.add_subplot(gs[row, col],
                                                     projection=projection)
Exemplo n.º 12
0
 def __init__(self,master,size,dpi,task):
     Figure.__init__(self,figsize=(size[0]/dpi,size[1]/dpi),dpi=dpi,facecolor='w',edgecolor='b',frameon=True,linewidth=0)
     FigureCanvas(self,master=master)
     self.master = master
     self._errors = collections.OrderedDict()
     self._dirty = True
     self._task = task
     self.add_subplot(111,axisbg='w')
Exemplo n.º 13
0
    def __init__(self, opt_model, eval_fct=trace_astigmatism, **kwargs):
        self.opt_model = opt_model
        self.scale_type = Fit.All
        self.eval_fct = eval_fct

        Figure.__init__(self, **kwargs)

        self.update_data()
Exemplo n.º 14
0
 def __init__(self, *args, **kwargs):
     """
     custom kwarg figtitle is a figure title
     """
     fig_title = kwargs.pop('figtitle')
     x_label = kwargs.pop('xlabel')
     Figure.__init__(self, *args, **kwargs)
     self.text(0.5, 0.95, fig_title, x_label, ha='center')
Exemplo n.º 15
0
 def __init__(self,
              figsize=None,
              ticksize=None,
              labelsize=None,
              titlesize=None,
              textsize=None):
     Figure.__init__()
     if ""
Exemplo n.º 16
0
 def __init__(self, x_list, y_list, title=None):
     Figure.__init__(self, facecolor="white")
     ax = self.add_subplot(111)
     if title is not None:
         ax.set_title(title, fontsize=10)
     ax.scatter(x_list, y_list)
     ind = np.arange(len(x_list)) + 1
     ax.set_xticks(ind)
     ax.set_xlim(left=0, right=len(x_list) + 1)
Exemplo n.º 17
0
 def __init__(self):
     Figure.__init__(self)
     self.subfigures = []
     self.subplots_adjust(bottom=0.1, right=0.8)
     self.dayLocator = DayLocator()
     self.hourLocator = HourLocator(interval=3)
     self.dateFormat = DateFormatter('%H:%M \n %Y-%m-%d')
     self.set_size_inches(12, 4)
     self.dirTickLocator = MultipleLocator(45)
Exemplo n.º 18
0
 def __init__(self):
     Figure.__init__(self)
     self.subfigures = []
     self.subplots_adjust(bottom=0.1, right=0.8)
     self.dayLocator = DayLocator()
     self.hourLocator = HourLocator(interval=3)
     self.dateFormat = DateFormatter('%H:%M \n %Y-%m-%d')
     self.set_size_inches(12, 4)
     self.dirTickLocator = MultipleLocator(45)
Exemplo n.º 19
0
 def __init__(self, **kwargs):
     Figure.__init__(self, **kwargs)
     self.markers = []
     self.epsilon = 10.0
     self.drag_idx = -1
     self.timer = None
     self.marker_line_info = None
     self.pick_sets = []
     self.pick_funs = []
Exemplo n.º 20
0
 def __init__(self, Acc_X=0, Acc_Y=1, Acc_Z=0, *args, **kwargs):
     Figure.__init__(self, *args, **kwargs)
     self.ax = self.gca(projection='3d')
     self.ax.set_aspect("equal")
     self.ax.set_xlim(-1, 1)
     self.ax.set_ylim(-1, 1)
     self.ax.set_zlim(-1, 1)
     self.ax.scatter([0], [0], [0], color="g", s=100)
     self.object = object3D(Acc_X, Acc_Y, Acc_Y)
     self.ax.add_artist(self.object)
Exemplo n.º 21
0
 def __init__(self):
     Figure.__init__(self, figsize=(5, 5), dpi=100)
     self.plot = self.add_subplot(
         111, projection='3d')  #projection='3d' for 3d view
     #sets limit of axis
     self.plot.set_ylim(0, 100)
     self.plot.set_xlim(0, 100)
     self.plot.set_zlim(0, 100)
     #self.plot.plot([1, 2, 3, 4, 5, 6, 7], [4, 3, 5, 0, 2, 0, 6],[7, 3, 5, 4, 2, 8, 6])
     GraphPage.line, = self.plot.plot(xar, yar, zar)  #plots the line
Exemplo n.º 22
0
 def __init__(self, *args, **kwds):
     Figure.__init__(self, *args, **kwds)
     self.xzoom = 10
     self.yzoom = 10
     self.zfloor = 1
     self.ax = []
     self.ay = []
     self.shiftsdat = 'shifts.dat'
     self.auxpeaks_loaded = False
     self.shift_globally = False
Exemplo n.º 23
0
    def __init__(self, width=5, height=4, dpi=100):

        Figure.__init__(self, figsize=(width, height), dpi=dpi)

        self._axes = self.add_subplot(111)

        # We want the axes cleared every time plot() is called

        self._plots = []
        self._grid = False
Exemplo n.º 24
0
    def __init__(self, dpi=200, figsize=(12, 8), data_lst=None):
        Figure.__init__(self, dpi=dpi, figsize=figsize)
        nccd = 3
        axh = 0.8

        self.ax_imag_lst = []
        self.ax_ycut_lst = []
        self.ax_hist_lst = []
        self.ax_cbar_lst = []
        for iccd in range(nccd):
            data = data_lst[iccd]
            ny, nx = data.shape
            axw = axh / figsize[0] * figsize[1] / ny * nx
            ax_imag = self.add_axes([0.1 + iccd * 0.20, 0.07, axw, axh])
            ax_ycut = ax_imag.twiny()
            ax_hist = self.add_axes(
                [0.7, 0.07 + (nccd - iccd - 1) * 0.28 + 0.03, 0.25, 0.2])
            ax_cbar = self.add_axes(
                [0.7, 0.07 + (nccd - iccd - 1) * 0.28, 0.25, 0.02])

            self.ax_imag_lst.append(ax_imag)
            self.ax_ycut_lst.append(ax_ycut)
            self.ax_hist_lst.append(ax_hist)
            self.ax_cbar_lst.append(ax_cbar)

            vmin = np.percentile(data, 1)
            vmax = np.percentile(data, 99)
            cax = ax_imag.imshow(data, origin='lower', vmin=vmin, vmax=vmax)
            self.colorbar(cax, cax=ax_cbar, orientation='horizontal')
            ax_imag.set_xlabel('X (pixel)')
            if iccd == 0:
                ax_imag.set_ylabel('Y (pixel)')

            ax_imag.set_xlim(0, nx - 1)
            ax_imag.set_ylim(0, ny - 1)
            ax_imag.xaxis.set_major_locator(tck.MultipleLocator(500))
            ax_imag.xaxis.set_minor_locator(tck.MultipleLocator(100))
            ax_imag.yaxis.set_major_locator(tck.MultipleLocator(500))
            ax_imag.yaxis.set_minor_locator(tck.MultipleLocator(100))
            ax_imag.set_title('CCD {}'.format(iccd + 1))
            #ax_ycut.set_ylim(0, ny-1)

            # plot histogram
            bins = np.linspace(vmin, vmax, 50)
            color = ('C0', 'C2', 'C3')[iccd]
            ax_hist.hist(data.flatten(),
                         bins=bins,
                         color=color,
                         label='CCD {}'.format(iccd + 1))
            ax_hist.legend(loc='upper right')
            ax_hist.set_xticklabels([])
            ax_hist.set_xlim(vmin, vmax)
            ax_cbar.set_xlim(vmin, vmax)

        self.suptitle('Bias')
Exemplo n.º 25
0
 def __init__(self, lat, lon, eP, cP, rMax, beta, beta1=1.5, beta2=1.4):
     Figure.__init__(self)
     self.R = np.array(list(range(1, 201)), 'f')
     self.lat = lat
     self.lon = lon
     self.rMax = rMax
     self.eP = eP
     self.cP = cP
     self.beta = beta
     self.beta1 = beta1
     self.beta2 = beta2
Exemplo n.º 26
0
 def __init__(self, lat, lon, eP, cP, rMax, beta, beta1=1.5, beta2=1.4):
     Figure.__init__(self)
     self.R = np.array(range(1, 201), 'f')
     self.lat = lat
     self.lon = lon
     self.rMax = rMax
     self.eP = eP
     self.cP = cP
     self.beta = beta
     self.beta1 = beta1
     self.beta2 = beta2
Exemplo n.º 27
0
 def __init__(self, *args, **kwargs):
     """
     custom kwarg figtitle is a figure title
     """
     figtitle = kwargs.pop('figtitle', 'hi mom')
     Figure.__init__(self, *args, **kwargs)
     self.text(0.5, 0.95, figtitle, ha='center')
     self.y = np.zeros(100, dtype=float)
     self.x = range(100)
     self.subplots_adjust(left=0.25, bottom=0.25)
     self.lock = threading.Lock()
Exemplo n.º 28
0
    def __init__(self, code_matrix, row_labels, title=None, show_it=True, gray_only=False, tailored_cmap_list=None, xlabels=None):
        Figure.__init__(self, figsize=(8,1))
        self.dialogs = []
        (ntopics, nsegments) = code_matrix.shape
        if gray_only:
            cmap_list = ["Greys"]
        elif tailored_cmap_list is not None:
            cmap_list = tailored_cmap_list
        else:
            cmap_list = ['Reds', "Oranges", 'Greens', "Blues", 'Purples', "Greys"]
        axes = []
        for j in range(ntopics):
            axes.append(self.add_subplot(ntopics, 1, j + 1))
            if j < ntopics:
                axes[j].set_xticks([])
        self.subplots_adjust(left=.15, bottom=.2, right=.98, top=.80)
        self.set_facecolor("white")
        # pylab.figure(fig.number)

        ind = np.arange(nsegments)

        axes[-1].set_xticks(ind)
        if xlabels is None:
            axes[-1].get_xaxis().set_ticklabels(ind + 1, size="x-small")
        else:
            axes[-1].get_xaxis().set_ticklabels(xlabels, size="x-small", rotation="vertical")

        # pylab.xticks(ind, ind + 1, size="small")

        for the_row in range(ntopics):
            for the_seg in range(nsegments):
                if code_matrix[the_row, the_seg] < 0:
                    code_matrix[the_row, the_seg] = 0

        if title is not None:
            axes[0].set_title(title, fontsize=10)

        vmax = np.amax(code_matrix)
        for topic in range(ntopics):
            ax = axes[topic]
            ax.set_yticks([])
            # pylab.sca(ax)
            ax.tick_params(length=0)
            for i in ind:
                ax.axvline(x=i+.5, linestyle = "-", linewidth = .25, color = 'black')
            for spine in ax.spines.itervalues():
                spine.set_visible(False)
            the_row = np.vstack((code_matrix[topic], code_matrix[topic]))
            ax.imshow(the_row, aspect="auto", cmap=get_cmap(cmap_list[topic % (len(cmap_list))]), interpolation='nearest', vmin=0, vmax=vmax)
            if row_labels is not None:
                the_label = row_labels[topic]
            else:
                the_label = "Topic " + str(topic)
            ax.set_ylabel(the_label, rotation="horizontal", horizontalalignment='right', verticalalignment='center', fontsize=10)
Exemplo n.º 29
0
 def __init__(self, *args, **kwargs):
     """
     custom kwarg figtitle is a figure title
     """
     figtitle = kwargs.pop('figtitle', 'hi mom')
     Figure.__init__(self, *args, **kwargs)
     self.text(0.5,
               0.95,
               figtitle,
               ha='center',
               va='bottom',
               fontsize=FONT_SIZE * 0.5)
Exemplo n.º 30
0
 def __init__(self,master,size,dpi,data,fold):
     Figure.__init__(self,figsize=(size[0]/dpi,size[1]/dpi),dpi=dpi,facecolor='w',edgecolor='b',frameon=True,linewidth=0)
     FigureCanvas(self,master=master)
     self.master = master
     self._dirty = True
     self._fold = fold
     self._indices = None
     self._targets = None
     self._outputs = None
     self._outshape = data.Yshape
     self._outrange = data.Yrange
     self.add_subplot(111,axisbg='w')
Exemplo n.º 31
0
 def __init__(self, x_name, y_name, *args, **kwargs):
     Figure.__init__(self, *args, **kwargs)
     self.plot_axes = self.add_subplot(111, xlabel=x_name,
                                       ylabel=y_name.upper())
     self.plot_line = None
     self.canvas = FigureCanvas(self)
     self.plot_xname = x_name
     self.plot_yname = y_name
     self.plot_xdata = []
     self.plot_ydata = []
     self.plot_line, = self.plot_axes.plot(self.plot_xdata, self.plot_ydata)
     self.plot_max_points = 200
Exemplo n.º 32
0
 def __init__(self,master,size,dpi,get_matrices_fn,percentiles,transposed,ranges=None,title=""):
     Figure.__init__(self,figsize=(size[0]/dpi,size[1]/dpi),dpi=dpi,facecolor='w',edgecolor='b',frameon=True,linewidth=0)
     FigureCanvas(self,master=master)
     self.master = master
     self._dirty = True
     self._get_matrices_fn = get_matrices_fn
     self._P = []
     self._t = percentiles
     self._ranges = ranges
     self._title = title
     self._transposed = transposed
     self.add_subplot(111,axisbg='w')
Exemplo n.º 33
0
 def __init__(self, **kwargs):
     if "dpi" in kwargs:
         dpi = kwargs["dpi"]
     else:
         dpi = 80
     if "title" in kwargs:
         title = kwargs["title"]
     else:
         title = None
     Figure.__init__(self, figsize=(self.width / dpi, self.height / 80), dpi=dpi)
     self.title = title
     self.dpi = dpi
     self.kwargs = kwargs
Exemplo n.º 34
0
    def __init__(self, *args, **kwargs):
        name = kwargs.get('name', None)
        if name is not None:
            del kwargs[name]
            self.name = name
        else:
            self.name = 'figure{0}'.format(Figure.figure_index)
            Figure.figure_index += 1

        PLTFigure.__init__(self, *args, **kwargs)

        self.axes_   = {}
        self.series_ = {}
Exemplo n.º 35
0
    def __init__(self, opt_model, refresh_gui, dgm_type, **kwargs):
        self.actions = {}
        self.opt_model = opt_model
        self.parax_model = opt_model.parax_model
        self.refresh_gui = refresh_gui
        self.setup_dgm_type(dgm_type)
        self.skip_build = False

        Figure.__init__(self, **kwargs)

        self.vertex = None
        self.update_data()
        self.select_point()
Exemplo n.º 36
0
    def __init__(self, *attributes):

        Figure.__init__(self, (5.0, 4.0), facecolor="white")

        self.attributes = attributes

        self.__axes = self.add_subplot(111)

        # Insert empty attributes with a dict for figure attributes
        if not self.attributes:
            self.attributes = [{}]

        self.draw_chart()
Exemplo n.º 37
0
    def __init__(self, code_matrix, trans_names, code_names, show_it=True, show_trans_names=False, color_map = "jet", legend_labels = None, title=None, horizontal_grid = True):
        Figure.__init__(self, facecolor="white", figsize=(12, 4))
        ldata = {}
        self.subplots_adjust(left=.05, bottom=.15, right=.98, top=.95)
        code_names = [c for c in range(code_matrix.shape[1])]
        for i, code in enumerate(range(len(code_names))):
            ldata[code] = [code_matrix[j, i] for j in range(len(trans_names))]
        ind = np.arange(len(trans_names))
        width = 1.0 / (len(code_names) + 1)
        traditional_colors = ['red', 'orange', 'yellow', 'green', 'blue', 'purple', 'black', 'grey', 'cyan', 'coral']

        ax = self.add_subplot(111)
        if title is not None:
            ax.set_title(title, fontsize=10)

        if color_map == "AA_traditional_":
            lcolors = traditional_colors
        else:
            cNorm = mpl_Normalize(vmin = 1, vmax = len(code_names))
            comap = get_cmap(color_map)
            scalar_map = ScalarMappable(norm = cNorm, cmap = comap)
            lcolors = [scalar_map.to_rgba(idx + 1) for idx in range(len(code_names))]

        the_bars = []

        for c in range(len(code_names)):
            new_bars = ax.bar(ind + (c + .5) * width, ldata[code_names[c]], width, color=lcolors[c % (len(lcolors))])
            the_bars.append(new_bars[0])
            # bar_groups.append(bars)
        if show_trans_names:
            ax.set_xticks(ind + .5)
            ax.set_xticklabels(trans_names, size="x-small", rotation= -45)
        else:
            ax.grid(b = horizontal_grid, which = "major", axis = 'y')
            ax.set_xticks(ind + .5)
            ax.set_xticklabels(ind + 1, size="x-small")
            for i in ind[1:]:
                ax.axvline(x = i, linestyle = "--", linewidth = .25, color = 'black')

        if legend_labels != None:
            fontP =FontProperties()
            fontP.set_size('small')
            box = ax.get_position()
            ax.set_position([box.x0, box.y0, box.width * 0.825, box.height])
            # Put a legend to the right of the current axis
            ax.legend(the_bars, legend_labels, loc='center left', bbox_to_anchor=(1, 0.5), prop = fontP)
        ax.set_xlim(right=len(trans_names))

        if show_it:
            self.show()
Exemplo n.º 38
0
 def __init__(self,master,size,dpi,model,featshape,direction='input'):
     Figure.__init__(self,figsize=(size[0]/dpi,size[1]/dpi),dpi=dpi,facecolor='w',edgecolor='b',frameon=True,linewidth=0)
     FigureCanvas(self,master=master)
     self.master = master
     self._dirty = True
     self._model = model
     self._feat  = None
     self._featrange = None
     self._featshape = featshape
     self._direction = direction
     self._sorted = True
     self._update_count = 0
     self._ordering = None
     self.add_subplot(111,axisbg='w')
Exemplo n.º 39
0
    def __init__(self,
                 dpi=150,
                 figsize=(12, 8),
                 data=None,
                 scale=(5, 95),
                 title=None):
        Figure.__init__(self, dpi=dpi, figsize=figsize)
        l1 = 0.07
        b1 = 0.10
        h1 = 0.80
        w1 = h1 / figsize[0] * figsize[1]
        l2 = 0.67
        w2 = 0.30
        hgap1 = 0.08
        h3 = 0.02
        h2 = (h1 - 2 * hgap1 - h3) / 2
        self.ax_image = self.add_axes([l1, b1, w1, h1])
        self.ax_hist1 = self.add_axes([l2, b1 + h3 + hgap1 * 2 + h2, w2, h2])
        self.ax_hist2 = self.add_axes([l2, b1 + h3 + hgap1, w2, h2])
        self.ax_cbar0 = self.add_axes([l2, b1, w2, h3])

        vmin = np.percentile(data, scale[0])
        vmax = np.percentile(data, scale[1])
        cax = self.ax_image.imshow(data, origin='lower', vmin=vmin, vmax=vmax)
        self.colorbar(cax, cax=self.ax_cbar0, orientation='horizontal')
        self.ax_image.set_xlabel('X (pixel)')
        self.ax_image.set_ylabel('X (pixel)')

        # plot hist1, the whole histogram
        self.ax_hist1.hist(data.flatten(), bins=50)
        self.ax_hist1.axvline(x=vmin,
                              color='C1',
                              ls='--',
                              lw=0.7,
                              label='{} %'.format(scale[0]))
        self.ax_hist1.axvline(x=vmax,
                              color='C2',
                              ls='--',
                              lw=0.7,
                              label='{} %'.format(scale[1]))
        self.ax_hist1.set_xlabel('Count')
        legend = self.ax_hist1.legend(loc='upper right')
        legend.get_frame().set_alpha(0.1)

        self.ax_hist2.hist(data.flatten(), bins=np.linspace(vmin, vmax, 50))
        self.ax_hist2.set_xlim(vmin, vmax)
        self.ax_hist2.set_xlabel('Count')

        if title is not None:
            self.suptitle(title)
Exemplo n.º 40
0
 def __init__(self, *args, **kwargs):
     Figure.__init__(self, *args, **kwargs)
     self.ax = self.gca(projection='3d')
     self.ax.set_aspect("equal")
     self.ax.set_xlim(-1, 1)
     self.ax.set_ylim(-1, 1)
     self.ax.set_zlim(-1, 1)
     self.ax.scatter([0], [0], [0], color="g", s=100)
     self.object = Arrow3D(0,
                           0,
                           0,
                           mutation_scale=20,
                           lw=1,
                           arrowstyle="-|>",
                           color="k")
     self.ax.add_artist(self.object)
Exemplo n.º 41
0
 def __init__(self, master, size, dpi, task):
     Figure.__init__(
         self,
         figsize=(size[0] / dpi, size[1] / dpi),
         dpi=dpi,
         facecolor="w",
         edgecolor="b",
         frameon=True,
         linewidth=0,
     )
     FigureCanvas(self, master=master)
     self.master = master
     self._errors = collections.OrderedDict()
     self._dirty = True
     self._task = task
     self.add_subplot(111, axisbg="w")
Exemplo n.º 42
0
 def __init__(self, master, size, dpi, get_matrices_fn, percentiles, transposed, ranges=None, title=""):
     Figure.__init__(
         self,
         figsize=(size[0] / dpi, size[1] / dpi),
         dpi=dpi,
         facecolor="w",
         edgecolor="b",
         frameon=True,
         linewidth=0,
     )
     FigureCanvas(self, master=master)
     self.master = master
     self._dirty = True
     self._get_matrices_fn = get_matrices_fn
     self._P = []
     self._t = percentiles
     self._ranges = ranges
     self._title = title
     self._transposed = transposed
     self.add_subplot(111, axisbg="w")
Exemplo n.º 43
0
     def __init__(self, similarity_matrix, cluster_sizes=None, title=None, show_it=False, cmap="Greys"):
        Figure.__init__(self, figsize=(12, 12))
        ax = self.add_subplot(111)
        if title is not None:
            ax.set_title(title, fontsize=10)
        cax = ax.imshow(similarity_matrix, cmap=cmap)

        tick_spots = [0]
        running_total = 0
        if cluster_sizes is not None:
            for size in cluster_sizes:
                running_total += size
                tick_spots.append(running_total)
            ax.set_xticks(tick_spots)
        # ax.grid(b=True)
        cbar = self.colorbar(cax)
        self.subplots_adjust(left=.05, bottom=.05, right=.98, top=.95)
        self.set_facecolor("white")
        if show_it==True:
            self.show()
Exemplo n.º 44
0
 def __init__(self, locking=True, disable_output=None, display=None, toolbar=None, **figkw):
     if disable_output is not None:
         self._disable_output = disable_output
     else:
         self._disable_output = _p.rcParams['refigure.disableoutput']
     if display is not None:
         self.display = display
     else:
         self.display = _p.rcParams['refigure.display']
     if toolbar is not None:
         self._toolbar = toolbar
     else:
         self._toolbar = _p.rcParams['refigure.toolbar']
     if not self._toolbar and 'facecolor' not in figkw:
         figkw['facecolor'] = 'white'
     
     _Figure.__init__(self, **figkw)
     c = _FigureCanvasBase(self) # For savefig to work
     # Set this here to allow 'f = figure()'  syntax
     if not locking:
         self.__class__.current_fig = self # Another thread can tweak this!
Exemplo n.º 45
0
 def __init__(self, master, size, dpi, model, featshape, direction="input"):
     Figure.__init__(
         self,
         figsize=(size[0] / dpi, size[1] / dpi),
         dpi=dpi,
         facecolor="w",
         edgecolor="b",
         frameon=True,
         linewidth=0,
     )
     FigureCanvas(self, master=master)
     self.master = master
     self._dirty = True
     self._model = model
     self._feat = None
     self._featrange = None
     self._featshape = featshape
     self._direction = direction
     self._sorted = True
     self._ordering = None
     self.add_subplot(111, axisbg="w")
Exemplo n.º 46
0
    def __init__(self, the_array, ylabels=None, title=None, show_it=True, color_map="Greys", xlabels=None, value_range=None):
        Figure.__init__(self, figsize=(8,1))
        self.dialogs = []
        (nrows, ncols) = the_array.shape
        ax = self.add_subplot(111)
        if title is not None:
            ax.set_title(title, fontsize=10)
        if value_range is not None:
            cax = ax.imshow(the_array, cmap=color_map, aspect="auto", interpolation='nearest',
                            vmin=value_range[0], vmax=value_range[1])
        else:
            cax = ax.imshow(the_array, cmap=color_map, aspect="auto", interpolation='nearest')

        ind = np.arange(ncols)

        ax.set_xticks(ind, minor=False)
        ax.set_xticks(ind + .5, minor=True)
        if xlabels is None:
            ax.get_xaxis().set_ticklabels(ind + 1, size="x-small")
        else:
            ax.get_xaxis().set_ticklabels(xlabels, size="x-small", rotation="vertical")

        ind = np.arange(nrows)
        ax.set_yticks(ind, minor=False)
        ax.set_yticks(ind + .5, minor=True)
        if ylabels is None:
            ax.get_yaxis().set_ticklabels(ind + 1, size="x-small")
        else:
            ax.get_yaxis().set_ticklabels(ylabels, size="x-small", rotation="horizontal")

        ax.grid(True, which='minor', linestyle='-')

        cbar = self.colorbar(cax)
        self.subplots_adjust(left=.12, bottom=.25, right=.99, top=.95)
        self.set_facecolor("white")
        if show_it==True:
            self.show()
Exemplo n.º 47
0
 def __init__(self, master, size, dpi, data):
     Figure.__init__(
         self,
         figsize=(size[0] / dpi, size[1] / dpi),
         dpi=dpi,
         facecolor="w",
         edgecolor="b",
         frameon=True,
         linewidth=0,
     )
     FigureCanvas(self, master=master)
     self.master = master
     self._dirty = True
     self._fold = "test" if data["test"].size > 0 else "train"
     self._indices = rnd.sample(arange(data[self._fold].size), minimum(data[self._fold].size, 50))  # 256))
     self._targets = (
         bm.as_numpy(data[self._fold].Y[self._indices, :])
         .transpose()
         .reshape(data.Yshape + tuple([len(self._indices)]))
     )
     self._outputs = None
     self._outshape = data.Yshape
     self._outrange = data.Yrange
     self.add_subplot(111, axisbg="w")
Exemplo n.º 48
0
 def __init__(self):
     Figure.__init__(self)
 def __init__(self, parent, width, height, dpi):
     Figure.__init__(self, figsize=(width, height), dpi=dpi)
     self.parent = parent
Exemplo n.º 50
0
 def __init__(self, series=None, **kwargs):
     self._series = series
     Figure.__init__(self,**kwargs)
     fspnum = kwargs.pop('fspnum',None)
     if fspnum is not None:
         self.add_tsplot(fspnum, series=series)
Exemplo n.º 51
0
 def __init__(self):
     Figure.__init__(self, figsize=(5, 6), dpi=100)
Exemplo n.º 52
0
 def __init__(self, **kwargs):
     self._series = series = kwargs.pop("series", None)
     Figure.__init__(self, **kwargs)
     fspnum = kwargs.pop("fspnum", None)
     if fspnum is not None:
         self.add_tsplot(fspnum, series=series)
Exemplo n.º 53
0
    def __init__(self, number_of_subplots):
        Figure.__init__(self)
        self.number_of_subplots = number_of_subplots
        
        #todo
        # there has to be an existing class that can hold four points together
        # Determine how multiple plots will be laid out, 2x1, 3x4 etc.
        if self.number_of_subplots <= 1:    
            self.num_rows = 1
            self.title_fontsize = 12
            self.legend_fontsize = 12
            self.axes_label_fontsize = 12
            self.axes_tick_fontsize = 10
            self.main_border_left = 0.05
            self.main_border_right = 0.05
            self.main_border_lower = 0.05
            self.main_border_upper = 0.05
            self.subplot_border_left = 0.0
            self.subplot_border_right = 0.0            
            self.subplot_border_lower = 0.05
            self.subplot_border_upper = 0.2
        elif ((self.number_of_subplots >= 2) and (self.number_of_subplots <= 6 )):
            self.num_rows = 2
            self.title_fontsize = 10
            self.legend_fontsize = 10
            self.axes_label_fontsize = 10
            self.axes_tick_fontsize = 8
            self.main_border_left = 0.05
            self.main_border_right = 0.05
            self.main_border_lower = 0.0
            self.main_border_upper = 0.05
            self.subplot_border_left = 0.0
            self.subplot_border_right = 0.0            
            self.subplot_border_lower = 0.05
            self.subplot_border_upper = 0.05
        else:
            self.num_rows = 3
            self.title_fontsize = 8
            self.legend_fontsize = 6
            self.axes_label_fontsize = 8
            self.axes_tick_fontsize = 6
            self.main_border_left = 0.05
            self.main_border_right = 0.05
            self.main_border_lower = 0.1
            self.main_border_upper = 0.0
            self.subplot_border_left = 0.0
            self.subplot_border_right = 0.0            
            self.subplot_border_lower = 0.0
            self.subplot_border_upper = 0.1
        
        self.num_cols = int(math.ceil(float(self.number_of_subplots)/float(self.num_rows)))    

        self.main_axes_width = 1.0 - (self.main_border_left + self.main_border_right)
        self.main_axes_height = 1.0 - (self.main_border_lower + self.main_border_upper)

        # Set up grid geometry
        self.col_width = (self.main_axes_width/self.num_cols)
        self.row_height = (self.main_axes_height/self.num_rows)

        self.subplot_width = self.col_width - (self.subplot_border_left + self.subplot_border_right) 
        self.subplot_height = self.row_height - (self.subplot_border_lower + self.subplot_border_upper)        
Exemplo n.º 54
0
    def __init__(self, *chart_data):
        self.chart_data = chart_data
        Figure.__init__(self, (5.0, 4.0), facecolor="white")

        self.__axes = self.add_subplot(111)
        self.draw_chart()
Exemplo n.º 55
0
 def __init__(self):
     Figure.__init__(self)
     self.subfigures = []
 def __init__(self, graph, width, height, dpi):
     Figure.__init__(self, figsize=(width, height), dpi=dpi)
     self.editAxes = False
     self.graph = graph
Exemplo n.º 57
0
 def __init__(self, *args, **kwargs):
     Figure.__init__(self, *args, **kwargs)
Exemplo n.º 58
0
 def __init__(self):
     Figure.__init__(self)
     self.subfigures = []
     self.subplots_adjust(hspace=0.5)