patch — Create filled polygon patch graphics from coordinate data or Faces/Vertices definitions.

patch creates filled polygon graphics objects from coordinate arrays, faces/vertices inputs, or name-value property forms, with MATLAB-compatible plotting-handle behavior.

Syntax

h = patch(X, Y, C)
h = patch(X, Y, Z)
h = patch(X, Y, Z, C)
h = patch(S)
h = patch('Faces', F, 'Vertices', V, ...)
h = patch(ax, ...)

Inputs

Returns

Errors

How patch works

• Vector coordinate inputs create one polygon.
• Matrix coordinate inputs create one polygon per column.
• Patch edges close automatically, matching MATLAB's open-polygon behavior.
• Faces values are interpreted as MATLAB-style one-based vertex indices.
• 2-D vertices are accepted as N-by-2; 3-D vertices are accepted as N-by-3.
• The returned value is a patch graphics handle that works with get, set, ishandle, and isgraphics.
• Per-vertex or per-face CData colormap interpolation is not yet implemented; non-scalar color data is accepted only as compatibility input and currently falls back to the default face color unless FaceColor supplies a concrete RGB/color-name value.

Options

• FaceColor accepts color names, RGB triples, flat, or none.
• EdgeColor accepts color names, RGB triples, or none.
• FaceAlpha and EdgeAlpha accept numeric values from 0 to 1.
• LineWidth, DisplayName, and Visible use the shared plotting property model.
• FaceColor, EdgeColor, alpha, line width, display name, visibility, Faces, Vertices, XData, YData, and ZData are the first supported patch property set. Lighting, normals, texture coordinates, and callback properties are deferred.

Does RunMat run patch on the GPU?

Patch rendering is a plotting sink and fusion barrier.

Host and gathered-GPU inputs produce the same graphics object and handle behavior.

A future direct GPU path should preserve the same Faces/Vertices semantics and only replace the triangulation/packing step.

GPU memory and residency

patch gathers GPU-resident coordinate inputs in the first implementation because MATLAB-compatible patch parsing requires shape validation, one-based Faces handling, NaN padding, and polygon triangulation. The rendered geometry still flows through the shared GPU plotting renderer.

Examples

Create a triangle patch

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

Create two rectangle patches from matrix columns

X = [0 2; 1 3; 1 3; 0 2];
Y = [0 0; 0 0; 1 1; 1 1];
patch(X, Y, 'cyan', 'EdgeColor', 'black');

Create a patch from Faces and Vertices

V = [0 0; 1 0; 1 1; 0 1];
F = [1 2 3 4];
h = patch('Faces', F, 'Vertices', V, 'FaceColor', [0.2 0.6 0.9]);
get(h, 'Type')

Expected output:

ans =
    'patch'

Create a 3-D patch

V = [0 0 0; 1 0 0; 0.5 1 0.5];
F = [1 2 3];
patch('Faces', F, 'Vertices', V, 'FaceAlpha', 0.6);
view(3);

Using patch with coding agents

Open a RunMat example with live inputs, then ask the agent to explain how patch changes the result.

FAQ

Related Plotting functions

More plotting resources

• Graphics Handles
• Plot replay and export

Open-source implementation

Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how patch is executed, line by line, in Rust.

• View the source for patch in Rust on GitHub
• Learn how the RunMat runtime works
• Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code blazing on any GPU. It is licensed under the Apache 2.0 license.

• RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed. Simulations that took hours now take minutes.
• Start running code in seconds. RunMat runs in the browser, on the desktop, or from the CLI. No license server, no IT ticket.

Getting started · Benchmarks · Pricing