patch

Crear parches de polígonos de colores

Sintaxis

patch(X,Y,C)

patch(X,Y,Z,C)

patch('XData',X,'YData',Y)

patch('XData',X,'YData',Y,'ZData',Z)

patch('Faces',F,'Vertices',V)

patch(S)

patch(___,Name,Value)

patch(ax,___)

p = patch(___)

Descripción

patch(X,Y,C) crea uno o varios parches de polígonos de colores especificando X e Y como coordenadas para cada vértice. patch conecta los vértices en el orden en el que se especifican. Para crear un parche, especifique X e Y como vectores. Para crear varios polígonos, especifique X e Y como matrices donde cada columna corresponde a un polígono diferente. C determina los colores del parche.

patch(X,Y,Z,C) crea los polígonos en coordenadas 3D utilizando X, Y y Z. Para ver los polígonos en una vista 3D, use el comando view(3). C determina el color.

patch('XData',X,'YData',Y) es similar a patch(X,Y,C), excepto que no es necesario especificar datos de color para las coordenadas 2D.

patch('XData',X,'YData',Y,'ZData',Z) es similar a patch(X,Y,Z,C), excepto que no es necesario especificar datos de color.

Nota

Cuando especifica datos mediante los argumentos nombre-valor 'XData', 'YData' o 'ZData', los datos deben ser de tipo numérico, como double, single o un tipo entero. Para especificar datos categorical, datetime o duration, utilice los argumentos X, Y y Z.

patch('Faces',F,'Vertices',V) crea uno o varios polígonos donde V especifica valores de vértice y F define qué vértices conectar. Especificar solo vértices únicos y su matriz de conexión puede reducir el tamaño de los datos cuando existen muchos polígonos. Especifique un vértice por fila en V. Para crear un polígono, especifique F como vector. Para crear varios polígonos, especifique F como matriz con una fila por polígono. No es necesario que cada cara tenga el mismo número de vértices. Para especificar distintos números de vértices, rellene F con valores NaN.

patch(S) crea uno o varios polígonos utilizando la estructura S. Los nombres de campo de estructura son los nombres de las propiedades del parche y los valores de campo son los valores de las propiedades. Por ejemplo, S puede contener los campos Faces y Vertices.

patch(___,Name,Value) crea polígonos y especifica una o varias propiedades de parche utilizando argumentos de par nombre-valor. Un parche es el objeto que contiene los datos de todos los polígonos creados. Puede especificar propiedades de parche con cualquiera de las combinaciones de argumentos de entrada de las sintaxis anteriores. Por ejemplo, 'LineWidth',2 establece el ancho de contorno de todos los polígonos en 2 puntos.

patch(ax,___) dibuja el parche en los ejes especificados por ax en lugar de en los ejes actuales (gca). La opción ax puede preceder a cualquiera de las combinaciones de argumentos de entrada de las sintaxis anteriores.

p = patch(___) devuelve el objeto de parche que contiene los datos de todos los polígonos. Utilice p para consultar y modificar las propiedades del objeto de parche después de crearlo. Para obtener una lista de las propiedades y las descripciones, consulte Patch Properties.

Ejemplos

Especificar coordenadas

Cree un único polígono especificando las coordenadas (x,y) de cada vértice. Luego, añada dos polígonos más a la figura.

Cree un cuadrado rojo con vértices en (0,0), (1,0), (1,1) y (0,1). Especifique x como coordenadas x de los vértices e y como coordenadas y. patch conecta automáticamente la última coordenada (x,y) con la primera coordenada (x,y).

x = [0 1 1 0];
y = [0 0 1 1];
patch(x,y,'red')

Cree dos polígonos especificando x e y como matrices de dos columnas. Cada columna define las coordenadas para uno de los polígonos. patch añade los polígonos a los ejes actuales sin borrar los ejes.

x2 = [2 5; 2 5; 8 8];
y2 = [4 0; 8 2; 4 0];
patch(x2,y2,'green')

Especificar coordenadas categóricas y de duración

Defina X como vector de valores categóricos y defina Y como vector de valores de duración. La función patch utiliza una lista ordenada de categorías, por lo que es posible que el eje x las muestre en un orden distinto al que esperaba. Para especificar el orden, llame a la función reordercats. Luego, cree un parche rojo para visualizar los datos.

X = categorical({'Freezing','Cold','Warm','Hot','Boiling','Boiling','Freezing'});
X = reordercats(X,{'Freezing','Cold','Warm','Hot','Boiling'});
Y = minutes([0 15 20 47 50 0 0]);
patch(X,Y,'red')

Especificar caras y vértices

Cree un único polígono especificando las coordenadas de cada vértice único y una matriz que defina cómo conectarlos. Luego, añada dos polígonos más a la figura.

Cree un cuadrado rojo con esquinas en (0,0), (1,0), (1,1) y (0,1). Especifique v de forma que cada fila defina las coordenadas (x,y) de un vértice. Después, especifique f como los vértices que se desea conectar. Establezca el color especificando la propiedad FaceColor.

v = [0 0; 1 0; 1 1; 0 1];
f = [1 2 3 4];
patch('Faces',f,'Vertices',v,'FaceColor','red')

Cree dos polígonos especificando f como matriz de dos filas. Cada fila define la cara de un parche.

v2 = [2 4; 2 8; 8 4; 5 0; 5 2; 8 0];
f2 = [1 2 3; 
    4 5 6];
patch('Faces',f2,'Vertices',v2,'FaceColor','green')

Diferentes colores de cara de los polígonos

Cree dos polígonos y utilice un color diferente para cada cara de los polígonos. Utilice una barra de colores para mostrar cómo los colores se asignan al mapa de colores.

Cree los polígonos utilizando las matrices x e y. Especifique c como vector columna con dos elementos, dado que existen dos caras de polígonos, y añada una barra de colores.

x = [2 5; 2 5; 8 8];
y = [4 0; 8 2; 4 0];
c = [0; 1];
figure
patch(x,y,c)
colorbar

Alternativamente, puede obtener el mismo resultado utilizando f y v en su lugar. Cuando cree los polígonos, establezca FaceVertexCData en un vector columna con dos elementos, dado que existen dos caras de polígonos. Establezca FaceColor en 'flat'.

v = [2 4; 2 8; 8 4; 5 0; 5 2; 8 0];
f = [1 2 3; 4 5 6];
col = [0; 1];
figure
patch('Faces',f,'Vertices',v,'FaceVertexCData',col,'FaceColor','flat');
colorbar

Colores de cara de polígonos interpolados

Interpole los colores en las caras de los polígonos especificando un color en cada vértice del polígono y utilice una barra de colores para mostrar cómo los colores se asignan al mapa de colores.

Cree los polígonos utilizando las matrices x e y. Especifique c como matriz del mismo tamaño que x e y definiendo un color por vértice, y añada una barra de colores.

x = [2 5; 2 5; 8 8];
y = [4 0; 8 2; 4 0];
c = [0 3; 6 4; 4 6];
figure
patch(x,y,c)
colorbar

Alternativamente, puede obtener el mismo resultado utilizando f y v en su lugar. Cuando cree los polígonos, establezca FaceVertexCData en un vector columna con un valor por vértice y establezca FaceColor en 'interp'.

v = [2 4; 2 8; 8 4; 5 0; 5 2; 8 0];
f = [1 2 3; 4 5 6];
col = [0; 6; 4; 3; 4; 6];
figure
patch('Faces',f,'Vertices',v,'FaceVertexCData',col,'FaceColor','interp');
colorbar

Aristas de polígonos sin caras

Cree un polígono con aristas verdes y no muestre la cara. Luego, cree un segundo polígono con un color diferente para cada arista.

v = [0 0; 1 0; 1 1];
f = [1 2 3];
figure
patch('Faces',f,'Vertices',v,...
    'EdgeColor','green','FaceColor','none','LineWidth',2);

Utilice un color diferente para cada arista especificando un color para cada vértice y estableciendo EdgeColor en 'flat'.

v = [2 0; 3 0; 3 1];
f = [1 2 3];
c = [1 0 0; % red
    0 1 0; % green
    0 0 1]; % blue
patch('Faces',f,'Vertices',v,'FaceVertexCData',c,...
    'EdgeColor','flat','FaceColor','none','LineWidth',2);

Polígonos que utilizan una estructura

Utilice una estructura para crear dos polígonos. Primero, cree una estructura con nombres de campos que coincidan con los nombres de las propiedades del parche. Después, utilice la estructura para crear los polígonos.

clear S
S.Vertices = [2 4; 2 8; 8 4; 5 0; 5 2; 8 0];
S.Faces = [1 2 3; 4 5 6];
S.FaceVertexCData = [0; 1];
S.FaceColor = 'flat';
S.EdgeColor = 'red';
S.LineWidth = 2;
figure
patch(S)

Polígonos semitransparentes

Cree dos polígonos semitransparentes estableciendo la propiedad FaceAlpha en un valor entre 0 y 1.

v1 = [2 4; 2 8; 8 4];
f1 = [1 2 3];
figure
patch('Faces',f1,'Vertices',v1,'FaceColor','red','FaceAlpha',.3);

v2 = [2 4; 2 8; 8 8];
f2 = [1 2 3];
patch('Faces',f2,'Vertices',v2,'FaceColor','blue','FaceAlpha',.5);

Crear una línea multicolor

Cree una línea multicolor con marcadores en cada vértice. Interpole los colores y utilice una barra de colores para mostrar cómo los valores se asignan al mapa de colores.

Cree los datos. Establezca la última entrada y en NaN de forma que la función patch cree una línea en vez de un polígono cerrado. Defina un color para cada vértice utilizando los valores y. Los valores de c se asignan a colores del mapa de colores.

x = linspace(1,10,15);
y = sin(x);
y(end) = NaN;
c = y;

Cree la línea. Muestre los marcadores de cada vértice y establezca EdgeColor en 'interp' para interpolar los colores entre los vértices. Añada una barra de colores.

figure
patch(x,y,c,'EdgeColor','interp','Marker','o','MarkerFaceColor','flat');
colorbar;

Argumentos de entrada

X — Coordenadas x de los vértices

vector | matriz

Coordenadas x de los vértices, especificadas de una de las siguientes formas:

• Vector: crea un polígono.

• Matriz: crea n polígonos con m vértices cada uno, donde [m,n] = size(X). Cada columna de la matriz se corresponde con un polígono.

Si los datos no definen polígonos cerrados, patch cierra los polígonos. Si las aristas de un polígono individual se cruzan entre sí, es posible que los polígonos resultantes estén parcialmente rellenos. En ese caso, es mejor dividir el objeto de parche en polígonos más pequeños.

Si especifica X, la función patch establece la propiedad XData del objeto de parche en el mismo valor. El objeto de parche calcula automáticamente los datos de cara y vértice y establece las propiedades Faces y Vertices en los valores adecuados.

Tipos de datos: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | categorical | datetime | duration

Y — Coordenadas y de los vértices

vector | matriz

Coordenadas y de los vértices, especificadas de una de las siguientes formas:

• Vector: crea un polígono.

• Matriz: crea n polígonos con m vértices cada uno, donde [m,n] = size(Y). Cada columna de la matriz se corresponde con un polígono.

Si los datos no definen polígonos cerrados, patch cierra los polígonos. Si las aristas de un polígono individual se cruzan entre sí, es posible que los polígonos resultantes estén parcialmente rellenos. En ese caso, es mejor dividir el objeto de parche en polígonos más pequeños.

Si especifica Y, la función patch establece la propiedad YData del objeto de parche en el mismo valor. El objeto de parche calcula automáticamente los datos de cara y vértice y establece las propiedades Faces y Vertices en los valores adecuados.

Tipos de datos: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | categorical | datetime | duration

Z — Coordenadas z de los vértices

vector | matriz

Coordenadas z de los vértices, especificadas de una de las siguientes formas:

• Vector: crea un polígono.

• Matriz: crea m polígonos con n vértices cada uno, donde [m,n] = size(Z). Cada columna de la matriz se corresponde con un polígono.

Si especifica Z, la función patch establece la propiedad ZData del objeto de parche en el mismo valor. El objeto de parche calcula automáticamente los datos de cara y vértice y establece las propiedades Faces y Vertices en los valores adecuados.

Tipos de datos: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | categorical | datetime | duration

C — Colores de polígonos

escalar | vector | matriz | Triplete RGB | 'r' | 'g' | 'b' | ...

Colores de polígonos, especificados como escalar, vector, matriz o nombre de color. El formato de la entrada determina si todos los polígonos tienen el mismo color, un color por cara o colores de cara interpolados.

Efecto deseado	Utilizar uno de estos formatos	Resultados
Un único color para todas las caras	Nombre del color, por ejemplo, 'r' para rojo. Triplete RGB, por ejemplo, [0 .5 .5]. Valor escalar, por ejemplo, 2. La propiedad CDataMapping determina cómo se asigna el valor al mapa de colores. Para ver un ejemplo, consulte Especificar coordenadas.	Establece la propiedad FaceColor en el color especificado.
Un color por cara	Vector de n por 1 de colores del mapa de colores, donde n es el número de caras. La propiedad CDataMapping determina cómo se asignan los valores al mapa de colores. Arreglo de n por 1 por 3 de valores RGB. La primera página del arreglo define los componentes rojos de los colores, la segunda página define los azules y la tercera página define los verdes. Para ver un ejemplo, consulte Diferentes colores de cara de los polígonos.	Establece la propiedad FaceColor en 'flat'. Establece las propiedades CData y FaceVertexCData utilizando los valores de color especificados.
Colores de cara interpolados	Matriz de m por n de valores del mapa de colores, donde [m,n] = size(X). Especifique un color por vértice. Arreglo de m por n por 3 de valores RGB. Para ver un ejemplo, consulte Colores de cara de polígonos interpolados.	Establece la propiedad FaceColor en 'interp'. Establece las propiedades CData y FaceVertexCData utilizando los valores de color especificados.

Un triplete RGB es un vector fila de tres elementos, cuyos elementos especifican las intensidades de los componentes rojo, verde y azul del color. Las intensidades deben estar en el rango [0,1]; por ejemplo, [0.4 0.6 0.7]. Como alternativa, puede especificar algunos colores frecuentes por su nombre. Esta tabla enumera las opciones de nombre largo y corto de los colores y los valores equivalentes del triplete RGB.

Opción	Descripción	Triplete RGB equivalente
'red' o 'r'	Rojo	[1 0 0]
'green' o 'g'	Verde	[0 1 0]
'blue' o 'b'	Azul	[0 0 1]
'yellow' o 'y'	Amarillo	[1 1 0]
'magenta' o 'm'	Magenta	[1 0 1]
'cyan' o 'c'	Cian	[0 1 1]
'white' o 'w'	Blanco	[1 1 1]
'black' o 'k'	Negro	[0 0 0]

V — Vértices de polígonos

matriz de dos columnas o tres columnas

Vértices de polígonos, especificados de una de las siguientes formas:

• Matriz de dos columnas: cada fila contiene las coordenadas (x,y) de un vértice.

• Matriz de tres columnas: cada fila contiene las coordenadas (x,y,Z) de un vértice.

Especifique solo vértices únicos. Puede hacer referencia a un vértice más de una vez cuando especifique las definiciones de caras en F.

Si especifica V, la función patch establece la propiedad Vertices del objeto de parche en el mismo valor. El objeto de parche calcula automáticamente los datos de coordenadas y establece XData, YData y ZData en los valores adecuados.

Tipos de datos: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

F — Definiciones de caras

vector fila | matriz

Definiciones de caras, especificadas de una de las siguientes formas:

• Vector fila: crea un único polígono.

• Matriz: crea varios polígonos, donde cada fila corresponde a un polígono.

Por ejemplo, este código define tres vértices en V y crea un polígono conectando el vértice 1 al 2, el 2 al 3 y el 3 al 1.

V = [1 1; 2 1; 2 2];
F = [1 2 3 1];
patch('Faces',F,'Vertices',V)

Si especifica F, la función patch establece la propiedad Faces del objeto de parche en el mismo valor. El objeto de parche calcula automáticamente los datos de coordenadas y establece XData, YData y ZData en los valores adecuados.

Tipos de datos: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

S — Definición de parche

estructura

Definición de parche, especificada como estructura con campos que corresponden a nombres de propiedades de parche y valores de campo que corresponden a valores de propiedades de parche.

ax — Ejes en los que representar

objeto Axes | objeto PolarAxes

Ejes en los que representar, especificados como un objeto Axes o PolarAxes. Si no especifica los ejes, patch representa en los ejes actuales o crea un objeto Axes (ejes cartesianos).

Argumentos de par nombre-valor

Especifique pares opcionales de argumentos como Name1=Value1,...,NameN=ValueN, donde Name es el nombre del argumento y Value es el valor correspondiente. Los argumentos nombre-valor deben aparecer después de otros argumentos, pero el orden de los pares no importa.

En las versiones anteriores a R2021a, utilice comas para separar cada nombre y valor, y encierre Name entre comillas.

Ejemplo: patch(x,y,c,'FaceAlpha',.5,'LineStyle',':') crea polígonos semitransparentes con aristas de puntos.

Las propiedades que se enumeran aquí son solo un subconjunto de propiedades de parches. Para obtener una lista completa, consulte Patch Properties.

FaceColor — Color de cara

'interp' | 'flat' | Triplete RGB | código de color hexadecimal | 'r' | 'g' | 'b' | ...

Color de cara, especificado como 'interp', 'flat', triplete RGB, código de color hexadecimal, nombre de color o nombre corto.

Para crear un color diferente para cada cara, especifique la propiedad CData o FaceVertexCData como un arreglo que contenga un color por cara o un color por vértice. Los colores pueden interpolarse a partir de los colores de los vértices circundantes de cada cara o pueden ser uniformes. Para obtener colores interpolados, especifique esta propiedad como 'interp'. Para obtener colores uniformes, especifique esta propiedad como 'flat'. Si especifica 'flat' y un color diferente para cada vértice, el color del primer vértice que especifica determina el color de cara.

Para designar un único color para todas las caras, especifique esta propiedad como triplete RGB, código de color hexadecimal, nombre de color o nombre corto.

• Un triplete RGB es un vector fila de tres elementos, cuyos elementos especifican las intensidades de los componentes rojo, verde y azul del color. Las intensidades deben estar en el rango [0,1]; por ejemplo, [0.4 0.6 0.7].

• Un código de color hexadecimal es un vector de caracteres o un escalar de cadena que comienza con el símbolo de almohadilla (#) seguido de tres o seis dígitos hexadecimales, que pueden oscilar entre 0 y F. Los valores no distinguen entre mayúsculas y minúsculas. Así, los códigos de color '#FF8800', '#ff8800', '#F80' y '#f80' son equivalentes.

Nombre del color	Nombre corto	Triplete RGB	Código de color hexadecimal	Apariencia
"red"	"r"	[1 0 0]	"#FF0000"
"green"	"g"	[0 1 0]	"#00FF00"
"blue"	"b"	[0 0 1]	"#0000FF"
"cyan"	"c"	[0 1 1]	"#00FFFF"
"magenta"	"m"	[1 0 1]	"#FF00FF"
"yellow"	"y"	[1 1 0]	"#FFFF00"
"black"	"k"	[0 0 0]	"#000000"
"white"	"w"	[1 1 1]	"#FFFFFF"
"none"	No se aplica	No se aplica	No se aplica	Sin color

En esta tabla, se enumeran las paletas de colores predeterminados para las gráficas en los temas claro y oscuro.

Paleta	Colores de la paleta
"gem": tema claro predeterminado Antes de R2025a: La mayoría de las gráficas utilizan estos colores de forma predeterminada.
"glow": tema oscuro predeterminado

Puede obtener los tripletes RGB y los códigos de color hexadecimales de estas paletas usando las funciones orderedcolors y rgb2hex. Por ejemplo, puede obtener los tripletes RGB de la paleta "gem" y convertirlos en códigos de color hexadecimales.

RGB = orderedcolors("gem");
H = rgb2hex(RGB);

Antes de R2023b: Obtenga los tripletes RGB usando RGB = get(groot,"FactoryAxesColorOrder").

Antes de R2024a: Obtenga los códigos de color hexadecimales usando H = compose("#%02X%02X%02X",round(RGB*255)).

FaceAlpha — Transparencia de cara

1 (predeterminado) | escalar en el intervalo [0,1] | 'flat' | 'interp'

Transparencia de cara, especificada como uno de estos valores:

• Escalar en el intervalo [0,1]: utiliza una transparencia uniforme en todas las caras. Un valor de 1 es totalmente opaco y 0 es totalmente transparente. Esta opción no utiliza los valores de transparencia en la propiedad FaceVertexAlphaData.

• 'flat': utiliza una transparencia diferente para cada cara según los valores en la propiedad FaceVertexAlphaData. En primer lugar, debe especificar la propiedad FaceVertexAlphaData como vector que contenga un valor de transparencia por cara o vértice. El valor de transparencia del primer vértice determina la transparencia de toda la cara.

• 'interp': utilice transparencia interpolada para cada cara según los valores de la propiedad FaceVertexAlphaData. En primer lugar, debe especificar la propiedad FaceVertexAlphaData como vector que contenga un valor de transparencia por vértice. La transparencia varía en cada cara interpolando los valores en los vértices.

EdgeColor — Colores de arista

'none' | 'flat' | 'interp' | Triplete RGB | código de color hexadecimal | 'r' | 'g' | 'b' | ...

Colores de arista, especificados como uno de los valores de esta tabla. El color de arista predeterminado es negro con un valor de [0 0 0]. Si varios polígonos comparten una arista, el primer polígono dibujado controla el color de arista mostrado.

Valor	Descripción	Resultado
Triplete RGB, código de color hexadecimal o nombre del color	Un único color para todas las aristas. Para obtener más información, consulte la siguiente tabla.
'flat'	Un color diferente para cada arista. Utilice los colores de los vértices para establecer el color de la arista que los sigue. Primero debe especificar CData o FaceVertexCData como arreglo que contenga un color por vértice. El color de la arista depende del orden en el que se especifican los vértices.
'interp'	Color de arista interpolado. Primero debe especificar CData o FaceVertexCData como arreglo que contenga un color por vértice. Determine el color de una arista interpolando linealmente los valores de los dos vértices delimitadores.
'none'	No se muestran aristas.	No se muestran aristas.

Los tripletes RGB y los códigos de color hexadecimales son útiles para especificar colores personalizados.

• Un triplete RGB es un vector fila de tres elementos, cuyos elementos especifican las intensidades de los componentes rojo, verde y azul del color. Las intensidades deben estar en el rango [0,1]; por ejemplo, [0.4 0.6 0.7].

• Un código de color hexadecimal es un vector de caracteres o un escalar de cadena que comienza con el símbolo de almohadilla (#) seguido de tres o seis dígitos hexadecimales, que pueden oscilar entre 0 y F. Los valores no distinguen entre mayúsculas y minúsculas. Así, los códigos de color "#FF8800", "#ff8800", "#F80" y "#f80" son equivalentes.

Como alternativa, puede especificar algunos colores frecuentes por su nombre. En esta tabla se enumeran las opciones de color con su nombre, los tripletes RGB equivalentes y los códigos de color hexadecimales.

Nombre del color	Nombre corto	Triplete RGB	Código de color hexadecimal	Apariencia
"red"	"r"	[1 0 0]	"#FF0000"
"green"	"g"	[0 1 0]	"#00FF00"
"blue"	"b"	[0 0 1]	"#0000FF"
"cyan"	"c"	[0 1 1]	"#00FFFF"
"magenta"	"m"	[1 0 1]	"#FF00FF"
"yellow"	"y"	[1 1 0]	"#FFFF00"
"black"	"k"	[0 0 0]	"#000000"
"white"	"w"	[1 1 1]	"#FFFFFF"

En esta tabla, se enumeran las paletas de colores predeterminados para las gráficas en los temas claro y oscuro.

Paleta	Colores de la paleta
"gem": tema claro predeterminado Antes de R2025a: La mayoría de las gráficas utilizan estos colores de forma predeterminada.
"glow": tema oscuro predeterminado

Puede obtener los tripletes RGB y los códigos de color hexadecimales de estas paletas usando las funciones orderedcolors y rgb2hex. Por ejemplo, puede obtener los tripletes RGB de la paleta "gem" y convertirlos en códigos de color hexadecimales.

RGB = orderedcolors("gem");
H = rgb2hex(RGB);

Antes de R2023b: Obtenga los tripletes RGB usando RGB = get(groot,"FactoryAxesColorOrder").

Antes de R2024a: Obtenga los códigos de color hexadecimales usando H = compose("#%02X%02X%02X",round(RGB*255)).

LineStyle — Estilo de línea

"-" (predeterminado) | "--" | ":" | "-." | "none"

Estilo de línea, especificado como una de las opciones enumeradas en esta tabla.

Estilo de línea	Descripción	Línea resultante
"-"	Línea continua
"--"	Línea discontinua
":"	Línea de puntos
"-."	Línea de puntos y rayas
"none"	Sin línea	Sin línea

Argumentos de salida

p — objeto de parche

escalar

Objeto de parche, devuelto como escalar. Cada objeto de parche puede constar de uno o varios polígonos. Utilice p para consultar y cambiar las propiedades del objeto de parche después de crearlo.

Capacidades ampliadas

Arreglos GPU

Acelere código mediante la ejecución en una unidad de procesamiento gráfico (GPU) mediante Parallel Computing Toolbox™.

La función patch es compatible con entradas de arreglos de GPU con estas notas y limitaciones de uso:

• Esta función acepta arreglos de GPU, pero no se ejecuta en una GPU.

Para obtener más información, consulte Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Arreglos distribuidos

Realice particiones de arreglos grandes por toda la memoria combinada de su cluster mediante Parallel Computing Toolbox™.

La función patch es compatible con arreglos distribuidos con estas notas y limitaciones de uso:

• Esta función opera sobre arreglos distribuidos, pero se ejecuta en el cliente MATLAB^®.

Para obtener más información, consulte Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Historial de versiones

Introducido antes de R2006a

R2025a: Crear parches en coordenadas polares

Cree parches rellenos en coordenadas polares especificando un objeto PolarAxes como primer argumento para la función patch.

Consulte también

Funciones

• area | fill | fill3

Propiedades

• Patch Properties

Temas

• Multifaceted Patches
• Cómo se relacionan los datos de parches a un mapa de colores
• Diferencias entre los mapas de colores y el color real