matplotlib.path#

Un modulo per gestire le polilinee utilizzate in Matplotlib.

La classe principale per la gestione della polilinea in Matplotlib è Path. Quasi tutti i disegni vettoriali fanno uso di Paths da qualche parte nella pipeline di disegno.

Sebbene Pathun'istanza stessa non possa essere disegnata, alcune Artistsottoclassi, come PathPatche PathCollection, possono essere utilizzate per una comoda Path visualizzazione.

classe matplotlib.path. Path ( vertici , codici = None , _interpolation_steps = 1 , closed = False , readonly = False ) [fonte] #

Basi:object

Una serie di segmenti di linee e curve possibilmente disconnessi, possibilmente chiusi.

L'archiviazione sottostante è costituita da due array numpy paralleli:

  • vertici : un array float Nx2 di vertici

  • codes : un array uint8 di lunghezza N di codici di percorso o Nessuno

Questi due array hanno sempre la stessa lunghezza nella prima dimensione. Ad esempio, per rappresentare una curva cubica, è necessario fornire tre vertici e tre CURVE4codici.

I tipi di codice sono:

  • STOP1 vertice (ignorato)

    Un indicatore per la fine dell'intero percorso (attualmente non richiesto e ignorato)

  • MOVETO1 vertice

    Prendi la penna e spostati sul vertice dato.

  • LINETO1 vertice

    Traccia una linea dalla posizione corrente al vertice dato.

  • CURVE31 punto di controllo, 1 punto finale

    Disegna una curva di Bézier quadratica dalla posizione corrente, con il dato punto di controllo, al dato punto finale.

  • CURVE42 punti di controllo, 1 endpoint

    Disegna una curva di Bezier cubica dalla posizione corrente, con i punti di controllo dati, al punto finale dato.

  • CLOSEPOLY1 vertice (ignorato)

    Disegna un segmento di linea fino al punto iniziale della polilinea corrente.

Se codes è None, viene interpretato come MOVETOseguito da una serie di LINETO.

Gli utenti degli oggetti Path non devono accedere direttamente ai vertici e agli array di codici. Invece, dovrebbero usare iter_segmentso cleanedper ottenere le coppie vertice/codice. Ciò aiuta, in particolare, a gestire in modo coerente il caso in cui i codici sono Nessuno.

Alcuni comportamenti degli oggetti Path possono essere controllati da rcParams. Vedi gli rcParams le cui chiavi iniziano con 'path.'.

Nota

I vertici e gli array di codici dovrebbero essere trattati come immutabili: ci sono una serie di ottimizzazioni e ipotesi formulate in anticipo nel costruttore che non cambieranno quando i dati cambiano.

Crea un nuovo percorso con i vertici e i codici dati.

Parametri :
vertici (N, 2) simili a array

I vertici del percorso, come matrice, matrice mascherata o sequenza di coppie. I valori mascherati, se presenti, verranno convertiti in NaN, che vengono quindi gestiti correttamente da Agg PathIterator e altri consumatori di dati di percorso, ad esempio iter_segments().

codici tipo array o Nessuno, facoltativo

Matrice di numeri interi di lunghezza N che rappresenta i codici del percorso. Se non è Nessuno, i codici devono avere la stessa lunghezza dei vertici. Se None, i vertici verranno trattati come una serie di segmenti di linea.

_interpolation_steps int, facoltativo

Utilizzato come suggerimento per alcune proiezioni, come Polar, che questo percorso dovrebbe essere interpolato linearmente immediatamente prima del disegno. Questo attributo è principalmente un dettaglio di implementazione e non è destinato all'uso pubblico.

bool chiuso , facoltativo

Se codici è None e closed è True, i vertici verranno trattati come segmenti di linea di un poligono chiuso. Si noti che l'ultimo vertice verrà quindi ignorato (poiché il codice corrispondente verrà impostato su CLOSEPOLY).

readonly bool, facoltativo

Fa in modo che il percorso si comporti in modo immutabile e imposta i vertici e i codici come array di sola lettura.

CLOSEPOLIO = 79 #
CURVA3 = 3 #
CURVA4 = 4 #
LINETO = 2 #
SPOSTA A = 1 #
NUM_VERTICES_FOR_CODE = {0: 1, 1: 1, 2: 1, 3: 2, 4: 3, 79: 1} #

Un dizionario che esegue il mapping dei codici Path al numero di vertici previsti dal codice.

FERMATI = 0 #
classmethod arc ( theta1 , theta2 , n = None , is_wedge = False ) [fonte] #

Restituisce a Pathper l'arco di circonferenza unitario dagli angoli theta1 a theta2 (in gradi).

theta2 viene scartato per produrre l'arco più corto entro 360 gradi. Cioè, se theta2 > theta1 + 360, l'arco andrà da theta1 a theta2 - 360 e non un cerchio completo più qualche sovrapposizione extra.

Se viene fornito n , è il numero di segmenti di spline da realizzare. Se n non viene fornito, il numero di segmenti spline viene determinato in base al delta tra theta1 e theta2 .

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

Restituisce a Pathche rappresenta un cerchio di raggio e centro dati.

Parametri :
center (float, float), predefinito: (0, 0)

Il centro del cerchio.

raggio mobile, predefinito: 1

Il raggio del cerchio.

sola lettura bool

Se il percorso creato deve avere l'argomento "sola lettura" impostato durante la creazione dell'istanza Path.

Appunti

Il cerchio viene approssimato utilizzando 8 curve di Bezier cubiche, come descritto in

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

Restituisce un nuovo percorso con vertici e codici puliti in base ai parametri.

Guarda anche

Path.iter_segments

per i dettagli sugli argomenti delle parole chiave.

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

Aggancia il percorso al riquadro di delimitazione specificato.

Il percorso deve essere costituito da uno o più poligoni chiusi. Questo algoritmo non si comporterà correttamente per i percorsi non chiusi.

Se all'interno è True, agganciare all'interno della scatola, altrimenti all'esterno della scatola.

tipo_codice #

alias diuint8

codici proprietà #

L'elenco dei codici in Pathun array numpy 1D. Ogni codice è uno tra STOP, MOVETO, LINETO, CURVE3o . Per i codici che corrispondono a più di un vertice ( e ), tale codice verrà ripetuto in modo che la lunghezza di e sia sempre la stessa.CURVE4CLOSEPOLYCURVE3CURVE4verticescodes

contiene_percorso ( percorso , trasformazione = Nessuno ) [fonte] #

Restituisce se questo percorso (chiuso) contiene completamente il percorso specificato.

Se transform non è None, il percorso verrà trasformato prima di verificare il contenimento.

contiene_punto ( punto , trasformazione = Nessuno , raggio = 0.0 ) [fonte] #

Restituisce se l'area racchiusa dal percorso contiene il punto specificato.

Il percorso è sempre considerato chiuso; cioè se l'ultimo codice non è CLOSEPOLY si assume un segmento implicito che collega l'ultimo vertice al primo vertice.

Parametri :
punto (float, float)

Il punto (x, y) da controllare.

trasformare matplotlib.transforms.Transform, facoltativo

In caso contrario None, il punto verrà confrontato con selftrasformato per trasformata ; cioè per un controllo corretto, transform dovrebbe trasformare il percorso nel sistema di coordinate del punto .

raggio mobile, predefinito: 0

Aggiungi un ulteriore margine sul percorso nelle coordinate del punto . Il percorso viene esteso tangenzialmente di raggio/2 ; ad esempio, se disegnassi il percorso con una larghezza di linea di radius , tutti i punti sulla linea sarebbero comunque considerati contenuti nell'area. Al contrario, i valori negativi restringono l'area: i punti sulla linea immaginaria saranno considerati al di fuori dell'area.

Resi :
bool

Appunti

L'attuale algoritmo ha alcune limitazioni:

  • Il risultato è indefinito per i punti esattamente al confine (cioè al percorso spostato di raggio/2 ).

  • Il risultato è indefinito se non c'è un'area chiusa, cioè tutti i vertici sono su una linea retta.

  • Se le linee di delimitazione iniziano a incrociarsi a causa dello spostamento del raggio , non è garantito che il risultato sia corretto.

contiene_punti ( punti , trasformazione = Nessuno , raggio = 0.0 ) [fonte] #

Restituisce se l'area racchiusa dal percorso contiene i punti dati.

Il percorso è sempre considerato chiuso; cioè se l'ultimo codice non è CLOSEPOLY si assume un segmento implicito che collega l'ultimo vertice al primo vertice.

Parametri :
matrice di punti (N, 2).

I punti da controllare. Le colonne contengono valori x e y.

trasformare matplotlib.transforms.Transform, facoltativo

In caso contrario None, i punti verranno confrontati con selftrasformati per trasformata ; cioè per un controllo corretto, transform dovrebbe trasformare il percorso nel sistema di coordinate dei punti .

raggio mobile, predefinito: 0

Aggiungi un ulteriore margine sul percorso in coordinate di punti . Il percorso viene esteso tangenzialmente di raggio/2 ; ad esempio, se disegnassi il percorso con una larghezza di linea di radius , tutti i punti sulla linea sarebbero comunque considerati contenuti nell'area. Al contrario, i valori negativi restringono l'area: i punti sulla linea immaginaria saranno considerati al di fuori dell'area.

Resi :
lunghezza-N matrice booleana

Appunti

L'attuale algoritmo ha alcune limitazioni:

  • Il risultato è indefinito per i punti esattamente al confine (cioè al percorso spostato di raggio/2 ).

  • Il risultato è indefinito se non c'è un'area chiusa, cioè tutti i vertici sono su una linea retta.

  • Se le linee di delimitazione iniziano a incrociarsi a causa dello spostamento del raggio , non è garantito che il risultato sia corretto.

copia ( ) [fonte] #

Restituisce una copia superficiale di Path, che condividerà i vertici e i codici con la sorgente Path.

deepcopy ( memo = Nessuno ) [fonte] #

Restituisci una copia profonda del file Path. Il Pathnon sarà di sola lettura, anche se la fonte lo Pathè.

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

Ottieni Bbox del percorso.

Parametri :
trasformare matplotlib.transforms.Transform, facoltativo

Trasforma da applicare al percorso prima di calcolare le estensioni, se presenti.

**kwargs

Inoltrato a iter_bezier.

Resi :
matplotlib.transforms.Bbox

Le estensioni del percorso Bbox([[xmin, ymin], [xmax, ymax]])

tratteggio statico ( tratteggio , densità = 6 ) [fonte] #

Dato un identificatore di tratteggio, hatchpattern , genera un Path che può essere utilizzato in un modello di tratteggio ripetuto. densità è il numero di linee per unità di quadrato.

interpolato ( passi ) [fonte] #

Restituisce un nuovo percorso ricampionato alla lunghezza N x passaggi.

I codici diversi da LINETO non vengono gestiti correttamente.

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

Restituisce se questo percorso interseca un dato Bbox.

Se filled è True, anche questo restituisce True se il percorso racchiude completamente Bbox(cioè, il percorso viene trattato come riempito).

Il riquadro di delimitazione è sempre considerato pieno.

intersects_path ( altro , riempito = True ) [fonte] #

Restituisce se questo percorso interseca un altro dato percorso.

Se filled è True, anche questo restituisce True se un percorso racchiude completamente l'altro (cioè, i percorsi sono trattati come pieni).

iter_bezier ( ** kwargs ) [fonte] #

Itera su ogni curva di bezier (linee incluse) in un percorso.

Parametri :
**kwargs

Inoltrato a iter_segments.

Rendimenti :
B matplotlib.bezier.BezierSegment

Le curve di bezier che compongono il percorso corrente. Si noti in particolare che i punti indipendenti sono curve di bezier di ordine 0 e le linee sono curve di bezier di ordine 1 (con due punti di controllo).

codice Percorso.codice_tipo

Il codice che descrive quale tipo di curva viene restituita. Path.MOVETO, Path.LINETO, Path.CURVE3, Path.CURVE4 corrispondono a curve di bezier con 1, 2, 3 e 4 punti di controllo (rispettivamente). Path.CLOSEPOLY è un Path.LINETO con i punti di controllo scelti correttamente in base ai punti di inizio/fine del tratto corrente.

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

Itera su tutti i segmenti di curva nel percorso.

Ogni iterazione restituisce un pair , dove è una sequenza di 1-3 coppie di coordinate ed è un codice.(vertices, code)verticescodePath

Inoltre, questo metodo può fornire una serie di ripuliture e conversioni standard al percorso.

Parametri :
trasformare Nessuno oTransform

In caso contrario, la trasformazione affine data verrà applicata al percorso.

remove_nans bool, facoltativo

Se rimuovere tutti i NaN dal percorso e ignorarli utilizzando i comandi MOVETO.

clip Nessuno o (float, float, float, float), facoltativo

Se non è None, deve essere una quattro tupla (x1, y1, x2, y2) che definisce un rettangolo in cui ritagliare il tracciato.

snap Nessuno o bool, facoltativo

Se True, aggancia tutti i nodi ai pixel; se false, non scattarle. Se Nessuno, esegue lo snap se il percorso contiene solo segmenti paralleli agli assi x o y e non più di 1024 di essi.

stroke_width float, facoltativo

La larghezza del tratto disegnato (utilizzato per l'aggancio al percorso).

semplificare None o bool, facoltativo

Se semplificare il percorso rimuovendo i vertici che non ne influenzano l'aspetto. Se None, utilizzare l' should_simplifyattributo. Vedere anche rcParams["path.simplify"](predefinito: True) e rcParams["path.simplify_threshold"](predefinito: 0.111111111111).

curve bool, facoltativo

Se True, i segmenti di curva verranno restituiti come segmenti di curva. Se False, tutte le curve verranno convertite in segmenti di linea.

schizzo Nessuno o sequenza, facoltativo

Se diverso da Nessuno, deve essere una tupla tripla della forma (scala, lunghezza, casualità), che rappresenta i parametri dello schizzo.

classmethod make_compound_path ( * args ) [fonte] #

Crea un percorso composto da un elenco di Pathoggetti. Rimuove alla cieca tutti Path.STOPi punti di controllo.

metodo di classe make_compound_path_from_polys ( XY ) [ fonte] #

Crea un oggetto tracciato composto per disegnare un numero di poligoni con un numero uguale di lati XY è un array di vertici (numpolys x numsides x 2). L'oggetto restituito è un file Path.

( Codice sorgente , png )

../_images/histogram_path_00_00.png
proprietà sola lettura #

Truese Pathè di sola lettura.

proprietà dovrebbe_semplificare #

Truese l'array dei vertici deve essere semplificato.

proprietà semplifica_soglia #

La frazione di una differenza di pixel al di sotto della quale i vertici verranno semplificati.

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

Converti questo percorso in un elenco di poligoni o polilinee. Ogni poligono/polilinea è un array Nx2 di vertici. In altre parole, ogni poligono non ha MOVETOistruzioni o curve. Questo è utile per la visualizzazione in backend che non supportano percorsi composti o curve di Bezier.

Se la larghezza e l' altezza sono entrambe diverse da zero, le linee verranno semplificate in modo che i vertici al di fuori di (0, 0), (larghezza, altezza) vengano tagliati.

Se closed_only è True(predefinito), verranno restituiti solo i poligoni chiusi, con l'ultimo punto uguale al primo punto. Eventuali polilinee non chiuse nel percorso verranno chiuse in modo esplicito. Se closed_only è False, tutti i poligoni non chiusi nel percorso verranno restituiti come poligoni non chiusi e i poligoni chiusi verranno restituiti esplicitamente chiusi impostando l'ultimo punto sullo stesso valore del primo punto.

trasformato ( trasformare ) [fonte] #

Restituisce una copia trasformata del percorso.

Guarda anche

matplotlib.transforms.TransformedPath

Una classe di percorso specializzata che memorizzerà nella cache il risultato trasformato e si aggiornerà automaticamente quando la trasformazione cambia.

classmethod unit_circle ( ) [fonte] #

Restituisce la sola lettura Pathdella circonferenza unitaria.

Per la maggior parte dei casi, Path.circle()sarà quello che vuoi.

classmethod unit_circle_righthalf ( ) [fonte] #

Restituisce a Pathdella metà destra di un cerchio unitario.

Vedere Path.circleper il riferimento sull'approssimazione utilizzata.

classmethod unit_rectangle ( ) [fonte] #

Restituisce Pathun'istanza del rettangolo unitario da (0, 0) a (1, 1).

classmethod unit_regular_asterisk ( numVertici ) [fonte] #

Restituisce a Pathper un asterisco regolare unitario con il dato numVertices e il raggio di 1.0, centrato su (0, 0).

classmethod unit_regular_polygon ( numVertici ) [fonte] #

Restituisce Pathun'istanza per un poligono regolare unitario con il dato numVertices tale che il cerchio circoscritto abbia raggio 1.0, centrato su (0, 0).

classmethod unit_regular_star ( numVertici , innerCircle = 0.5 ) [fonte] #

Restituisce a Pathper una stella regolare unitaria con il dato numVertices e il raggio di 1.0, centrato su (0, 0).

proprietà vertici #

L'elenco dei vertici in Pathun array numpy Nx2.

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

Restituisce a Pathper il cuneo del cerchio unitario dagli angoli theta1 a theta2 (in gradi).

theta2 viene scartato per produrre il cuneo più corto entro 360 gradi. Cioè, se theta2 > theta1 + 360, il cuneo sarà da theta1 a theta2 - 360 e non un cerchio completo più qualche sovrapposizione extra.

Se viene fornito n , è il numero di segmenti di spline da realizzare. Se n non viene fornito, il numero di segmenti spline viene determinato in base al delta tra theta1 e theta2 .

Vedere Path.arcper il riferimento sull'approssimazione utilizzata.

matplotlib.percorso. get_path_collection_extents ( master_transform , percorsi , trasformazioni , offset , offset_transform ) [fonte] #

Data una sequenza di Paths, Transforms oggetti e offset, come trovato in a PathCollection, restituisce il riquadro di delimitazione che li incapsula tutti.

Parametri :
master_transformTransform

Trasformazione globale applicata a tutti i percorsi.

elenco percorsi diPath
trasforma l' elenco diAffine2D
offset (N, 2) come un array
offset_transformAffine2D

Trasformazione applicata agli offset prima dell'offset del percorso.

Appunti

Il modo in cui i percorsi , le trasformazioni e gli offset sono combinati segue lo stesso metodo delle raccolte: ognuno viene iterato in modo indipendente, quindi se hai 3 percorsi, 2 trasformazioni e 1 offset, le loro combinazioni sono le seguenti:

(LA, LA, LA), (SI, SI, LA), (DO, LA, LA)