IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Colorier des zones d'un repère cartésien


Sujet :

Python

  1. #1
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2016
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2016
    Messages : 5
    Points : 4
    Points
    4
    Par défaut Colorier des zones d'un repère cartésien
    Bonsoir à vous !

    Je possède un quadrillage dans un repère cartésien, comportant n carrés (codé par un ensemble de listes de quatre points) et une liste de n valeurs et j'aimerais colorier chaque carrés en fonction des coefficients de ma liste, sauriez-vous comment je peux faire ?

    Merci, à bientôt !

  2. #2
    Membre expérimenté Avatar de plxpy
    Homme Profil pro
    Ingénieur géographe
    Inscrit en
    Janvier 2009
    Messages
    792
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Ingénieur géographe
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Janvier 2009
    Messages : 792
    Points : 1 481
    Points
    1 481
    Par défaut
    Bonjour

    "Colorier des carrés" en python n'a pas de sens !

    Si j'en crois la dernière discussion que tu as ouverte, c'est certainement sous matplotlib que tu travailles.

    Matplotlib ne fait pas partie des - terme consacré - "batteries included" de python. N'oublie pas qu'on "n'est pas dans ta tête" et donne toutes les infos nécessaires quand tu postes : tu auras plus de chance d'avoir des réponses.

    ps : mais comme je ne connais pas plus que ça Matplotlib, je ne peux pas t'aider d'avantage.
    "La simplicité ne précède pas la complexité, elle la suit." - Alan J. Perlis
    DVP ? Pensez aux cours et tutos, ainsi qu'à la FAQ !

  3. #3
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2016
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2016
    Messages : 5
    Points : 4
    Points
    4
    Par défaut
    Merci pour la réponse rapide

    Je voulais plutôt dire que j'ai besoin de remplir une zone du graphe (que j'importe grâce à matplotlib) définie par quatre segments avec pleins de points que je colorerai avec un certain niveau de gris en fonction d'une valeur d'une liste de n2 éléments.

    Si cela peut aider, j'ai donc un programme aff_quadr(Q) qui prend en argument une liste de listes de 4 points (chaque point étant lui-même représenté par une liste de deux valeurs (abscisse et ordonnée)) et qui affiche un quadrillage :


    import matplotlib.pyplot as pl

    def aff_quadr(Q):
    ___for carre in Q:
    ______A, B, D, C = carre[0], carre[1], carre[2], carre[3]
    ______pl.plot([A[0], B[0]], [A[1], B[1]], "y")
    ______pl.plot([D[0], A[0]], [D[1], A[1]], "y")
    ______pl.plot([B[0], C[0]], [B[1], C[1]], "y")
    ______pl.plot([C[0], D[0]], [C[1], D[1]], "y")

    ______pl.show()

    A partir de ce quadrillage, est-il possible de "remplir" chaque case avec un niveau de gris et de l'afficher grâce à matplotlib.pyplot ? Puisque je peux colorier mes droites, je me suis dis que je pourrais colorier pleins de points dans mes cases, mais comment avancer ?
    J'espère avoir été suffisamment clair, n'hésitez pas à me demander plus de détails

    A bientôt !

  4. #4
    Membre éprouvé

    Homme Profil pro
    Ingénieur
    Inscrit en
    Août 2010
    Messages
    654
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Août 2010
    Messages : 654
    Points : 1 150
    Points
    1 150
    Par défaut
    Salut!

    Personnellement je partirais non pas sur des segments, mais sur des carrés directement. Matplotlib permet de tracer des formes pleines dont des carrés (voir exemple). On peut tracer un carré rouge plein comme ceci:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    from __future__ import division
    import matplotlib.pyplot as plt
    import matplotlib.patches as ptc
     
    def plot_rectangle(vtx, color='red'):
        """plot a rectangle with matplotlib
     
        vtx : list of vertices [(x1,y1), (x2,y2), ...]
        """
        # Create a figure and a 'plot' inside it.
        fig = plt.figure(1)
        ax = fig.add_subplot(111)
        # Create a rectangle. Size defined as lower left coordinates + width
        # + height
        x0, y0 = vtx[0]
        width = vtx[2][0] - vtx[0][0]
        height = vtx[2][1] - vtx[0][1]
        rectangle = ptc.Rectangle(
            (x0, y0),
            width,
            height,
            # Color option, alpha to play with transparency
            color=color, alpha=1.0,
            # Option to handle patches overlapping.
            zorder=0
            )
        # Add the rectangle patch to the plot
        ax.add_artist(rectangle)
     
        # Set axis limits to see something
        ax.set_xlim((-10, 10))
        ax.set_ylim((-10, 10))
        ax.grid(True)
        plt.show()
     
     
    # Example
    vertices = [(0., 0.), (0., 1.), (1., 1.), (1., 0.)]
    plot_rectangle(vertices)
    Maintenant il faut gérer la couleur en fonction d'une valeur. Pour cela on peut utiliser ce que l'on appel un "colormap". On peut grosso modo dire à Matplotlib d'utiliser un nuancier calé sur un range de valeurs. Voici l'exemple ci-dessus modifier pour accepter une colormap:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    from __future__ import division
    import matplotlib.pyplot as plt
    import matplotlib.patches as ptc
    from random import random
     
    def plot_rectangle(vtxs, values):
        """plot a rectangle with matplotlib
     
        vtxs   : list of vertices [[(x1,y1), (x2,y2), ...]
        values : value associated with the rectangle. Must be
                 between 0.0 and 1.0 (normalized)
        """
        # Create a figure and a 'plot' inside it.
        fig = plt.figure(1)
        ax = fig.add_subplot(111)
     
        for vtx, value in zip(vtxs, values):
     
            # Create a rectangle. Size defined as lower left coordinates +
            # width + height
            x0, y0 = vtx[0]
            width = vtx[2][0] - vtx[0][0]
            height = vtx[2][1] - vtx[0][1]
            rectangle = ptc.Rectangle(
                (x0, y0),
                width,
                height,
                # Color option, alpha to play with transparency
                color=plt.cm.gray(value), alpha=0.5,
                # Option to handle patches overlapping.
                zorder=0
                )
            # Add the rectangle patch to the plot
            ax.add_artist(rectangle)
     
        # Set axis limits to see something
        ax.set_xlim((0, 1))
        ax.set_ylim((0, 1))
        ax.grid(True)
        plt.show()
     
     
    # Example
    n_rectangles = 10
    vertices = [[(random(), random()), (random(), random()), (random(),
                 random()), (random(), random())] for i in range(n_rectangles)]
    values = [random() for i in range(n_rectangles )]
     
    plot_rectangle(vertices, values)
    Bien sûr a adapté a ton cas.

    J

  5. #5
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2016
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mai 2016
    Messages : 5
    Points : 4
    Points
    4
    Par défaut
    Super, je vais essayer de me débrouiller avec ça ! Merci pour vos réponses, à la prochaine !

Discussions similaires

  1. Réponses: 3
    Dernier message: 17/02/2016, 20h52
  2. colorier des zones spécifiques d'un cadre
    Par terminator01 dans le forum Word
    Réponses: 1
    Dernier message: 10/06/2015, 14h07
  3. Réponses: 0
    Dernier message: 19/07/2010, 19h20
  4. [FLASH MX2004 ] Définir des "zones cliquables"
    Par chodaboy34 dans le forum Flash
    Réponses: 3
    Dernier message: 07/11/2004, 19h58
  5. Réponses: 4
    Dernier message: 11/06/2004, 11h21

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo