--- title: "ListContourPlot3D" language: "en" type: "Symbol" summary: "ListContourPlot3D[farr] generates a contour plot from an array farr with values farr[[i, j, k]] at points {k, j, i}. ListContourPlot3D[{{x1, y1, z1, f1}, {x2, y2, z2, f2}, ...}] generates a contour plot from values fi at point {xi, yi, zi}." keywords: - list contour plot3 - contour levels - contour lines - contour plot 3D - contour surface - implicit surface - iso set - iso surface - level set - level surface - ISOSURFACE - contour3 canonical_url: "https://reference.wolfram.com/language/ref/ListContourPlot3D.html" source: "Wolfram Language Documentation" related_guides: - title: "Data Visualization" link: "https://reference.wolfram.com/language/guide/DataVisualization.en.md" - title: "Tabular Visualization" link: "https://reference.wolfram.com/language/guide/TabularVisualization.en.md" - title: "Image Computation for Microscopy" link: "https://reference.wolfram.com/language/guide/ImageComputationForMicroscopy.en.md" related_functions: - title: "ListSliceContourPlot3D" link: "https://reference.wolfram.com/language/ref/ListSliceContourPlot3D.en.md" - title: "ContourPlot3D" link: "https://reference.wolfram.com/language/ref/ContourPlot3D.en.md" - title: "ListContourPlot" link: "https://reference.wolfram.com/language/ref/ListContourPlot.en.md" - title: "RegionPlot3D" link: "https://reference.wolfram.com/language/ref/RegionPlot3D.en.md" - title: "ListPlot3D" link: "https://reference.wolfram.com/language/ref/ListPlot3D.en.md" - title: "ListSurfacePlot3D" link: "https://reference.wolfram.com/language/ref/ListSurfacePlot3D.en.md" - title: "ListVectorPlot3D" link: "https://reference.wolfram.com/language/ref/ListVectorPlot3D.en.md" --- # ListContourPlot3D ListContourPlot3D[farr] generates a contour plot from an array farr with values farr[[i, j, k]] at points {k, j, i}. ListContourPlot3D[{{x1, y1, z1, f1}, {x2, y2, z2, f2}, …}] generates a contour plot from values fi at point {xi, yi, zi}. ## Details and Options * ``ListContourPlot3D`` is also known as an isosurface or level set plot. * ``ListContourPlot3D`` constructs contour surfaces where the interpolated function $f(x,y,z)$ has constant values ``d1``, ``d2``, etc. * For regular data, the function $f(x,y,z)$ has value ``farr[[i, j, k]]`` at $\{x,y,z\}=\{k,j,i\}$. * For irregular data, $f(x,y,z)$ has value ``fi`` at $\{x,y,z\}=\left\{x_i,y_i,z_i\right\}$. * It visualizes the surfaces $\left\{(x,y,z)|f(x,y,z)=d_i\land (x,y,z)\in \text{reg}\right\}$ where the region $\text{reg}$ is the Cartesian product $[1,t]\times [1,s]\times [1,r]$ for regular data and the convex hull of ``{{x1, y1, z1}, …, {xn, yn, zn}}`` for irregular data. [image] * ``ListContourPlot3D[Tabular[…] -> cspec]`` extracts and plots values from the tabular object using the column specification ``cspec``. * The following forms of column specifications ``cspec`` are allowed for plotting tabular data: {Subscript[``col``, ``x``], Subscript[``col``, ``y``], Subscript[``col``, ``z``], Subscript[``col``, ``f``]} plot column ``f`` against columns ``x``, ``y`` and ``z`` * The contour surfaces plotted by ``ListContourPlot3D`` can contain disconnected parts. * By default, ``ListContourPlot3D`` shows each contour level as an opaque white surface, with normals pointing outward. * ``ListContourPlot3D`` by default shows three contour levels, equally spaced in ``f`` value. * With the option setting ``Contours -> {f0}``, ``ListContourPlot3D`` shows only the one contour level ``f = f0``. * ``ListContourPlot3D`` has the same options as ``Graphics3D``, with the following additions and changes: [] | | | | | :------------------------- | :---------------------------- | :------------------------------------------------------ | | Axes | True | whether to draw axes | | BoundaryStyle | Automatic | how to draw boundaries of regions | | BoxRatios | {1, 1, 1} | bounding 3D box ratios | | ColorFunction | Automatic | how to color contour surfaces | | ColorFunctionScaling | True | whether to scale arguments to ColorFunction | | Contours | 3 | how many or what contour surfaces to show | | ContourStyle | White | the style for contour surfaces | | DataRange | Automatic | the range of coordinate values to assume for data | | MaxPlotPoints | Automatic | the maximum number of points to include | | Mesh | Automatic | how many mesh lines in each direction to draw | | MeshFunctions | {#1&, #2&, #3&} | how to determine the placement of mesh divisions | | MeshShading | None | how to shade regions between mesh lines | | MeshStyle | Automatic | the style for mesh divisions | | Method | Automatic | the method to use for interpolation and data reduction | | PerformanceGoal | \$PerformanceGoal | aspects of performance to try to optimize | | PlotLegends | None | legends for surfaces | | PlotRange | {Full, Full, Full, Automatic} | the range of values to include | | PlotTheme | \$PlotTheme | overall theme for the plot | | RegionFunction | (True&) | how to determine whether a point should be included | | ScalingFunctions | None | how to scale individual coordinates | | TextureCoordinateFunction | Automatic | how to determine texture coordinates | | TextureCoordinateScaling | True | whether to scale arguments to TextureCoordinateFunction | * ``ListContourPlot3D`` linearly interpolates values to give smooth contours. * ``array`` should be a rectangular array of real numbers; holes will be left in the plot whenever there are elements that are not real numbers. * ``ListContourPlot3D[array]`` by default takes the ``x``, ``y``, and ``z`` coordinate values for each data point to be successive integers starting at 1. * The setting ``DataRange -> {{xmin, xmax}, {ymin, ymax}, {zmin, zmax}}`` specifies other ranges of coordinate values to use. * ``array`` can be a ``SparseArray`` object. * The arguments supplied to functions in ``MeshFunctions`` and ``RegionFunction`` are ``x``, ``y``, ``z``, ``f``. Functions in ``ColorFunction`` and ``TextureCoordinateFunction`` are by default supplied with scaled versions of these arguments. * Possible settings for ``ScalingFunctions`` include: {Subscript[``s``, ``x``], Subscript[``s``, ``y``], Subscript[``s``, ``z``]} scale ``x``, ``y`` and ``z`` axes * Common built-in scaling functions ``s`` include: | | | | | ----------- | ------- | --------------------------------------------------- | | "Log" | [image] | log scale with automatic tick labeling | | "Log10" | [image] | base-10 log scale with powers of 10 for ticks | | "SignedLog" | [image] | log-like scale that includes 0 and negative numbers | | "Reverse" | [image] | reverse the coordinate direction | * ``ListContourPlot3D`` returns ``Graphics3D[GraphicsComplex[data]]``. * Themes that affect 3D surfaces include: | | | | | ------- | -------------- | --------------------------------- | | [image] | "DarkMesh" | dark mesh lines | | [image] | "GrayMesh" | gray mesh lines | | [image] | "LightMesh" | light mesh lines | | [image] | "ZMesh" | vertically distributed mesh lines | | [image] | "ThickSurface" | add thickness to surfaces | ### List of all options | | | | | ------------------------- | ----------------------------- | ---------------------------------------------------------------------------------- | | AlignmentPoint | Center | the default point in the graphic to align with | | AspectRatio | Automatic | ratio of height to width | | Axes | True | whether to draw axes | | AxesEdge | Automatic | on which edges to put axes | | AxesLabel | None | axes labels | | AxesOrigin | Automatic | where axes should cross | | AxesStyle | {} | graphics directives to specify the style for axes | | Background | None | background color for the plot | | BaselinePosition | Automatic | how to align with a surrounding text baseline | | BaseStyle | {} | base style specifications for the graphic | | BoundaryStyle | Automatic | how to draw boundaries of regions | | Boxed | True | whether to draw the bounding box | | BoxRatios | {1, 1, 1} | bounding 3D box ratios | | BoxStyle | {} | style specifications for the box | | ClipPlanes | None | clipping planes | | ClipPlanesStyle | Automatic | style specifications for clipping planes | | ColorFunction | Automatic | how to color contour surfaces | | ColorFunctionScaling | True | whether to scale arguments to ColorFunction | | ContentSelectable | Automatic | whether to allow contents to be selected | | Contours | 3 | how many or what contour surfaces to show | | ContourStyle | White | the style for contour surfaces | | ControllerLinking | False | when to link to external rotation controllers | | ControllerPath | Automatic | what external controllers to try to use | | DataRange | Automatic | the range of coordinate values to assume for data | | Epilog | {} | 2D graphics primitives to be rendered after the main plot | | FaceGrids | None | grid lines to draw on the bounding box | | FaceGridsStyle | {} | style specifications for face grids | | FormatType | TraditionalForm | default format type for text | | ImageMargins | 0. | the margins to leave around the graphic | | ImagePadding | All | what extra padding to allow for labels, etc. | | ImageSize | Automatic | absolute size at which to render the graphic | | LabelStyle | {} | style specifications for labels | | Lighting | Automatic | simulated light sources to use | | MaxPlotPoints | Automatic | the maximum number of points to include | | Mesh | Automatic | how many mesh lines in each direction to draw | | MeshFunctions | {#1&, #2&, #3&} | how to determine the placement of mesh divisions | | MeshShading | None | how to shade regions between mesh lines | | MeshStyle | Automatic | the style for mesh divisions | | Method | Automatic | the method to use for interpolation and data reduction | | PerformanceGoal | \$PerformanceGoal | aspects of performance to try to optimize | | PlotLabel | None | a label for the plot | | PlotLegends | None | legends for surfaces | | PlotRange | {Full, Full, Full, Automatic} | the range of values to include | | PlotRangePadding | Automatic | how much to pad the range of values | | PlotRegion | Automatic | final display region to be filled | | PlotTheme | \$PlotTheme | overall theme for the plot | | PreserveImageOptions | Automatic | whether to preserve image options when displaying new versions of the same graphic | | Prolog | {} | 2D graphics primitives to be rendered before the main plot | | RegionFunction | (True&) | how to determine whether a point should be included | | RotationAction | "Fit" | how to render after interactive rotation | | ScalingFunctions | None | how to scale individual coordinates | | SphericalRegion | Automatic | whether to make the circumscribing sphere fit in the final display area | | TextureCoordinateFunction | Automatic | how to determine texture coordinates | | TextureCoordinateScaling | True | whether to scale arguments to TextureCoordinateFunction | | Ticks | Automatic | specification for ticks | | TicksStyle | {} | style specification for ticks | | TouchscreenAutoZoom | False | whether to zoom to fullscreen when activated on a touchscreen | | ViewAngle | Automatic | angle of the field of view | | ViewCenter | Automatic | point to display at the center | | ViewMatrix | Automatic | explicit transformation matrix | | ViewPoint | {1.3, -2.4, 2.} | viewing position | | ViewProjection | Automatic | projection method for rendering objects distant from the viewer | | ViewRange | All | range of viewing distances to include | | ViewVector | Automatic | position and direction of a simulated camera | | ViewVertical | {0, 0, 1} | direction to make vertical | --- ## Examples (106) ### Basic Examples (5) Find a contour in an array of values: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2 + RandomReal[0.1], {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -2, 2, 0.2}], Contours -> {0}, Mesh -> None] Out[1]= [image] ``` --- Find several contours: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2 + RandomReal[0.1], {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -2, 2, 0.2}], Contours -> 3, Mesh -> None] Out[1]= [image] ``` --- Find a contour from irregular data: ```wl In[1]:= data = Table[{x = RandomReal[{-1, 1}], y = RandomReal[{-1, 1}], z = RandomReal[{-1, 1}], x ^ 2 + y ^ 2 - z ^ 2}, {5000}]; In[2]:= ListContourPlot3D[data, Contours -> {0.5}, Mesh -> None] Out[2]= [image] ``` --- Style the contours: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2 + RandomReal[0.1], {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -2, 2, 0.2}], Contours -> 3, Mesh -> None, ContourStyle -> {Red, Orange, Yellow}] Out[1]= [image] ``` --- Use legends to identify contours by color: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -2, 2, 0.2}], Contours -> 5, Mesh -> None, PlotLegends -> "Expressions"] Out[1]= [image] ``` ### Scope (7) #### Data (5) For regular data consisting of $w$ values, the $x$, $y$, and $z$ data ranges are taken to be integer values: ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}]] Out[1]= [image] ``` --- Provide explicit $x$, $y$, and $z$ data ranges by using ``DataRange``: ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], DataRange -> {{0, 3}, {0, 3}, {0, 3}}] Out[1]= [image] ``` --- For irregular data consisting of $(x,y,z,w)$ triples, the $x$, $y$, and $z$ data ranges are inferred from data: ```wl In[1]:= data = Table[{x = RandomReal[{-1, 1}], y = RandomReal[{0, 1}], z = RandomReal[{-1, 1}], Sqrt[x ^ 2 + y ^ 2 + z ^ 2]}, {1000}]; In[2]:= ListContourPlot3D[data, Mesh -> All] Out[2]= [image] ``` --- Use ``MaxPlotPoints`` to limit the number of points used: ```wl In[1]:= Table[ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], MaxPlotPoints -> mp, Mesh -> All], {mp, {Infinity, 15, 5}}] Out[1]= {[image], [image], [image]} ``` --- Use data with a different unit for each dimension: ```wl In[1]:= data = Table[{Quantity[x = RandomReal[{-1, 1}], "Meters"], Quantity[y = RandomReal[{-1, 1}], "Seconds"], Quantity[z = RandomReal[{-1, 1}], "Kilograms"], x ^ 2 + y ^ 2 - z ^ 2}, {1000}]; In[2]:= ListContourPlot3D[data, BoxRatios -> Automatic, Contours -> {0}, AxesLabel -> Automatic] Out[2]= [image] ``` Specify the units to use: ```wl In[3]:= ListContourPlot3D[data, AxesLabel -> Automatic, Contours -> {0}, TargetUnits -> {"Feet", "Seconds", "Pounds", Automatic}] Out[3]= [image] ``` #### Tabular Data (1) Get tabular data: ```wl In[1]:= tabular = Tabular[IconizedObject[«data»], {"f", "x", "y", "z"}] Out[1]= Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["f" -> Association["ElementType" -> "RealExpression"], "x" -> Association["ElementType" -> "RealExpression"], "y" -> Association["ElementType" -> " ... 981312`8.028119456470119, 264.5886054514999906559`8.674383110290135, 476.2594898126999831807`8.882659052717216, 687.9303741738999757053`8.99995604703164}, {}, None}, "ElementType" -> "RealExpression"]]}}]]]] ``` Plot tabular data in which each column represents data in the form ``{x, y, z, f}`` : ```wl In[2]:= ListContourPlot3D[tabular -> {"x", "y", "z", "f"}] Out[2]= [image] ``` Include a legend for the plot: ```wl In[3]:= ListContourPlot3D[tabular -> {"x", "y", "z", "f"}, PlotLegends -> Automatic] Out[3]= [image] ``` #### Presentation (1) Apply a log scale to the ``z`` direction of a plot: ```wl In[1]:= ListContourPlot3D[Table[x + y + z, {z, 1, 10}, {y, 1, 10}, {x, 1, 10}], ScalingFunctions -> {None, None, "Log"}] Out[1]= [image] ``` ### Options (93) #### Axes (3) By default, ``Axes`` are drawn for ``ListContourPlot3D`` : ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}]] Out[1]= [image] ``` --- Use ``Axes -> False`` to turn off axes: ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], Axes -> False] Out[1]= [image] ``` --- Turn each axis on individually: ```wl In[1]:= {ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], Axes -> {True, False, False}], ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], Axes -> {False, True, False}], ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], Axes -> {False, False, True}]} Out[1]= [image] ``` #### AxesLabel (4) No axes labels are drawn by default: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -1, 1, 0.02}, {y, -1, 1, 0.02}, {x, -1, 1, 0.02}]] Out[1]= [image] ``` --- Place a label on the $z$ axis: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -1, 1, 0.02}, {y, -1, 1, 0.02}, {x, -1, 1, 0.02}], AxesLabel -> z] Out[1]= [image] ``` --- Specify axes labels: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -1, 1, 0.02}, {y, -1, 1, 0.02}, {x, -1, 1, 0.02}], AxesLabel -> {"x", "y", "z"}] Out[1]= [image] ``` --- Use units as labels: ```wl In[1]:= data = Table[{Quantity[x = RandomReal[{-1, 1}], "Meters"], Quantity[y = RandomReal[{-1, 1}], "Seconds"], Quantity[z = RandomReal[{-1, 1}], "Kilograms"], x ^ 2 + y ^ 2 - z ^ 2}, {1000}]; In[2]:= ListContourPlot3D[data, BoxRatios -> Automatic, Contours -> {0}, AxesLabel -> Automatic] Out[2]= [image] ``` #### AxesOrigin (2) The position of the axes is determined automatically: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -1, 1, 0.02}, {y, -1, 1, 0.02}, {x, -1, 1, 0.02}]] Out[1]= [image] ``` --- Specify an explicit origin for the axes: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -1, 1, 0.02}, {y, -1, 1, 0.02}, {x, -1, 1, 0.02}], AxesOrigin -> {100, 0, 100}] Out[1]= [image] ``` #### AxesStyle (4) Change the style for the axes: ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], AxesStyle -> Red] Out[1]= [image] ``` --- Specify the style of each axis: ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], AxesStyle -> {{Thick, Brown}, {Thick, Blue}, {Thick, Green}}] Out[1]= [image] ``` --- Use different styles for the ticks and the axes: ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], AxesStyle -> Green, TicksStyle -> Black] Out[1]= [image] ``` --- Use different styles for the labels and the axes: ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], AxesStyle -> Green, LabelStyle -> Black] Out[1]= [image] ``` #### BoundaryStyle (3) Use a red boundary around the edges of the contours: ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], BoundaryStyle -> Red, Mesh -> None] Out[1]= [image] ``` --- Use ``None`` to omit the boundary: ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], BoundaryStyle -> None, Mesh -> None] Out[1]= [image] ``` --- ``BoundaryStyle`` applies to holes cut by ``RegionFunction`` : ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, -3, 3, 0.1}, {y, -3, 3, 0.1}, {z, -3, 3, 0.1}], DataRange -> {{-3, 3}, {-3, 3}, {-3, 3}}, BoundaryStyle -> Red, Mesh -> None, RegionFunction -> Function[{x, y, z, w}, x < 0 || y > 0]] Out[1]= [image] ``` #### BoxRatios (3) By default, the edges of the bounding box have the same length: ```wl In[1]:= ListContourPlot3D[Table[{x = RandomReal[{-1, 1}], y = RandomReal[{-2, 2}], z = RandomReal[{-0.5, 0.5}], x ^ 2 + (y / 2) ^ 2 + (2z) ^ 2}, {2500}]] Out[1]= [image] ``` --- Specify the ratios between the bounding box lengths: ```wl In[1]:= ListContourPlot3D[Table[{x = RandomReal[{-1, 1}], y = RandomReal[{-2, 2}], z = RandomReal[{-0.5, 0.5}], x ^ 2 + (y / 2) ^ 2 + (2z) ^ 2}, {2500}], BoxRatios -> {1, 2, 1 / 2}] Out[1]= [image] ``` --- Use the actual coordinate values for the ratios: ```wl In[1]:= ListContourPlot3D[Table[{x = RandomReal[{-1, 1}], y = RandomReal[{-2, 2}], z = RandomReal[{-0.5, 0.5}], x ^ 2 + (y / 2) ^ 2 + (2z) ^ 2}, {2500}], BoxRatios -> Automatic] Out[1]= [image] ``` #### ColorFunction (5) Color the contours according to the $x$, $y$, $z$, or $f$ values: ```wl In[1]:= Table[ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {x, -3, 3, 0.1}, {y, -3, 3, 0.1}, {z, -3, 3, 0.1}], ColorFunction -> Function[{x, y, z, f}, Evaluate[c]], PlotLabel -> c, Axes -> None], {c, {Hue[x], Hue[y], Hue[z], Hue[f]}}] Out[1]= [image] ``` --- Use a named color gradient: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {x, -3, 3, 0.1}, {y, -3, 3, 0.1}, {z, -3, 3, 0.1}], Mesh -> None, Contours -> 4, ColorFunction -> "DarkRainbow"] Out[1]= [image] ``` --- ``ColorFunction`` has higher priority than ``ContourStyle`` : ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {x, -3, 3, 0.1}, {y, -3, 3, 0.1}, {z, -3, 3, 0.1}], Mesh -> None, Contours -> 4, ColorFunction -> "DarkRainbow", ContourStyle -> Directive[Opacity[0.5], Red]] Out[1]= [image] ``` --- Use red when $z<0$ : ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {x, -3, 3, 0.1}, {y, -3, 3, 0.1}, {z, -3, 3, 0.1}], DataRange -> {{-3, 3}, {-3, 3}, {-3, 3}}, ColorFunction -> Function[{x, y, z, f}, If[z < 0, Red, Green]], ColorFunctionScaling -> False] Out[1]= [image] ``` --- ``ColorFunction`` has lower priority than ``MeshShading`` : ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {x, -3, 3, 0.1}, {y, -3, 3, 0.1}, {z, -3, 3, 0.1}], ColorFunction -> Function[{x, y, z, f}, Hue[z]], MeshFunctions -> {#3&}, MeshShading -> {Automatic, Black}] Out[1]= [image] ``` #### ColorFunctionScaling (2) Use unscaled values to color the contours: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {x, -3, 3, 0.1}, {y, -3, 3, 0.1}, {z, -3, 3, 0.1}], Mesh -> None, Contours -> 4, ColorFunction -> Function[{x, y, z, f}, Hue[f / 5]], ColorFunctionScaling -> False] Out[1]= [image] ``` --- Use an overlay density based on the coordinate values: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {x, -3, 3, 0.1}, {y, -3, 3, 0.1}, {z, -3, 3, 0.1}], DataRange -> {{-3, 3}, {-3, 3}, {-3, 3}}, ColorFunction -> Function[{x, y, z, f}, Hue[Sin[x]Sin[y]]], ColorFunctionScaling -> False, Mesh -> None] Out[1]= [image] ``` #### Contours (3) Use five equally spaced contours: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> 5, Mesh -> None] Out[1]= [image] ``` --- Use automatic contour selection: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> Automatic, Mesh -> None] Out[1]= [image] ``` --- Use specific contours: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {-2, 2}, Mesh -> None] Out[1]= [image] ``` #### ContourStyle (7) Use transparent contours: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Mesh -> None, ContourStyle -> Opacity[0.5]] Out[1]= [image] ``` --- Use distinct colors for each contour: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Mesh -> None, ContourStyle -> {Red, Green, Blue}] Out[1]= [image] ``` --- Use ``FaceForm`` to get different colors on the inside and outside: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {1}, Mesh -> 5, ContourStyle -> {FaceForm[Yellow, Blue]}] Out[1]= [image] ``` --- Alternate styles for contour surfaces: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> 4, Mesh -> None, ContourStyle -> {Blue, Opacity[0.5]}] Out[1]= [image] ``` --- Use the same style for all the contours: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> 6, Mesh -> None, ContourStyle -> Directive[Opacity[0.5], Orange]] Out[1]= [image] ``` --- ``ColorFunction`` has higher priority than ``ContourStyle`` : ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {1}, Mesh -> None, ContourStyle -> Directive[Opacity[0.5], Red], ColorFunction -> Function[{x, y, z, f}, Hue[z]]] Out[1]= [image] ``` --- ``MeshShading`` has higher priority than ``ContourStyle`` : ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {1}, MeshFunctions -> {#3&}, ContourStyle -> Directive[Opacity[0.5], Yellow], MeshShading -> {Red, Automatic}] Out[1]= [image] ``` #### DataRange (3) Arrays of values are displayed against the number of elements in each direction: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}]] Out[1]= [image] ``` --- Rescale to the sampling space: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], DataRange -> {{-2, 2}, {-2, 2}, {-2, 2}}] Out[1]= [image] ``` --- Tuples are interpreted as $x$, $y$, $z$, $w$ coordinates: ```wl In[1]:= data = Table[{x = RandomReal[{-2, 2}], y = RandomReal[{-2, 2}], z = RandomReal[{-2, 2}], x ^ 3 + y ^ 2 - z ^ 2}, {2500}]; In[2]:= ListContourPlot3D[data] Out[2]= [image] ``` #### ImageSize (7) Use named sizes such as ``Tiny``, ``Small``, ``Medium`` and ``Large`` : ```wl In[1]:= {ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], ImageSize -> Tiny], ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], ImageSize -> Small]} Out[1]= [image] ``` --- Specify the width of the plot: ```wl In[1]:= {ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], ImageSize -> 150], ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], AspectRatio -> 1.5, ImageSize -> 150]} Out[1]= [image] ``` Specify the height of the plot: ```wl In[2]:= {ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], ImageSize -> {Automatic, 150}], ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], AspectRatio -> 2, ImageSize -> {Automatic, 150}]} Out[2]= [image] ``` --- Allow the width and height to be up to a certain size: ```wl In[1]:= {ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], ImageSize -> UpTo[200]], ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], AspectRatio -> 2, ImageSize -> UpTo[200]]} Out[1]= [image] ``` --- Specify the width and height for a graphic, padding with space if necessary: ```wl In[1]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], ImageSize -> {200, 250}, Background -> LightBlue] Out[1]= [image] ``` Setting ``AspectRatio -> Full`` will fill the available space: ```wl In[2]:= ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], AspectRatio -> Full, ImageSize -> {200, 250}, Background -> LightBlue] Out[2]= [image] ``` --- Use maximum sizes for the width and height: ```wl In[1]:= {ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], ImageSize -> {UpTo[150], UpTo[150]}], ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], AspectRatio -> 2, ImageSize -> {UpTo[150], UpTo[150]}]} Out[1]= [image] ``` --- Use ``ImageSize -> Full`` to fill the available space in an object: ```wl In[1]:= Framed[Pane[ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], ImageSize -> Full, Background -> LightBlue], {200, 100}]] Out[1]= [image] ``` --- Specify the image size as a fraction of the available space: ```wl In[1]:= Framed[Pane[ListContourPlot3D[Table[Sqrt[x ^ 2 + y ^ 2 + z ^ 2], {x, 0, 3, 0.1}, {y, 0, 3, 0.1}, {z, 0, 3, 0.1}], AspectRatio -> Full, ImageSize -> {Scaled[0.5], Scaled[0.5]}, Background -> LightBlue], {200, 200}]] Out[1]= [image] ``` #### MaxPlotPoints (3) ``ListContourPlot`` normally uses all of the points in the dataset: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Mesh -> All] Out[1]= [image] In[2]:= data = Table[{x = RandomReal[{-2, 2}], y = RandomReal[{-2, 2}], z = RandomReal[{-2, 2}], x ^ 3 + y ^ 2 - z ^ 2}, {5000}]; In[3]:= ListContourPlot3D[data, Mesh -> All] Out[3]= [image] ``` --- Limit the number of points used in each direction: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], MaxPlotPoints -> 10, Mesh -> All] Out[1]= [image] ``` --- ``MaxPlotPoints`` imposes a regular grid on irregular data: ```wl In[1]:= data = Table[{x = RandomReal[{-2, 2}], y = RandomReal[{-2, 2}], z = RandomReal[{-2, 2}], x ^ 3 + y ^ 2 - z ^ 2}, {5000}]; In[2]:= ListContourPlot3D[data, MaxPlotPoints -> 10, Mesh -> All] Out[2]= [image] ``` #### Mesh (6) Show the complete mesh: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Mesh -> All] Out[1]= [image] ``` --- Use ``None`` to not draw any mesh: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Mesh -> None] Out[1]= [image] ``` --- Use five mesh levels in each direction: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Mesh -> 5, MeshFunctions -> {#1&, #2&, #3&}] Out[1]= [image] ``` --- Use five mesh levels in the $x$ direction and 10 in the $y$ direction: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Mesh -> {5, 10}, MeshFunctions -> {#1&, #2&}] Out[1]= [image] ``` --- Use mesh lines at specific values: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], DataRange -> {{-2, 2}, {-2, 2}, {-2, 2}}, Contours -> {1}, Mesh -> {{0}, {0}}, MeshFunctions -> {#1&, #2&}] Out[1]= [image] ``` --- Use different styles for different mesh lines: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], DataRange -> {{-2, 2}, {-2, 2}, {-2, 2}}, Contours -> {1}, Mesh -> {{{0, Thick}}, {{0, Red}}}] Out[1]= [image] ``` #### MeshFunctions (2) Use a mesh evenly spaced in the $x$, $y$, and $z$ directions: ```wl In[1]:= Table[ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], DataRange -> {{-2, 2}, {-2, 2}, {-2, 2}}, Contours -> {1}, PlotLabel -> f, MeshFunctions -> {Function[{x, y, z}, f]}, Axes -> None], {f, {x, y, z}}] Out[1]= [image] ``` --- Mesh with respect to radial distance: ```wl In[1]:= ListContourPlot3D[Table[x ^ 3 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], DataRange -> {{-2, 2}, {-2, 2}, {-2, 2}}, MeshFunctions -> (Norm[{#1, #2, #3}]&)] Out[1]= [image] ``` #### MeshShading (5) Alternate red and blue sections in the $z$ direction: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {1}, MeshFunctions -> {#3&}, MeshShading -> {Red, Blue}] Out[1]= [image] ``` --- ``MeshShading`` has higher priority than ``ContourStyle`` for styling: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> 1, MeshFunctions -> {#3&}, MeshShading -> {None, Blue}] Out[1]= [image] ``` --- Use ``ContourStyle`` for some segments by setting ``MeshShading`` to ``Automatic`` : ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {1}, MeshFunctions -> {#3&}, MeshShading -> {Red, Automatic}, ContourStyle -> Directive[Opacity[0.5], Yellow]] Out[1]= [image] ``` --- ``MeshShading`` can be used with ``ColorFunction`` : ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {1}, MeshFunctions -> {#3&}, MeshShading -> {Black, Automatic}, ColorFunction -> Function[{x, y, z, f}, Hue[z]]] Out[1]= [image] ``` --- Fill between regions defined by multiple mesh functions: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {1}, Mesh -> 5, Lighting -> "Neutral", MeshShading -> Table[RGBColor[r, g, b], {r, 0, 1, 1 / 5}, {g, 0, 1, 1 / 5}, {b, 0, 1, 1 / 5}]] Out[1]= [image] ``` #### MeshStyle (2) Use a dashed mesh in the $x$ direction: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {1}, MeshFunctions -> {#1&}, MeshStyle -> Dashed, Mesh -> 5] Out[1]= [image] ``` --- Use a dashed mesh in the $x$ direction and a blue mesh in the $y$ direction: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {1}, Mesh -> 5, MeshFunctions -> {#1&, #2&}, MeshStyle -> {Dashed, Blue}] Out[1]= [image] ``` #### PerformanceGoal (2) Generate a higher-quality plot: ```wl In[1]:= Timing[ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], PerformanceGoal -> "Quality"]] Out[1]= [image] ``` --- Emphasize performance, possibly at the cost of quality: ```wl In[1]:= Timing[ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], PerformanceGoal -> "Speed"]] Out[1]= {0.045735, [image]} ``` #### PlotRange (2) Show the contours over the full $x$, $y$, $z$ range: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], DataRange -> {{-2, 2}, {-2, 2}, {-2, 2}}, Contours -> 5] Out[1]= [image] ``` --- Use specific ranges to show more detail: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], DataRange -> {{-2, 2}, {-2, 2}, {-2, 2}}, Contours -> 5, PlotRange -> {{-2, 0}, {-2, 2}, {-2, 2}}, BoxRatios -> Automatic] Out[1]= [image] ``` #### PlotTheme (3) Use a highly stylized theme: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], PlotTheme -> "Marketing"] Out[1]= [image] ``` --- Adjust the appearance by removing the ticks and some mesh lines: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], PlotTheme -> "Marketing", Ticks -> None, Mesh -> 5] Out[1]= [image] ``` --- Create a thick surface for 3D printing: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {z, -2, 2, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], Contours -> {0}, PlotTheme -> "ThickSurface"] Out[1]= [image] ``` #### RegionFunction (2) Select a region in $x$, $y$, and $z$: ```wl In[1]:= Table[ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -1, 1, 0.02}, {y, -1, 1, 0.02}, {x, -1, 1, 0.02}], DataRange -> {{-1, 1}, {-1, 1}, {-1, 1}}, Mesh -> None, Axes -> None, Contours -> 4, RegionFunction -> Function[{x, y, z}, Evaluate[f]], PlotLabel -> f], {f, {-1 / 2 < x < 1 / 2, -1 / 2 < y < 1 / 2, -1 / 2 < z < 1 / 2}}] Out[1]= [image] ``` --- Remove a wedge to see hidden features: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 + z ^ 2, {z, -1, 1, 0.02}, {y, -1, 1, 0.02}, {x, -1, 1, 0.02}], DataRange -> {{-1, 1}, {-1, 1}, {-1, 1}}, Contours -> 4, Mesh -> None, Axes -> None, RegionFunction -> Function[{x, y, z}, x < 0 || y > 0]] Out[1]= [image] ``` #### ScalingFunctions (4) By default, ``ContourPlot3D`` uses linear scales in all directions: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z, {z, 1, 10, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}]] Out[1]= [image] ``` --- Use a log scale in the $z$ direction: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z, {z, 1, 10, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], ScalingFunctions -> {None, None, "Log"}, PlotRange -> All] Out[1]= [image] ``` --- Reverse the coordinate direction of the $z$ axis: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z, {z, 1, 10, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], ScalingFunctions -> {None, None, "Reverse"}] Out[1]= [image] ``` --- Use a scale defined by a function, specifying the function and its inverse: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z, {z, 1, 10, 0.1}, {y, -2, 2, 0.1}, {x, -2, 2, 0.1}], ScalingFunctions -> {None, None, {-Log[# + 1]&, Exp[-#] - 1&}}] Out[1]= [image] ``` #### TargetUnits (1) Units are automatically determined from the data: ```wl In[1]:= data = Table[{Quantity[x = RandomReal[{-1, 1}], "Meters"], Quantity[y = RandomReal[{-1, 1}], "Seconds"], Quantity[z = RandomReal[{-1, 1}], "Kilograms"], x ^ 2 + y ^ 2 - z ^ 2}, {1000}]; In[2]:= ListContourPlot3D[data, BoxRatios -> Automatic, Contours -> {0}, AxesLabel -> Automatic] Out[2]= [image] ``` Specify the units to use: ```wl In[3]:= ListContourPlot3D[data, AxesLabel -> Automatic, Contours -> {0}, TargetUnits -> {"Feet", "Seconds", "Pounds", Automatic}] Out[3]= [image] ``` #### TextureCoordinateFunction (5) Textures use scaled $x$ and $y$ coordinates by default: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.1}, {y, -2, 2, 0.1}, {z, -2, 2, 0.1}], Contours -> {1}, Mesh -> None, Lighting -> "Neutral", ContourStyle -> Texture[ExampleData[{"ColorTexture", "WavesPattern"}]]] Out[1]= [image] ``` --- Use the $x$ and $z$ coordinates: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.1}, {y, -2, 2, 0.1}, {z, -2, 2, 0.1}], Contours -> {1}, Mesh -> None, Lighting -> "Neutral", TextureCoordinateFunction -> ({#1, #3}&), ContourStyle -> Texture[ExampleData[{"ColorTexture", "WavesPattern"}]]] Out[1]= [image] ``` --- Use different textures for different surfaces: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.1}, {y, -2, 2, 0.1}, {z, -2, 2, 0.1}], Mesh -> None, Lighting -> "Neutral", ContourStyle -> {Texture[ExampleData[{"ColorTexture", "Ash"}]], Texture[ExampleData[{"ColorTexture", "Amboyna"}]], Texture[ExampleData[{"ColorTexture", "Laurel"}]]}] Out[1]= [image] ``` --- Use unscaled coordinates: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.1}, {y, -2, 2, 0.1}, {z, -2, 2, 0.1}], Contours -> {1}, Mesh -> None, Lighting -> "Neutral", TextureCoordinateScaling -> False, ContourStyle -> Texture[ExampleData[{"ColorTexture", "WavesPattern"}]]] Out[1]= [image] ``` --- Use textures to highlight how parameters map onto a surface: ```wl In[1]:= texture = ArrayPlot[{{1, 1, 1, 2, 1, 1}, {2, 0, 0, 2, 0, 0}, {2, 0, 0, 2, 0, 0}, {2, 1, 1, 1, 1, 1}, {2, 0, 0, 2, 0, 0}, {2, 0, 0, 2, 0, 0}}, ColorRules -> {1 -> Red, 2 -> Blue, 0 -> White}, Frame -> False, PlotRangePadding -> None, ImagePadding -> None, ImageSize -> 100] Out[1]= [image] In[2]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.1}, {y, -2, 2, 0.1}, {z, -2, 2, 0.1}], Contours -> {1}, Mesh -> None, Lighting -> "Neutral", ContourStyle -> Texture[texture]] Out[2]= [image] ``` #### TextureCoordinateScaling (1) Use scaled or unscaled coordinates for textures: ```wl In[1]:= texture = ArrayPlot[{{1, 1, 1, 2, 1, 1}, {2, 0, 0, 2, 0, 0}, {2, 0, 0, 2, 0, 0}, {2, 1, 1, 1, 1, 1}, {2, 0, 0, 2, 0, 0}, {2, 0, 0, 2, 0, 0}}, ColorRules -> {1 -> Red, 2 -> Blue, 0 -> White}, Frame -> False, PlotRangePadding -> None, ImagePadding -> None, ImageSize -> 100] Out[1]= [image] In[2]:= Table[ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.1}, {y, -2, 2, 0.1}, {z, -2, 2, 0.1}], Mesh -> None, Lighting -> "Neutral", ContourStyle -> Texture[texture], TextureCoordinateScaling -> s, PlotLabel -> s], {s, {True, False}}] Out[2]= [image] ``` #### Ticks (6) Ticks are placed automatically in each plot: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -4, 4, .2}], Mesh -> None] Out[1]= [image] ``` --- Use ``Ticks -> None`` to not draw any tick marks: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -4, 4, .2}], Mesh -> None, Ticks -> None] Out[1]= [image] ``` --- Place tick marks at specific positions: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -4, 4, .2}], Mesh -> None, Ticks -> {{0, 20, 40}, {0, 10, 20}, {0, 10, 20}}] Out[1]= [image] ``` --- Draw tick marks at the specified positions with the specified labels: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -4, 4, .2}], Mesh -> None, Ticks -> {{{0, a}, {20, b}, {40, c}}, {{0, a}, {10, b / 2}, {20, b}}, {{0, a}, {10, b / 2}, {20, b}}}] Out[1]= [image] ``` --- Specify tick marks with scaled lengths: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -4, 4, .2}], Mesh -> None, Ticks -> {{{0, a, .05}, {20, b, .17}, {40, c, .09}}, {{0, a, .01}, {10, b / 2, .05}, {20, b, .01}}, {{0, a, .01}, {10, b / 2, .08}, {20, b, .02}}}] Out[1]= [image] ``` --- Customize each tick with position, length,labeling and styling: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -4, 4, .2}], Mesh -> None, Ticks -> {{{0, a, .05, Directive[Thick, Red]}, {20, b, .17, Directive[Thick, Red]}, {40, c, .09, Directive[Thick, Red]}}, {{0, a, .01, Directive[Thick, Blue]}, {10, b / 2, .03, Directive[Thick, Blue]}, {20, b, .01, Directive[Thick, Blue]}}, {{0, a, .01, Directive[Thick, Black]}, {10, b / 2, .08, Directive[Thick, Black]}, {20, b, .02, Directive[Thick, Black]}}}] Out[1]= [image] ``` #### TicksStyle (3) By default, the ticks and tick labels use the same styles as the axis: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -4, 4, .2}], Mesh -> None, AxesStyle -> Directive[Red, Thick]] Out[1]= [image] ``` --- Specify overall ticks style, including the tick labels: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -4, 4, .2}], Mesh -> None, TicksStyle -> Red] Out[1]= [image] ``` --- Specify tick style for each of the axes: ```wl In[1]:= ListContourPlot3D[Table[x ^ 2 + y ^ 2 - z ^ 2, {x, -2, 2, 0.2}, {y, -2, 2, 0.2}, {z, -4, 4, .2}], Mesh -> None, TicksStyle -> {Red, Directive[Blue, Bold], Directive[Brown, 16]}] Out[1]= [image] ``` ### Neat Examples (1) The zero contour for a random field: ```wl In[1]:= ListContourPlot3D[RandomReal[{-1, 1}, {10, 10, 10}], Contours -> {0}] Out[1]= [image] ``` ## See Also * [`ListSliceContourPlot3D`](https://reference.wolfram.com/language/ref/ListSliceContourPlot3D.en.md) * [`ContourPlot3D`](https://reference.wolfram.com/language/ref/ContourPlot3D.en.md) * [`ListContourPlot`](https://reference.wolfram.com/language/ref/ListContourPlot.en.md) * [`RegionPlot3D`](https://reference.wolfram.com/language/ref/RegionPlot3D.en.md) * [`ListPlot3D`](https://reference.wolfram.com/language/ref/ListPlot3D.en.md) * [`ListSurfacePlot3D`](https://reference.wolfram.com/language/ref/ListSurfacePlot3D.en.md) * [`ListVectorPlot3D`](https://reference.wolfram.com/language/ref/ListVectorPlot3D.en.md) ## Related Guides * [Data Visualization](https://reference.wolfram.com/language/guide/DataVisualization.en.md) * [Tabular Visualization](https://reference.wolfram.com/language/guide/TabularVisualization.en.md) * [Image Computation for Microscopy](https://reference.wolfram.com/language/guide/ImageComputationForMicroscopy.en.md) ## History * [Introduced in 2007 (6.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn60.en.md) \| [Updated in 2010 (8.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn80.en.md) ▪ [2012 (9.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn90.en.md) ▪ [2014 (10.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn100.en.md) ▪ [2016 (11.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn110.en.md) ▪ [2022 (13.1)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn131.en.md) ▪ [2025 (14.2)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn142.en.md)