`matplotlib.path`#

Um módulo para lidar com as polilinhas usadas em todo o Matplotlib.

A classe primária para manipulação de polilinhas no Matplotlib é Path. Quase todos os desenhos vetoriais usam Paths em algum lugar do pipeline de desenho.

Embora uma Pathinstância em si não possa ser desenhada, algumas Artistsubclasses, como PathPatche , podem ser usadas para visualização PathCollectionconveniente .Path

classe matplotlib.path. Path ( vertices , codes = None , _interpolation_steps = 1 , closed = False , readonly = False ) [source] #

Bases:object

Uma série de segmentos de linha e curva possivelmente desconectados, possivelmente fechados.

O armazenamento subjacente é composto por dois arrays numpy paralelos:

vértices : uma matriz flutuante Nx2 de vértices
codes : uma matriz uint8 de comprimento N de códigos de caminho, ou None

Essas duas matrizes sempre têm o mesmo comprimento na primeira dimensão. Por exemplo, para representar uma curva cúbica, você deve fornecer três vértices e três CURVE4códigos.

Os tipos de código são:

STOP1 vértice (ignorado)
Um marcador para o final de todo o caminho (atualmente não obrigatório e ignorado)
MOVETO1 vértice
Pegue a caneta e mova para o vértice dado.
LINETO1 vértice
Desenhe uma linha da posição atual até o vértice dado.
CURVE31 ponto de controle, 1 ponto final
Desenhe uma curva quadrática de Bezier da posição atual, com o ponto de controle dado, até o ponto final dado.
CURVE42 pontos de controle, 1 ponto final
Desenhe uma curva cúbica de Bezier da posição atual, com os pontos de controle fornecidos, até o ponto final especificado.
CLOSEPOLY1 vértice (ignorado)
Desenhe um segmento de linha até o ponto inicial da polilinha atual.

Se os códigos forem Nenhum, ele será interpretado como MOVETOseguido por uma série de LINETO.

Usuários de objetos Path não devem acessar os arrays de vértices e códigos diretamente. Em vez disso, eles devem usar iter_segmentsou cleanedpara obter os pares vértice/código. Isso ajuda, em particular, a lidar consistentemente com o caso de códigos sendo Nenhum.

Alguns comportamentos dos objetos Path podem ser controlados por rcParams. Veja os rcParams cujas chaves começam com 'path.'.

Observação

As matrizes de vértices e códigos devem ser tratadas como imutáveis - há várias otimizações e suposições feitas no construtor que não serão alteradas quando os dados forem alterados.

Crie um novo caminho com os vértices e códigos fornecidos.

Parâmetros :

vértices (N, 2) tipo matriz: Os vértices do caminho, como uma matriz, matriz mascarada ou sequência de pares. Os valores mascarados, se houver, serão convertidos em NaNs, que serão tratados corretamente pelo Agg PathIterator e outros consumidores de dados de caminho, como iter_segments().
códigos array-like ou None, opcional: Matriz de comprimento N de inteiros representando os códigos do caminho. Se não for Nenhum, os códigos devem ter o mesmo comprimento que os vértices. Se Nenhum, os vértices serão tratados como uma série de segmentos de linha.
_interpolation_steps int, opcional: Usado como uma dica para certas projeções, como Polar, de que esse caminho deve ser linearmente interpolado imediatamente antes do desenho. Este atributo é principalmente um detalhe de implementação e não se destina ao uso público.
bool fechado , opcional: Se code for None e closed for True, os vértices serão tratados como segmentos de linha de um polígono fechado. Observe que o último vértice será ignorado (pois o código correspondente será definido como CLOSEPOLY).
bool somente leitura , opcional: Faz com que o caminho se comporte de maneira imutável e define os vértices e códigos como arrays somente leitura.

CLOSEPOLY = 79 #

CURVA3 = 3 #

CURVE4 = 4 #

LINHATO = 2 #

MOVER = 1 #

NUM_VERTICES_FOR_CODE = {0: 1, 1: 1, 2: 1, 3: 2, 4: 3, 79: 1} #: Um dicionário mapeando códigos de caminho para o número de vértices que o código espera.

PARAR = 0 #

classmethod arc ( theta1 , theta2 , n = None , is_wedge = False ) [source] #

Retorne a Pathpara o arco de círculo unitário dos ângulos theta1 a theta2 (em graus).

theta2 é desdobrado para produzir o arco mais curto dentro de 360 graus. Ou seja, se theta2 > theta1 + 360, o arco será de theta1 a theta2 - 360 e não um círculo completo mais alguma sobreposição extra.

Se n for fornecido, é o número de segmentos spline a serem feitos. Se n não for fornecido, o número de segmentos spline será determinado com base no delta entre theta1 e theta2 .

Masionobe, L. 2003. Desenho de um arco elíptico usando polilinhas, curvas quadráticas ou cúbicas de Bezier .

classmethod circle ( center = (0.0, 0.0) , radius = 1.0 , readonly = False ) [source] #

Retorna um Pathrepresentando um círculo de um determinado raio e centro.

Parâmetros :

centro (float, float), padrão: (0, 0): O centro do círculo.
flutuação do raio , padrão: 1: O raio do círculo.
somente leitura bool: Se o caminho criado deve ter o argumento "readonly" definido ao criar a instância Path.

Notas

O círculo é aproximado usando 8 curvas cúbicas de Bezier, conforme descrito em

Lencastre, Don. Aproximando um círculo ou uma elipse usando quatro splines cúbicos de Bezier .

clean ( transform = None , remove_nans = False , clip = None , * , simplificar = False , curves = False , stroke_width = 1.0 , snap = False , sketch = None ) [source] #

Retorne um novo Path com vértices e códigos limpos de acordo com os parâmetros.

Veja também

Path.iter_segments: para obter detalhes dos argumentos de palavra-chave.

clip_to_bbox ( bbox , inside = True ) [source] #

Recorte o caminho para a caixa delimitadora fornecida.

O caminho deve ser formado por um ou mais polígonos fechados. Este algoritmo não se comportará corretamente para caminhos não fechados.

Se dentro for True, prenda na parte interna da caixa, caso contrário, na parte externa da caixa.

code_type #: pseudônimo deuint8

códigos de propriedade #: A lista de códigos Pathcomo uma matriz numpy 1D. Cada código é um dos STOP, MOVETO, LINETO, CURVE3ou . Para códigos que correspondem a mais de um vértice ( e ), esse código será repetido para que o comprimento de e seja sempre o mesmo.CURVE4CLOSEPOLYCURVE3CURVE4verticescodes

contém_caminho ( caminho , transform = Nenhum ) [origem] #

Retorna se este caminho (fechado) contém completamente o caminho fornecido.

Se transform não for None, o caminho será transformado antes da verificação da contenção.

contém_ponto ( point , transform = None , radius = 0.0 ) [source] #

Retorna se a área delimitada pelo caminho contém o ponto fornecido.

O caminho é sempre tratado como fechado; ou seja, se o último código não for CLOSEPOLY, um segmento implícito conectando o último vértice ao primeiro vértice é assumido.

Parâmetros :

ponto (flutuar, flutuar): O ponto (x, y) a ser verificado.
transformar matplotlib.transforms.Transform, opcional: Caso contrário None, o ponto será comparado a selftransformado por transform ; ou seja, para uma verificação correta, transform deve transformar o caminho no sistema de coordenadas do ponto .
flutuação do raio , padrão: 0: Adicione uma margem adicional no caminho nas coordenadas do ponto . A trajetória é estendida tangencialmente pelo raio/2 ; ou seja, se você desenhar o caminho com uma largura de linha de raio , todos os pontos na linha ainda serão considerados contidos na área. Por outro lado, valores negativos encolhem a área: Pontos na linha imaginária serão considerados fora da área.

Devoluções :

bool

Notas

O algoritmo atual tem algumas limitações:

O resultado é indefinido para pontos exatamente no limite (ou seja, no caminho deslocado pelo raio/2 ).
O resultado é indefinido se não houver área delimitada, ou seja, todos os vértices estão em uma linha reta.
Se as linhas delimitadoras começarem a se cruzar devido ao deslocamento do raio , não há garantia de que o resultado esteja correto.

contém_pontos ( points , transform = None , radius = 0.0 ) [source] #

Retorna se a área delimitada pelo caminho contém os pontos dados.

O caminho é sempre tratado como fechado; ou seja, se o último código não for CLOSEPOLY, um segmento implícito conectando o último vértice ao primeiro vértice é assumido.

Parâmetros :

matriz de pontos (N, 2): Os pontos a verificar. As colunas contêm valores x e y.
transformar matplotlib.transforms.Transform, opcional: Caso contrário None, os pontos serão comparados a selftransformados por transform ; ou seja, para uma verificação correta, transform deve transformar o caminho no sistema de coordenadas de pontos .
flutuação do raio , padrão: 0: Adicione uma margem adicional no caminho em coordenadas de pontos . A trajetória é estendida tangencialmente pelo raio/2 ; ou seja, se você desenhar o caminho com uma largura de linha de raio , todos os pontos na linha ainda serão considerados contidos na área. Por outro lado, valores negativos encolhem a área: Pontos na linha imaginária serão considerados fora da área.

Devoluções :

array bool comprimento-N

Notas

O algoritmo atual tem algumas limitações:

O resultado é indefinido para pontos exatamente no limite (ou seja, no caminho deslocado pelo raio/2 ).
O resultado é indefinido se não houver área delimitada, ou seja, todos os vértices estão em uma linha reta.
Se as linhas delimitadoras começarem a se cruzar devido ao deslocamento do raio , não há garantia de que o resultado esteja correto.

copiar ( ) [fonte] #: Retorne uma cópia rasa de Path, que compartilhará os vértices e códigos com a fonte Path.

deepcopy ( memo = None ) [fonte] #: Retorne uma cópia profunda do arquivo Path. O Pathnão será somente leitura, mesmo que a fonte Pathseja.

get_extents ( transform = None , ** kwargs ) [source] #

Obter Bbox do caminho.

Parâmetros :

transform matplotlib.transforms.Transform, opcional: Transformar para aplicar ao caminho antes de calcular as extensões, se houver.
** kwargs: Encaminhado para iter_bezier.

Devoluções :

matplotlib.transforms.Bbox: As extensões do caminho Bbox([[xmin, ymin], [xmax, ymax]])

hachura estática ( hatchpattern , densidade = 6 ) [fonte] #: Dado um especificador de hachura, hatchpattern , gera um Path que pode ser usado em um padrão de hachura repetido. densidade é o número de linhas por unidade quadrada.

interpolado ( passos ) [fonte] #

Retorne um novo caminho reamostrado para comprimento N x passos.

Códigos diferentes de LINETO não são tratados corretamente.

intersects_bbox ( bbox , preenchido = True ) [fonte] #

Retorna se este caminho cruza um determinado Bbox.

Se preenchido for Verdadeiro, isso também retornará Verdadeiro se o caminho incluir completamente o Bbox(ou seja, o caminho for tratado como preenchido).

A caixa delimitadora é sempre considerada preenchida.

intersects_path ( outro , preenchido = True ) [fonte] #

Retorna se este caminho intercepta outro caminho dado.

Se preenchido for True, isso também retornará True se um caminho incluir completamente o outro (ou seja, os caminhos são tratados como preenchidos).

iter_bezier ( ** kwargs ) [fonte] #

Iterar sobre cada curva bezier (linhas incluídas) em um Path.

Parâmetros :

** kwargs: Encaminhado para iter_segments.

Rendimentos :

B matplotlib.bezier.BezierSegment: As curvas bezier que compõem o caminho atual. Observe em particular que os pontos independentes são curvas bezier de ordem 0 e as linhas são curvas bezier de ordem 1 (com dois pontos de controle).
código Path.code_type: O código que descreve que tipo de curva está sendo retornado. Path.MOVETO, Path.LINETO, Path.CURVE3, Path.CURVE4 correspondem a curvas Bezier com 1, 2, 3 e 4 pontos de controle (respectivamente). Path.CLOSEPOLY é um Path.LINETO com os pontos de controle escolhidos corretamente com base nos pontos inicial/final do traço atual.

iter_segments ( transform = None , remove_nans = True , clip = None , snap = False , stroke_width = 1.0 , simplificar = None , curves = True , sketch = None ) [source] #

Itere sobre todos os segmentos de curva no caminho.

Cada iteração retorna um par , onde é uma sequência de 1-3 pares de coordenadas e é um código.(vertices, code)verticescodePath

Além disso, esse método pode fornecer várias limpezas e conversões padrão para o caminho.

Parâmetros :

transformar Nenhum ouTransform: Se não for Nenhum, a transformação afim fornecida será aplicada ao caminho.
remove_nans bool, opcional: Se deve remover todos os NaNs do caminho e ignorá-los usando comandos MOVETO.
clipe Nenhum ou (flutuar, flutuar, flutuar, flutuar), opcional: Se não for None, deve ser uma tupla de quatro (x1, y1, x2, y2) definindo um retângulo no qual recortar o caminho.
snap Nenhum ou bool, opcional: Se True, encaixa todos os nós em pixels; se False, não os quebre. Se Nenhum, encaixe se o caminho contiver apenas segmentos paralelos aos eixos x ou y e não mais que 1024 deles.
float stroke_width , opcional: A largura do traçado que está sendo desenhado (usado para encaixe de caminho).
simplificar Nenhum ou bool, opcional: Se deve simplificar o caminho removendo vértices que não afetam sua aparência. Se Nenhum, use o should_simplifyatributo. Consulte também rcParams["path.simplify"](padrão: True) e rcParams["path.simplify_threshold"](padrão: 0.111111111111).
curvas bool, opcional: Se for True, os segmentos de curva serão retornados como segmentos de curva. Se Falso, todas as curvas serão convertidas em segmentos de linha.
esboço Nenhum ou sequência, opcional: Se não for None, deve ser uma tupla de 3 da forma (escala, comprimento, aleatoriedade), representando os parâmetros do sketch.

classmethod make_compound_path ( * args ) [fonte] #: Faça um caminho composto de uma lista de Pathobjetos. Remove cegamente todos Path.STOPos pontos de controle.

classmethod make_compound_path_from_polys ( XY ) [fonte] #

Faça um objeto de caminho composto para desenhar um número de polígonos com números iguais de lados XY é uma matriz numpy de vértices (numpolys x numsides x 2). O objeto de retorno é um arquivo Path.

( Código fonte , png )

propriedade somente leitura #: Truese Pathfor somente leitura.

propriedade should_simplify #: Truese a matriz de vértices deve ser simplificada.

propriedade simplifica_limite #: A fração de uma diferença de pixel abaixo da qual os vértices serão simplificados.

to_polygons ( transform = None , width = 0 , height = 0 , closed_only = True ) [source] #

Converta este caminho em uma lista de polígonos ou polilinhas. Cada polígono/polilinha é uma matriz Nx2 de vértices. Em outras palavras, cada polígono não possui MOVETOinstruções ou curvas. Isso é útil para exibição em back-ends que não suportam caminhos compostos ou curvas Bezier.

Se a largura e a altura forem diferentes de zero, as linhas serão simplificadas para que os vértices fora de (0, 0), (largura, altura) sejam cortados.

Se closed_only for True(padrão), apenas polígonos fechados, com o último ponto igual ao primeiro, serão retornados. Quaisquer polilinhas não fechadas no caminho serão explicitamente fechadas. Se closed_only for False, quaisquer polígonos não fechados no caminho serão retornados como polígonos não fechados, e os polígonos fechados serão retornados explicitamente fechados definindo o último ponto como o primeiro ponto.

transformado ( transformar ) [fonte] #

Retorne uma cópia transformada do caminho.

Veja também

matplotlib.transforms.TransformedPath: Uma classe de caminho especializada que armazenará em cache o resultado transformado e atualizará automaticamente quando a transformação for alterada.

classmethod unit_circle ( ) [fonte] #

Retorna o readonly Pathdo círculo unitário.

Na maioria dos casos, Path.circle()será o que você deseja.

classmethod unit_circle_righthalf ( ) [fonte] #

Retorne a Pathda metade direita de um círculo unitário.

Consulte Path.circlea referência sobre a aproximação utilizada.

classmethod unit_rectangle ( ) [fonte] #: Retorne uma Pathinstância do retângulo unitário de (0, 0) para (1, 1).

classmethod unit_regular_asterisk ( numVertices ) [fonte] #: Retorne a Pathpara um asterisco regular de unidade com o numVertices fornecido e raio de 1,0, centralizado em (0, 0).

classmethod unit_regular_polygon ( numVertices ) [fonte] #: Retorne uma Pathinstância para um polígono regular unitário com os numVertices fornecidos, de modo que o círculo circunscrito tenha raio 1,0, centrado em (0, 0).

classmethod unit_regular_star ( numVertices , innerCircle = 0.5 ) [source] #: Retorne a Pathpara uma estrela regular unitária com o numVertices fornecido e raio de 1,0, centralizado em (0, 0).

vértices de propriedade #: A lista de vértices Pathcomo uma matriz Nx2 numpy.

classmethod wedge ( theta1 , theta2 , n = None ) [fonte] #

Retorne a Pathpara a cunha do círculo unitário dos ângulos theta1 a theta2 (em graus).

theta2 é desembrulhado para produzir a cunha mais curta em 360 graus. Ou seja, se theta2 > theta1 + 360, a cunha será de theta1 a theta2 - 360 e não um círculo completo mais alguma sobreposição extra.

Se n for fornecido, é o número de segmentos spline a serem feitos. Se n não for fornecido, o número de segmentos spline será determinado com base no delta entre theta1 e theta2 .

Consulte Path.arca referência sobre a aproximação utilizada.

matplotlib.path. get_path_collection_extents ( master_transform , paths , transforms , offsets , offset_transform ) [fonte] #

Dada uma sequência de objetos s Path, Transforms e deslocamentos, conforme encontrados em a PathCollection, retorna a caixa delimitadora que encapsula todos eles.

Parâmetros :

master_transformTransform: Transformação global aplicada a todos os caminhos.
lista de caminhos dePath
transforma lista deAffine2D
offsets (N, 2) tipo array
offset_transformAffine2D: Transformação aplicada aos deslocamentos antes de compensar o caminho.

Notas

A forma como caminhos , transformações e deslocamentos são combinados segue o mesmo método das coleções: Cada um é iterado de forma independente, portanto, se você tiver 3 caminhos, 2 transformações e 1 deslocamento, suas combinações serão as seguintes:

(A, A, A), (B, B, A), (C, A, A)

matplotlib.path#

`matplotlib.path`#