Пример #1
0
def _get_cmap(cmap):
    # matplotlib 2.0 deprecated 'spectral' colormap, renamed to nipy_spectral.
    from matplotlib import __version__
    version = tuple(map(int, __version__.split('.')))
    if cmap == 'spectral' and version >= (2, ):
        cmap = 'nipy_spectral'
    return cmap
Пример #2
0
class MyToolbar(NavigationToolbar2GTKAgg):
    #idea borrowed from: http://dalelane.co.uk/blog/?p=778
    # but redone a bit differently.

    # we inhereit the navigation toolbar, but redefine the toolitems

    # list of toolitems to add to the toolbar, format is:
    # text, tooltip_text, image_file, callback(str)
    vers = matplotlib_version.split('.')
    if int(vers[0]) <= 1 and int(vers[1]) < 2:
        toolitems = (  #icon names are different in older versions
            ('Home', 'Reset original view', 'home.png', 'home'),
            ('Back', 'Back to  previous view', 'back.png', 'back'),
            ('Forward', 'Forward to next view', 'forward.png', 'forward'),
            ('Pan', 'Pan axes with left mouse, zoom with right', 'move.png',
             'pan'),
            ('Zoom', 'Zoom to rectangle', 'zoom_to_rect.png', 'zoom'),
            (None, None, None, None),
            #        ('Subplots', 'Configure subplots','subplots', 'configure_subplots'),
            ('Save', 'Save the figure', 'filesave.png', 'save_figure'),
        )
    else:
        toolitems = (  #first home used to be home.png etc
            ('Home', 'Reset original view', 'home', 'home'),
            ('Back', 'Back to  previous view', 'back', 'back'),
            ('Forward', 'Forward to next view', 'forward', 'forward'),
            ('Pan', 'Pan axes with left mouse, zoom with right', 'move',
             'pan'),
            ('Zoom', 'Zoom to rectangle', 'zoom_to_rect', 'zoom'),
            (None, None, None, None),
            #        ('Subplots', 'Configure subplots','subplots', 'configure_subplots'),
            ('Save', 'Save the figure', 'filesave', 'save_figure'),
        )
Пример #3
0
    def hist(self,hold=False,xlabel=None,ylabel='$ \\mathrm{probability\\:density} $',
             title=None,**kwds):
        """
        Generates a histogram from the simulated data.
        
        Parameters
        ----------
        hold:  `bool`, optional
            If this is `False`, pyplot.show() will be called before the method
            exits.  The default is `False`
            
        xlabel:  `str` or `None`, optional
            a label for the histogram horizontal axis, the default is `None`
        
        ylabel: `str` or `None`, optional
            a label for the histogram vertical axis, the default is 'probability
            density'
            
        title: `str` or `None`
            a title for the histogram, the default is `None`
        
        kwds:
            additional key words that will be passed to the `pyplot.hist` method
            that actually created the histogram

        Raises
        ------
        `NoSimulatedDataError`:
            if no simulated data is available from a call to
            `Distribution.simulate`.
        """
        import matplotlib.pyplot as plt
        if self.simdata is None:
            raise NoSimulatedDataError('simulate must be called to generate some data')
        if not 'bins' in kwds:
            kwds['bins'] = 100
        if not ('normed' in kwds or 'density' in kwds):
            try:
                from matplotlib import __version__ as version
                version = [int(v) for v in version.split('.')[:2]]
                usedensity = (version[0] > 2 or 
                              (version[0] == 2 and version[1] > 0))
            except:
                usedensity = True
            if usedensity:
                kwds['density'] = True
            else:
                kwds['normed'] = True
        if not 'histtype' in kwds:
            kwds['histtype'] ='stepfilled'
        plt.hist(self.simsorted[np.abs(self.simsorted) != np.inf],**kwds)
        if ylabel is not None:
            plt.ylabel(ylabel)
        if xlabel is not None:
            plt.xlabel(xlabel)
        if title is not None:
            plt.title(title)
        if not hold:
            plt.show()
Пример #4
0
    def clicked(self, event):
        """
        Call if an element of this plottype is clicked.

        Implement in sub class.
        """
        group = event.artist._mt_group
        indices = event.ind

        # double click only supported on 1.2 or later
        major, minor, _ = mpl_version.split('.')
        if (int(major), int(minor)) < (1, 2) or not event.mouseevent.dblclick:
            for i in indices:
                print(self.groups[group][i].line_str)

        else:
            # toggle durline
            first = indices[0]
            logevent = self.groups[group][first]

            try:
                # remove triangle for this event
                idx = map(itemgetter(0), self.durlines).index(logevent)
                _, poly = self.durlines[idx]
                poly.remove()
                plt.gcf().canvas.draw()
                del self.durlines[idx]

            except ValueError:
                # construct triangle and add to list of durlines

                if self.args['optime_start']:
                    pts = [[date2num(logevent.datetime), 0],
                           [date2num(logevent.datetime), logevent.duration],
                           [
                               date2num(logevent.datetime + timedelta(
                                   milliseconds=logevent.duration)), 0
                           ]]
                else:
                    pts = [[date2num(logevent.datetime), 0],
                           [date2num(logevent.datetime), logevent.duration],
                           [
                               date2num(logevent.datetime - timedelta(
                                   milliseconds=logevent.duration)), 0
                           ]]

                poly = Polygon(pts,
                               closed=True,
                               alpha=0.2,
                               linewidth=0,
                               facecolor=event.artist.get_markerfacecolor(),
                               edgecolor=None,
                               zorder=-10000)

                ax = plt.gca()
                ax.add_patch(poly)
                plt.gcf().canvas.draw()

                self.durlines.append((logevent, poly))
Пример #5
0
 def get_children(self):
     from matplotlib import __version__ as mversion
     children = super().get_children()
     major, minor, patch = [int(_) for _ in mversion.split('.')]
     if (major, minor) <= (3, 0):
         children.remove(self.xaxis)
         children.remove(self.yaxis)
         children.extend(self._get_axis_list())
     return children
Пример #6
0
    def clicked(self, event):
        """
        Call if an element of this plottype is clicked.

        Implement in sub class.
        """
        group = event.artist._mt_group
        indices = event.ind

        # double click only supported on 1.2 or later
        major, minor, _ = mpl_version.split('.')
        if (int(major), int(minor)) < (1, 2) or not event.mouseevent.dblclick:
            for i in indices:
                print(self.groups[group][i].line_str)

        else:
            # toggle durline
            first = indices[0]
            logevent = self.groups[group][first]

            try:
                # remove triangle for this event
                idx = map(itemgetter(0), self.durlines).index(logevent)
                _, poly = self.durlines[idx]
                poly.remove()
                plt.gcf().canvas.draw()
                del self.durlines[idx]

            except ValueError:
                # construct triangle and add to list of durlines

                if self.args['optime_start']:
                    pts = [[date2num(logevent.datetime), 0],
                           [date2num(logevent.datetime), logevent.duration],
                           [date2num(logevent.datetime +
                                     timedelta(milliseconds=logevent.duration)
                                     ), 0]]
                else:
                    pts = [[date2num(logevent.datetime), 0],
                           [date2num(logevent.datetime), logevent.duration],
                           [date2num(logevent.datetime -
                                     timedelta(milliseconds=logevent.duration)
                                     ), 0]]

                poly = Polygon(pts, closed=True, alpha=0.2, linewidth=0,
                               facecolor=event.artist.get_markerfacecolor(),
                               edgecolor=None, zorder=-10000)

                ax = plt.gca()
                ax.add_patch(poly)
                plt.gcf().canvas.draw()

                self.durlines.append((logevent, poly))
Пример #7
0
def check_maplotlib_max_version(ver_maj, ver_min):
    """
    return True if check_maplotlib_version is lower than specified version
    """
    parts = matplotlib_version.split('.')
    if not parts:
        return False
    if parts[0] < str(ver_maj):
        return True
    if len(parts) > 1 and parts[1] < str(ver_min):
        return True
    return False
Пример #8
0
def env_check(args):
    # check mpl_version
    t = mpl_version.split('.')
    if int(t[0]) < 2:
        print("matplotlib >= 2.0.0 needed. Now version " + mpl_version + ".")
        exit()

    # check tex environment
    if args.mode[0] == 'normal':
        try:
            subprocess.check_output('tex --version')
        except subprocess.CalledProcessError:
            print("Tex not found. Install tex or run in draft mode: `python run.py <json_file> --mode=draft`")
            exit()
Пример #9
0
 def test_matplotlib_suported_version(self):
     """matplotlib version is supported """
     min_acceptable_version = (1, 1, 0)
     max_acceptable_version = (1, 3, 1)
     try:
         from matplotlib import __version__ as matplotlib_lib_version
         version = tuple(map(int, matplotlib_lib_version.split('.')))
         pass_test = (version >= min_acceptable_version and
                      version <= max_acceptable_version)
         version_string = str(matplotlib_lib_version)
     except ImportError:
         pass_test = False
         version_string = "Not installed"
     self.assertTrue(pass_test,
                     "Unsupported matplotlib version. Must be >= %s and <= %s , but running %s."
                     % ('.'.join(map(str, min_acceptable_version)),
                        '.'.join(map(str, max_acceptable_version)), version_string))
Пример #10
0
 def test_matplotlib_suported_version(self):
     """matplotlib version is supported """
     min_acceptable_version = (1, 1, 0)
     max_acceptable_version = (1, 3, 1)
     try:
         from matplotlib import __version__ as matplotlib_lib_version
         version = tuple(map(int, matplotlib_lib_version.split('.')))
         pass_test = (version >= min_acceptable_version
                      and version <= max_acceptable_version)
         version_string = str(matplotlib_lib_version)
     except ImportError:
         pass_test = False
         version_string = "Not installed"
     self.assertTrue(pass_test,\
      "Unsupported matplotlib version. Must be >= %s and <= %s , but running %s." \
      % ('.'.join(map(str,min_acceptable_version)),
         '.'.join(map(str,max_acceptable_version)), version_string))
Пример #11
0
def plot_attribute(cur, planners, attribute, typename):
    """Create a box plot for a particular attribute. It will include data for
    all planners that have data for this attribute."""
    plt.clf()
    ax = plt.gca()
    labels = []
    measurements = []
    nan_counts = []
    is_bool = True
    for planner in planners:
        cur.execute('SELECT * FROM `%s`' % planner)
        attributes = [ t[0] for t in cur.description]
        if attribute in attributes:
            cur.execute('SELECT `%s` FROM `%s` WHERE `%s` IS NOT NULL' % (attribute, planner, attribute))
            measurement = [ t[0] for t in cur.fetchall() ]
            cur.execute('SELECT count(*) FROM `%s` WHERE `%s` IS NULL' % (planner, attribute))
            nan_counts.append(cur.fetchone()[0])
            cur.execute('SELECT DISTINCT `%s` FROM `%s`' % (attribute, planner))
            is_bool = is_bool and set([t[0] for t in cur.fetchall() if not t[0]==None]).issubset(set([0,1]))
            measurements.append(measurement)
            labels.append(planner.replace('planner_geometric_','').replace('planner_control_',''))
    if is_bool:
        width = .5
        measurements_percentage = [sum(m)*100./len(m) for m in measurements]
        ind = range(len(measurements))
        plt.bar(ind, measurements_percentage, width)
        xtickNames = plt.xticks([x+width/2. for x in ind], labels, rotation=30)
        ax.set_ylabel(attribute.replace('_',' ') + ' (%)')
    else:
        if int(matplotlibversion.split('.')[0])<1:
            plt.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5)
        else:
            plt.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5, bootstrap=1000)
        ax.set_ylabel(attribute.replace('_',' '))
        xtickNames = plt.setp(ax,xticklabels=labels)
        plt.setp(xtickNames, rotation=25)
    ax.set_xlabel('Motion planning algorithm')
    ax.yaxis.grid(True, linestyle='-', which='major', color='lightgrey', alpha=0.5)
    if max(nan_counts)>0:
        maxy = max([max(y) for y in measurements])
        for i in range(len(labels)):
            x = i+width/2 if is_bool else i+1
            ax.text(x, .95*maxy, str(nan_counts[i]), horizontalalignment='center', size='small')
    plt.show()
    def plot_measurements(self, measurements, total_per_planner, planners, attribute, typename, labels, layout):
        plt.clf()

        width = 5
        height = 4
        dpi = 100
        fig = Figure(figsize=(width, height), dpi=dpi, facecolor=(1.0, 1.0, 1.0, 1.0))
        ax = fig.add_subplot(111)

        figcanvas = FigureCanvas(fig)
        figcanvas.setParent(self._widget)
        FigureCanvas.setSizePolicy(figcanvas, QSizePolicy.Expanding, QSizePolicy.Expanding)
        FigureCanvas.updateGeometry(figcanvas)

        if typename == 'BOOLEAN':
            width = .5
            measurementsPercentage = [sum(m) * 100. / total_per_planner[counter] for counter, m in
                                      enumerate(measurements)]
            ind = range(len(measurements))
            ax.bar(ind, measurementsPercentage, width)
            plt.setp(ax, xticks=[x + width / 2. for x in ind])
            ax.set_ylim([0, 100])
            ax.set_xlim([0, len(planners)])
        else:
            if int(matplotlibversion.split('.')[0]) < 1:
                ax.boxplot(measurements, notch=0, sym='r+', vert=1, whis=1.5)
            else:
                ax.boxplot(measurements, notch=0, sym='r+', vert=1, whis=1.5, bootstrap=1000)

        xtickNames = plt.setp(ax, xticklabels=labels)
        plt.setp(xtickNames, rotation=90)
        for tick in ax.xaxis.get_major_ticks():  # shrink the font size of the x tick labels
            tick.label.set_fontsize(7)
        for tick in ax.yaxis.get_major_ticks():  # shrink the font size of the y tick labels
            tick.label.set_fontsize(7)
        fig.subplots_adjust(bottom=0.32, top=0.90, left=0.08, right=0.98)
        ax.yaxis.grid(True, linestyle='-', which='major', color='lightgrey', alpha=0.5)

        if "clearance" in attribute:
            ax.ticklabel_format(style='sci', axis='y', scilimits=(-3, 4), useLocale=True)
            ax.yaxis.offsetText.set_fontsize(7)

        self.clearLayout(layout)
        layout.addWidget(figcanvas)
Пример #13
0
def checkVersions():
    """Helper function to determine whether the versions of yt, pyqt and mpl
    the user has installed are sufficient for a smooth run."""
    errorString = "It seems that you do not have the required modules \
        installed.\n"

    ytNums = yt.__version__.split(".")
    ytCheck = float(ytNums[0]) >= 3 and float(ytNums[1]) >= 5
    if not ytCheck:
        errorString += (f"Your version of the yt-module is {yt.__version__}, "
                        "but you need v. 3.5 or later\n")
    PyQtNums = PyQtVersion.split(".")
    PyQtCheck = float(PyQtNums[0]) >= 5 and float(PyQtNums[1]) >= 9
    if not PyQtCheck:
        errorString += (f"Your version of the PyQt-module is {PyQtVersion}, "
                        "but you need v. 5.9 or later\n")
    mplNums = mplVersion.split(".")
    mplCheck = float(mplNums[0]) >= 3
    if not mplCheck:
        errorString += (f"Your version of the matplotlib-module is "
                        f"{mplVersion}, but you need v. 3.0 or later\n")
    if not (ytCheck and PyQtCheck and mplCheck):
        raise RuntimeError(errorString)
Пример #14
0
    def test_matplotlib_suported_version(self):
        """maptplotlib version is supported """
        # min_acceptable_version = (1,1,0)
        # min_unacceptable_version = (1,1,0)
        matplotlib_acceptable_version = (1, 1, 0)
        try:
            from matplotlib import __version__ as matplotlib_lib_version

            version = tuple(map(int, matplotlib_lib_version.split(".")))
            pass_test = version == matplotlib_acceptable_version
            version_string = str(matplotlib_lib_version)
        except ImportError:
            pass_test = False
            version_string = "Not installed"
        self.assertTrue(
            pass_test,
            "Unsupported matplotlib version. Must be >= %s and <= %s , but running %s."
            % (
                ".".join(map(str, matplotlib_acceptable_version)),
                ".".join(map(str, matplotlib_acceptable_version)),
                version_string,
            ),
        )
Пример #15
0
###########################################################
# We check what extensions are available
###########################################################
__extensions__ = {'matplotlib': False, 'mplot3d': False, 'pygmo': False, 'scikit-learn': False, 'scipy': False}
# 1 - matplotlib
try:
    from matplotlib import __version__ as matplotlib_ver
    __extensions__['matplotlib'] = True

    # We detect the version and if more than 1.1.0 mplot3d is there
    mver = matplotlib_ver.split('.')
    mver = int(mver[0]) * 100 + int(mver[1]) * 10 + int(mver[2])
    if mver >= 110:
        __extensions__['mplot3d'] = True
    del mver
except ImportError:
    pass

# 2 - PyGMO
try:
    # Here we cannot try to import __version__ as PyGMO also imports PyKEP and would then always fail
    # to import anything from PyGMO __init__.py
    from PyGMO.problem._base import base
    __extensions__['pygmo'] = True
except ImportError:
    pass

# 3 - scikit-learn is installed
try:
    from sklearn import __version__ as sklearn_ver
    __extensions__['scikit-learn'] = True
Пример #16
0
    def plot(self):
        # check if there is anything to plot
        if len(self.plot_instances) == 0:
            raise SystemExit('no data to plot.')

        self.artists = []
        plt.figure(figsize=(12,8), dpi=100, facecolor='w', edgecolor='w')
        axis = plt.subplot(111)

        # set xlim from min to max of logfile ranges
        xlim_min = min([pi.date_range[0] for pi in self.plot_instances])
        xlim_max = max([pi.date_range[1] for pi in self.plot_instances])

        if xlim_max < xlim_min:
            raise SystemExit('no data to plot.')

        xlabel = 'time'
        ylabel = ''
        for i, plot_inst in enumerate(sorted(self.plot_instances, key=lambda pi: pi.sort_order)):
            self.artists.extend(plot_inst.plot(axis, i, len(self.plot_instances), (xlim_min, xlim_max) ))
            if hasattr(plot_inst, 'xlabel'):
                xlabel = plot_inst.xlabel
            if hasattr(plot_inst, 'ylabel'):
                ylabel = plot_inst.ylabel
        self.print_shortcuts()

        axis.set_xlabel(xlabel)
        axis.set_xticklabels(axis.get_xticks(), rotation=90, fontsize=10)
        axis.xaxis.set_major_formatter(DateFormatter('%b %d\n%H:%M:%S'))

        for label in axis.get_xticklabels():  # make the xtick labels pickable
            label.set_picker(True)
            
        axis.set_xlim(date2num([xlim_min, xlim_max]))

        # ylabel for y axis
        if self.args['logscale']:
            ylabel += ' (log scale)'
        axis.set_ylabel(ylabel)

        # title and mtools link
        axis.set_title(self.args['title'] or ', '.join([l.name for l in self.logfiles if l.name != '<stdin>']))
        plt.subplots_adjust(bottom=0.15, left=0.1, right=0.95, top=0.95)
        self.footnote = plt.annotate('created with mtools v%s: https://github.com/rueckstiess/mtools' % __version__, (10, 10), xycoords='figure pixels', va='bottom', fontsize=8)

        handles, labels = axis.get_legend_handles_labels()
        if len(labels) > 0:
            # only change fontsize if supported 
            major, minor, _ = mpl_version.split('.')
            if (int(major), int(minor)) >= (1, 3):
                self.legend = axis.legend(loc='upper left', frameon=False, numpoints=1, fontsize=9)
            else:
                self.legend = axis.legend(loc='upper left', frameon=False, numpoints=1)
        
        if self.args['type'] == 'scatter':
            # enable legend picking for scatter plots
            for i, legend_line in enumerate(self.legend.get_lines()):
                legend_line.set_picker(10)
                legend_line._mt_legend_item = i

        plt.gcf().canvas.mpl_connect('pick_event', self.onpick)
        plt.gcf().canvas.mpl_connect('key_press_event', self.onpress)
        plt.show()
def plotAttribute(cur, planners, attribute, typename):
    """Create a plot for a particular attribute. It will include data for
    all planners that have data for this attribute."""
    labels = []
    measurements = []
    nanCounts = []
    if typename == 'ENUM':
        cur.execute('SELECT description FROM enums where name IS "%s"' % attribute)
        descriptions = [ t[0] for t in cur.fetchall() ]
        numValues = len(descriptions)
    for planner in planners:
        cur.execute('SELECT %s FROM runs WHERE plannerid = %s AND %s IS NOT NULL' \
            % (attribute, planner[0], attribute))
        measurement = [ t[0] for t in cur.fetchall() if t[0] != None ]
        if len(measurement) > 0:
            cur.execute('SELECT count(*) FROM runs WHERE plannerid = %s AND %s IS NULL' \
                % (planner[0], attribute))
            nanCounts.append(cur.fetchone()[0])
            labels.append(planner[1])
            if typename == 'ENUM':
                scale = 100. / len(measurement)
                measurements.append([measurement.count(i)*scale for i in range(numValues)])
            else:
                measurements.append(measurement)

    if len(measurements)==0:
        print('Skipping "%s": no available measurements' % attribute)
        return

    plt.clf()
    ax = plt.gca()
    if typename == 'ENUM':
        width = .5
        measurements = np.transpose(np.vstack(measurements))
        colsum = np.sum(measurements, axis=1)
        rows = np.where(colsum != 0)[0]
        heights = np.zeros((1,measurements.shape[1]))
        ind = range(measurements.shape[1])
        legend_labels = []
        for i in rows:
            plt.bar(ind, measurements[i], width, bottom=heights[0],
                color=matplotlib.cm.hot(int(floor(i*256/numValues))),
                label=descriptions[i])
            heights = heights + measurements[i]
        xtickNames = plt.xticks([x+width/2. for x in ind], labels, rotation=30)
        ax.set_ylabel(attribute.replace('_',' ') + ' (%)')
        box = ax.get_position()
        ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
        props = matplotlib.font_manager.FontProperties()
        props.set_size('small')
        ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop = props)
    elif typename == 'BOOLEAN':
        width = .5
        measurementsPercentage = [sum(m) * 100. / len(m) for m in measurements]
        ind = range(len(measurements))
        plt.bar(ind, measurementsPercentage, width)
        xtickNames = plt.xticks([x + width / 2. for x in ind], labels, rotation=30)
        ax.set_ylabel(attribute.replace('_',' ') + ' (%)')
    else:
        if int(matplotlibversion.split('.')[0])<1:
            plt.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5)
        else:
            plt.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5, bootstrap=1000)
        ax.set_ylabel(attribute.replace('_',' '))
        xtickNames = plt.setp(ax,xticklabels=labels)
        plt.setp(xtickNames, rotation=25)
    ax.set_xlabel('Motion planning algorithm')
    ax.yaxis.grid(True, linestyle='-', which='major', color='lightgrey', alpha=0.5)
    if max(nanCounts)>0:
        maxy = max([max(y) for y in measurements])
        for i in range(len(labels)):
            x = i+width/2 if typename=='BOOLEAN' else i+1
            ax.text(x, .95*maxy, str(nanCounts[i]), horizontalalignment='center', size='small')
    plt.show()
Пример #18
0
    def plot(self):
        # check if there is anything to plot
        if len(self.plot_instances) == 0:
            raise SystemExit('no data to plot.')

        if self.args['output_file'] is not None:
            # --output-file means don't depend on X,
            # so switch to a pure-image backend before doing any plotting.
            plt.switch_backend('agg')

        self.artists = []
        plt.figure(figsize=(12, 8), dpi=100, facecolor='w', edgecolor='w')
        axis = plt.subplot(111)

        # set xlim from min to max of logfile ranges
        xlim_min = min([pi.date_range[0] for pi in self.plot_instances])
        xlim_max = max([pi.date_range[1] for pi in self.plot_instances])

        if xlim_max < xlim_min:
            raise SystemExit('no data to plot.')

        xlabel = 'time'
        ylabel = ''

        # use timezone of first log file (may not always be what user wants
        # but must make a choice)
        tz = self.logfiles[0].timezone
        # tzformat='%b %d\n%H:%M:%S' if tz == tzutc() else '%b %d\n%H:%M:%S%z'

        locator = AutoDateLocator(tz=tz, minticks=5, maxticks=10)
        formatter = AutoDateFormatter(locator, tz=tz)

        formatter.scaled = {
            365.0: '%Y',
            30.: '%b %Y',
            1.0: '%b %d %Y',
            1. / 24.: '%b %d %Y\n%H:%M:%S',
            1. / (24. * 60.): '%b %d %Y\n%H:%M:%S',
        }

        # add timezone to format if not UTC
        if tz != tzutc():
            formatter.scaled[1. / 24.] = '%b %d %Y\n%H:%M:%S%z'
            formatter.scaled[1. / (24. * 60.)] = '%b %d %Y\n%H:%M:%S%z'

        for i, plot_inst in enumerate(
                sorted(self.plot_instances, key=lambda pi: pi.sort_order)):
            self.artists.extend(
                plot_inst.plot(axis, i, len(self.plot_instances),
                               (xlim_min, xlim_max)))
            if hasattr(plot_inst, 'xlabel'):
                xlabel = plot_inst.xlabel
            if hasattr(plot_inst, 'ylabel'):
                ylabel = plot_inst.ylabel
        if self.args['output_file'] is None:
            self.print_shortcuts(scatter=isinstance(self.plot_instance,
                                                    plottypes.ScatterPlotType))

        axis.set_xlabel(xlabel)
        axis.set_xticklabels(axis.get_xticks(), rotation=90, fontsize=9)
        axis.xaxis.set_major_locator(locator)
        axis.xaxis.set_major_formatter(formatter)

        axis.set_xlim(date2num([xlim_min, xlim_max]))

        # ylabel for y axis
        if self.args['logscale']:
            ylabel += ' (log scale)'
        axis.set_ylabel(ylabel)

        # enable grid
        axis.grid(True)

        # title and mtools link
        axis.set_title(self.args['title'] or ', '.join(
            [l.name for l in self.logfiles if l.name != '<stdin>']))
        plt.subplots_adjust(bottom=0.15, left=0.1, right=0.95, top=0.95)
        self.footnote = plt.annotate("created with mtools v%s: "
                                     "https://github.com/rueckstiess/mtools" %
                                     __version__, (10, 10),
                                     xycoords='figure pixels',
                                     va='bottom',
                                     fontsize=8)

        handles, labels = axis.get_legend_handles_labels()
        if len(labels) > 0:
            # only change fontsize if supported
            major, minor, _ = mpl_version.split('.')
            if (int(major), int(minor)) >= (1, 3):
                self.legend = axis.legend(loc='upper left',
                                          frameon=False,
                                          numpoints=1,
                                          fontsize=9)
            else:
                self.legend = axis.legend(loc='upper left',
                                          frameon=False,
                                          numpoints=1)

        if self.args['type'] == 'scatter':
            # enable legend picking for scatter plots
            for i, legend_line in enumerate(self.legend.get_lines()):
                legend_line.set_picker(10)
                legend_line._mt_legend_item = i

        # overwrite y-axis limits if set
        if self.args['ylimits'] is not None:
            print(self.args['ylimits'])
            axis.set_ylim(self.args['ylimits'])

        plt.gcf().canvas.mpl_connect('pick_event', self.onpick)
        plt.gcf().canvas.mpl_connect('key_press_event', self.onpress)
        if self.args['output_file'] is not None:
            plt.savefig(self.args['output_file'])
        else:
            plt.show()
Пример #19
0
from contextlib import contextmanager
from enum import Enum

# 3rd party imports
from matplotlib.legend import Legend
from matplotlib import cm, __version__ as mpl_version_str
from matplotlib.container import ErrorbarContainer

# -----------------------------------------------------------------------------
# Constants
# -----------------------------------------------------------------------------
# matplotlib version information
MPLVersionInfo = collections.namedtuple("MPLVersionInfo",
                                        ("major", "minor", "patch"))
MATPLOTLIB_VERSION_INFO = MPLVersionInfo._make(
    map(int, mpl_version_str.split(".")))

# Use the correct draggable method based on the matplotlib version
if hasattr(Legend, "set_draggable"):
    SET_DRAGGABLE_METHOD = "set_draggable"
else:
    SET_DRAGGABLE_METHOD = "draggable"


# Any changes here must be reflected in the definition in
# the C++ MplCpp/Plot.h header. See the comment in that file
# for the reason for duplication.
class MantidAxType(Enum):
    """Define an list of possible axis types for plotting"""

    BIN = 0
def plot_attribute(cur, planners, attribute, typename):
    """Create a plot for a particular attribute. It will include data for
    all planners that have data for this attribute."""
    plt.clf()
    ax = plt.gca()
    labels = []
    measurements = []
    nan_counts = []
    cur.execute('SELECT count(*) FROM enums where name IS "%s"' % attribute)
    num_vals = cur.fetchone()[0]
    is_enum = False if num_vals==0 else True
    is_bool = not is_enum
    for planner in planners:
        cur.execute('SELECT * FROM `%s`' % planner)
        attributes = [ t[0] for t in cur.description]
        if attribute in attributes:
            cur.execute('SELECT `%s` FROM `%s` WHERE `%s` IS NOT NULL' % (attribute, planner, attribute))
            measurement = [ 0 if np.isinf(t[0]) else t[0] for t in cur.fetchall() ]
            cur.execute('SELECT count(*) FROM `%s` WHERE `%s` IS NULL' % (planner, attribute))
            nan_counts.append(cur.fetchone()[0])
            cur.execute('SELECT DISTINCT `%s` FROM `%s`' % (attribute, planner))
            is_bool = is_bool and set([t[0] for t in cur.fetchall() if not t[0]==None]).issubset(set([0,1]))
            if is_enum:
                scale = 100. / len(measurement)
                measurements.append([measurement.count(i)*scale for i in range(num_vals)])
            else:
                measurements.append(measurement)
            labels.append(planner.replace('planner_geometric_','').replace('planner_control_',''))

    if is_enum:
        width = .5
        measurements = np.transpose(np.vstack(measurements))
        colsum = np.sum(measurements, axis=1)
        rows = np.where(colsum != 0)[0]
        heights = np.zeros((1,measurements.shape[1]))
        ind = range(measurements.shape[1])
        legend_labels = []
        for i in rows:
            cur.execute('SELECT `description` FROM enums WHERE name IS "%s" AND value IS "%d"' % (attribute,i))
            plt.bar(ind, measurements[i], width, bottom=heights[0],
                color=matplotlib.cm.hot(int(floor(i*256/num_vals))), label=cur.fetchone()[0])
            heights = heights + measurements[i]
        xtickNames = plt.xticks([x+width/2. for x in ind], labels, rotation=30)
        ax.set_ylabel(attribute.replace('_',' ') + ' (%)')
        box = ax.get_position()
        ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
        props = matplotlib.font_manager.FontProperties()
        props.set_size('small')
        ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop = props)
    elif is_bool:
        width = .5
        measurements_percentage = [sum(m)*100./len(m) for m in measurements]
        ind = range(len(measurements))
        plt.bar(ind, measurements_percentage, width)
        xtickNames = plt.xticks([x+width/2. for x in ind], labels, rotation=30)
        ax.set_ylabel(attribute.replace('_',' ') + ' (%)')
    else:
        if int(matplotlibversion.split('.')[0])<1:
            plt.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5)
        else:
            plt.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5, bootstrap=1000)
        ax.set_ylabel(attribute.replace('_',' '))
        xtickNames = plt.setp(ax,xticklabels=labels)
        plt.setp(xtickNames, rotation=25)
    ax.set_xlabel('Motion planning algorithm')
    ax.yaxis.grid(True, linestyle='-', which='major', color='lightgrey', alpha=0.5)
    if max(nan_counts)>0:
        maxy = max([max(y) for y in measurements])
        for i in range(len(labels)):
            x = i+width/2 if is_bool else i+1
            ax.text(x, .95*maxy, str(nan_counts[i]), horizontalalignment='center', size='small')
    plt.show()
Пример #21
0
    def setmask(self, im):
        """
        input an image (for now an HDU) and set self.mask to 
        an array the size of the image with the phot region =1
          and expanded background annulus =2
        for now we also create a mask the size of the image, so I recommend
          to extract a subimage and call this method with that input
        this method well trim the polyon to fit in the image
        """
        imshape = im.shape
        mask = pl.zeros(imshape)

        if self.type == "circle":
            x, y, r = self.imcoords(im)
            x0 = int(x)
            y0 = int(y)
            dx = x - x0
            dy = y - y0
            # grr pixel centers again - is this right?
            #            dx=dx-0.5; dy=dy-0.5

            bg0_r = self.imcoords(im, reg="bg0")[2]  #-0.2 # fudge
            bg1_r = self.imcoords(im, reg="bg1")[2]  #+0.2 # fudge
            bg1_r0 = int(pl.ceil(bg1_r))
            r2 = r**2
            bg0_r2 = bg0_r**2
            bg1_r2 = bg1_r**2
            for i in pl.array(range(2 * bg1_r0 + 1)) - bg1_r0:
                for j in pl.array(range(2 * bg1_r0 + 1)) - bg1_r0:
                    if y0 + j >= 0 and x0 + i >= 0 and y0 + j < (
                            imshape[0] - 1) and x0 + i < (imshape[1] - 1):
                        d2 = (1. * i - dx)**2 + (1. * j - dy)**2
                        # d2 = (i-x)**2 + (j-y)**2 -> (i-x0-(x-x0))**2 + ...
                        if d2 <= r2:
                            mask[y0 + j,
                                 x0 + i] = 1  # remember indices inverted
                        if d2 >= bg0_r2 and d2 <= bg1_r2:
                            mask[y0 + j,
                                 x0 + i] = 2  # remember indices inverted
#                        if x0+i==6:
#                           print i,j,x0+i,y0+j,dx,dy,d2,bg0_r2,bg1_r2

        elif self.type == "polygon":
            # turn annulus back into mask, will trim at edges of image
            from matplotlib.path import Path
            from matplotlib import __version__ as mpver
            v = mpver.split('.')
            if v[0] < 1:
                raise Exception(
                    "need matplotlib >=1.3.1, or tell remy to add fallback nxutils option for Path.contains_points"
                )
            elif v[1] < 3:
                raise Exception(
                    "need matplotlib >=1.3.1, or tell remy to add fallback nxutils option for Path.contains_points"
                )
            elif v[2] < 1:
                raise Exception(
                    "need matplotlib >=1.3.1, or tell remy to add fallback nxutils option for Path.contains_points"
                )

            # Create vertex coordinates for each grid cell
            x, y = pl.meshgrid(pl.arange(imshape[1]), pl.arange(imshape[0]))
            x, y = x.flatten(), y.flatten()
            points = pl.vstack((x, y)).T
            mask1 = Path(self.imcoords(im, reg="bg1")).contains_points(points)
            mask1 = mask1.reshape((imshape[0], imshape[1]))
            mask0 = Path(self.imcoords(im, reg="bg0")).contains_points(points)
            #,radius=1)
            mask0 = mask0.reshape((imshape[0], imshape[1]))
            mask = Path(self.imcoords(im, reg="ap")).contains_points(points)
            mask = mask.reshape((imshape[0], imshape[1]))

            mask = mask + (1 * mask1 - 1 * mask0) * 2
        else:
            raise Exception("unknown region type %s" % self.type)
        self.mask = mask
        return mask
Пример #22
0
def plotAttribute(cur, planners, attribute, typename):
    """Create a plot for a particular attribute. It will include data for
    all planners that have data for this attribute."""
    labels = []
    measurements = []
    nanCounts = []
    if typename == 'ENUM':
        cur.execute('SELECT description FROM enums where name IS "%s"' %
                    attribute)
        descriptions = [t[0] for t in cur.fetchall()]
        numValues = len(descriptions)
    for planner in planners:
        cur.execute('SELECT %s FROM runs WHERE plannerid = %s AND %s IS NOT NULL' \
            % (attribute, planner[0], attribute))
        measurement = [t[0] for t in cur.fetchall() if t[0] != None]
        if len(measurement) > 0:
            cur.execute('SELECT count(*) FROM runs WHERE plannerid = %s AND %s IS NULL' \
                % (planner[0], attribute))
            nanCounts.append(cur.fetchone()[0])
            labels.append(planner[1])
            if typename == 'ENUM':
                scale = 100. / len(measurement)
                measurements.append(
                    [measurement.count(i) * scale for i in range(numValues)])
            else:
                measurements.append(measurement)

    if len(measurements) == 0:
        print('Skipping "%s": no available measurements' % attribute)
        return

    plt.clf()
    ax = plt.gca()
    if typename == 'ENUM':
        width = .5
        measurements = np.transpose(np.vstack(measurements))
        colsum = np.sum(measurements, axis=1)
        rows = np.where(colsum != 0)[0]
        heights = np.zeros((1, measurements.shape[1]))
        ind = range(measurements.shape[1])
        legend_labels = []
        for i in rows:
            plt.bar(ind,
                    measurements[i],
                    width,
                    bottom=heights[0],
                    color=matplotlib.cm.hot(int(floor(i * 256 / numValues))),
                    label=descriptions[i])
            heights = heights + measurements[i]
        xtickNames = plt.xticks([x + width / 2. for x in ind],
                                labels,
                                rotation=30,
                                fontsize=8,
                                ha='right')
        ax.set_ylabel(attribute.replace('_', ' ') + ' (%)')
        box = ax.get_position()
        ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
        props = matplotlib.font_manager.FontProperties()
        props.set_size('small')
        ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop=props)
    elif typename == 'BOOLEAN':
        width = .5
        measurementsPercentage = [sum(m) * 100. / len(m) for m in measurements]
        ind = range(len(measurements))
        plt.bar(ind, measurementsPercentage, width)
        ### uncommenting this line will remove the term 'kConfigDefault' from the labels for OMPL Solvers.
        ### Fits situations where you need more control in the plot, such as in an academic publication for example
        #labels = [l.replace('kConfigDefault', '') for l in labels]

        xtickNames = plt.xticks([x + width / 2. for x in ind],
                                labels,
                                rotation=30,
                                fontsize=8,
                                ha='right')
        ax.set_ylabel(attribute.replace('_', ' ') + ' (%)')
        plt.subplots_adjust(
            bottom=0.3
        )  # Squish the plot into the upper 2/3 of the page.  Leave room for labels
    else:
        if int(matplotlibversion.split('.')[0]) < 1:
            plt.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5)
        else:
            plt.boxplot(measurements,
                        notch=0,
                        sym='k+',
                        vert=1,
                        whis=1.5,
                        bootstrap=1000)
        ax.set_ylabel(attribute.replace('_', ' '))

        #xtickNames = plt.xticks(labels, rotation=30, fontsize=10)
        #plt.subplots_adjust(bottom=0.3) # Squish the plot into the upper 2/3 of the page.  Leave room for labels

        ### uncommenting this line will remove the term 'kConfigDefault' from the labels for OMPL Solvers.
        ### Fits situations where you need more control in the plot, such as in an academic publication for example
        #labels = [l.replace('kConfigDefault', '') for l in labels]

        xtickNames = plt.setp(ax, xticklabels=labels)
        plt.setp(xtickNames, rotation=30, fontsize=8, ha='right')
        for tick in ax.xaxis.get_major_ticks(
        ):  # shrink the font size of the x tick labels
            tick.label.set_fontsize(8)
        plt.subplots_adjust(
            bottom=0.3
        )  # Squish the plot into the upper 2/3 of the page.  Leave room for labels
    ax.set_xlabel('Motion planning algorithm', fontsize=12)
    ax.yaxis.grid(True,
                  linestyle='-',
                  which='major',
                  color='lightgrey',
                  alpha=0.5)
    if max(nanCounts) > 0:
        maxy = max([max(y) for y in measurements])
        for i in range(len(labels)):
            x = i + width / 2 if typename == 'BOOLEAN' else i + 1
        ### uncommenting the next line, the number of failed planning attempts will be added to each bar
        # ax.text(x, .95*maxy, str(nanCounts[i]), horizontalalignment='center', size='small')
    plt.show()
Пример #23
0
         command = 'python --version'
         proc = Popen(command,shell=True,universal_newlines=True, \
                          stdout=PIPE,stderr=STDOUT)
@@ -285,7 +285,7 @@
     def test_numpy_suported_version(self):
         """numpy version is supported """
         min_acceptable_version = (1,5,1)
-        max_acceptable_version = (1,7,1)
+        max_acceptable_version = (1,8,1)
         try:
             from numpy import __version__ as numpy_lib_version
             version = tuple(map(int,numpy_lib_version.split('.')))
@@ -304,7 +304,7 @@
     def test_matplotlib_suported_version(self):
         """matplotlib version is supported """
         min_acceptable_version = (1,1,0)
-        max_acceptable_version = (1,3,1)
+        max_acceptable_version = (1,4,0)
         try:
             from matplotlib import __version__ as matplotlib_lib_version
             version = tuple(map(int,matplotlib_lib_version.split('.')))
@@ -345,7 +345,7 @@
 
     def test_FastTree_supported_version(self):
         """FastTree is in path and version is supported """
-        acceptable_version = (2,1,3)
+        acceptable_version = (2,1,7)
         self.assertTrue(app_path('FastTree'),
          "FastTree not found. This may or may not be a problem depending on "+\
          "which components of QIIME you plan to use.")
Пример #24
0
def plotAttribute(cur, planners, attribute, typename):
    """Create a plot for a particular attribute. It will include data for
    all planners that have data for this attribute."""
    labels = []
    measurements = []
    nanCounts = []
    if typename == 'ENUM':
        cur.execute('SELECT description FROM enums where name IS "%s"' % attribute)
        descriptions = [ t[0] for t in cur.fetchall() ]
        numValues = len(descriptions)
    for planner in planners:
        cur.execute('SELECT %s FROM runs WHERE plannerid = %s AND %s IS NOT NULL' \
            % (attribute, planner[0], attribute))
        measurement = [ t[0] for t in cur.fetchall() if t[0] != None ]
        if len(measurement) > 0:
            cur.execute('SELECT count(*) FROM runs WHERE plannerid = %s AND %s IS NULL' \
                % (planner[0], attribute))
            nanCounts.append(cur.fetchone()[0])
            labels.append(planner[1])
            if typename == 'ENUM':
                scale = 100. / len(measurement)
                measurements.append([measurement.count(i)*scale for i in range(numValues)])
            else:
                measurements.append(measurement)

    if len(measurements)==0:
        print('Skipping "%s": no available measurements' % attribute)
        return

    plt.clf()
    ax = plt.gca()
    if typename == 'ENUM':
        width = .5
        measurements = np.transpose(np.vstack(measurements))
        colsum = np.sum(measurements, axis=1)
        rows = np.where(colsum != 0)[0]
        heights = np.zeros((1,measurements.shape[1]))
        ind = range(measurements.shape[1])
        legend_labels = []
        for i in rows:
            plt.bar(ind, measurements[i], width, bottom=heights[0],
                color=matplotlib.cm.hot(int(floor(i*256/numValues))),
                label=descriptions[i])
            heights = heights + measurements[i]
        xtickNames = plt.xticks([x+width/2. for x in ind], labels, rotation=30)
        ax.set_ylabel(attribute.replace('_',' ') + ' (%)')
        box = ax.get_position()
        ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
        props = matplotlib.font_manager.FontProperties()
        props.set_size('small')
        ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop = props)
    elif typename == 'BOOLEAN':
        width = .5
        measurementsPercentage = [sum(m) * 100. / len(m) for m in measurements]
        ind = range(len(measurements))
        plt.bar(ind, measurementsPercentage, width)
        xtickNames = plt.xticks([x + width / 2. for x in ind], labels, rotation=30)
        ax.set_ylabel(attribute.replace('_',' ') + ' (%)')
    else:
        if int(matplotlibversion.split('.')[0])<1:
            plt.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5)
        else:
            plt.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5, bootstrap=1000)
        ax.set_ylabel(attribute.replace('_',' '))
        xtickNames = plt.setp(ax,xticklabels=labels)
        plt.setp(xtickNames, rotation=25)
    ax.set_xlabel('Motion planning algorithm')
    ax.yaxis.grid(True, linestyle='-', which='major', color='lightgrey', alpha=0.5)
    if max(nanCounts)>0:
        maxy = max([max(y) for y in measurements])
        for i in range(len(labels)):
            x = i+width/2 if typename=='BOOLEAN' else i+1
            ax.text(x, .95*maxy, str(nanCounts[i]), horizontalalignment='center', size='small')
    plt.show()
Пример #25
0
    def plot(self):
        # check if there is anything to plot
        if len(self.plot_instances) == 0:
            raise SystemExit('no data to plot.')

        if self.args['output_file'] is not None:
            # --output-file means don't depend on X,
            # so switch to a pure-image backend before doing any plotting.
            plt.switch_backend('agg')

        self.artists = []
        plt.figure(figsize=(12,8), dpi=100, facecolor='w', edgecolor='w')
        axis = plt.subplot(111)

        # set xlim from min to max of logfile ranges
        xlim_min = min([pi.date_range[0] for pi in self.plot_instances])
        xlim_max = max([pi.date_range[1] for pi in self.plot_instances])

        if xlim_max < xlim_min:
            raise SystemExit('no data to plot.')

        xlabel = 'time'
        ylabel = ''

        # use timezone of first log file (may not always be what user wants but must make a choice)
        tz = self.logfiles[0].timezone
        tzformat = '%b %d\n%H:%M:%S' if tz == tzutc() else '%b %d\n%H:%M:%S%z'

        locator = AutoDateLocator(tz=tz, minticks=5, maxticks=10)
        formatter = AutoDateFormatter(locator, tz=tz)

        formatter.scaled = {
           365.0  : '%Y',
           30.    : '%b %Y',
           1.0    : '%b %d %Y',
           1./24. : '%b %d %Y\n%H:%M:%S',
           1./(24.*60.): '%b %d %Y\n%H:%M:%S',
        }

        # add timezone to format if not UTC
        if tz != tzutc():
            formatter.scaled[1./24.] = '%b %d %Y\n%H:%M:%S%z'
            formatter.scaled[1./(24.*60.)] = '%b %d %Y\n%H:%M:%S%z'

        for i, plot_inst in enumerate(sorted(self.plot_instances, key=lambda pi: pi.sort_order)):
            self.artists.extend(plot_inst.plot(axis, i, len(self.plot_instances), (xlim_min, xlim_max) ))
            if hasattr(plot_inst, 'xlabel'):
                xlabel = plot_inst.xlabel
            if hasattr(plot_inst, 'ylabel'):
                ylabel = plot_inst.ylabel
        if self.args['output_file'] is None:
            self.print_shortcuts(scatter=isinstance(self.plot_instance, plottypes.ScatterPlotType))

        axis.set_xlabel(xlabel)
        axis.set_xticklabels(axis.get_xticks(), rotation=90, fontsize=9)
        axis.xaxis.set_major_locator(locator)
        axis.xaxis.set_major_formatter(formatter)
            
        axis.set_xlim(date2num([xlim_min, xlim_max]))

        # ylabel for y axis
        if self.args['logscale']:
            ylabel += ' (log scale)'
        axis.set_ylabel(ylabel)

        # title and mtools link
        axis.set_title(self.args['title'] or ', '.join([l.name for l in self.logfiles if l.name != '<stdin>']))
        plt.subplots_adjust(bottom=0.15, left=0.1, right=0.95, top=0.95)
        self.footnote = plt.annotate('created with mtools v%s: https://github.com/rueckstiess/mtools' % __version__, (10, 10), xycoords='figure pixels', va='bottom', fontsize=8)

        handles, labels = axis.get_legend_handles_labels()
        if len(labels) > 0:
            # only change fontsize if supported 
            major, minor, _ = mpl_version.split('.')
            if (int(major), int(minor)) >= (1, 3):
                self.legend = axis.legend(loc='upper left', frameon=False, numpoints=1, fontsize=9)
            else:
                self.legend = axis.legend(loc='upper left', frameon=False, numpoints=1)
        
        if self.args['type'] == 'scatter':
            # enable legend picking for scatter plots
            for i, legend_line in enumerate(self.legend.get_lines()):
                legend_line.set_picker(10)
                legend_line._mt_legend_item = i

        # overwrite y-axis limits if set
        if self.args['ylimits'] != None:
            print self.args['ylimits']
            axis.set_ylim( self.args['ylimits'])

        plt.gcf().canvas.mpl_connect('pick_event', self.onpick)
        plt.gcf().canvas.mpl_connect('key_press_event', self.onpress)
        if self.args['output_file'] is not None:
            plt.savefig(self.args['output_file'])
        else:
            plt.show()
    def plot_attribute_per_query(self, cur, planner, attribute, typename,
                                 layout):
        measurements = []
        if typename == 'ENUM':
            # TODO: Implement enum support
            return

        cur.execute('SELECT %s FROM runs WHERE plannerid = %s' %
                    (attribute, planner[0]))
        measurement_including_nan = [t[0] for t in cur.fetchall()]

        if 0 == len(measurement_including_nan):
            rospy.logwarn(
                "No measurements for {} available!".format(attribute))
            self.clearLayout(layout)
            return

        # Find the number of runs
        cur.execute('SELECT runcount FROM experiments WHERE id = 1')
        runcount = cur.fetchall()[0][0]

        # Find names and number of queries
        cur.execute('SELECT id FROM experiments')
        queries = [q[0] for q in cur.fetchall()]
        num_queries = len(queries)

        cur.execute('SELECT experimentid FROM runs WHERE plannerid = %s' %
                    (planner[0]))
        queryid_to_run_mapping = [t[0] for t in cur.fetchall()]

        per_query_runcount = []
        for query_id in queries:
            per_query_runcount.append(queryid_to_run_mapping.count(query_id))

        matrix_measurements_with_nans = []
        for runcount in per_query_runcount:
            matrix_measurements_with_nans.append(
                measurement_including_nan[0:runcount])
            del measurement_including_nan[0:runcount]

        # Remove NaNs from the measurement array
        matrix_measurements = []
        for per_query_result in matrix_measurements_with_nans:
            matrix_measurements.append(
                [x for x in per_query_result if x is not None])

        # Add the unit if the attribute is known
        attribute = attribute.replace('_', ' ')
        if "time" in attribute:
            attribute += ' (s)'
        elif "clearance" in attribute:
            attribute += ' (m)'
        elif "cartesian" in attribute:
            attribute += ''
        elif "length" in attribute or "quality" in attribute or "smoothness" in attribute:
            attribute += ' (rad)'
        elif typename == "BOOLEAN":
            attribute += ' (%)'

        plt.clf()
        # GUI
        width = 5
        height = 4
        dpi = 100
        fig = Figure(figsize=(width, height),
                     dpi=dpi,
                     facecolor=(1.0, 1.0, 1.0, 1.0))
        ax = fig.add_subplot(111)

        figcanvas = FigureCanvas(fig)
        figcanvas.setParent(self._widget)

        FigureCanvas.setSizePolicy(figcanvas, QSizePolicy.Expanding,
                                   QSizePolicy.Expanding)
        FigureCanvas.updateGeometry(figcanvas)

        if typename == 'BOOLEAN':
            width = .5
            measurements_percentage = []
            missing_measurements = []
            missing_measurements_index = []
            for i, m in enumerate(matrix_measurements):
                if 0 == len(m):
                    measurements_percentage.append(0)
                    missing_measurements.append(50)
                    missing_measurements_index.append(i + width / 2)
                else:
                    measurements_percentage.append(sum(m) * 100 / len(m))
            idx = range(len(measurements_percentage))
            ax.bar(idx, measurements_percentage, width)
            ax.scatter(missing_measurements_index,
                       missing_measurements,
                       color='r',
                       marker='x')
            plt.setp(ax,
                     xticks=[x + width / 2 for x in idx],
                     xticklabels=[x + 1 for x in idx])
            ax.set_ylim([0, 100])
            ax.set_xlim([0, len(matrix_measurements)])
        else:
            if int(matplotlibversion.split('.')[0]) < 1:
                ax.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5)
            else:
                ax.boxplot(matrix_measurements,
                           notch=0,
                           sym='k+',
                           vert=1,
                           whis=1.5,
                           bootstrap=1000)

        for tick in ax.xaxis.get_major_ticks(
        ):  # shrink the font size of the x tick labels
            tick.label.set_fontsize(8)
        for tick in ax.yaxis.get_major_ticks(
        ):  # shrink the font size of the x tick labels
            tick.label.set_fontsize(8)

        self.clearLayout(layout)
        layout.addWidget(figcanvas)
    def plot_attribute_per_query(self, cur, planner, attribute, typename, layout):
        # Plotting for the selected planner results for each query
        measurements = []
        cur.execute('SELECT %s FROM runs WHERE plannerid = %s'
                    % (attribute, planner[0]))
        measurement_including_nan = [t[0] for t in cur.fetchall()]

        if 0 == len(measurement_including_nan):
            rospy.logwarn("No measurements for {} available!".format(attribute))
            self.clearLayout(layout)
            return

        cur.execute('SELECT experimentid FROM runs WHERE plannerid = %s' % (planner[0]))
        queryid_to_run_mapping = [t[0] for t in cur.fetchall()]

        per_query_runcount = []
        for query in self.queries:
            per_query_runcount.append(queryid_to_run_mapping.count(query[0]))

        matrix_measurements_with_nans = []
        for runcount in per_query_runcount:
            matrix_measurements_with_nans.append(measurement_including_nan[0: runcount])
            del measurement_including_nan[0: runcount]

        # Remove NaNs from the measurement array
        matrix_measurements = []
        for per_query_result in matrix_measurements_with_nans:
            matrix_measurements.append([x for x in per_query_result if x is not None])

        plt.clf()
        # GUI
        width = 5
        height = 4
        dpi = 100
        fig = Figure(figsize=(width, height), dpi=dpi, facecolor=(1.0, 1.0, 1.0, 1.0))
        ax = fig.add_subplot(111)

        figcanvas = FigureCanvas(fig)
        figcanvas.setParent(self._widget)
        FigureCanvas.setSizePolicy(figcanvas, QSizePolicy.Expanding, QSizePolicy.Expanding)
        FigureCanvas.updateGeometry(figcanvas)

        if typename == 'BOOLEAN':
            width = .5
            measurements_percentage = []
            missing_measurements = []
            missing_measurements_index = []
            for i, m in enumerate(matrix_measurements):
                if 0 == len(m):
                    measurements_percentage.append(0)
                    missing_measurements.append(50)
                    missing_measurements_index.append(i + width / 2)
                else:
                    measurements_percentage.append(sum(m) * 100 / per_query_runcount[i])
            idx = range(len(measurements_percentage))
            ax.bar(idx, measurements_percentage, width)
            ax.scatter(missing_measurements_index, missing_measurements, color='r', marker='x')
            plt.setp(ax, xticks=[x + width / 2 for x in idx], xticklabels=[x + 1 for x in idx])
            ax.set_ylim([0, 100])
            ax.set_xlim([0, len(matrix_measurements)])
        else:
            if int(matplotlibversion.split('.')[0]) < 1:
                ax.boxplot(measurements, notch=0, sym='r+', vert=1, whis=1.5)
            else:
                ax.boxplot(matrix_measurements, notch=0, sym='r+', vert=1, whis=1.5, bootstrap=1000)

        for tick in ax.xaxis.get_major_ticks():  # shrink the font size of the x tick labels
            tick.label.set_fontsize(7)
        for tick in ax.yaxis.get_major_ticks():  # shrink the font size of the x tick labels
            tick.label.set_fontsize(7)

        fig.subplots_adjust(bottom=0.1, top=0.90, left=0.08, right=0.98)
        ax.yaxis.grid(True, linestyle='-', which='major', color='lightgrey', alpha=0.5)

        if "clearance" in attribute:
            ax.ticklabel_format(style='sci', axis='y', scilimits=(-3, 4), useLocale=True)
            ax.yaxis.offsetText.set_fontsize(7)

        self.clearLayout(layout)
        layout.addWidget(figcanvas)
Пример #28
0
# We check what extensions are available
###########################################################
__extensions__ = {
    'matplotlib': False,
    'mplot3d': False,
    'pygmo': False,
    'scikit-learn': False,
    'scipy': False
}
# 1 - matplotlib
try:
    from matplotlib import __version__ as matplotlib_ver
    __extensions__['matplotlib'] = True

    # We detect the version and if more than 1.1.0 mplot3d is there
    mver = matplotlib_ver.split('.')
    mver = int(mver[0]) * 100 + int(mver[1]) * 10
    if mver >= 110:
        __extensions__['mplot3d'] = True
    del mver
except ImportError:
    pass

# 2 - pygmo2
try:
    from pygmo import __version__ as pygmo_ver
    __extensions__['pygmo'] = True
except ImportError:
    pass

# 3 - scikit-learn is installed
    def plot_attribute(self, cur, planners, attribute, typename, layout):
        labels = []
        measurements = []
        nanCounts = []
        if typename == 'ENUM':
            cur.execute('SELECT description FROM enums where name IS "%s"' %
                        attribute)
            descriptions = [t[0] for t in cur.fetchall()]
            numValues = len(descriptions)
        for planner in planners:
            cur.execute(
                'SELECT %s FROM runs WHERE plannerid = %s AND %s IS NOT NULL' %
                (attribute, planner[0], attribute))
            measurement = [t[0] for t in cur.fetchall() if t[0] != None]
            if len(measurement) > 0:
                cur.execute(
                    'SELECT count(*) FROM runs WHERE plannerid = %s AND %s IS NULL'
                    % (planner[0], attribute))
                nanCounts.append(cur.fetchone()[0])
                labels.append(planner[1])
                if typename == 'ENUM':
                    scale = 100. / len(measurement)
                    measurements.append([
                        measurement.count(i) * scale for i in range(numValues)
                    ])
                else:
                    measurements.append(measurement)

        if len(measurements) == 0:
            print('Skipping "%s": no available measurements' % attribute)
            return

        # Add the unit if the attribute is known
        attribute = attribute.replace('_', ' ')
        if "time" in attribute:
            attribute += ' (s)'
        elif "clearance" in attribute:
            attribute += ' (m)'
        elif "cartesian" in attribute:
            attribute += ''
        elif "length" in attribute or "quality" in attribute or "smoothness" in attribute:
            attribute += ' (rad)'
        elif typename == "BOOLEAN":
            attribute += ' (%)'

        plt.clf()
        # GUI
        width = 5
        height = 4
        dpi = 100
        fig = Figure(figsize=(width, height),
                     dpi=dpi,
                     facecolor=(1.0, 1.0, 1.0, 1.0))
        ax = fig.add_subplot(111)

        figcanvas = FigureCanvas(fig)
        figcanvas.setParent(self._widget)

        FigureCanvas.setSizePolicy(figcanvas, QSizePolicy.Expanding,
                                   QSizePolicy.Expanding)
        FigureCanvas.updateGeometry(figcanvas)

        # ax = plt.gca()
        if typename == 'ENUM':
            width = .5
            measurements = np.transpose(np.vstack(measurements))
            colsum = np.sum(measurements, axis=1)
            rows = np.where(colsum != 0)[0]
            heights = np.zeros((1, measurements.shape[1]))
            ind = range(measurements.shape[1])
            for i in rows:
                ax.bar(ind,
                       measurements[i],
                       width,
                       bottom=heights[0],
                       color=matplotlib.cm.hot(int(floor(i * 256 /
                                                         numValues))),
                       label=descriptions[i])
                heights = heights + measurements[i]
            plt.setp(ax, xticks=[x + width / 2. for x in ind])
            box = ax.get_position()
            ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
            props = matplotlib.font_manager.FontProperties()
            props.set_size('small')
            ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop=props)
        elif typename == 'BOOLEAN':
            width = .5
            measurementsPercentage = [
                sum(m) * 100. / len(m) for m in measurements
            ]
            ind = range(len(measurements))
            ax.bar(ind, measurementsPercentage, width)
            plt.setp(ax, xticks=[x + width / 2. for x in ind])
        else:
            if int(matplotlibversion.split('.')[0]) < 1:
                ax.boxplot(measurements, notch=0, sym='k+', vert=1, whis=1.5)
            else:
                ax.boxplot(measurements,
                           notch=0,
                           sym='k+',
                           vert=1,
                           whis=1.5,
                           bootstrap=1000)

        xtickNames = plt.setp(ax, xticklabels=labels)
        plt.setp(xtickNames, rotation=90)
        for tick in ax.xaxis.get_major_ticks(
        ):  # shrink the font size of the x tick labels
            tick.label.set_fontsize(8)
        for tick in ax.yaxis.get_major_ticks(
        ):  # shrink the font size of the x tick labels
            tick.label.set_fontsize(8)
        fig.subplots_adjust(bottom=0.3, top=0.95, left=0.1, right=0.98)

        ax.yaxis.grid(True,
                      linestyle='-',
                      which='major',
                      color='lightgrey',
                      alpha=0.5)
        if max(nanCounts) > 0:
            maxy = max([max(y) for y in measurements])
            for i in range(len(labels)):
                x = i + width / 2 if typename == 'BOOLEAN' else i + 1
                ax.text(x,
                        .95 * maxy,
                        str(nanCounts[i]),
                        horizontalalignment='center',
                        size='small')

        self.clearLayout(layout)
        layout.addWidget(figcanvas)