Obtenir matplotlib couleur cycle d'état

Est-il possible d'interroger l'état actuel de la matplotlib couleur de cycle? En d'autres termes est-il une fonction get_cycle_state qui se comportent de la manière suivante?

>>> plot(x1, y1)
>>> plot(x2, y2)
>>> state = get_cycle_state()
>>> print state
2

Où j'attends l'état à l'index de la couleur suivante, qui sera utilisé dans une parcelle. Sinon, si il est revenu le lendemain de couleur ("r" pour le cycle par défaut dans l'exemple ci-dessus), qui serait bien aussi.

InformationsquelleAutor mwaskom | 2012-12-12
  1. 99

    Accès à la couleur cycle d'itérateur

    Il n'y a pas de "l'utilisateur-face" (un.k.un. "public") la méthode pour accéder au sous-jacente itérateur, mais vous pouvez y accéder par le biais de "privé" (par convention) des méthodes. Cependant, vous feriez peut pas obtenir l'état d'un iterator sans la modifier.

    Réglage de la couleur de cycle

    Rapide de côté: Vous pouvez définir la couleur et de la propriété cycle dans une variété de façons (p. ex. ax.set_color_cycle dans les versions <1,5 ou ax.set_prop_cycler dans >=1.5). Jetez un oeil à la exemple ici pour la version 1.5 ou plus, ou le de style précédentes ici.

    Accès à la sous-jacentes itérateur

    Cependant, il n'y a pas de public en face de la méthode pour accéder à l'objet iterable, vous pouvez y accéder pour un des axes de l'objet (ax) par le biais de la _get_lines helper instance de classe. ax._get_lines est une touche prêter à confusion du nom, mais c'est le derrière-le-scènes de la machinerie qui permet à l' plot commande de traitement de tous les bizarres et variées des moyens qu' plot peut être appelé. Entre autres choses, c'est ce qui garde la trace de ce que les couleurs que pour attribuer automatiquement. De même, il n'y a ax._get_patches_for_fill pour contrôler le vélo par défaut, les couleurs de remplissage et de patch propriétés.

    En tout cas, la couleur de cycle itératif est ax._get_lines.color_cycle pour les lignes et les ax._get_patches_for_fill.color_cycle pour les patchs. Sur matplotlib >=1.5, cela a changé à utilisation de l'option - cycleur de la bibliothèque, et l'itérable est appelé prop_cycler au lieu de color_cycle et donne un dict de propriétés, au lieu de seulement une couleur.

    Dans l'ensemble, vous feriez quelque chose comme:

    import matplotlib.pyplot as plt

fig, ax = plt.subplots()
color_cycle = ax._get_lines.color_cycle
# or ax._get_lines.prop_cycler on version >= 1.5
# Note that prop_cycler cycles over dicts, so you'll want next(cycle)['color']

    Vous ne pouvez pas afficher l'état d'un iterator

    Cependant, cet objet est un "nu" iterator. Nous pouvons facilement obtenir l'élément suivant (par exemple,next_color = next(color_cycle), mais cela signifie que la prochaine couleur après que est ce qui va être tracée. De par sa conception, il n'y a aucun moyen d'obtenir l'état actuel d'un itérateur sans la modifier.

    Dans v1.5 ou plus, il serait bien d'obtenir le cycler objet qui est utilisé, comme nous avons pu en déduire son état actuel. Cependant, la cycler objet lui-même n'est pas accessible (public ou privé) n'importe où. Au lieu de cela, seuls les itertools.cycle instance créée à partir de la cycler objet est accessible. De toute façon, il n'y a aucun moyen d'obtenir de l'état sous-jacent de la couleur et de la propriété du cycleur.

    Correspondre à la couleur de la déjà tracées élément au lieu

    Dans votre cas, il semble que vous êtes désireux de faire correspondre la couleur de quelque chose qui vient d'être tracée. Au lieu d'essayer de déterminer ce que la couleur de la propriété sera, définir la couleur/etc de votre nouvel élément basé sur les propriétés de ce qui est tracé.

    Par exemple, dans le cas que vous avez décrit, je ferais quelque chose comme ceci:

    import matplotlib.pyplot as plt
import numpy as np

def custom_plot(x, y, **kwargs):
    ax = kwargs.pop('ax', plt.gca())
    base_line, = ax.plot(x, y, **kwargs)
    ax.fill_between(x, 0.9*y, 1.1*y, facecolor=base_line.get_color(), alpha=0.5)

x = np.linspace(0, 1, 10)
custom_plot(x, x)
custom_plot(x, 2*x)
custom_plot(x, -x, color='yellow', lw=3)

plt.show()

    Obtenir matplotlib couleur cycle d'état

    Ce n'est pas le seul moyen, mais son plus propre que d'essayer d'obtenir la couleur de la ligne tracée à l'avance, dans ce cas.

    • Je suis en train d'écrire quelques fonctions supérieures pour automatiser les tâches de traçage pour mon domaine de travail. Souvent ceux-ci n'entraînent dessin de multiples matplotlib objets, et j'aimerais avoir plusieurs objets partagent une couleur dans la couleur de cycle, donc je n'ai pas toujours fournir une couleur argument si je me sens paresseux.
    • Par exemple, j'ai une fonction qui prend des données 2D avec les dimensions correspondant à (observations, de temps), et en tire un timecourse ligne (représentant la moyenne au cours des observations) et ombragée erreur bandes (représentant la variation par rapport à des observations). J'aimerais que ceux qui doivent être de la même couleur.
    • Si vous êtes juste de vouloir correspondre à la couleur d'un objet particulier, vous pouvez toujours prendre sa couleur. par exemple, line, = ax.plot(x, y) et ensuite utiliser line.get_color() d'obtenir la couleur de la précédemment tracé de la ligne.
    • Bien sûr, le problème est que, parfois, j' ne vous voulez être en mesure de spécifier une couleur pour ces choses, afin que ma fonction prend une couleur=Aucun argument, mais Aucun passage à la couleur argument pour maplotlob soulève une exception. Donc j'ai besoin d'être en mesure de savoir de quelle couleur je vais utiliser avant que je le tracé de la première chose.
    • Si vous n'avez pas l'esprit à l'aide de **kwargs, cela rend les choses beaucoup plus propre, dans ce cas. Aussi, si vous décidez plus tard que vous souhaitez spécifier une autre propriété (par exemple, largeur de raie) que vous n'avez pas à l'origine explicitement code, il permet tout d'être transmis à plot. Je tiens à ajouter la possibilité de spécifier explicitement un des axes de l'objet à tracer sur quand j'écris des fonctions similaires, de sorte que j'ai l'habitude de faire quelque chose le long des lignes de ax = kwargs.pop('ax', plt.gca()).
    • Il semble ax._get_lines.color_cycle n'existe plus dans la version 1.5?
    • Ouais, ils ont changé le mécanisme du cycle d'utilisation de Tom nouveaux cycler de la bibliothèque. Il permet beaucoup plus de souplesse style de vélo. Désinvolte, je ne me souviens pas de ce que l'équivalent est, et je suis en voyage sans un ordinateur portable. Si vous le trouvez, n'hésitez pas à modifier la question. Je vais essayer de mettre à jour plus tard, si je n'oublie pas.
    • Je pense que la (quasi) équivalent est un objet iterable ax._get_lines.prop_cycler vous pouvez construire quelque chose comme if 'color' in ax._get_lines._prop_keys: suivie par next(ax._get_lines.prop_cycler)['color'] à faire l'équivalent de ce qui est proposé avec color_cycle dans la réponse, je crois. Je ne suis pas sûr de savoir si vous pouvez obtenir un objet iterable seulement les couleurs, j'avais besoin d'explorer plus.
    • Assurez-vous (et merci) mais j'ai juste senti qu'il serait mieux assis dans Joe est déjà très bon et a accepté de répondre. Si il ne veut pas aller faire un tour pour mettre en avant le lundi - je vais m'en tenir une bonne réponse là-haut au lieu de la redoutable "réponse en commentaires"
    • pour matplotlib <1.5, pour obtenir la couleur suivante à partir de la iteratore utilisation de la fonction intégrée dans next() sur l'itérateur ax._get_lines.color_cycle --> next_color = next(ax._get_lines.color_cycle).

    InformationsquelleAutor Joe Kington
  2. 18

    Voici une manière qui fonctionne dans la version 1.5 qui va, espérons-le futur-preuve qu'il ne repose pas sur des méthodes précédées par des caractères de soulignement:

    colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]

    Cela vous donnera une liste des couleurs définies dans l'ordre pour le style actuel.

    • Travaille en 2.0.2.
    InformationsquelleAutor Mike DePalatis
  3. 15

    Remarque: Dans les versions les plus récentes de matplotlib (>= 1.5) _get_lines a changé. Vous devez maintenant utiliser next(ax._get_lines.prop_cycler)['color'] en Python 2 ou 3 (ou ax._get_lines.prop_cycler.next()['color'] dans Python 2) pour obtenir la prochaine couleur dans le cycle.

    Dans la mesure du possible d'utiliser l'approche la plus directe affiché dans la partie inférieure de @joe-kingston portant la réponse. Comme _get_lines n'est pas API-face, il pourrait à nouveau changer en un pas vers l'arrière compatible manière dans le futur.

    • Comment éviter que l'interrogation de l'élément suivant de la couleur du cycleur changements le cycleur de l'état?
    InformationsquelleAutor Andi
  4. 6

    Sûr, cela va faire il.

    #rainbow

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0,2*np.pi)
ax= plt.subplot(1,1,1)
ax.plot(np.sin(x))
ax.plot(np.cos(x))

rainbow = ax._get_lines.color_cycle
print rainbow
for i, color in enumerate(rainbow):
    if i<10:
        print color,

    Donne:

    <itertools.cycle object at 0x034CB288>
r c m y k b g r c m

    Ici est la itertools fonction que matplotlib utilise itertools.cycle

    Edit: Merci pour le commentaire, il semble qu'il n'est pas possible de copier un itérateur. Une idée serait de faire un dump d'un cycle complet, et de garder trace de la valeur que vous utilisez, permettez-moi de revenir sur ce que.

    Edit2: Bon, cela vous donnera de la couleur suivante et faire un nouvel itérateur qui se comporte comme si le prochain n'a pas été appelé. Ce n'est pas de conserver l'ordre de la coloration, la juste valeur de couleur, je vous laisse faire.

    Cela donne le résultat suivant, notez que la pente du tracé correspond à l'index, par exemple, d'abord g est le bottomest graphique et ainsi de suite.

    #rainbow

import matplotlib.pyplot as plt
import numpy as np
import collections
import itertools

x = np.linspace(0,2*np.pi)
ax= plt.subplot(1,1,1)


def create_rainbow():
    rainbow = [ax._get_lines.color_cycle.next()]
    while True:
        nextval = ax._get_lines.color_cycle.next()
        if nextval not in rainbow:
            rainbow.append(nextval)
        else:
            return rainbow

def next_color(axis_handle=ax):
    rainbow = create_rainbow()
    double_rainbow = collections.deque(rainbow)
    nextval = ax._get_lines.color_cycle.next()
    double_rainbow.rotate(-1)
    return nextval, itertools.cycle(double_rainbow)


for i in range(1,10):
    nextval, ax._get_lines.color_cycle = next_color(ax)
    print "Next color is: ", nextval
    ax.plot(i*(x))


plt.savefig("SO_rotate_color.png")
plt.show()

    Console

    Next color is:  g
Next color is:  c
Next color is:  y
Next color is:  b
Next color is:  r
Next color is:  m
Next color is:  k
Next color is:  g
Next color is:  c

    Obtenir matplotlib couleur cycle d'état

    • Merci! Juste pour préciser, il n'a pas l'air comme ça renvoie une copie, mais plutôt une référence à la réalité de cycle. Ainsi, l'appel de arc-en-ciel.next() est en fait va changer de ce que la prochaine intrigue va ressembler, trop.
    InformationsquelleAutor arynaq
  5. 4

    Je tiens juste à ajouter sur ce @Andi dit ci-dessus. Depuis color_cycle est obsolète dans matplotlib 1.5, vous devez utiliser prop_cycler, cependant, l'Andi solution (ax._get_lines.prop_cycler.next()['color']) retourné cette erreur pour moi:

    AttributeError: 'itertools.cycle "l'objet n'a pas d'attribut "suivant"

    Le code qui a fonctionné pour moi a été: next(ax._get_lines.prop_cycler), qui en réalité n'est pas loin de @joe-kingston portant l'original de la réponse.

    Personnellement, je n'ai rencontré ce problème lors d'un twinx (axe), qui reset la couleur du cycleur. J'avais besoin d'un moyen de rendre les couleurs de cycle correctement parce que j'ai été en utilisant style.use('ggplot'). Il pourrait y avoir un moyen plus facile/mieux à faire, alors n'hésitez pas à me corriger.

    • veuillez formater votre post sous forme de réponse, non pas comme une base de discussion (sinon, c'est un commentaire), votre principal point next(ax._get_lines.prop_cycler) est une alternative possible.
    • Comment éviter que l'appel next(ax._get_lines.prop_cycler) fait des changements de l'état de la couleur du cycleur?
    • C'est effectivement ce que je tente de faire -- changer l'état de la prop_cycler. Si vous lisez la accepté de répondre à cette question, vous verrez qu'il n'y a aucun moyen d'accéder à l'état de prop_cycler sans changer son état parce que c'est un objet iterable.
    • L'erreur que vous soulignez est un Python 2 et Python 3 différence. Merci de souligner ce point, j'ai édité ma réponse en conséquence.
    InformationsquelleAutor Carson
  6. 1

    Depuis matplotlib utilise itertools.cycle nous pouvons regarder à travers l'ensemble de la couleur de cycle, puis restaurer l'itérateur à son état précédent:

    def list_from_cycle(cycle):
    first = next(cycle)
    result = [first]
    for current in cycle:
        if current == first:
            break
        result.append(current)

    # Reset iterator state:
    for current in cycle:
        if current == result[-1]:
            break
    return result

    Il doit retourner la liste sans modification de l'état de l'itérateur.

    L'utiliser avec matplotlib >= 1.5:

    >>> list_from_cycle(ax._get_lines.prop_cycler)
[{'color': 'r'}, {'color': 'g'}, {'color': 'b'}]

    ou avec matplotlib < 1.5:

    >>> list_from_cycle(ax._get_lines.color_cycle)
['r', 'g', 'b']
    InformationsquelleAutor freidrichen
  7. -1

    Dans matplotlib version 2.2.3 il y a un get_next_color() méthode sur la _get_lines propriété:

    import from matplotlib import pyplot as plt
fig, ax = plt.subplots()
next_color = ax._get_lines.get_next_color()

    get_next_color() renvoie une couleur html chaîne, et les progrès de la couleur cycle d'itérateur.

    InformationsquelleAutor jkokorian