matplotlib.pyplot.pcolormesh #

matplotlib.pyplot. pcolormesh ( * args , alpha = None , norm = None , cmap = None , vmin = None , vmax = None , shading = None , antialiased = False , data = None , ** kwargs ) [source] #

Crie um gráfico de pseudocor com uma grade retangular não regular.

Assinatura de chamada:

pcolormesh([X, Y,] C, **kwargs)

X e Y podem ser usados para especificar os cantos dos quadriláteros.

Dica

pcolormeshé semelhante a pcolor. É muito mais rápido e preferido na maioria dos casos. Para uma discussão detalhada sobre as diferenças, consulte Diferenças entre pcolor() e pcolormesh() .

Parâmetros :

C 2D semelhante a array

Os valores mapeados por cores. O mapeamento de cores é controlado por cmap , norm , vmin e vmax .

X, Y tipo array, opcional

As coordenadas dos cantos dos quadriláteros de uma pcolormesh:

(X[i+1, j], Y[i+1, j])       (X[i+1, j+1], Y[i+1, j+1])
                      +-----+
                      |     |
                      +-----+
    (X[i, j], Y[i, j])       (X[i, j+1], Y[i, j+1])

Observe que o índice da coluna corresponde à coordenada x e o índice da linha corresponde a y. Para obter detalhes, consulte a seção Notas abaixo.

Se shading='flat'as dimensões de X e Y devem ser maiores que as de C , e o quadrilátero é colorido devido ao valor em . Se X , Y e C tiverem dimensões iguais, um aviso será gerado e a última linha e coluna de C serão ignoradas.C[i, j]

Se shading='nearest'ou 'gouraud', as dimensões de X e Y devem ser iguais às de C (caso contrário, será levantado um ValueError). Pois 'nearest'a cor é centralizada em . Para , uma interpolação suave é realizada entre os vértices do quadrilátero.C[i, j](X[i, j], Y[i, j])'gouraud'

Se X e/ou Y forem matrizes 1-D ou vetores de coluna, eles serão expandidos conforme necessário nas matrizes 2D apropriadas, criando uma grade retangular.

cmap str ou Colormap, padrão: rcParams["image.cmap"](padrão: 'viridis')

A instância do Colormap ou nome do mapa de cores registrado usado para mapear dados escalares para cores.

norma str ou Normalize, opcional

O método de normalização usado para dimensionar dados escalares para o intervalo [0, 1] antes de mapear para cores usando cmap . Por padrão, uma escala linear é usada, mapeando o valor mais baixo para 0 e o mais alto para 1.

Se fornecido, pode ser um dos seguintes:

Uma instância Normalizeou uma de suas subclasses (consulte Normalização do mapa de cores ).
Um nome de escala, ou seja, um de "linear", "log", "symlog", "logit", etc. Para obter uma lista de escalas disponíveis, chame matplotlib.scale.get_scale_names(). Nesse caso, uma Normalizesubclasse adequada é gerada e instanciada dinamicamente.

vmin, vmax flutuante, opcional

Ao usar dados escalares e nenhuma norma explícita , vmin e vmax definem o intervalo de dados que o mapa de cores cobre. Por padrão, o mapa de cores cobre toda a faixa de valores dos dados fornecidos. É um erro usar vmin / vmax quando uma instância de norma é fornecida (mas usar um nome de norma junto com vmin / vmax é aceitável).str

edgecolors {'nenhum', nenhum, 'face', cor, sequência de cores}, opcional

A cor das bordas. O padrão é 'nenhum'. Valores possíveis:

'nenhum' ou '': Sem borda.
Nenhum : rcParams["patch.edgecolor"](padrão: 'black') será usado. Observe que atualmente rcParams["patch.force_edgecolor"](padrão: False) deve ser True para que isso funcione.
'face': Use a cor da face adjacente.
Uma cor ou sequência de cores definirá a cor da borda.

A forma singular edgecolor funciona como um alias.

float alfa , padrão: nenhum

O valor de mistura alfa, entre 0 (transparente) e 1 (opaco).

sombreamento {'flat', 'nearest', 'gouraud', 'auto'}, opcional

O estilo de preenchimento do quadrilátero; o padrão é 'flat' ou rcParams["pcolor.shading"](padrão: 'auto'). Valores possíveis:

'flat': Uma cor sólida é usada para cada quadrante. A cor do quadrado (i, j), (i+1, j), (i, j+1), (i+1, j+1) é dada por . As dimensões de X e Y devem ser maiores que as de C ; se forem iguais a C , um aviso de descontinuação será gerado e a última linha e coluna de C serão descartadas.C[i, j]
'mais próximo': Cada ponto da grade terá uma cor centralizada nele, estendendo-se a meio caminho entre os centros da grade adjacentes. As dimensões de X e Y devem ser as mesmas de C .
'gouraud': Cada quad será sombreado por Gouraud: A cor dos cantos (i', j') é dada por . Os valores de cor da área intermediária são interpolados a partir dos valores dos cantos. As dimensões de X e Y devem ser as mesmas de C . Quando o sombreamento Gouraud é usado, as cores das arestas são ignoradas.C[i', j']
'auto': Escolha 'flat' se as dimensões de X e Y forem maiores que C . Escolha 'mais próximo' se as dimensões forem as mesmas.

Consulte grades e sombreamento pcolormesh para obter mais descrições.

snap bool, padrão: False

Se deve ajustar a malha aos limites de pixel.

bool rasterizado , opcional

Rasterize o pcolormesh ao desenhar gráficos vetoriais. Isso pode acelerar a renderização e produzir arquivos menores para grandes conjuntos de dados. Consulte também Rasterização para gráficos vetoriais .

Devoluções :

matplotlib.collections.QuadMesh

Outros Parâmetros :

objeto indexável de dados , opcional

Se fornecido, todos os parâmetros também aceitam uma string s, que é interpretada como data[s](a menos que isso gere uma exceção).

** kwargs

Além disso, os seguintes argumentos são permitidos. Eles são passados para o QuadMeshconstrutor:

Propriedade	Descrição
`agg_filter`	uma função de filtro, que usa uma matriz flutuante (m, n, 3) e um valor de dpi e retorna uma matriz (m, n, 3) e dois deslocamentos do canto inferior esquerdo da imagem
`alpha`	tipo array ou escalar ou Nenhum
`animated`	bool
`antialiased`ou aa ou antialiaseds	bool ou lista de bools
`array`	(M, N) tipo array ou M*N tipo array
`capstyle`	`CapStyle`ou {'bunda', 'projetando', 'redondo'}
`clim`	(vmin: flutuante, vmax: flutuante)
`clip_box`	`Bbox`
`clip_on`	bool
`clip_path`	Patch ou (Caminho, Transformação) ou Nenhum
`cmap`	`Colormap`ou str ou Nenhum
`color`	cor ou lista de tuplas rgba
`edgecolor`ou ec ou cores de borda	cor ou lista de cores ou 'face'
`facecolor`ou facecolors ou fc	cor ou lista de cores
`figure`	`Figure`
`gid`	str
`hatch`	{'/', '\', '\|', '-', '+', 'x', 'o', 'O', '.', '*'}
`in_layout`	bool
`joinstyle`	`JoinStyle`ou {'esquadria', 'redondo', 'chanfrado'}
`label`	objeto
`linestyle`ou traços ou estilos de linha ou ls	str ou tupla ou lista dos mesmos
`linewidth`ou larguras de linha ou lw	flutuador ou lista de flutuadores
`mouseover`	bool
`norm`	`Normalize`ou str ou Nenhum
`offset_transform`ou transOffset	desconhecido
`offsets`	(N, 2) ou (2,) tipo matriz
`path_effects`	`AbstractPathEffect`
`picker`	None ou bool ou float ou callable
`pickradius`	desconhecido
`rasterized`	bool
`sketch_params`	(escala: flutuante, comprimento: flutuante, aleatoriedade: flutuante)
`snap`	bool ou nenhum
`transform`	`Transform`
`url`	str
`urls`	lista de str ou None
`visible`	bool
`zorder`	flutuador

Veja também

pcolor: Uma implementação alternativa com recursos ligeiramente diferentes. Para uma discussão detalhada sobre as diferenças, consulte Diferenças entre pcolor() e pcolormesh() .
imshow: Se X e Y forem equidistantes, imshowpode ser uma alternativa mais rápida.

Notas

Matrizes mascaradas

C pode ser um array mascarado. Se estiver mascarado, o quadrilátero correspondente será transparente. O mascaramento de X e Y não é suportado. Use se precisar dessa funcionalidade.C[i, j]pcolor

Orientação da grade

A orientação da grade segue a convenção de matriz padrão: uma matriz C com forma (nrows, ncolumns) é plotada com o número da coluna como X e o número da linha como Y .

Diferenças entre pcolor() e pcolormesh()

Ambos os métodos são usados para criar um gráfico de pseudocor de uma matriz 2D usando quadriláteros.

A principal diferença está no objeto criado e na manipulação interna dos dados: Enquanto pcolorretorna um PolyCollection, pcolormesh retorna um QuadMesh. O último é mais especializado para o propósito determinado e, portanto, é mais rápido. Quase sempre deve ser preferido.

Há também uma pequena diferença na manipulação de arrays mascarados. Ambos pcolore pcolormeshsuportam matrizes mascaradas para C . No entanto, pcolorsuporta apenas matrizes mascaradas para X e Y . A razão está no tratamento interno dos valores mascarados. pcolordeixa de fora os respectivos polígonos do PolyCollection. pcolormeshdefine a cor da face dos elementos mascarados como transparente. Você pode ver a diferença ao usar cores de borda. Enquanto todas as bordas são desenhadas independentemente do mascaramento em um QuadMesh, a borda entre dois quadriláteros mascarados adjacentes pcolornão é desenhada porque os polígonos correspondentes não existem na PolyCollection.

Outra diferença é o suporte de sombreamento Gouraud em pcolormesh, que não está disponível com pcolor.