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

Version imprimable

09/06/2016, 00h59
nicopython

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 !
09/06/2016, 12h53
plxpy

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.
12/06/2016, 10h44
nicopython

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 n² é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 ! :)

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:

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:

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

13/06/2016, 21h27
nicopython

Super, je vais essayer de me débrouiller avec ça ! ;) Merci pour vos réponses, à la prochaine !