surfc — Create composite surface-and-contour plots with MATLAB-compatible surfc behavior.
surfc combines a shaded surf-style surface with projected contour lines on the base plane. It supports MATLAB-compatible surface-family inputs and returns the primary surface handle.
Syntax
h = surfc(Z)
h = surfc(X, Y, Z)
h = surfc(Z, Name, Value, ...)
h = surfc(X, Y, Z, Name, Value, ...)Inputs
Z- Type
NumericArray- Required
- Yes
- Description
- Surface height grid.
X- Type
NumericArray- Required
- Yes
- Description
- X axis vector/meshgrid matrix matching Z columns.
Y- Type
NumericArray- Required
- Yes
- Description
- Y axis vector/meshgrid matrix matching Z rows.
props- Type
Any- Required
- Variadic
- Description
- Name/value surface style options.
Returns
h- Type
NumericScalar- Description
- Handle to the rendered surface plot (with contour overlay).
Errors
RunMat:surfc:InvalidArgument- When
- Surface/grid/axis inputs or style name/value arguments are invalid.
- Message
surfc: invalid argument
RunMat:surfc:Internal- When
- Internal surface/contour construction or render preparation fails unexpectedly.
- Message
surfc: internal operation failed
RunMat:plotting:TooManyOutputs- When
- More than one output is requested from a coordinate chart constructor.
- Message
plotting: too many output arguments
Behavior
surfc shares the same surface semantics as surf for the primary surface object.
The primary surface's XData, YData, and ZData retain native single, double, or integer class, exact values, and shape; surface rendering and projected-contour construction are explicit floating boundaries.
The returned handle is the surface handle for the composite result, while contour overlays are attached as the secondary composite plot content.
The contour overlay uses the same modern contour-generation path as contour, rather than a one-off composite implementation.
Colormap, colorbar, view, and subplot-local state all operate on the composite through the same shared axes metadata model.
GPU-aware execution applies to both the surface side and the contour side where supported.
Rendering and residency
surfc retains exact owner-aware source data for the primary surface while combining the shared floating rendering path with the modern contour path.
Declared source precision and class coverage
single
double
Coordinate broadcasting
none
Runtime contract and boundaries
Graphics results are host double handles; fill/fill3 may return a row of handles for independently created polygon columns/groups. Sphere instead supports zero through three requested outputs: statement form plots, while output forms return host double coordinate grids. Handle aliases, value-selected options and exact graphics receiver roles are resolved by Runtime, not guessed from scalar facts.
The existing numerical and geometry owners validate coordinates, integer controls, shapes and properties. Single/double and all eight integer source classes retain their native storage wherever the object has authoritative source properties; client geometry and renderer buffers are deliberate floating boundaries, not a promise of exact wide-integer pixel positions. There is no sparse/complex plotting implementation or numeric broadcasting promise here. Logical, scalar, vector, matrix, rank and empty admission follows each documented owner below rather than a universal coercion.
RuntimeOwned preparation retains the original BuiltinArguments through suspension and completion. Eligible direct GPU routes require the live owning provider, admitted precision/storage/shape, compatible exports and installed plotting device. NoAttempt means pre-effect inapplicability, not permission to swallow export, allocation, cancellation or emission errors. Existing provider errors are propagated and ingress errors are terminal Never replay. Source-property queries and figure persistence may require explicit owner-aware readback; surface property snapshots and quiver3/patch construction are not zero-copy routes.
Canonical UserInterface capability and host-callback effects reflect scene creation/presentation; function-sampling entries additionally declare Unknown effects for arbitrary user callbacks and require the Process execution stack. NativeAndWasm means the Runtime entry is portable, not that an absent graphics host is emulated. Portable Runtime linkage introduces no separate native numerical library artifact. Rendering is a fusion boundary and distributed execution is unsupported; no numeric provider kernel or fusion primitive is invented.
Chart scratch, metadata, retained render state and the sphere coordinate builder do not yet have complete finite host allocation ownership. The shared canonical HostAllocationReceipt policy guard refuses Managed work before extraction/gather/callbacks or scene mutation, preserves ordinary Unbounded routes, and checks captured cancellation generation and policy before publication. This is an explicit L25 gap, not allocation completion. Long synchronous geometry/copy loops, renderer/provider-private allocation accounting, full MATLAB property parity, physical performance and actual example execution remain independently required.
Supported representations and remaining forms
Supported input forms are Z and X,Y,Z, followed by the existing shared surface style name/value grammar. Z-only styles retain the rooted tail instead of being misclassified as three coordinates. X indexes columns and Y indexes rows. Explicit vectors or opposite-varying meshgrid coordinate matrices must match the height grid; mesh/meshc/surfc do not implement arbitrary parametric X/Y matrices, independent C color arrays or leading-axes forms merely because surf supports a broader surface representation.
Native Single/double/integer XData/YData/ZData and their shape remain authoritative for properties and scene persistence. Resident source snapshots are real owning-provider gathers even when eligible floating rendering also uses device buffers. A retained native property snapshot and a later host geometry fallback can perform repeated owning-provider readback/copy of the same resident source. This is an explicit performance frontier, not a precision-preserving provider numerical result or a one-readback guarantee. Complex/sparse inputs and malformed/empty grids follow existing shape/type errors, not silently accepted MATLAB parity.
Surface style parsing includes ColorMap/Colormap, Alpha/FaceAlpha, Wireframe, Shading, FaceColor, EdgeColor, Lighting, Visible and DisplayName according to the shared style owner. Mesh defaults to Turbo/faceted/wireframe; surfc defaults to Parula/smooth and composites add default-level contours at the surface base. The result is the primary surface handle, not a vector of composite handles. Broader property compatibility remains incomplete.
Examples
Create a shaded surface with projected contour lines
[X, Y] = meshgrid(linspace(-2, 2, 60), linspace(-2, 2, 60));
Z = X .* exp(-X.^2 - Y.^2);
surfc(X, Y, Z);Style the composite with colormap and camera controls
[X, Y] = meshgrid(linspace(-3, 3, 80), linspace(-3, 3, 80));
Z = cos(X) .* sin(Y);
h = surfc(X, Y, Z);
colormap('turbo');
colorbar;
view(45, 25);Inspect the returned primary surface handle
[X, Y] = meshgrid(1:20, 1:20);
Z = X + Y;
h = surfc(X, Y, Z);
get(h, 'Type')Expected output:
ans =
'surface'Rendered surfc example
[X, Y] = meshgrid(linspace(-4, 4, 120), linspace(-4, 4, 120));
R = sqrt(X.^2 + Y.^2) + 0.15;
Z = cos(2.5*R).*exp(-0.22*R);
surfc(X, Y, Z);
shading interp;
colormap('turbo');
colorbar;
title('Damped Radial Response');
xlabel('x');
ylabel('y');
zlabel('Amplitude');
view(38, 27);
Compare this result with other chart types in the plot examples.
Using surfc with coding agents
Open a RunMat example with live inputs, then ask the agent to explain how surfc changes the result.
Run a small surfc example, explain the result, then change one input and compare the output.
FAQ
Where do the contour lines appear in a surfc plot?⌄
The contour lines are projected onto the base plane (the z-minimum of the axes). They sit below the surface as a 2-D footprint of the height field. The contour overlay uses the same colormap as the surface, so the colors stay consistent.
When should I use surfc vs calling surf and contour separately?⌄
surfc handles the composite in one call — the contour is automatically projected to the base plane and shares the surface's colormap and axes state. If you call surf and contour separately, the contour sits at z=0 by default and you'd need to manage hold state and z-placement yourself. Use surfc unless you need the contour at a custom z-level or with different level spacing than the default.
Can I control how many contour levels surfc draws?⌄
The contour overlay in surfc uses the default level-generation logic from the contour pipeline. If you need explicit control over level count or spacing, call surf and contour separately so you can pass a level vector to contour directly.
Related Plotting functions
2D Charts
area · bar · errorbar · heatmap · hist · histogram · loglog · pie · plot · scatter · semilogx · semilogy · stairs · stem
Other
addpoints · ancestor · animatedline · autumn · axes · barh · bone · caxis · cla · clf · clim · colorcube · colororder · cool · copper · copyobj · cylinder · daspect · datacursormode · dataTipTextRow · drawnow · fcontour · figure · fill · fill3 · findobj · fsurf · gobjects · gray · groot · hgload · hgsave · hidden · histogram2 · hold · hot · inferno · isgraphics · ishandle · jet · line · lines · linkaxes · magma · openfig · opengl · pan · parula · patch · pink · plasma · plotmatrix · plotyy · polarhistogram · polarplot · polarscatter · print · quiver3 · ribbon · saveas · savefig · sphere · spring · stackedplot · subtitle · summer · suptitle · text · textscatter · textscatter3 · triplot · turbo · viridis · waitbar · winter · wordcloud · xlabel · xlim · xline · xscale · xtickangle · xtickformat · xticklabels · xticks · ylabel · ylim · yline · yscale · ytickangle · ytickformat · yticklabels · yticks · zlim · zoom
More plotting resources
Source you can read
Every RunMat function's source is public. Read exactly how surfc is executed, line by line, in Rust.
- View the source for surfc in Rust on GitHub
- Learn how the RunMat runtime works
- Found a bug? Open an issue with a minimal reproduction.
About RunMat
RunMat is a runtime that executes MATLAB-syntax code fast on any GPU. The runtime is free for individuals, including freelancers; students and faculty at an academic institution, for teaching or research there; contributors to an open-source project, for work on that project; organizations with 250 or fewer people and US$10M or less in annual revenue; and anyone, for non-production use. See runmat.com/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.