Example #1
0
    def on_combobox_lineprops_changed(self, item):
        "update the widgets from the active line"
        if not self._inited:
            return
        self._updateson = False
        line = self.get_active_line()

        ls = line.get_linestyle()
        if ls is None:
            ls = "None"
        self.cbox_linestyles.set_active(self.linestyled[ls])

        marker = line.get_marker()
        if marker is None:
            marker = "None"
        self.cbox_markers.set_active(self.markerd[marker])

        rgba = mcolors.to_rgba(line.get_color())
        color = gtk.gdk.Color(*[int(val * 65535) for val in rgba[:3]])
        button = self.wtree.get_widget("colorbutton_linestyle")
        button.set_color(color)

        rgba = mcolors.to_rgba(line.get_markerfacecolor())
        color = gtk.gdk.Color(*[int(val * 65535) for val in rgba[:3]])
        button = self.wtree.get_widget("colorbutton_markerface")
        button.set_color(color)
        self._updateson = True
Example #2
0
def volume_overlay(ax, opens, closes, volumes,
                   colorup='k', colordown='r',
                   width=4, alpha=1.0):
    """Add a volume overlay to the current axes.  The opens and closes
    are used to determine the color of the bar.  -1 is missing.  If a
    value is missing on one it must be missing on all

    Parameters
    ----------
    ax : `Axes`
        an Axes instance to plot to
    opens : sequence
        a sequence of opens
    closes : sequence
        a sequence of closes
    volumes : sequence
        a sequence of volumes
    width : int
        the bar width in points
    colorup : color
        the color of the lines where close >= open
    colordown : color
        the color of the lines where close <  open
    alpha : float
        bar transparency

    Returns
    -------
    ret : `barCollection`
        The `barrCollection` added to the axes

    """

    colorup = mcolors.to_rgba(colorup, alpha)
    colordown = mcolors.to_rgba(colordown, alpha)
    colord = {True: colorup, False: colordown}
    colors = [colord[open < close]
              for open, close in zip(opens, closes)
              if open != -1 and close != -1]

    delta = width / 2.
    bars = [((i - delta, 0), (i - delta, v), (i + delta, v), (i + delta, 0))
            for i, v in enumerate(volumes)
            if v != -1]

    barCollection = PolyCollection(bars,
                                   facecolors=colors,
                                   edgecolors=((0, 0, 0, 1), ),
                                   antialiaseds=(0,),
                                   linewidths=(0.5,),
                                   )

    ax.add_collection(barCollection)
    corners = (0, 0), (len(bars), max(volumes))
    ax.update_datalim(corners)
    ax.autoscale_view()

    # add these last
    return barCollection
Example #3
0
    def __init__(self, fontsize=14, labelcolor='black', bgcolor='yellow',
                 alpha=1.0):
        self.fontsize = fontsize
        self.labelcolor = labelcolor
        self.bgcolor = bgcolor
        self.alpha = alpha

        self.labelcolor_rgb = colors.to_rgba(labelcolor)[:3]
        self.bgcolor_rgb = colors.to_rgba(bgcolor)[:3]
Example #4
0
def test_legend_edgecolor():
    get_func = 'get_edgecolor'
    rcparam = 'legend.edgecolor'
    test_values = [({rcparam: 'r'},
                    mcolors.to_rgba('r')),
                   ({rcparam: 'inherit', 'axes.edgecolor': 'r'},
                    mcolors.to_rgba('r')),
                   ({rcparam: 'g', 'axes.facecolor': 'r'},
                    mcolors.to_rgba('g'))]
    for rc_dict, target in test_values:
        yield _legend_rcparam_helper, rc_dict, target, get_func
Example #5
0
def test_conversions():
    # to_rgba_array("none") returns a (0, 4) array.
    assert_array_equal(mcolors.to_rgba_array("none"), np.zeros((0, 4)))
    # alpha is properly set.
    assert_equal(mcolors.to_rgba((1, 1, 1), .5), (1, 1, 1, .5))
    # builtin round differs between py2 and py3.
    assert_equal(mcolors.to_hex((.7, .7, .7)), "#b2b2b2")
    # hex roundtrip.
    hex_color = "#1234abcd"
    assert_equal(mcolors.to_hex(mcolors.to_rgba(hex_color), keep_alpha=True),
                 hex_color)
Example #6
0
def test_failed_conversions():
    with pytest.raises(ValueError):
        mcolors.to_rgba('5')
    with pytest.raises(ValueError):
        mcolors.to_rgba('-1')
    with pytest.raises(ValueError):
        mcolors.to_rgba('nan')
    with pytest.raises(ValueError):
        mcolors.to_rgba('unknown_color')
    with pytest.raises(ValueError):
        # Gray must be a string to distinguish 3-4 grays from RGB or RGBA.
        mcolors.to_rgba(0.4)
Example #7
0
def convert_colors_string_to_tuple(cols):
    for col in cols:
        if isinstance(col, str):
            if col in BASE_COLORS:
                yield to_rgba(BASE_COLORS[col])
            elif col in CSS4_COLORS:
                yield to_rgba(CSS4_COLORS[col])
            else:
                raise ValueError("Color specifier {} "
                                 "not recognized".format(col))
        else:
            yield to_rgba(col)
Example #8
0
def draw_3d(verts, ymin, ymax, line_at_zero=True, colors=True):
    '''Given verts as a list of plots, each plot being a list
       of (x, y) vertices, generate a 3-d figure where each plot
       is shown as a translucent polygon.
       If line_at_zero, a line will be drawn through the zero point
       of each plot, otherwise the baseline will be at the bottom of
       the plot regardless of where the zero line is.
    '''
    # add_collection3d() wants a collection of closed polygons;
    # each polygon needs a base and won't generate it automatically.
    # So for each subplot, add a base at ymin.
    if line_at_zero:
        zeroline = 0
    else:
        zeroline = ymin
    for p in verts:
        p.insert(0, (p[0][0], zeroline))
        p.append((p[-1][0], zeroline))

    if colors:
        # All the matplotlib color sampling examples I can find,
        # like cm.rainbow/linspace, make adjacent colors similar,
        # the exact opposite of what most people would want.
        # So cycle hue manually.
        hue = 0
        huejump = .27
        facecolors = []
        edgecolors = []
        for v in verts:
            hue = (hue + huejump) % 1
            c = mcolors.hsv_to_rgb([hue, 1, 1])
                                    # random.uniform(.8, 1),
                                    # random.uniform(.7, 1)])
            edgecolors.append(c)
            # Make the facecolor translucent:
            facecolors.append(mcolors.to_rgba(c, alpha=.7))
    else:
        facecolors = (1, 1, 1, .8)
        edgecolors = (0, 0, 1, 1)

    poly = PolyCollection(verts,
                          facecolors=facecolors, edgecolors=edgecolors)

    zs = range(len(data))
    # zs = range(len(data)-1, -1, -1)

    fig = plt.figure()
    ax = fig.add_subplot(1,1,1, projection='3d')

    plt.tight_layout(pad=2.0, w_pad=10.0, h_pad=3.0)

    ax.add_collection3d(poly, zs=zs, zdir='y')

    ax.set_xlabel('X')
    ax.set_ylabel('Y')
    ax.set_zlabel('Z')

    ax.set_xlim3d(0, len(data[1]))
    ax.set_ylim3d(-1, len(data))
    ax.set_zlim3d(ymin, ymax)
Example #9
0
 def make_image(self, renderer, magnification=1.0, unsampled=False):
     if self._A is None:
         raise RuntimeError('You must first set the image array')
     if unsampled:
         raise ValueError('unsampled not supported on PColorImage')
     fc = self.axes.patch.get_facecolor()
     bg = mcolors.to_rgba(fc, 0)
     bg = (np.array(bg)*255).astype(np.uint8)
     l, b, r, t = self.axes.bbox.extents
     width = (np.round(r) + 0.5) - (np.round(l) - 0.5)
     height = (np.round(t) + 0.5) - (np.round(b) - 0.5)
     # The extra cast-to-int is only needed for python2
     width = int(np.round(width * magnification))
     height = int(np.round(height * magnification))
     if self._rgbacache is None:
         A = self.to_rgba(self._A, bytes=True)
         self._rgbacache = A
         if self._A.ndim == 2:
             self.is_grayscale = self.cmap.is_gray()
     else:
         A = self._rgbacache
     vl = self.axes.viewLim
     im = _image.pcolor2(self._Ax, self._Ay, A,
                         height,
                         width,
                         (vl.x0, vl.x1, vl.y0, vl.y1),
                         bg)
     return im, l, b, IdentityTransform()
Example #10
0
 def __init__(self, offset=(2, -2),
              shadow_color='k', alpha=0.3, rho=0.3, **kwargs):
     """
     Parameters
     ----------
     offset : pair of floats
         The offset to apply to the path, in points.
     shadow_color : color
         The shadow color. Default is black.
         A value of ``None`` takes the original artist's color
         with a scale factor of `rho`.
     alpha : float
         The alpha transparency of the created shadow patch.
         Default is 0.3.
     rho : float
         A scale factor to apply to the rgbFace color if `shadow_rgbFace`
         is ``None``. Default is 0.3.
     **kwargs
         Extra keywords are stored and passed through to
         :meth:`AbstractPathEffect._update_gc`.
     """
     super().__init__(offset)
     if shadow_color is None:
         self._shadow_color = shadow_color
     else:
         self._shadow_color = mcolors.to_rgba(shadow_color)
     self._alpha = alpha
     self._rho = rho
     #: The dictionary of keywords to update the graphics collection with.
     self._gc = kwargs
Example #11
0
        def print_jpg(self, filename_or_obj, *args, **kwargs):
            """
            Supported kwargs:

            *quality*: The image quality, on a scale from 1 (worst) to
                95 (best). The default is 95, if not given in the
                matplotlibrc file in the savefig.jpeg_quality parameter.
                Values above 95 should be avoided; 100 completely
                disables the JPEG quantization stage.

            *optimize*: If present, indicates that the encoder should
                make an extra pass over the image in order to select
                optimal encoder settings.

            *progressive*: If present, indicates that this image
                should be stored as a progressive JPEG file.
            """
            buf, size = self.print_to_buffer()
            if kwargs.pop("dryrun", False):
                return
            # The image is "pasted" onto a white background image to safely
            # handle any transparency
            image = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1)
            rgba = mcolors.to_rgba(rcParams.get('savefig.facecolor', 'white'))
            color = tuple([int(x * 255.0) for x in rgba[:3]])
            background = Image.new('RGB', size, color)
            background.paste(image, image)
            options = restrict_dict(kwargs, ['quality', 'optimize',
                                             'progressive'])

            if 'quality' not in options:
                options['quality'] = rcParams['savefig.jpeg_quality']

            return background.save(filename_or_obj, format='jpeg', **options)
Example #12
0
def get_color_range(n):
    colors = mcolors.TABLEAU_COLORS
    by_hsv = sorted((tuple(mcolors.rgb_to_hsv(mcolors.to_rgba(color)[:3])), name)
                    for name, color in colors.items())
    sorted_names = [name for hsv, name in by_hsv]
    delta = int(len(sorted_names)/n)
    return sorted_names[::delta]
Example #13
0
def test_conversions():
    # to_rgba_array("none") returns a (0, 4) array.
    assert_array_equal(mcolors.to_rgba_array("none"), np.zeros((0, 4)))
    # a list of grayscale levels, not a single color.
    assert_array_equal(
        mcolors.to_rgba_array([".2", ".5", ".8"]),
        np.vstack([mcolors.to_rgba(c) for c in [".2", ".5", ".8"]]))
    # alpha is properly set.
    assert mcolors.to_rgba((1, 1, 1), .5) == (1, 1, 1, .5)
    assert mcolors.to_rgba(".1", .5) == (.1, .1, .1, .5)
    # builtin round differs between py2 and py3.
    assert mcolors.to_hex((.7, .7, .7)) == "#b2b2b2"
    # hex roundtrip.
    hex_color = "#1234abcd"
    assert mcolors.to_hex(mcolors.to_rgba(hex_color), keep_alpha=True) == \
        hex_color
Example #14
0
def test_conversions_masked():
    x1 = np.ma.array(['k', 'b'], mask=[True, False])
    x2 = np.ma.array([[0, 0, 0, 1], [0, 0, 1, 1]])
    x2[0] = np.ma.masked
    assert mcolors.to_rgba(x1[0]) == (0, 0, 0, 0)
    assert_array_equal(mcolors.to_rgba_array(x1),
                       [[0, 0, 0, 0], [0, 0, 1, 1]])
    assert_array_equal(mcolors.to_rgba_array(x2), mcolors.to_rgba_array(x1))
Example #15
0
def to_qcolor(color):
    """Create a QColor from a matplotlib color"""
    qcolor = QtGui.QColor()
    try:
        rgba = mcolors.to_rgba(color)
    except ValueError:
        warnings.warn('Ignoring invalid color %r' % color)
        return qcolor  # return invalid QColor
    qcolor.setRgbF(*rgba)
    return qcolor
Example #16
0
        def print_jpg(self, filename_or_obj, *args, dryrun=False,
                      pil_kwargs=None, **kwargs):
            """
            Write the figure to a JPEG file.

            Parameters
            ----------
            filename_or_obj : str or PathLike or file-like object
                The file to write to.

            Other Parameters
            ----------------
            quality : int
                The image quality, on a scale from 1 (worst) to 100 (best).
                The default is :rc:`savefig.jpeg_quality`.  Values above
                95 should be avoided; 100 completely disables the JPEG
                quantization stage.

            optimize : bool
                If present, indicates that the encoder should
                make an extra pass over the image in order to select
                optimal encoder settings.

            progressive : bool
                If present, indicates that this image
                should be stored as a progressive JPEG file.

            pil_kwargs : dict, optional
                Additional keyword arguments that are passed to
                `PIL.Image.save` when saving the figure.  These take precedence
                over *quality*, *optimize* and *progressive*.
            """
            buf, size = self.print_to_buffer()
            if dryrun:
                return
            # The image is "pasted" onto a white background image to safely
            # handle any transparency
            image = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1)
            rgba = mcolors.to_rgba(rcParams['savefig.facecolor'])
            color = tuple([int(x * 255) for x in rgba[:3]])
            background = Image.new('RGB', size, color)
            background.paste(image, image)
            if pil_kwargs is None:
                pil_kwargs = {}
            for k in ["quality", "optimize", "progressive"]:
                if k in kwargs:
                    pil_kwargs.setdefault(k, kwargs[k])
            pil_kwargs.setdefault("quality", rcParams["savefig.jpeg_quality"])
            pil_kwargs.setdefault("dpi", (self.figure.dpi, self.figure.dpi))
            return background.save(
                filename_or_obj, format='jpeg', **pil_kwargs)
Example #17
0
def plot_colortable(colors, title, sort_colors=True, emptycols=0):

    cell_width = 212
    cell_height = 22
    swatch_width = 48
    margin = 12
    topmargin = 40

    # Sort colors by hue, saturation, value and name.
    by_hsv = ((tuple(mcolors.rgb_to_hsv(mcolors.to_rgba(color)[:3])), name)
                    for name, color in colors.items())
    if sort_colors is True:
        by_hsv = sorted(by_hsv)
    names = [name for hsv, name in by_hsv]

    n = len(names)
    ncols = 4 - emptycols
    nrows = n // ncols + int(n % ncols > 0)

    width = cell_width * 4 + 2 * margin
    height = cell_height * nrows + margin + topmargin
    dpi = 72

    fig, ax = plt.subplots(figsize=(width / dpi, height / dpi), dpi=dpi)
    fig.subplots_adjust(margin/width, margin/height,
                        (width-margin)/width, (height-topmargin)/height)
    ax.set_xlim(0, cell_width * 4)
    ax.set_ylim(cell_height * (nrows-0.5), -cell_height/2.)
    ax.yaxis.set_visible(False)
    ax.xaxis.set_visible(False)
    ax.set_axis_off()
    ax.set_title(title, fontsize=24, loc="left", pad=10)

    for i, name in enumerate(names):
        row = i % nrows
        col = i // nrows
        y = row * cell_height

        swatch_start_x = cell_width * col
        swatch_end_x = cell_width * col + swatch_width
        text_pos_x = cell_width * col + swatch_width + 7

        ax.text(text_pos_x, y, name, fontsize=14,
                horizontalalignment='left',
                verticalalignment='center')

        ax.hlines(y, swatch_start_x, swatch_end_x,
                  color=colors[name], linewidth=18)

    return fig
Example #18
0
        def print_jpg(self, filename_or_obj, *args, dryrun=False, **kwargs):
            """
            Write the figure to a JPEG file.

            Parameters
            ----------
            filename_or_obj : str or PathLike or file-like object
                The file to write to.

            Other Parameters
            ----------------
            quality : int
                The image quality, on a scale from 1 (worst) to 100 (best).
                The default is :rc:`savefig.jpeg_quality`.  Values above
                95 should be avoided; 100 completely disables the JPEG
                quantization stage.

            optimize : bool
                If present, indicates that the encoder should
                make an extra pass over the image in order to select
                optimal encoder settings.

            progressive : bool
                If present, indicates that this image
                should be stored as a progressive JPEG file.
            """
            buf, size = self.print_to_buffer()
            if dryrun:
                return
            # The image is "pasted" onto a white background image to safely
            # handle any transparency
            image = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1)
            rgba = mcolors.to_rgba(rcParams['savefig.facecolor'])
            color = tuple([int(x * 255) for x in rgba[:3]])
            background = Image.new('RGB', size, color)
            background.paste(image, image)
            options = {k: kwargs[k]
                       for k in ['quality', 'optimize', 'progressive', 'dpi']
                       if k in kwargs}
            options.setdefault('quality', rcParams['savefig.jpeg_quality'])
            if 'dpi' in options:
                # Set the same dpi in both x and y directions
                options['dpi'] = (options['dpi'], options['dpi'])

            return background.save(filename_or_obj, format='jpeg', **options)
Example #19
0
def get_colors(c, num):
    """Stretch the color argument to provide the required number num"""

    if type(c) == type("string"):
        c = mcolors.to_rgba(c)

    if iscolor(c):
        return [c] * num
    if len(c) == num:
        return c
    elif iscolor(c):
        return [c] * num
    elif len(c) == 0: #if edgecolor or facecolor is specified as 'none'
        return [[0,0,0,0]] * num
    elif iscolor(c[0]):
        return [c[0]] * num
    else:
        raise ValueError('unknown color format %s' % c)
Example #20
0
def display_frame_coords(data, coords, window, vectors=None, ref=None, outlines=None,
                         **kws):
    
    from grafico.imagine import ImageDisplay #FITSCubeDisplay,
    from obstools.aps import ApertureCollection

    fig, ax = plt.subplots()
    imd = ImageDisplay(ax, data)
    imd.connect()

    aps = ApertureCollection(coords=coords[:,::-1], radii=7, 
                             ec='darkorange', lw=1, ls='--',
                             **kws)
    aps.axadd(ax)
    aps.annotate(color='orangered', size='small')
    
    if window:
        from matplotlib.patches import Rectangle
        from matplotlib.collections import PatchCollection
        
        llc = coords[:,::-1] - window/2
        patches = [Rectangle(coo-window/2, window, window) for coo in llc] 
        rcol = PatchCollection(patches, edgecolor='r', facecolor='none',
                               lw=1, linestyle=':')
        ax.add_collection(rcol)
        
    
    if outlines is not None:
        from matplotlib.colors import to_rgba
        overlay = np.empty(data.shape+(4,))
        overlay[...] = to_rgba('0.8', 0)
        overlay[...,-1][~outlines.mask] = 1
        ax.hold(True)
        ax.imshow(overlay)
    
    if vectors is not None:
        if ref is None:
            'cannot plot vectors without reference star'
        Y, X = coords[ref]
        V, U = vectors.T
        ax.quiver(X, Y, U, V, color='r', scale_units='xy', scale=1, alpha=0.6)

    return fig
Example #21
0
    def __init__(self, offset=(2, -2),
                 shadow_rgbFace=None, alpha=None,
                 rho=0.3, **kwargs):
        """
        Parameters
        ----------
        offset : pair of floats
            The offset of the shadow in points.
        shadow_rgbFace : color
            The shadow color.
        alpha : float
            The alpha transparency of the created shadow patch.
            Default is 0.3.
            http://matplotlib.1069221.n5.nabble.com/path-effects-question-td27630.html
        rho : float
            A scale factor to apply to the rgbFace color if `shadow_rgbFace`
            is not specified. Default is 0.3.
        **kwargs
            Extra keywords are stored and passed through to
            :meth:`AbstractPathEffect._update_gc`.

        """
        super(SimplePatchShadow, self).__init__(offset)

        if shadow_rgbFace is None:
            self._shadow_rgbFace = shadow_rgbFace
        else:
            self._shadow_rgbFace = mcolors.to_rgba(shadow_rgbFace)

        if alpha is None:
            alpha = 0.3

        self._alpha = alpha
        self._rho = rho

        #: The dictionary of keywords to update the graphics collection with.
        self._gc = kwargs

        #: The offset transform object. The offset isn't calculated yet
        #: as we don't know how big the figure will be in pixels.
        self._offset_tran = mtransforms.Affine2D()
Example #22
0
def pastel(colour, weight=2.4):
    """ Convert colour into a nice pastel shade"""
    rgb = np.asarray(mcolors.to_rgba(colour)[:3])
    # scale colour
    maxc = max(rgb)
    if maxc < 1.0 and maxc > 0:
        # scale colour
        scale = 1.0 / maxc
        rgb = rgb * scale
    # now decrease saturation
    total = rgb.sum()
    slack = 0
    for x in rgb:
        slack += 1.0 - x

    # want to increase weight from total to weight
    # pick x s.t.  slack * x == weight - total
    # x = (weight - total) / slack
    x = (weight - total) / slack

    rgb = [c + (x * (1.0 - c)) for c in rgb]

    return rgb
Example #23
0
def figure_edit(axes, parent=None):
    """Edit matplotlib figure options"""
    sep = (None, None)  # separator

    # Get / General
    xmin, xmax = map(float, axes.get_xlim())
    ymin, ymax = map(float, axes.get_ylim())
    general = [('Title', axes.get_title()),
               sep,
               (None, "<b>X-Axis</b>"),
               ('Min', xmin), ('Max', xmax),
               ('Label', axes.get_xlabel()),
               ('Scale', [axes.get_xscale(), 'linear', 'log']),
               sep,
               (None, "<b>Y-Axis</b>"),
               ('Min', ymin), ('Max', ymax),
               ('Label', axes.get_ylabel()),
               ('Scale', [axes.get_yscale(), 'linear', 'log']),
               sep,
               ('(Re-)Generate automatic legend', False),
               ]

    # Save the unit data
    xconverter = axes.xaxis.converter
    yconverter = axes.yaxis.converter
    xunits = axes.xaxis.get_units()
    yunits = axes.yaxis.get_units()

    # Sorting for default labels (_lineXXX, _imageXXX).
    def cmp_key(label):
        match = re.match(r"(_line|_image)(\d+)", label)
        if match:
            return match.group(1), int(match.group(2))
        else:
            return label, 0

    # Get / Curves
    linedict = {}
    for line in axes.get_lines():
        label = line.get_label()
        if label == '_nolegend_':
            continue
        linedict[label] = line
    curves = []

    def prepare_data(d, init):
        """Prepare entry for FormLayout.

        `d` is a mapping of shorthands to style names (a single style may
        have multiple shorthands, in particular the shorthands `None`,
        `"None"`, `"none"` and `""` are synonyms); `init` is one shorthand
        of the initial style.

        This function returns an list suitable for initializing a
        FormLayout combobox, namely `[initial_name, (shorthand,
        style_name), (shorthand, style_name), ...]`.
        """
        # Drop duplicate shorthands from dict (by overwriting them during
        # the dict comprehension).
        name2short = {name: short for short, name in d.items()}
        # Convert back to {shorthand: name}.
        short2name = {short: name for name, short in name2short.items()}
        # Find the kept shorthand for the style specified by init.
        canonical_init = name2short[d[init]]
        # Sort by representation and prepend the initial value.
        return ([canonical_init] +
                sorted(short2name.items(),
                       key=lambda short_and_name: short_and_name[1]))

    curvelabels = sorted(linedict, key=cmp_key)
    for label in curvelabels:
        line = linedict[label]
        color = mcolors.to_hex(
            mcolors.to_rgba(line.get_color(), line.get_alpha()),
            keep_alpha=True)
        ec = mcolors.to_hex(line.get_markeredgecolor(), keep_alpha=True)
        fc = mcolors.to_hex(line.get_markerfacecolor(), keep_alpha=True)
        curvedata = [
            ('Label', label),
            sep,
            (None, '<b>Line</b>'),
            ('Line style', prepare_data(LINESTYLES, line.get_linestyle())),
            ('Draw style', prepare_data(DRAWSTYLES, line.get_drawstyle())),
            ('Width', line.get_linewidth()),
            ('Color (RGBA)', color),
            sep,
            (None, '<b>Marker</b>'),
            ('Style', prepare_data(MARKERS, line.get_marker())),
            ('Size', line.get_markersize()),
            ('Face color (RGBA)', fc),
            ('Edge color (RGBA)', ec)]
        curves.append([curvedata, label, ""])
    # Is there a curve displayed?
    has_curve = bool(curves)

    # Get / Images
    imagedict = {}
    for image in axes.get_images():
        label = image.get_label()
        if label == '_nolegend_':
            continue
        imagedict[label] = image
    imagelabels = sorted(imagedict, key=cmp_key)
    images = []
    cmaps = [(cmap, name) for name, cmap in sorted(cm.cmap_d.items())]
    for label in imagelabels:
        image = imagedict[label]
        cmap = image.get_cmap()
        if cmap not in cm.cmap_d.values():
            cmaps = [(cmap, cmap.name)] + cmaps
        low, high = image.get_clim()
        imagedata = [
            ('Label', label),
            ('Colormap', [cmap.name] + cmaps),
            ('Min. value', low),
            ('Max. value', high),
            ('Interpolation',
             [image.get_interpolation()]
             + [(name, name) for name in sorted(image.iterpnames)])]
        images.append([imagedata, label, ""])
    # Is there an image displayed?
    has_image = bool(images)

    datalist = [(general, "Axes", "")]
    if curves:
        datalist.append((curves, "Curves", ""))
    if images:
        datalist.append((images, "Images", ""))

    def apply_callback(data):
        """This function will be called to apply changes"""
        general = data.pop(0)
        curves = data.pop(0) if has_curve else []
        images = data.pop(0) if has_image else []
        if data:
            raise ValueError("Unexpected field")

        # Set / General
        (title, xmin, xmax, xlabel, xscale, ymin, ymax, ylabel, yscale,
         generate_legend) = general

        if axes.get_xscale() != xscale:
            axes.set_xscale(xscale)
        if axes.get_yscale() != yscale:
            axes.set_yscale(yscale)

        axes.set_title(title)
        axes.set_xlim(xmin, xmax)
        axes.set_xlabel(xlabel)
        axes.set_ylim(ymin, ymax)
        axes.set_ylabel(ylabel)

        # Restore the unit data
        axes.xaxis.converter = xconverter
        axes.yaxis.converter = yconverter
        axes.xaxis.set_units(xunits)
        axes.yaxis.set_units(yunits)
        axes.xaxis._update_axisinfo()
        axes.yaxis._update_axisinfo()

        # Set / Curves
        for index, curve in enumerate(curves):
            line = linedict[curvelabels[index]]
            (label, linestyle, drawstyle, linewidth, color, marker, markersize,
             markerfacecolor, markeredgecolor) = curve
            line.set_label(label)
            line.set_linestyle(linestyle)
            line.set_drawstyle(drawstyle)
            line.set_linewidth(linewidth)
            rgba = mcolors.to_rgba(color)
            line.set_alpha(None)
            line.set_color(rgba)
            if marker is not 'none':
                line.set_marker(marker)
                line.set_markersize(markersize)
                line.set_markerfacecolor(markerfacecolor)
                line.set_markeredgecolor(markeredgecolor)

        # Set / Images
        for index, image_settings in enumerate(images):
            image = imagedict[imagelabels[index]]
            label, cmap, low, high, interpolation = image_settings
            image.set_label(label)
            image.set_cmap(cm.get_cmap(cmap))
            image.set_clim(*sorted([low, high]))
            image.set_interpolation(interpolation)

        # re-generate legend, if checkbox is checked
        if generate_legend:
            draggable = None
            ncol = 1
            if axes.legend_ is not None:
                old_legend = axes.get_legend()
                draggable = old_legend._draggable is not None
                ncol = old_legend._ncol
            new_legend = axes.legend(ncol=ncol)
            if new_legend:
                new_legend.draggable(draggable)

        # Redraw
        figure = axes.get_figure()
        figure.canvas.draw()

    data = formlayout.fedit(datalist, title="Figure options", parent=parent,
                            icon=get_icon('qt4_editor_options.svg'),
                            apply=apply_callback)
    if data is not None:
        apply_callback(data)
Example #24
0
    def print_jpg(self,
                  filename_or_obj,
                  *args,
                  dryrun=False,
                  pil_kwargs=None,
                  **kwargs):
        """
        Write the figure to a JPEG file.

        Parameters
        ----------
        filename_or_obj : str or path-like or file-like
            The file to write to.

        Other Parameters
        ----------------
        quality : int, default: :rc:`savefig.jpeg_quality`
            The image quality, on a scale from 1 (worst) to 95 (best).
            Values above 95 should be avoided; 100 disables portions of
            the JPEG compression algorithm, and results in large files
            with hardly any gain in image quality.  This parameter is
            deprecated.

        optimize : bool, default: False
            Whether the encoder should make an extra pass over the image
            in order to select optimal encoder settings.  This parameter is
            deprecated.

        progressive : bool, default: False
            Whether the image should be stored as a progressive JPEG file.
            This parameter is deprecated.

        pil_kwargs : dict, optional
            Additional keyword arguments that are passed to
            `PIL.Image.Image.save` when saving the figure.  These take
            precedence over *quality*, *optimize* and *progressive*.
        """
        # Remove transparency by alpha-blending on an assumed white background.
        r, g, b, a = mcolors.to_rgba(self.figure.get_facecolor())
        try:
            self.figure.set_facecolor(a * np.array([r, g, b]) + 1 - a)
            FigureCanvasAgg.draw(self)
        finally:
            self.figure.set_facecolor((r, g, b, a))
        if dryrun:
            return
        if pil_kwargs is None:
            pil_kwargs = {}
        for k in ["quality", "optimize", "progressive"]:
            if k in kwargs:
                pil_kwargs.setdefault(k, kwargs[k])
        if "quality" not in pil_kwargs:
            quality = pil_kwargs["quality"] = \
                dict.__getitem__(mpl.rcParams, "savefig.jpeg_quality")
            if quality not in [0, 75, 95]:  # default qualities.
                cbook.warn_deprecated(
                    "3.3",
                    name="savefig.jpeg_quality",
                    obj_type="rcParam",
                    addendum="Set the quality using "
                    "`pil_kwargs={'quality': ...}`; the future default "
                    "quality will be 75, matching the default of Pillow and "
                    "libjpeg.")
        pil_kwargs.setdefault("dpi", (self.figure.dpi, self.figure.dpi))
        # Drop alpha channel now.
        return (Image.fromarray(np.asarray(self.buffer_rgba())[..., :3]).save(
            filename_or_obj, format='jpeg', **pil_kwargs))
Example #25
0
    # If --metrics was used, add space and a subplot for the system metrics
    if has_system_metrics:
        figh += 4
        nrows += 1

    # Create the plot
    fig, axes = plt.subplots(nrows=nrows, sharex=True)
    axes = [axes] if nrows == 1 else axes

    # Add the benchmarks to the plot
    for i, benchmark_name in enumerate(benchmark_names):
        ax = axes[i] if is_detailed else axes[0]

        color = default_colors[i % len(default_colors)]
        name_to_color[benchmark_name] = color
        single_run_color = [colors.to_rgba(lighten_color(color, 0.7), 0.5)]

        # Filter the runs that belong to this benchmark item
        filtered_df = run_durations_df[run_durations_df["name"] == benchmark_name]

        # Plot runs into combined graph
        for success in [True, False]:
            data = filtered_df[filtered_df["success"] == success]
            if not data.empty:
                data.plot(
                    ax=ax,
                    kind="scatter",
                    x="begin",
                    y="duration",
                    color=single_run_color,
                    figsize=(figw, figh),
Example #26
0
 def gray_from_float_rgba():
     return mcolors.to_rgba(0.4)
Example #27
0
def plot_pcl_prediction(df,
                        axis,
                        probabilities_col=None,
                        colors=None,
                        xcol="x",
                        ycol="y",
                        zcol="z",
                        use_plotly=False,
                        inv_z=True):
    """Plots the pointcloud of a dataframe with interpolated coloring,
    dependent on probability estimates of corresponding classes.

    :param df: dataframe containing points and probability estimates.
    :type df: pandas.DataFrame
    :param axis: The matplotlib-axis the pointcloud should be plotted on
    :type axis: matplotlib.axes.Axes
    :param probabilities_col: Columns with probability estimates,
        defaults to None
    :type probabilities_col: list, optional
    :param colors: Colors associates with probability estimates,
        defaults to None
    :type colors: list, optional
    :param xcol: Column containing x-position, defaults to "x"
    :type xcol: str, optional
    :param ycol: Column containing y-position, defaults to "y"
    :type ycol: str, optional
    :param zcol: Column containing z-position, defaults to "z"
    :type zcol: str, optional
    :param use_plotly: Whether plotly should be used for plotting or not
    :type use_plotly: bool, optional
    :param inv_z: Whether the z-axis should be inverted.
    :type inv_z: bool, optional
    """
    if probabilities_col is None:
        probabilities_col = [col for col in df.columns if "pred_" in col]
    if colors is None:
        colors = [
            "blue", "orange", "green", "red", "purple", "brown", "pink",
            "gray", "olive", "cyan"
        ][:len(probabilities_col)]

    probarr = np.array(df[probabilities_col])
    # linear interpolation between colors
    rgba_colors = np.array([to_rgba(color) for color in colors])
    colorsarr = np.zeros(shape=(df.shape[0], 4))
    for idx, col in enumerate(rgba_colors):
        colorsarr += (probarr[:, idx] * np.array([col] * df.shape[0]).T).T
    colorsarr = (colorsarr - np.min(colorsarr)) / (np.max(colorsarr) -
                                                   np.min(colorsarr))

    if use_plotly:
        layout = go.Layout(scene=dict(aspectmode="data"), showlegend=True)
        fig = go.Figure(layout=layout)
        predicted = np.argmax(df[probabilities_col].to_numpy(), axis=1)
        for idx, colname in enumerate(probabilities_col):
            selected = df[predicted == idx]
            selectedcolors = colorsarr[predicted == idx, :]
            fig.add_trace(
                go.Scatter3d(x=selected[xcol],
                             y=selected[ycol],
                             z=(-1 if inv_z else 1) * selected[zcol],
                             opacity=1,
                             mode='markers',
                             marker=dict(size=1,
                                         color=selectedcolors,
                                         opacity=1),
                             name=colname))

        fig.show()
    else:
        # initialize 3d-plot
        axis.scatter(df[xcol],
                     df[ycol], (-1 if inv_z else 1) * df[zcol],
                     color=colorsarr,
                     marker=".",
                     s=0.7)

        for color, classname in zip(colors, probabilities_col):
            axis.add_line(
                plt.Line2D([0], [0], color=color, label=classname, lw=4))

        legend = axis.legend(loc="lower left", title="Classes")
        axis.add_artist(legend)

        axis.grid(False)
        axis.set_axis_off()
        axis.set_xlim3d(-60, 60)
        axis.set_ylim3d(-60, 60)
        axis.set_zlim3d(-60, 60)
        axis.view_init(elev=40., azim=-120.)
        axis.set_xlabel('X')
        axis.set_ylabel('Y')
        axis.set_zlabel('Z')
    mean_occ_df = occ_df.groupby('program').mean()
    std_occ_df = occ_df.groupby('program').std()

    fig = plt.figure(figsize=(7,5.4))
    ax = plt.subplot(111)
    ax.spines["right"].set_visible(False)
    ax.spines["top"].set_visible(False)
    for mean, std in zip(mean_occ_df.iterrows(), std_occ_df.iterrows()):

        ax.errorbar(x=mean[1]['Occupancy'],
                    y=mean[1]['B_factor'],
                    xerr=std[1]['Occupancy'],
                    yerr=std[1]['B_factor'],
                    color=cols[mean[0]],
                    fmt='o',
                    ecolor=to_rgba(cols[mean[0]], 0.4),
                    markersize=8,
                    label=mean[0].replace('_',' ')
                    )

    # Dashed joining lines
    ax.plot([mean_occ_df.loc['buster', 'Occupancy'],
             mean_occ_df.loc['buster_superposed', 'Occupancy']],
            [mean_occ_df.loc['buster', 'B_factor'],
             mean_occ_df.loc['buster_superposed', 'B_factor']],
            linestyle='dashed',
            color=to_rgba('forestgreen', 0.5))

    ax.plot([mean_occ_df.loc['refmac', 'Occupancy'],
             mean_occ_df.loc['refmac_superposed', 'Occupancy']],
            [mean_occ_df.loc['refmac', 'B_factor'],
Example #29
0
 def edge_color(self):
     if self.show_edge:
         return to_rgba(self.text_color, self.alpha)
     else:
         return None
Example #30
0
segs = np.zeros((50, 100, 2), float)
segs[:, :, 1] = ys
segs[:, :, 0] = x

# Mask some values to test masked array support:
segs = np.ma.masked_where((segs > 50) & (segs < 60), segs)

# We need to set the plot limits.
ax = plt.axes()
ax.set_xlim(x.min(), x.max())
ax.set_ylim(ys.min(), ys.max())

# colors is sequence of rgba tuples
# linestyle is a string or dash tuple. Legal string values are
#          solid|dashed|dashdot|dotted.  The dash tuple is (offset, onoffseq)
#          where onoffseq is an even length tuple of on and off ink in points.
#          If linestyle is omitted, 'solid' is used
# See matplotlib.collections.LineCollection for more information
colors = [
    mcolors.to_rgba(c)
    for c in plt.rcParams['axes.prop_cycle'].by_key()['color']
]

line_segments = LineCollection(segs,
                               linewidths=(0.5, 1, 1.5, 2),
                               colors=colors,
                               linestyle='solid')
ax.add_collection(line_segments)
ax.set_title('Line collection with masked arrays')
plt.show()
Example #31
0
#!/usr/bin/env python

import nilearn
from nilearn import plotting
from nilearn import datasets
from nilearn import surface
from nilearn import image
import matplotlib.pyplot as plt
from matplotlib.colors import to_rgba
import numpy as np

VOIS = ['Action', 'LTM', 'Perception', 'Procedural', 'WM']

COLS = [list(to_rgba(x)) for x in \
        ["#cc00cc", "#ff9900", "#ff3333", "#00cc33", "#00ccff"]]


def load_vois(task):
    f = open("%s/vois.txt" % task)
    vois = {}
    for line in f.readlines():
        name, coords = line.split()[:2]
        xyz = [int(x) for x in coords.split(",")]
        vois[name] = xyz
    
    return vois


def load_individual_coords(task):
    vdict = {}
    for voi in VOIS:
Example #32
0
 def _map_scalar(self, x, alpha=None, bytes=False):
     y = to_rgba(BLUE, alpha) if x < 0.5 else to_rgba(RED, alpha)
     if bytes:
         y = np.floor(y * 255.).astype("int")
     return y
theta = np.linspace(0, 2*np.pi, nverts)
xx = r * np.sin(theta)
yy = r * np.cos(theta)
spiral = list(zip(xx, yy))

# Make some offsets
# Fixing random state for reproducibility
rs = np.random.RandomState(19680801)


xo = rs.randn(npts)
yo = rs.randn(npts)
xyo = list(zip(xo, yo))

# Make a list of colors cycling through the default series.
colors = [colors.to_rgba(c)
          for c in plt.rcParams['axes.prop_cycle'].by_key()['color']]

fig, axes = plt.subplots(2, 2)
fig.subplots_adjust(top=0.92, left=0.07, right=0.97,
                    hspace=0.3, wspace=0.3)
((ax1, ax2), (ax3, ax4)) = axes  # unpack the axes


col = collections.LineCollection([spiral], offsets=xyo,
                                 transOffset=ax1.transData)
trans = fig.dpi_scale_trans + transforms.Affine2D().scale(1.0/72.0)
col.set_transform(trans)  # the points to pixels transform
# Note: the first argument to the collection initializer
# must be a list of sequences of x,y tuples; we have only
# one sequence, but we still have to put it in a list.
Example #34
0
def plot_results(hosts_filename="output_hosts_0.csv",
                 event_filename="output_events_0.csv"):
    """Animate a particular epidemic simulation."""

    state_colours = {
        "S": colors.to_rgba("green"),
        "E": colors.to_rgba("cyan"),
        "C": colors.to_rgba("blue"),
        "D": colors.to_rgba("orange"),
        "I": colors.to_rgba("red"),
        "R": colors.to_rgba("grey"),
        "Culled": colors.to_rgba("black"),
    }

    hosts_df = pd.read_csv(hosts_filename)
    events_df = pd.read_csv(event_filename)

    for i, x in enumerate(hosts_df.columns):
        if "timeEnter" in x:
            host_start_idx = i
            break

    host_points = np.zeros(len(hosts_df),
                           dtype=[('position', float, 2),
                                  ('colour', float, 4)])

    for index, host in hosts_df.iterrows():
        host_points['position'][index] = (host['posX'], host['posY'])
        for name, timeEnter in host[host_start_idx:].iteritems():
            if 0 in eval(timeEnter):
                state = name[9:]
        host_points['colour'][index] = state_colours[state]

    initial_colours = host_points['colour'][:]

    frame_rate = 30
    animation_length = 5
    frame_interval = max(events_df['time']) / (animation_length * frame_rate)
    nframes = animation_length * frame_rate + 1

    fig = plt.figure(figsize=(7, 7))
    ax = fig.add_axes([0, 0, 1, 1], frameon=False)
    ax.set_xlim(min(host_points['position'][:, 0]),
                max(host_points['position'][:, 0]))
    ax.set_xticks([])
    ax.set_ylim(min(host_points['position'][:, 1]),
                max(host_points['position'][:, 1]))
    ax.set_yticks([])

    scat = ax.scatter(host_points['position'][:, 0],
                      host_points['position'][:, 1],
                      c=host_points['colour'])

    time_text = ax.text(0.02,
                        0.95,
                        '',
                        transform=ax.transAxes,
                        weight="bold",
                        fontsize=12,
                        bbox=dict(facecolor='white', alpha=0.6))

    global start_from_idx
    start_from_idx = 0

    def init():
        global start_from_idx
        start_from_idx = 0
        host_points['colour'] = initial_colours
        new_time = 0
        scat.set_color(host_points['colour'])
        time_text.set_text('time = %.3f' % new_time)

        return scat, time_text

    def update(frame_number):
        new_time = frame_number * frame_interval
        global start_from_idx

        row = events_df.iloc[start_from_idx]

        while row['time'] <= new_time:
            hostID = row['hostID']
            new_state = row['newState']
            host_points['colour'][hostID] = state_colours[new_state]
            start_from_idx += 1
            if start_from_idx >= len(events_df):
                break
            row = events_df.iloc[start_from_idx]

        scat.set_color(host_points['colour'])
        time_text.set_text('time = %.3f' % new_time)

        return scat, time_text

    animation = FuncAnimation(fig,
                              update,
                              interval=1000 / frame_rate,
                              frames=nframes,
                              blit=True,
                              repeat=False,
                              init_func=init)
    plt.show()
Example #35
0
    where=monthly_sum != 0))

# define heatmaps for displaying monthly issue mix data
cm_greens = cm.get_cmap('Greens', 15)  # green = good (list reduction)
cm_reds = cm.get_cmap('Reds', 15)  # red   = bad  (list growth)
cm_greens.set_over(
    '#FFFF00')  # use yellow as default out of range green colour
cm_reds.set_over('#FF00FF')  # use purple as default out of range red colour

# constrauct the colorbar from the heatmaps
pos_cmap = cm.get_cmap('Greens_r', 15)
neg_cmap = cm.get_cmap('Reds', 15)
newcolors = np.vstack(
    (pos_cmap(np.linspace(0, 0.7, 15)), neg_cmap(np.linspace(0.3, 1, 15))))
combined_cmap = ListedColormap(newcolors, name='GreenRed')
neutral = np.array(to_rgba('skyblue'))
newcolors[
    14:16, :] = neutral  # define neutral colour for balanced mix of issues
for color in newcolors:  # set transparency level (same as for plots)
    color[3] = 0.75

# set monthly time block separation space
bar_spacing = 0.1

# figure settings
#plt.style.use('seaborn-whitegrid')
fig, ax = plt.subplots(3, 1, figsize=(15, 10), constrained_layout=False)
plt.subplots_adjust(left=None,
                    bottom=None,
                    right=None,
                    top=None,
Example #36
0
    with _api.suppress_matplotlib_deprecation_warning():
        with mpl.rc_context():
            _copy = mpl.rcParams.copy()
            for key in _copy:
                mpl.rcParams[key] = _copy[key]
        with mpl.rc_context():
            copy.deepcopy(mpl.rcParams)
    with pytest.raises(ValueError):
        validate_bool(None)
    with pytest.raises(ValueError):
        with mpl.rc_context():
            mpl.rcParams['svg.fonttype'] = True


legend_color_tests = [
    ('face', {'color': 'r'}, mcolors.to_rgba('r')),
    ('face', {'color': 'inherit', 'axes.facecolor': 'r'},
     mcolors.to_rgba('r')),
    ('face', {'color': 'g', 'axes.facecolor': 'r'}, mcolors.to_rgba('g')),
    ('edge', {'color': 'r'}, mcolors.to_rgba('r')),
    ('edge', {'color': 'inherit', 'axes.edgecolor': 'r'},
     mcolors.to_rgba('r')),
    ('edge', {'color': 'g', 'axes.facecolor': 'r'}, mcolors.to_rgba('g'))
]
legend_color_test_ids = [
    'same facecolor',
    'inherited facecolor',
    'different facecolor',
    'same edgecolor',
    'inherited edgecolor',
    'different facecolor',
Example #37
0
from PIL import Image, ImageTk
try:
    box_icon = Image.open(r"icons\box_icon.png")
except:
    import matplotlib as mpl
    import matplotlib.pyplot as plt
    import numpy as np
    import tkinter as tk
    from matplotlib.colors import to_rgba
    from itertools import product, combinations
    import mpl_toolkits.mplot3d.art3d as art3d

    mpl.style.use("fast")

    fig = plt.figure(figsize=(6, 6))
    bgc = to_rgba("#F0F0F0")
    fig.patch.set_facecolor("black")
    fig.patch._alpha = 0.0
    canvas = fig.canvas
    canvas.draw()
    ax = fig.add_subplot(
        projection="3d",
        facecolor=bgc,
    )
    ax.view_init(19, -62)
    a = 0.96
    xl, yl, zl = (-a, a), (-a, a), (-a, a)
    ax.set(xlim=xl, ylim=yl, zlim=zl)
    ax.patch._alpha = 0.0
    ax.set_position([0, 0, 1, 1])
    children = []
Example #38
0
def visualize_accuracy(accr_dict, path, record_epoch):
    '''
    Plot classification accuracy graph. It contains graph from several experimental versions to compare.
    
    Args:
        accr_dict (dict) : Classification accuracy. Each key denotes experimental version and each value contains 
                           'test_num' lists. For example, if test_num is three,
                            accr_dict['version_1] == [[accr_history_1], [accr_history_2], [accr_history_3]]
                            accr_dict['version_2] == [[accr_history_1], [accr_history_2], [accr_history_3]]
                            accr_dict['version_3] == [[accr_history_1], [accr_history_2], [accr_history_3]]

        tst_dloader (Dataloader) : Data loader for test set
        
    Return:
        classification accuracy
    '''

    colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS)

    # Sort colors by hue, saturation, value and name.
    by_hsv = sorted(
        (tuple(mcolors.rgb_to_hsv(mcolors.to_rgba(color)[:3])), name)
        for name, color in colors.items())
    sorted_names = [name for hsv, name in by_hsv]

    # Selected color
    color_names = ['steelblue', 'mediumseagreen', 'coral']

    plt.switch_backend('agg')
    plt.figure(figsize=(12, 6))

    total_len = len(accr_dict[list(accr_dict.keys())[0]][0])
    x = range(0, record_epoch * total_len, record_epoch)

    for i, (exp_version, accr_hists) in enumerate(accr_dict.items()):
        max_accr = 0
        color_val = colors[color_names[i]]

        # Find the one maximum accuracy among all tests in an experiment version
        # This value will be represented as a maximum accuracy of current experiment version
        for hist in accr_hists:
            cur_max_accr = max(hist)
            max_accr = cur_max_accr if cur_max_accr > max_accr else max_accr

        # plot
        for j, hist in enumerate(accr_hists):
            cur_max_accr = max(hist)
            max_accr = cur_max_accr if cur_max_accr > max_accr else max_accr
            label = 'M' + str(i + 1) + ': ' + str(
                round(max_accr, 6) * 100) + '%'
            if j == 0:
                plt.plot(x, hist, color_val, label=label)
            else:
                plt.plot(x, hist, color_val)

    plt.xlabel('Epoch')
    plt.ylabel('Accr')
    plt.legend(loc=4)
    plt.grid(True)
    plt.tight_layout()

    path = os.path.join(path, 'accr_model_compare.png')
    plt.savefig(path)
    plt.close()
def snap_plot(nets, size_scale=1 / 10, dims=(10, 10), savefigs=False):
    '''
    '''

    last_net = nets[-1]

    last_props = get_nodes_by_type(last_net, 'proposal')
    M = len(last_props)
    last_parts = get_nodes_by_type(last_net, 'participant')
    N = len(last_parts)
    pos = {}

    for ind in range(N):
        i = last_parts[ind]
        pos[i] = np.array([0, 2 * ind - N])

    for ind in range(M):
        j = last_props[ind]
        pos[j] = np.array([1, 2 * N / M * ind - N])

    if savefigs:
        counter = 0
        length = 10

    for net in nets:
        edges = get_edges_by_type(net, 'support')
        max_tok = np.max([net.edges[e]['tokens'] for e in edges])

        E = len(edges)

        net_props = get_nodes_by_type(net, 'proposal')
        net_parts = get_nodes_by_type(net, 'participant')
        net_node_label = {}

        num_nodes = len([node for node in net.nodes])

        node_color = np.empty((num_nodes, 4))
        node_size = np.empty(num_nodes)

        edge_color = np.empty((E, 4))
        cm = plt.get_cmap('Reds')

        cNorm = colors.Normalize(vmin=0, vmax=max_tok)
        scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=cm)

        net_cand = [
            j for j in net_props if net.nodes[j]['status'] == 'candidate'
        ]

        for j in net_props:
            node_size[j] = net.nodes[j]['funds_requested'] * size_scale
            if net.nodes[j]['status'] == "candidate":
                node_color[j] = colors.to_rgba('blue')
                trigger = net.nodes[j]['trigger']
                conviction = net.nodes[j]['conviction']
                percent_of_trigger = "          " + str(
                    int(100 * conviction / trigger)) + '%'
                net_node_label[j] = str(percent_of_trigger)
            elif net.nodes[j]['status'] == "active":
                node_color[j] = colors.to_rgba('orange')
                net_node_label[j] = ''
            elif net.nodes[j]['status'] == "completed":
                node_color[j] = colors.to_rgba('green')
                net_node_label[j] = ''
            elif net.nodes[j]['status'] == "failed":
                node_color[j] = colors.to_rgba('gray')
                net_node_label[j] = ''
            elif net.nodes[j]['status'] == "killed":
                node_color[j] = colors.to_rgba('black')
                net_node_label[j] = ''

        for i in net_parts:
            node_size[i] = net.nodes[i]['holdings'] * size_scale / 10
            node_color[i] = colors.to_rgba('red')
            net_node_label[i] = ''

        included_edges = []
        for ind in range(E):
            e = edges[ind]
            tokens = net.edges[e]['tokens']
            edge_color[ind] = scalarMap.to_rgba(tokens)
            if e[1] in net_cand:
                included_edges.append(e)

        iE = len(included_edges)
        included_edge_color = np.empty((iE, 4))
        for ind in range(iE):
            e = included_edges[ind]
            tokens = net.edges[e]['tokens']
            included_edge_color[ind] = scalarMap.to_rgba(tokens)

        else:
            plt.figure(figsize=dims)
            nx.draw(net,
                    pos=pos,
                    node_size=node_size,
                    node_color=node_color,
                    edge_color=included_edge_color,
                    edgelist=included_edges,
                    labels=net_node_label)
            plt.title('Tokens Staked by Partipants to Proposals')
            plt.tight_layout()
            plt.axis('on')
            plt.xticks([])
            plt.yticks([])
            if savefigs:
                plt.savefig('images/snap/' + str(counter) + '.png',
                            bbox_inches='tight')

                counter = counter + 1
            plt.show()
Example #40
0
For more information on colors in matplotlib see

* the :doc:`/tutorials/colors/colors` tutorial;
* the `matplotlib.colors` API;
* the :doc:`/gallery/color/color_demo`.
"""

import matplotlib.pyplot as plt
from matplotlib import colors as mcolors


colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS)

# Sort colors by hue, saturation, value and name.
by_hsv = sorted((tuple(mcolors.rgb_to_hsv(mcolors.to_rgba(color)[:3])), name)
                for name, color in colors.items())
sorted_names = [name for hsv, name in by_hsv]

n = len(sorted_names)
ncols = 4
nrows = n // ncols + 1

fig, ax = plt.subplots(figsize=(8, 5))

# Get height and width
X, Y = fig.get_dpi() * fig.get_size_inches()
h = Y / (nrows + 1)
w = X / ncols

for i, name in enumerate(sorted_names):
Example #41
0
def get_rgb(x):
    rgba = to_rgba(x)
    return rgba[:3]
def volume_overlay(ax,
                   opens,
                   closes,
                   volumes,
                   colorup='k',
                   colordown='r',
                   width=4,
                   alpha=1.0):
    """Add a volume overlay to the current axes.  The opens and closes
    are used to determine the color of the bar.  -1 is missing.  If a
    value is missing on one it must be missing on all

    Parameters
    ----------
    ax : `Axes`
        an Axes instance to plot to
    opens : sequence
        a sequence of opens
    closes : sequence
        a sequence of closes
    volumes : sequence
        a sequence of volumes
    width : int
        the bar width in points
    colorup : color
        the color of the lines where close >= open
    colordown : color
        the color of the lines where close <  open
    alpha : float
        bar transparency

    Returns
    -------
    ret : `barCollection`
        The `barrCollection` added to the axes

    """

    colorup = mcolors.to_rgba(colorup, alpha)
    colordown = mcolors.to_rgba(colordown, alpha)
    colord = {True: colorup, False: colordown}
    colors = [
        colord[open < close] for open, close in zip(opens, closes)
        if open != -1 and close != -1
    ]

    delta = width / 2.
    bars = [((i - delta, 0), (i - delta, v), (i + delta, v), (i + delta, 0))
            for i, v in enumerate(volumes) if v != -1]

    barCollection = PolyCollection(
        bars,
        facecolors=colors,
        edgecolors=((0, 0, 0, 1), ),
        antialiaseds=(0, ),
        linewidths=(0.5, ),
    )

    ax.add_collection(barCollection)
    corners = (0, 0), (len(bars), max(volumes))
    ax.update_datalim(corners)
    ax.autoscale_view()

    # add these last
    return barCollection
Example #43
0
 def has_alpha(x):
     return to_rgba(x) != to_rgba(x, 1)
def cc(arg):
    return mcolors.to_rgba(arg, alpha=0.6)
Example #45
0
def _is_transparent(color):
    """Determine transparency from alpha."""
    rgba = colors.to_rgba(color)
    return rgba[3] < .5
Example #46
0
def cc(color, alpha=0.3):
    return mcolors.to_rgba(color, alpha=alpha)
Example #47
0
def candlestick2_ohlc(ax,
                      opens,
                      highs,
                      lows,
                      closes,
                      width=4,
                      colorup='k',
                      colordown='r',
                      alpha=0.75):
    """Represent the open, close as a bar line and high low range as a
    vertical line.
    NOTE: this code assumes if any value open, low, high, close is
    missing they all are missing
    Parameters
    ----------
    ax : `Axes`
        an Axes instance to plot to
    opens : sequence
        sequence of opening values
    highs : sequence
        sequence of high values
    lows : sequence
        sequence of low values
    closes : sequence
        sequence of closing values
    width : int
        size of open and close ticks in points
    colorup : color
        the color of the lines where close >= open
    colordown : color
        the color of the lines where close <  open
    alpha : float
        bar transparency
    Returns
    -------
    ret : tuple
        (lineCollection, barCollection)
    """

    _check_input(opens, highs, lows, closes)

    delta = width / 2.
    barVerts = [((i - delta, open), (i - delta, close), (i + delta, close),
                 (i + delta, open))
                for i, open, close in zip(xrange(len(opens)), opens, closes)
                if open != -1 and close != -1]

    rangeSegments = [((i, low), (i, high))
                     for i, low, high in zip(xrange(len(lows)), lows, highs)
                     if low != -1]

    colorup = mcolors.to_rgba(colorup, alpha)
    colordown = mcolors.to_rgba(colordown, alpha)
    colord = {True: colorup, False: colordown}
    colors = [
        colord[open < close] for open, close in zip(opens, closes)
        if open != -1 and close != -1
    ]

    useAA = 0,  # use tuple here
    lw = 0.5,  # and here
    rangeCollection = LineCollection(
        rangeSegments,
        colors=colors,
        linewidths=lw,
        antialiaseds=useAA,
    )

    barCollection = PolyCollection(
        barVerts,
        facecolors=colors,
        edgecolors=colors,
        antialiaseds=useAA,
        linewidths=lw,
    )

    minx, maxx = 0, len(rangeSegments)
    miny = min([low for low in lows if low != -1])
    maxy = max([high for high in highs if high != -1])

    corners = (minx, miny), (maxx, maxy)
    ax.update_datalim(corners)
    ax.autoscale_view()

    # add these last
    ax.add_collection(rangeCollection)
    ax.add_collection(barCollection)
    return rangeCollection, barCollection
Example #48
0
#!/usr/bin/python3
# coding: utf-8

# https://stackoverflow.com/questions/22408237/named-colors-in-matplotlib

import matplotlib.pyplot as plt
from matplotlib import colors as mcolors


colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS)

# Sort colors by hue, saturation, value and name.
by_hsv = sorted((tuple(mcolors.rgb_to_hsv(mcolors.to_rgba(color)[:3])), name)
                for name, color in colors.items())
sorted_names = [name for hsv, name in by_hsv]

n = len(sorted_names)
ncols = 4
nrows = n // ncols

fig, ax = plt.subplots(figsize=(12, 10))

# Get height and width
X, Y = fig.get_dpi() * fig.get_size_inches()
h = Y / (nrows + 1)
w = X / ncols

for i, name in enumerate(sorted_names):
    row = i % nrows
    col = i // nrows
    y = Y - (row * h) - h
Example #49
0
def cc(arg):
    '''
    Shorthand to convert 'named' colors to rgba format at 60% opacity.
    '''
    return mcolors.to_rgba(arg, alpha=0.6)
def plot_positions_scatter(goal_object, runs_dir, img_dir, filename):
    """

    :param goal_object
    :param runs_dir:
    :param img_dir:
    :param filename:
    """
    dataset_states = load_dataset(runs_dir)
    dataset_states = dataset_states[[
        'goal_position', 'goal_angle', 'position', 'initial_position',
        'initial_angle'
    ]]

    fig, axes = plt.subplots(ncols=2,
                             figsize=(9.8, 4.8),
                             constrained_layout=True,
                             sharey='row')
    plt.ylim(-220, 220)

    # initial positions
    step_states = dataset_states.where(dataset_states.step == 0, drop=True)
    x, y = unpack(step_states.initial_position, 'axis')
    label = 'initial positions'

    goal_position = step_states.goal_position[0]
    goal_angle = step_states.goal_angle[0]

    radius = 8.5
    axes[0].scatter(x,
                    y,
                    alpha=0.1,
                    label=label,
                    marker='o',
                    s=(radius * np.pi)**2 / 5,
                    facecolor=colors.to_rgba('tab:blue', alpha=0.1),
                    edgecolor='none')
    axes[0].set_ylabel('y axis', fontsize=11)
    draw_docking_station(axes[0], goal_object)
    draw_marxbot(axes[0], goal_position, goal_angle, label='goal position')

    axes[0].set_xlim(-250, 250)
    axes[0].set_aspect('equal')

    axes[0].set_xlabel('x axis', fontsize=11)
    axes[0].legend()

    # final positions
    step_states = dataset_states.groupby("run").map(
        lambda x: x.isel(sample=[-1]))
    x, y = unpack(step_states.position, 'axis')

    goal_position = step_states.goal_position[0]
    goal_angle = step_states.goal_angle[0]

    axes[1].scatter(x,
                    y,
                    label='final positions',
                    marker='o',
                    s=(radius * np.pi)**2 / 5,
                    facecolor=colors.to_rgba('tab:blue', alpha=0.1),
                    edgecolor='none')
    draw_docking_station(axes[1], goal_object)
    draw_marxbot(axes[1], goal_position, goal_angle, label='goal position')

    axes[1].set_xlim(-250, 250)
    axes[1].set_aspect('equal')

    axes[1].set_xlabel('x axis', fontsize=11)
    axes[1].legend()

    save_visualisation(filename, img_dir)
Example #51
0
    def test_to_rgba(self):

        self.assertEqual(str(colors.to_rgba(self.color)), self.expectedRGBA)
Example #52
0
def plot_surf_contours(surf_mesh, roi_map, axes=None, figure=None, levels=None,
                       labels=None, colors=None, legend=False, cmap='tab20',
                       title=None, output_file=None, **kwargs):
    """Plotting contours of ROIs on a surface, optionally over a statistical map.

    Parameters
    ----------
    surf_mesh : str or list of two numpy.ndarray
        Surface mesh geometry, can be a file (valid formats are
        .gii or Freesurfer specific files such as .orig, .pial,
        .sphere, .white, .inflated) or
        a list of two Numpy arrays, the first containing the x-y-z coordinates
        of the mesh vertices, the second containing the indices
        (into coords) of the mesh faces.

    roi_map : str or numpy.ndarray or list of numpy.ndarray
        ROI map to be displayed on the surface mesh, can be a file
        (valid formats are .gii, .mgz, .nii, .nii.gz, or Freesurfer specific
        files such as .annot or .label), or
        a Numpy array with a value for each vertex of the surf_mesh.
        The value at each vertex one inside the ROI and zero inside ROI, or an
        integer giving the label number for atlases.

    axes : instance of matplotlib axes, None, optional
        The axes instance to plot to. The projection must be '3d' (e.g.,
        `figure, axes = plt.subplots(subplot_kw={'projection': '3d'})`,
        where axes should be passed.).
        If None, uses axes from figure if available, else creates new axes.

    figure : instance of matplotlib figure, None, optional
        The figure instance to plot to.
        If None, uses figure of axes if available, else creates a new figure.

    levels : list of integers, or None, optional
        A list of indices of the regions that are to be outlined.
        Every index needs to correspond to one index in roi_map.
        If None, all regions in roi_map are used.

    labels : list of strings or None, or None, optional
        A list of labels for the individual regions of interest.
        Provide None as list entry to skip showing the label of that region.
        If None no labels are used.

    colors : list of matplotlib color names or RGBA values, or None, optional
        Colors to be used.

    legend : boolean,  optional
        Whether to plot a legend of region's labels. Default=False.

    cmap : matplotlib colormap, str or colormap object, optional
        To use for plotting of the contours. Either a string
        which is a name of a matplotlib colormap, or a matplotlib
        colormap object. Default='tab20'.

    title : str, optional
        Figure title.

    output_file : str, or None, optional
        The name of an image file to export plot to. Valid extensions
        are .png, .pdf, .svg. If output_file is not None, the plot
        is saved to a file, and the display is closed.

    See Also
    --------
    nilearn.datasets.fetch_surf_fsaverage : For surface data object to be
        used as background map for this plotting function.

    nilearn.plotting.plot_surf_stat_map : for plotting statistical maps on
        brain surfaces.

    nilearn.surface.vol_to_surf : For info on the generation of surfaces.

    """
    if figure is None and axes is None:
        figure = plot_surf(surf_mesh, **kwargs)
        axes = figure.axes[0]
    if figure is None:
        figure = axes.get_figure()
    if axes is None:
        axes = figure.axes[0]
    if axes.name != '3d':
        raise ValueError('Axes must be 3D.')
    # test if axes contains Poly3DCollection, if not initialize surface
    if not axes.collections or not isinstance(axes.collections[0],
                                              Poly3DCollection):
        _ = plot_surf(surf_mesh, axes=axes, **kwargs)

    coords, faces = load_surf_mesh(surf_mesh)
    roi = load_surf_data(roi_map)
    if levels is None:
        levels = np.unique(roi_map)
    if colors is None:
        n_levels = len(levels)
        vmax = n_levels
        cmap = get_cmap(cmap)
        norm = Normalize(vmin=0, vmax=vmax)
        colors = [cmap(norm(color_i)) for color_i in range(vmax)]
    else:
        try:
            colors = [to_rgba(color, alpha=1.) for color in colors]
        except ValueError:
            raise ValueError('All elements of colors need to be either a'
                             ' matplotlib color string or RGBA values.')

    if labels is None:
        labels = [None] * len(levels)
    if not (len(labels) == len(levels) and len(colors) == len(labels)):
        raise ValueError('Levels, labels, and colors '
                         'argument need to be either the same length or None.')

    patch_list = []
    for level, color, label in zip(levels, colors, labels):
        roi_indices = np.where(roi == level)[0]
        faces_outside = _get_faces_on_edge(faces, roi_indices)
        # Fix: Matplotlib version 3.3.2 to 3.3.3
        # Attribute _facecolors3d changed to _facecolor3d in
        # matplotlib version 3.3.3
        try:
            axes.collections[0]._facecolors3d[faces_outside] = color
        except AttributeError:
            axes.collections[0]._facecolor3d[faces_outside] = color
        if label and legend:
            patch_list.append(Patch(color=color, label=label))
    # plot legend only if indicated and labels provided
    if legend and np.any([lbl is not None for lbl in labels]):
        figure.legend(handles=patch_list)
    if title:
        figure.suptitle(title)
    # save figure if output file is given
    if output_file is not None:
        figure.savefig(output_file)
        plt.close(figure)
    else:
        return figure
Example #53
0
                         mfc='blue')
line3 = axesList[3].plot(f,
                         z,
                         'o',
                         ls='-',
                         color='blue',
                         alpha=alpha,
                         ms=3,
                         markevery=.05,
                         mec='None',
                         mfc='red')

# Plot fifth graph:

# Create RGBA tuples for lines
lcolor1 = colors.to_rgba('red', alpha=alpha)
lcolor2 = colors.to_rgba('limegreen', alpha=alpha)
lcolor3 = colors.to_rgba('blue', alpha=alpha)

# Create RGBA tuples for markers
mcolor1 = colors.to_rgba('limegreen', alpha=1.0)
mcolor2 = colors.to_rgba('blue', alpha=0.4)
mcolor3 = colors.to_rgba('red', alpha=0.15)

# Plot x, y, and z lines and markers- the lines have the same
# transparency level, but the markers vary in alpha value
line1 = axesList[4].plot(f,
                         x,
                         'o',
                         ls='-',
                         color=lcolor1,
Example #54
0
 def test_default_color(self):
     assert self.state.frame_color == settings.BACKGROUND_COLOR
     assert self.state.edge_color == to_rgba(settings.FOREGROUND_COLOR, self.state.alpha)
Example #55
0
        with mpl.rc_context():
            _copy = mpl.rcParams.copy()
            for key in _copy:
                mpl.rcParams[key] = _copy[key]
        with mpl.rc_context():
            copy.deepcopy(mpl.rcParams)
    with pytest.raises(ValueError):
        validate_bool(None)
    with pytest.raises(ValueError):
        with mpl.rc_context():
            mpl.rcParams['svg.fonttype'] = True


legend_color_tests = [('face', {
    'color': 'r'
}, mcolors.to_rgba('r')),
                      ('face', {
                          'color': 'inherit',
                          'axes.facecolor': 'r'
                      }, mcolors.to_rgba('r')),
                      ('face', {
                          'color': 'g',
                          'axes.facecolor': 'r'
                      }, mcolors.to_rgba('g')),
                      ('edge', {
                          'color': 'r'
                      }, mcolors.to_rgba('r')),
                      ('edge', {
                          'color': 'inherit',
                          'axes.edgecolor': 'r'
                      }, mcolors.to_rgba('r')),
Example #56
0
# ----------------------------------------------------------------------------
# Title:   Scientific Visualisation - Python & Matplotlib
# Author:  Nicolas P. Rougier
# License: BSD
# ----------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as colors
from matplotlib.ticker import NullFormatter

X = np.random.uniform(0, 1, 1000)
Y = np.random.uniform(0, 1, 1000)
S = np.sqrt((X - 0.5)**2 + (Y - 0.5)**2)
C = np.ones((1000, 4)) * colors.to_rgba("C0")
C[S > 0.5] = colors.to_rgba("C1")

figure = plt.figure(figsize=(8, 4))

# Linear scale
ax = plt.subplot(1, 2, 1, xlim=(0, 1), ylim=(0, 1))
ax.scatter(X, Y, s=25, facecolor=C, edgecolor="none", alpha=0.5)
T = np.linspace(0, 2 * np.pi, 100)
X2 = 0.5 + 0.5 * np.cos(T)
Y2 = 0.5 + 0.5 * np.sin(T)
ax.plot(X2, Y2, color="black", linestyle="--", linewidth=0.75)

#
ax = plt.subplot(1, 2, 2, xlim=(0.01, 0.99), ylim=(0.01, 0.99))
ax.set_xscale("logit")
ax.set_yscale("logit")
ax.scatter(X, Y, s=25, facecolor=C, edgecolor="none", alpha=0.5)
Example #57
0
    def apply_callback(data):
        """This function will be called to apply changes"""
        general = data.pop(0)
        curves = data.pop(0) if has_curve else []
        images = data.pop(0) if has_image else []
        if data:
            raise ValueError("Unexpected field")

        # Set / General
        (title, xmin, xmax, xlabel, xscale, ymin, ymax, ylabel, yscale,
         generate_legend) = general

        if axes.get_xscale() != xscale:
            axes.set_xscale(xscale)
        if axes.get_yscale() != yscale:
            axes.set_yscale(yscale)

        axes.set_title(title)
        axes.set_xlim(xmin, xmax)
        axes.set_xlabel(xlabel)
        axes.set_ylim(ymin, ymax)
        axes.set_ylabel(ylabel)

        # Restore the unit data
        axes.xaxis.converter = xconverter
        axes.yaxis.converter = yconverter
        axes.xaxis.set_units(xunits)
        axes.yaxis.set_units(yunits)
        axes.xaxis._update_axisinfo()
        axes.yaxis._update_axisinfo()

        # Set / Curves
        for index, curve in enumerate(curves):
            line = linedict[curvelabels[index]]
            (label, linestyle, drawstyle, linewidth, color, marker, markersize,
             markerfacecolor, markeredgecolor) = curve
            line.set_label(label)
            line.set_linestyle(linestyle)
            line.set_drawstyle(drawstyle)
            line.set_linewidth(linewidth)
            rgba = mcolors.to_rgba(color)
            line.set_alpha(None)
            line.set_color(rgba)
            if marker is not 'none':
                line.set_marker(marker)
                line.set_markersize(markersize)
                line.set_markerfacecolor(markerfacecolor)
                line.set_markeredgecolor(markeredgecolor)

        # Set / Images
        for index, image_settings in enumerate(images):
            image = imagedict[imagelabels[index]]
            label, cmap, low, high, interpolation = image_settings
            image.set_label(label)
            image.set_cmap(cm.get_cmap(cmap))
            image.set_clim(*sorted([low, high]))
            image.set_interpolation(interpolation)

        # re-generate legend, if checkbox is checked
        if generate_legend:
            draggable = None
            ncol = 1
            if axes.legend_ is not None:
                old_legend = axes.get_legend()
                draggable = old_legend._draggable is not None
                ncol = old_legend._ncol
            new_legend = axes.legend(ncol=ncol)
            if new_legend:
                new_legend.draggable(draggable)

        # Redraw
        figure = axes.get_figure()
        figure.canvas.draw()
Example #58
0
def cc(arg, alpha=.6):
    """
    Shorthand to convert 'named' colors to rgba format with opacity.
    """
    return mcolors.to_rgba(arg, alpha=alpha)
Example #59
0
            _deep_copy = copy.deepcopy(mpl.rcParams)
        # real test is that this does not raise
        assert validate_bool_maybe_none(None) is None
        assert validate_bool_maybe_none("none") is None

    with pytest.raises(ValueError):
        validate_bool_maybe_none("blah")
    with pytest.raises(ValueError):
        validate_bool(None)
    with pytest.raises(ValueError):
        with mpl.rc_context():
            mpl.rcParams['svg.fonttype'] = True


legend_color_tests = [
    ('face', {'color': 'r'}, mcolors.to_rgba('r')),
    ('face', {'color': 'inherit', 'axes.facecolor': 'r'},
     mcolors.to_rgba('r')),
    ('face', {'color': 'g', 'axes.facecolor': 'r'}, mcolors.to_rgba('g')),
    ('edge', {'color': 'r'}, mcolors.to_rgba('r')),
    ('edge', {'color': 'inherit', 'axes.edgecolor': 'r'},
     mcolors.to_rgba('r')),
    ('edge', {'color': 'g', 'axes.facecolor': 'r'}, mcolors.to_rgba('g'))
]
legend_color_test_ids = [
    'same facecolor',
    'inherited facecolor',
    'different facecolor',
    'same edgecolor',
    'inherited edgecolor',
    'different facecolor',
Example #60
0
def test_2d_to_rgba():
    color = np.array([0.1, 0.2, 0.3])
    rgba_1d = mcolors.to_rgba(color.reshape(-1))
    rgba_2d = mcolors.to_rgba(color.reshape((1, -1)))
    assert rgba_1d == rgba_2d