---
title: "SliceContourPlot3D"
language: "en"
type: "Symbol"
summary: "SliceContourPlot3D[f, surf, {x, xmin, xmax}, {y, ymin, ymax}, {z, zmin, zmax}] generates a contour plot of f over the slice surface surf as a function of x, y, and z. SliceContourPlot3D[f, surf, {x, y, z} \\[Element] reg] restricts the surface to be within region reg. SliceContourPlot3D[f, {surf1, surf2, ...}, ...] generates contour plots over several slices."
keywords: 
- slice plot
- contour plot
- slice surfaces
- surface contours
- slice
canonical_url: "https://reference.wolfram.com/language/ref/SliceContourPlot3D.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Function Visualization"
    link: "https://reference.wolfram.com/language/guide/FunctionVisualization.en.md"
related_functions: 
  - 
    title: "ListSliceContourPlot3D"
    link: "https://reference.wolfram.com/language/ref/ListSliceContourPlot3D.en.md"
  - 
    title: "SliceDensityPlot3D"
    link: "https://reference.wolfram.com/language/ref/SliceDensityPlot3D.en.md"
  - 
    title: "ContourPlot"
    link: "https://reference.wolfram.com/language/ref/ContourPlot.en.md"
  - 
    title: "ContourPlot3D"
    link: "https://reference.wolfram.com/language/ref/ContourPlot3D.en.md"
---
# SliceContourPlot3D

SliceContourPlot3D[f, surf, {x, xmin, xmax}, {y, ymin, ymax}, {z, zmin, zmax}] generates a contour plot of f over the slice surface surf as a function of x, y, and z.

SliceContourPlot3D[f, surf, {x, y, z}∈reg] restricts the surface to be within region reg.

SliceContourPlot3D[f, {surf1, surf2, …}, …] generates contour plots over several slices.

## Details and Options

* ``SliceContourPlot3D`` constructs contour curves on the surface ``surf`` corresponding to the level sets where ``f[x, y, z]`` has constant values ``d1``, ``d2``, etc. By default, the regions between the curves are shaded to more easily identify regions whose values are between ``di`` and ``di + 1``.

* It visualizes the areas $\left\{(x,y,z)\left|d_i<f(x,y,z)<d_{i+1}\land (x,y,z)\in \text{reg}\cap \text{surf}\right.\right\}$.

[image]

* The following basic slice surfaces ``surfi`` can be given :

|         |                         |                                                                        |
| ------- | ----------------------- | ---------------------------------------------------------------------- |
|         | Automatic               | automatically determine slice surfaces                                 |
| [image] | "CenterPlanes"          | coordinate planes through the center                                   |
| [image] | "BackPlanes"            | coordinate planes at the back of the plot                              |
| [image] | "XStackedPlanes"        | coordinate planes stacked along $x$ axis |
| [image] | "YStackedPlanes"        | coordinate planes stacked along $y$ axis |
| [image] | "ZStackedPlanes"        | coordinate planes stacked along $z$ axis |
| [image] | "DiagonalStackedPlanes" | planes stacked diagonally                                              |
| [image] | "CenterSphere"          | a sphere in the center                                                 |
| [image] | "CenterCutSphere"       | a sphere with a cutout wedge                                           |
| [image] | "CenterCutBox"          | a box with a cutout octant                                             |

* ``SliceContourPlot3D[f, {x, xmin, xmax}, …]`` is equivalent to ``SliceContourPlot3D[f, Automatic, {x, xmin, xmax}, …]`` etc.

* The following parametrizations can be used for basic slice surfaces:

|                                     |                                                                                            |
| ----------------------------------- | ------------------------------------------------------------------------------------------ |
| {"XStackedPlanes", n},              | generate n equally spaced planes                                                           |
| {"XStackedPlanes", {x1, x2, …}}     | generate planes for $x=x_i$                                  |
| {"CenterCutSphere", ϕopen}          | cut angle ϕopen facing the view point                                                      |
| {"CenterCutSphere", ϕopen, ϕcenter} | cut angle ϕopen with center angle ϕcenter in the $x y$ plane |

* ``"YStackedPlanes"``, ``"ZStackedPlanes"`` follow the specifications for ``"XStackedPlanes"``, with additional features shown in the scope examples.

* The following general slice surfaces ``surfi`` can be used :

|               |                                                                                            |
| ------------- | ------------------------------------------------------------------------------------------ |
| expr == 0      | implicit equation in x, y, and z, e.g. x y z - 1 == 0                                       |
| surfaceregion | a two-dimensional region in 3D, e.g. Hyperplane                                            |
| volumeregion  | a three-dimensional region in 3D where surfi is taken as the boundary surface, e.g. Cuboid |

* The following wrappers can be used for slice surfaces ``surfi`` :

|                         |                                                         |
| ----------------------- | ------------------------------------------------------- |
| Annotation[surf, label] | provide an annotation                                   |
| Button[surf, action]    | define an action to execute when the surface is clicked |
| EventHandler[surf, …]   | define a general event handler for the surface          |
| Hyperlink[surf, uri]    | make the surface act as a hyperlink                     |
| PopupWindow[surf, cont] | attach a popup window to the surface                    |
| StatusArea[surf, label] | display in status area when the surface is moused over  |
| Tooltip[surf, label]    | attach an arbitrary tooltip to the surface              |

* ``SliceContourPlot3D`` has the same options as ``Graphics3D``, with the following additions and changes :  []

|                       |                               |                                                                                         |
| --------------------- | ----------------------------- | --------------------------------------------------------------------------------------- |
| Axes                  | True                          | whether to draw axes                                                                    |
| BoundaryStyle         | Automatic                     | how to style surface boundaries                                                         |
| BoxRatios             | {1, 1, 1}                     | bounding 3D box ratios                                                                  |
| ClippingStyle         | None                          | how to draw values clipped by PlotRange                                                 |
| ColorFunction         | Automatic                     | how to color the plot                                                                   |
| ColorFunctionScaling  | True                          | whether to scale the arguments to ColorFunction                                         |
| Contours              | Automatic                     | how many or what contours to show                                                       |
| ContourShading        | Automatic                     | how to shade regions between contours                                                   |
| ContourStyle          | Automatic                     | the style for contour lines                                                             |
| PerformanceGoal       | \$PerformanceGoal             | aspects of performance to optimize                                                      |
| PlotLegends           | None                          | legends for color gradients                                                             |
| PlotPoints            | Automatic                     | initial number of samples for the function f and slice surfaces surfi in each direction |
| PlotRange             | {Full, Full, Full, Automatic} | range of f or other 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                                                     |
| TargetUnits           | Automatic                     | desired units to use                                                                    |
| WorkingPrecision      | MachinePrecision              | the precision used in internal computations                                             |

* ``ColorFunction`` is by default supplied with the scaled value of ``f``.

* ``RegionFunction`` is by default supplied with ``x``, ``y``, ``z`` and ``f``.

* Possible settings for ``ScalingFunctions`` include:

|                  |                                            |
| ---------------- | ------------------------------------------ |
| sf               | scale the f contour values                 |
| {sx, sy, sz}     | scale x, y and z axes                      |
| {sx, sy, sz, sf} | scale x, y and z axes and f contour values |

* 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                    |
| "Infinite"  | [image] | infinite scale                                      |

### 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 style surface boundaries                                                         |
| Boxed                | True                          | whether to draw the bounding box                                                        |
| BoxRatios            | {1, 1, 1}                     | bounding 3D box ratios                                                                  |
| BoxStyle             | {}                            | style specifications for the box                                                        |
| ClippingStyle        | None                          | how to draw values clipped by PlotRange                                                 |
| ClipPlanes           | None                          | clipping planes                                                                         |
| ClipPlanesStyle      | Automatic                     | style specifications for clipping planes                                                |
| ColorFunction        | Automatic                     | how to color the plot                                                                   |
| ColorFunctionScaling | True                          | whether to scale the arguments to ColorFunction                                         |
| ContentSelectable    | Automatic                     | whether to allow contents to be selected                                                |
| Contours             | Automatic                     | how many or what contours to show                                                       |
| ContourShading       | Automatic                     | how to shade regions between contours                                                   |
| ContourStyle         | Automatic                     | the style for contour lines                                                             |
| ControllerLinking    | False                         | when to link to external rotation controllers                                           |
| ControllerPath       | Automatic                     | what external controllers to try to use                                                 |
| 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                                                          |
| Method               | Automatic                     | details of 3D graphics methods to use                                                   |
| PerformanceGoal      | \$PerformanceGoal             | aspects of performance to optimize                                                      |
| PlotLabel            | None                          | a label for the plot                                                                    |
| PlotLegends          | None                          | legends for color gradients                                                             |
| PlotPoints           | Automatic                     | initial number of samples for the function f and slice surfaces surfi in each direction |
| PlotRange            | {Full, Full, Full, Automatic} | range of f or other 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                 |
| TargetUnits          | Automatic                     | desired units to use                                                                    |
| 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                                                              |
| WorkingPrecision     | MachinePrecision              | the precision used in internal computations                                             |

---

## Examples (120)

### Basic Examples (2)

Plot the contours of the function $\exp \left(-\left(x^2+y^2+z^2\right)\right)$ over slice planes through the center :

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Plot the contours over the surface $x^3+y^2-z^2=0$ :

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], x ^ 3 + y ^ 2 - z ^ 2 == 0, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

### Scope (24)

#### Surfaces (9)

Generate a contour plot over standard slice surfaces:

```wl
In[1]:= Table[SliceContourPlot3D[Sin[x] + y ^ 2 - z ^ 3, sl, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotLabel -> sl], {sl, {"CenterPlanes", "BackPlanes", "DiagonalStackedPlanes"}}]

Out[1]= [image]
```

---

Standard axis-aligned stacked slice surfaces:

```wl
In[1]:= Table[SliceContourPlot3D[Sin[x] + y ^ 2 - z ^ 3, sl, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotLabel -> sl], {sl, {"XStackedPlanes", "YStackedPlanes", "ZStackedPlanes"}}]

Out[1]= [image]
```

---

Standard boundary surfaces:

```wl
In[1]:= Table[SliceContourPlot3D[Sin[x] + y ^ 2 - z ^ 3, sl, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotLabel -> sl], {sl, {"CenterSphere", "CenterCutSphere", "CenterCutBox"}}]

In[2]:= {[image], [image], [image]}
```

---

Plot the contours over any surface region:

```wl
In[1]:= SliceContourPlot3D[x + y + z, HalfPlane[{{0, 0, 0}, {1, 0, 0}}, {0, 1, 1}], {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[1]= [image]
```

---

Plotting over a volume primitive is equivalent to plotting over ``RegionBoundary[reg]`` :

```wl
In[1]:= SliceContourPlot3D[x + y + z, Cylinder[], {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[1]= [image]
```

---

Plot the contours over the surface $x^3+y^2-z^2=0$ :

```wl
In[1]:= SliceContourPlot3D[Sin[x y z], x ^ 3 + y ^ 2 - z ^ 2 == 0, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Plot the contours over multiple surfaces:

```wl
In[1]:= SliceContourPlot3D[Sin[x y z], {Cylinder[], "BackPlanes"}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> 3]

Out[1]= [image]
```

---

Specify the number of stacked planes:

```wl
In[1]:= SliceContourPlot3D[x + y + z, {"XStackedPlanes", 7}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Specify the cutting angle for a center-cut sphere slice:

```wl
In[1]:= SliceContourPlot3D[Sin[x y z], {"CenterCutSphere", 2Pi / 3}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

#### Sampling (4)

Use ``Contours`` to specify the number of contours :

```wl
In[1]:= SliceContourPlot3D[x + y + z, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> 5]

Out[1]= [image]
```

Or the list of function values $f(x,y,z)=\text{\textit{val}}$ to put contours :

```wl
In[2]:= SliceContourPlot3D[x + y + z, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> {-1, 0, 1}]

Out[2]= [image]
```

---

Areas where the function becomes nonreal are excluded:

```wl
In[1]:= SliceContourPlot3D[Sqrt[x y z], "CenterSphere", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

In[2]:= [image]
```

---

Use ``RegionFunction`` to expose obscured slices:

```wl
In[1]:= SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "ZStackedPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, RegionFunction -> Function[{x, y, z}, x < 0 || y > 0]]

Out[1]= [image]
```

---

The domain may be specified by a region including ``Cone`` :

```wl
In[1]:= SliceContourPlot3D[x + y + z, "CenterPlanes", {x, y, z}∈Cone[]]

Out[1]= [image]
```

A formula region including ``ImplicitRegion`` :

```wl
In[2]:= ℛ = ImplicitRegion[(x ^ 2 + (9 / 4)y ^ 2 + z ^ 2 - 1) ^ 3 - x ^ 2z ^ 3 - (9 / 80)y ^ 2z ^ 3 <= 0, {{x, -1.2, 1.2}, {y, -0.7, 0.7}, {z, -1, 1.3}}];

In[3]:= SliceContourPlot3D[x + y + z, "CenterPlanes", {x, y, z}∈ℛ]

Out[3]= [image]
```

A mesh-based region including ``BoundaryMeshRegion`` :

```wl
In[4]:= ℛ = ConvexHullMesh[RandomReal[1, {25, 3}]]

Out[4]= [image]

In[5]:= SliceContourPlot3D[x + y + z, "CenterPlanes", {x, y, z}∈ℛ]

Out[5]= [image]
```

#### Presentation (11)

Use ``PlotTheme`` to immediately get overall styling :

```wl
In[1]:= Table[SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotLabel -> t, PlotTheme -> t], {t, {"Minimal", "Scientific", "Marketing"}}]

Out[1]= [image]
```

---

Use ``PlotLegends`` to get a color bar for the different values:

```wl
In[1]:= SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotLegends -> Automatic]

Out[1]= [image]
```

---

Control the display of axes with ``Axes`` :

```wl
In[1]:= Table[SliceContourPlot3D[x + y + z, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotLabel -> a, Axes -> a], {a, {True, False, {True, False, True}}}]

Out[1]= [image]
```

---

Label axes using ``AxesLabel`` and the whole plot using ``PlotLabel`` :

```wl
In[1]:= SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> None, AxesLabel -> {x, y, z}, PlotLabel -> x ^ 2 + y ^ 2 + z ^ 2]

Out[1]= [image]
```

---

Color the plot by the function values with ``ColorFunction`` :

```wl
In[1]:= Table[SliceContourPlot3D[Sin[3x y z], "ZStackedPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotLabel -> c, ColorFunction -> c], {c, {Hue, "BlueGreenYellow"}}]

Out[1]= [image]
```

---

Style regions between contours with ``ContourShading`` :

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Contours -> 9, BoundaryStyle -> None, ContourShading -> {Orange, None, Blue}]

Out[1]= [image]
```

---

Use ``ContourStyle`` to style the contour lines :

```wl
In[1]:= SliceContourPlot3D[x ^ 4 + y ^ 4 + z ^ 4 - x ^ 2 - y ^ 2 - z ^ 2, "CenterSphere", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, ContourStyle -> Dotted]

In[2]:= [image]
```

---

Style the slice surface boundaries with ``BoundaryStyle`` :

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, BoundaryStyle -> Gray]

Out[1]= [image]
```

---

``TargetUnits`` specifies which units to use in the visualization:

```wl
In[1]:= SliceContourPlot3D[Quantity[-(x ^ 2 + y ^ 2 + z ^ 2), "kg/m^3"], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesLabel -> Automatic, PlotLegends -> Automatic, TargetUnits -> {"Feet", "Feet", "Feet", "g/ft^3"}]

Out[1]= [image]
```

---

Create a plot with a log-scaled $x$ axis:

```wl
In[1]:= SliceContourPlot3D[x + y + z, {x, 1, 100}, {y, 1, 100}, {z, 1, 100}, ScalingFunctions -> {"Log", None, None}]

Out[1]= [image]
```

---

Reverse the coordinate direction in the $z$ direction:

```wl
In[1]:= SliceContourPlot3D[x + y + z, {x, 1, 100}, {y, 1, 100}, {z, 1, 100}, ScalingFunctions -> {None, None, "Reverse"}]

Out[1]= [image]
```

### Options (71)

#### Axes (3)

Axes are drawn by default:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Use ``Axes -> False`` to remove the axes:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Axes -> False]

Out[1]= [image]
```

---

Turn on each axis individually:

```wl
In[1]:= {SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Axes -> {False, False, True}], SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Axes -> {False, True, False}], SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Axes -> {True, False, False}]}

Out[1]= [image]
```

#### AxesLabel (4)

No axes labels are drawn by default:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Label the $z$ axis:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesLabel -> "height"]

Out[1]= [image]
```

---

Use specific labels for each axis:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesLabel -> {"width", "depth", "height"}]

Out[1]= [image]
```

---

Use labels based on variables specified in ``SliceContourPlot3D`` :

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesLabel -> Automatic]

Out[1]= [image]
```

#### AxesOrigin (2)

The position of the axes is determined automatically:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Specify an explicit origin for the axes:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesOrigin -> {2, -2, 2}]

Out[1]= [image]
```

#### AxesStyle (3)

Change the style for the axes:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesStyle -> Red]

Out[1]= [image]
```

---

Specify the style of each axis:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesStyle -> {{Thick, Brown}, {Thick, Blue}, {Thick, Green}}]

Out[1]= [image]
```

---

Use different styles for the ticks and the axes:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesStyle -> Green, TicksStyle -> Black]

Out[1]= [image]
```

#### BoundaryStyle (1)

Style the slice surface boundaries with ``BoundaryStyle`` :

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, BoundaryStyle -> Gray]

Out[1]= [image]
```

#### BoxRatios (3)

By default, the edges of the bounding box have the same length:

```wl
In[1]:= SliceContourPlot3D[x y z, "CenterSphere", {x, 0, 1}, {y, 0, 1}, {z, -1, 2}]

In[2]:= [image]
```

---

Use ``BoxRatios -> Automatic`` to show the natural scale of the 3D coordinate values:

```wl
In[1]:= SliceContourPlot3D[x y z, "CenterSphere", {x, 0, 1}, {y, 0, 1}, {z, -1, 2}, BoxRatios -> Automatic]

In[2]:= [image]
```

---

Use custom length ratios for each side of the bounding box:

```wl
In[1]:= SliceContourPlot3D[x y z, "CenterSphere", {x, 0, 1}, {y, 0, 1}, {z, -1, 2}, BoxRatios -> {1, 2, 2}]

In[2]:= [image]
```

#### ClippingStyle (2)

Color clipped regions:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotRange -> {0.09, 0.72}, ClippingStyle -> {Gray, Green}]

Out[1]= [image]
```

---

Remove clipped regions with ``None`` :

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotRange -> {0.09, 0.72}, ClippingStyle -> None]

Out[1]= [image]
```

#### ColorFunction (3)

Color the contours according to the $f$ values:

```wl
In[1]:= SliceContourPlot3D[x + y z, "ZStackedPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, ColorFunction -> Hue]

Out[1]= [image]
```

---

Use a named color gradient:

```wl
In[1]:= SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ColorFunction -> "IslandColors"]

Out[1]= [image]
```

---

Use red when $f<0$ :

```wl
In[1]:=
SliceContourPlot3D[Sin[2 x y z], "ZStackedPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ColorFunction -> Function[f, If[f < 0, Red, Green]], 
	ColorFunctionScaling -> False, Contours -> 3]

Out[1]= [image]
```

#### ColorFunctionScaling (2)

By default, scaled values are used:

```wl
In[1]:= SliceContourPlot3D[x y z, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ColorFunction -> Hue]

Out[1]= [image]
```

---

Use ``ColorFunctionScaling -> False`` to get unscaled values:

```wl
In[1]:= SliceContourPlot3D[x y z, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ColorFunction -> (If[# <= 0, Red, Green]&), ColorFunctionScaling -> False]

Out[1]= [image]
```

#### Contours (4)

Use 5 equally spaced contours:

```wl
In[1]:= SliceContourPlot3D[x ^ 3 + y ^ 2 - z ^ 2, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> 5]

Out[1]= [image]
```

---

Use automatic contour selection:

```wl
In[1]:= SliceContourPlot3D[x ^ 3 + y ^ 2 - z ^ 2, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> Automatic]

Out[1]= [image]
```

---

Specify an explicit set of contours:

```wl
In[1]:= SliceContourPlot3D[x ^ 3 + y ^ 2 - z ^ 2, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> {-1, 1}]

Out[1]= [image]
```

---

Use specific contours with specific styles:

```wl
In[1]:= SliceContourPlot3D[x ^ 3 + y ^ 2 - z ^ 2, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> {{-1, Green}, {1, Dashed}}]

Out[1]= [image]
```

#### ContourStyle (1)

Specify a style for all contours:

```wl
In[1]:= SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "ZStackedPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ContourStyle -> Red]

Out[1]= [image]
```

#### ContourShading (4)

``ContourShading -> Automatic`` computes contour region shading from the ``ColorFunction`` :

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Contours -> 9, BoundaryStyle -> None, ContourShading -> Automatic, ColorFunction -> "BrightBands"]

Out[1]= [image]
```

---

Cyclically repeat shading styles:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Contours -> 9, BoundaryStyle -> None, ContourShading -> {Orange, Blue}]

Out[1]= [image]
```

---

Leave every third contour region empty, starting from the second:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Contours -> 9, BoundaryStyle -> None, ContourShading -> {Orange, None, Blue}]

Out[1]= [image]
```

---

Leave the regions between contours blank:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Contours -> 9, BoundaryStyle -> None, ContourShading -> None]

Out[1]= [image]
```

#### ImageSize (7)

Use named sizes such as ``Tiny``, ``Small``, ``Medium`` and ``Large`` :

```wl
In[1]:= {SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ImageSize -> Tiny], SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ImageSize -> Small]}

Out[1]= [image]
```

---

Specify the width of the plot:

```wl
In[1]:= {SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ImageSize -> 150], SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AspectRatio -> 1.5, ImageSize -> 150]}

Out[1]= [image]
```

Specify the height of the plot:

```wl
In[2]:= {SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ImageSize -> {Automatic, 150}], SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AspectRatio -> 2, ImageSize -> {Automatic, 150}]}

Out[2]= [image]
```

---

Allow the width and height to be up to a certain size:

```wl
In[1]:= {SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ImageSize -> UpTo[200]], SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AspectRatio -> 2, ImageSize -> UpTo[200]]}

Out[1]= [image]
```

---

Specify the width and height for a graphic, padding with space if necessary:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ImageSize -> {200, 250}, Background -> LightBlue]

Out[1]= [image]
```

Setting ``AspectRatio -> Full`` will fill the available space:

```wl
In[2]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AspectRatio -> Full, ImageSize -> {200, 250}, Background -> LightBlue]

Out[2]= [image]
```

---

Use maximum sizes for the width and height:

```wl
In[1]:= {SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ImageSize -> {UpTo[150], UpTo[100]}], SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AspectRatio -> 2, ImageSize -> {UpTo[150], UpTo[100]}]}

Out[1]= [image]
```

---

Use ``ImageSize -> Full`` to fill the available space in an object:

```wl
In[1]:= Framed[Pane[SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ImageSize -> Full, Background -> LightBlue], {200, 200}]]

Out[1]= [image]
```

---

Specify the image size as a fraction of the available space:

```wl
In[1]:= Framed[Pane[SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AspectRatio -> Full, ImageSize -> {Scaled[0.5], Scaled[0.5]}, Background -> LightBlue], {200, 200}]]

Out[1]= [image]
```

#### PerformanceGoal (2)

Generate a higher-quality plot:

```wl
In[1]:= Timing[SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PerformanceGoal -> "Quality"]]

Out[1]= [image]
```

---

Emphasize performance, possibly at the cost of quality:

```wl
In[1]:= Timing[SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PerformanceGoal -> "Speed"]]

Out[1]= [image]
```

#### PlotLegends (4)

Add a color bar for the different values:

```wl
In[1]:= SliceContourPlot3D[Sin[x]Sin[y]Sin[z], "BackPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotLegends -> Automatic]

Out[1]= [image]
```

---

``PlotLegends`` automatically picks up ``Contours`` and ``ContourShading`` values :

```wl
In[1]:= SliceContourPlot3D[Sin[x]Sin[y]Sin[z], "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ContourShading -> {Red, Green, Blue, Yellow}, Contours -> 3, PlotLegends -> Automatic]

Out[1]= [image]
```

---

With the setting ``ContourShading -> Automatic``, the colors are derived from ``ColorFunction`` :

```wl
In[1]:= SliceContourPlot3D[Sin[x]Sin[y]Sin[z], "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ColorFunction -> "Rainbow", PlotLegends -> Automatic]

Out[1]= [image]
```

---

Control placement of the legend with ``Placed`` :

```wl
In[1]:= SliceContourPlot3D[Sin[x]Sin[y]Sin[z], "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotLegends -> Placed[Automatic, Above]]

Out[1]= [image]
```

#### PlotPoints (1)

Use more plot points to get a smoother contour:

```wl
In[1]:= Table[SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "BackPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Axes -> False, Boxed -> False, PlotPoints -> pp], {pp, {3, 5, 20}}]

Out[1]= [image]
```

#### PlotRange (3)

Show ``All`` contours by default:

```wl
In[1]:= SliceContourPlot3D[Sin[3x y z], "CenterSphere", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

In[2]:= [image]
```

---

Show a select range:

```wl
In[1]:= SliceContourPlot3D[Sin[3x y z], "CenterSphere", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotRange -> {All, All, {0, 2}}, BoxRatios -> Automatic]

In[2]:= [image]
```

---

Show only function values between 0 and 2:

```wl
In[1]:= SliceContourPlot3D[x + y + z, "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotRange -> {0, 2}]

Out[1]= [image]
```

This is equivalent to the fully qualified form:

```wl
In[2]:= SliceContourPlot3D[x + y + z, "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotRange -> {All, All, All, {0, 2}}]

Out[2]= [image]
```

#### PlotTheme (3)

Use a theme with detailed grid lines, ticks, and legends:

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotTheme -> "Detailed"]

Out[1]= [image]
```

---

Any option setting overrides ``PlotTheme`` settings, in this case removing face grids :

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotTheme -> "Detailed", FaceGrids -> None]

Out[1]= [image]
```

---

Compare different plot themes:

```wl
In[1]:= Table[SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotLabel -> t, PlotTheme -> t, ImageSize -> 130], {t, {"Scientific", "Monochrome", "Minimal", "Web", "Working", "Classic", "Business", "Marketing", "Detailed"}}]

Out[1]= [image]
```

#### RegionFunction (2)

Include only the contours where $x<0$ or $y>0$ :

```wl
In[1]:= SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "ZStackedPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, RegionFunction -> Function[{x, y, z, f}, x < 0 || y > 0]]

Out[1]= [image]
```

---

Include only the contours where $f>2$ :

```wl
In[1]:= SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, RegionFunction -> Function[{x, y, z, f}, f > 2]]

Out[1]= [image]
```

#### ScalingFunctions (5)

By default, plots have linear scales in all directions:

```wl
In[1]:= SliceContourPlot3D[x + y + z, {x, 1, 20}, {y, 1, 20}, {z, 1, 20}]

Out[1]= [image]
```

---

Create a plot with a log-scaled $x$ axis:

```wl
In[1]:= SliceContourPlot3D[x + y + z, {x, 1, 50}, {y, 1, 50}, {z, 1, 50}, ScalingFunctions -> {"Log", None, None}]

Out[1]= [image]
```

---

Use ``ScalingFunctions`` to scale to reverse the coordinate direction in the $z$ direction:

```wl
In[1]:= SliceContourPlot3D[x + y + z, {x, 1, 100}, {y, 1, 100}, {z, 1, 100}, ScalingFunctions -> {None, None, "Reverse"}]

Out[1]= [image]
```

---

Use a scale defined by a function and its inverse:

```wl
In[1]:= SliceContourPlot3D[x + y + z, {x, 1, 100}, {y, 1, 100}, {z, 1, 100}, ScalingFunctions -> {None, None, {-Log[#]&, Exp[-#]&}}]

Out[1]= [image]
```

---

Slice surfaces that are defined relative to the bounding box are unaffected by scaling functions:

```wl
In[1]:= SliceContourPlot3D[x + y + z, "CenterCutSphere", {x, 1, 100}, {y, 1, 100}, {z, 1, 100}, ScalingFunctions -> {None, None, "Log"}]

Out[1]= [image]
```

#### TargetUnits (2)

Axes and legends are labeled with the units specified by ``TargetUnits`` :

```wl
In[1]:= SliceContourPlot3D[-(x ^ 2 + y ^ 2 + z ^ 2), "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesLabel -> Automatic, PlotLegends -> Automatic, TargetUnits -> {"Meters", "Meters", "Meters", "kg/m^3"}]

Out[1]= [image]
```

---

Units specified by ``Quantity`` are converted to those specified by ``TargetUnits`` :

```wl
In[1]:= SliceContourPlot3D[Quantity[-(x ^ 2 + y ^ 2 + z ^ 2), "kg/m^3"], "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotLegends -> Automatic, TargetUnits -> "g/ft^3"]

Out[1]= [image]
```

#### Ticks (6)

Ticks are placed automatically in each plot:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Use ``Ticks -> None`` to not draw any tick marks:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> None]

Out[1]= [image]
```

---

Place tick marks at specific positions:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> {{-1.5, 0, 1.5}, {-1.5, 0, 1.5}, {-1.5, 0, 1.5}}]

Out[1]= [image]
```

---

Draw tick marks at the specified positions with the specified labels:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> {{{-1.5, -a}, {0, 0}, {1.5, a}}, {{-1.5, -a}, {0, 0}, {1.5, a}}, {{-1.5, -a}, {0, 0}, {1.5, a}}}]

Out[1]= [image]
```

---

Specify tick marks with scaled lengths:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> {{{-1.5, -a, .1}, {0, 0, .1}, {1.5, a, .1}}, {{-1.5, -a, .05}, {0, 0, .05}, {1.5, a, .05}}, {{-1.5, -a, .15}, {0, 0, .15}, {1.5, a, .15}}}]

Out[1]= [image]
```

---

Customize each tick with position, length, labeling and styling:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> {{{-1.5, -a, .1, Directive[Red, Dashed, Thick]}, {0, 0, .1, Directive[Red, Dashed]}, {1.5, a, .1, Directive[Red]}}, {{-1.5, -a, .05, Directive[Blue, Dashed, Thick]}, {0, 0, .05, Directive[Blue, Dashed]}, {1.5, a, .05, Directive[Blue]}}, {{-1.5, -a, .15, Directive[Darker@Green, Dashed, Thick]}, {0, 0, .15, Directive[Darker@Green, Dashed]}, {1.5, a, .15, Directive[Darker@Green]}}}]

Out[1]= [image]
```

#### TicksStyle (3)

By default, the ticks and tick labels use the same styles as the axis:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesStyle -> Directive[Bold, Red]]

Out[1]= [image]
```

---

Specify the overall tick style, including the tick labels:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, TicksStyle -> Directive[Bold, Red]]

Out[1]= [image]
```

---

Specify the tick style for each of the axes:

```wl
In[1]:= SliceContourPlot3D[Exp[-(x ^ 2 + y ^ 2 + z ^ 2)], "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, TicksStyle -> {Directive[Black, Bold], Directive[Bold, Red], Directive[Bold, Blue]}]

Out[1]= [image]
```

#### WorkingPrecision (1)

Evaluate functions using machine-precision arithmetic:

```wl
In[1]:= SliceContourPlot3D[Sin[x y z + 10 ^ 16], "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

### Applications (17)

#### Elementary Functions (4)

Plot the function $f(x,y,z)=x$ :

```wl
In[1]:= SliceContourPlot3D[x, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

Plot the functions $f(x,y,z)=y$ and $f(x,y,z)=z$ :

```wl
In[2]:=
{SliceContourPlot3D[y, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}], 
	SliceContourPlot3D[z, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]}

Out[2]= [image]
```

Plot the functions $f(x,y,z)=x+y$ and $f(x,y,z)=y+z$ :

```wl
In[3]:=
{SliceContourPlot3D[x + y, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}], 
	SliceContourPlot3D[y + z, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]}

Out[3]= [image]
```

Plot the functions $f(x,y,z)=x+y+z$ and $f(x,y,z)=x-y+z$ :

```wl
In[4]:=
{SliceContourPlot3D[x + y + z, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}], 
	SliceContourPlot3D[x - y + z, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]}

Out[4]= [image]
```

---

Plot the functions $f(x,y,z)=x^2+y^2$ and $f(x,y,z)=y^2+z^2$ :

```wl
In[1]:= {SliceContourPlot3D[x ^ 2 + y ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> 5], SliceContourPlot3D[y ^ 2 + z ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> 5]}

Out[1]= [image]
```

Plot the functions $f(x,y,z)=x^2+y^2+z^2$ and $f(x,y,z)=x^2+y^2+2 z^2$ :

```wl
In[2]:= {SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> 5], SliceContourPlot3D[x ^ 2 + y ^ 2 + 2z ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> 5]}

Out[2]= [image]
```

---

Plot $\sin (\pi  x) \sin (\pi  y) \sin (\pi  z)$, a product of univariate functions :

```wl
In[1]:= surf = {{"XStackedPlanes", {-0.5, 0.5}}, {"ZStackedPlanes", {-0.5, 0.5}}};

In[2]:= SliceContourPlot3D[Sin[π x]Sin[π y]Sin[π z], surf, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Contours -> 5]

Out[2]= [image]
```

Plot $\sin (\pi  x) \sin (\pi  (y+z))$ and $\sin (\pi  z) \sin (\pi  (x+y))$, univariate and bivariate functions:

```wl
In[3]:= {SliceContourPlot3D[Sin[π x]Sin[π (y + z)], surf, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Contours -> 5], SliceContourPlot3D[Sin[π (x + y)]Sin[π z], surf, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Contours -> 5]}

Out[3]= [image]
```

Plot $\sin (\pi  (x+y+z))$, a trivariate function:

```wl
In[4]:= SliceContourPlot3D[Sin[π (x + y + z)], surf, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Contours -> 5]

Out[4]= [image]
```

---

Plot a sum of exponentials $\sum _i \alpha _i \exp \left(-\left\| p-p_i\right\| {}^2\right)$ :

```wl
In[1]:= f = Exp[-Norm[{x, y, z} - {-1, -1, -1}]^2] + Exp[-Norm[{x, y, z} - {1, 1, 1}]^2];

In[2]:= SliceContourPlot3D[f, {{"XStackedPlanes", {1, -1}}, {"YStackedPlanes", {1, -1}}, {"ZStackedPlanes", {-1, 1}}}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, Contours -> 5, PlotRange -> {0.1, 1.1}]

Out[2]= [image]
```

Pick the points $p_i$ randomly in a box :

```wl
In[3]:= f = Sum[Exp[-2Norm[{x, y, z} - pi]^2], {pi, RandomPoint[Cuboid[{-1, -1, -1}, {1, 1, 1}], 10]}];

In[4]:= SliceContourPlot3D[f, "CenterPlanes", {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, Contours -> 5, PlotRange -> {0.1, 4}]

Out[4]= [image]
```

#### Distribution Functions (6)

Plot the ``PDF`` of a distribution:

```wl
In[1]:=
\[ScriptCapitalD] = MultinormalDistribution[{0, 0, 0}, {{1, 0.5, 0}, {0.5, 1, 0}, {0, 0, 1}}];
f = PDF[\[ScriptCapitalD], {x, y, z}];

In[2]:= d = SliceContourPlot3D[f, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ColorFunction -> (ColorData["SunsetColors"][1 - #]&)]

Out[2]= [image]
```

Simulate the distribution and show point distribution:

```wl
In[3]:= pts = RandomVariate[\[ScriptCapitalD], 10 ^ 4];

In[4]:= Show[d, Graphics3D[{Green, AbsolutePointSize[1], Point[pts]}]]

Out[4]= [image]
```

---

Plot the ``CDF`` of a distribution:

```wl
In[1]:=
\[ScriptCapitalD] = MultinormalDistribution[{0, 0, 0}, {{1, 0.5, 0}, {0.5, 1, 0}, {0, 0, 1}}];
cdf = CDF[\[ScriptCapitalD], {x, y, z}];

In[2]:= SliceContourPlot3D[cdf, {x == y, x == 2, y == 2}, {x, -2, 2}, {y, -2, 2}, {z, -1, 2}, Contours -> 5, PlotRange -> {0.1, 1}]

Out[2]= [image]
```

The ``SurvivalFunction`` :

```wl
In[3]:= sf = SurvivalFunction[\[ScriptCapitalD], {x, y, z}];

In[4]:= SliceContourPlot3D[sf, {x == y, x == -2, y == -2}, {x, -2, 2}, {y, -2, 2}, {z, -1, 2}, Contours -> 5, PlotRange -> {0.1, 1}]

Out[4]= [image]
```

The ``HazardFunction`` :

```wl
In[5]:= hf = HazardFunction[\[ScriptCapitalD], {x, y, z}];

In[6]:= SliceContourPlot3D[hf, {x == y, x == 2, y == 2}, {x, -2, 2}, {y, -2, 2}, {z, -1, 2}, Contours -> 5, PlotRange -> {1, 8}]

Out[6]= [image]
```

---

Explore ``Correlation`` parameters for a ``MultinormalDistribution``, where ``ρab`` is the correlation between ``a`` and ``b`` :

```wl
In[1]:= cov[{σx_, σy_, σz_}, {ρxy_, ρyz_, ρxz_}] := {{σx^2, σx σy ρxy, σx σz ρxz}, {σx σy ρxy, σy^2, σy σz ρyz}, {σx σz ρxz, σy σz ρyz, σz^2}};
```

Correlation between ``x`` and ``y`` only :

```wl
In[2]:=
Σ = cov[{1, 1, 1}, {0.5, 0, 0}];
f = PDF[MultinormalDistribution[{0, 0, 0}, Σ], {x, y, z}];

In[3]:= SliceContourPlot3D[f, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ColorFunction -> (ColorData["SunsetColors"][1 - #]&)]

Out[3]= [image]
```

Correlation between ``y`` and ``z`` only:

```wl
In[4]:=
Σ = cov[{1, 1, 1}, {0, 0.5, 0}];
f = PDF[MultinormalDistribution[{0, 0, 0}, Σ], {x, y, z}];

In[5]:= SliceContourPlot3D[f, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ColorFunction -> (ColorData["SunsetColors"][1 - #]&)]

Out[5]= [image]
```

Correlation between ``y`` and ``z`` only, but larger variance $\sigma _z^2$ in the ``z`` component:

```wl
In[6]:=
Σ = cov[{1, 1, 2}, {0, 0.5, 0}];
f = PDF[MultinormalDistribution[{0, 0, 0}, Σ], {x, y, z}];

In[7]:= SliceContourPlot3D[f, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -4, 4}, BoxRatios -> Automatic, ColorFunction -> (ColorData["SunsetColors"][1 - #]&)]

Out[7]= [image]
```

---

Visualize the ``PDF`` of a ``ProductDistribution`` :

```wl
In[1]:=
\[ScriptCapitalD] = ProductDistribution[{NormalDistribution[0, 1], 3}];
f = PDF[\[ScriptCapitalD], {x, y, z}]

Out[1]= (E^-(x^2/2) - (y^2/2) - (z^2/2)/2 Sqrt[2] π^3 / 2)

In[2]:= SliceContourPlot3D[f, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ColorFunction -> (ColorData["SunsetColors"][1 - #]&)]

Out[2]= [image]
```

A product of three different distributions:

```wl
In[3]:=
\[ScriptCapitalD] = ProductDistribution[NormalDistribution[], LaplaceDistribution[], WeibullDistribution[1, 1]];
f = PDF[\[ScriptCapitalD], {x, y, z}]

Out[3]=
Piecewise[{{E^(-(x^2/2) - y - z)/(2*Sqrt[2*Pi]), y >= 0 && z > 0}, 
  {E^(-(x^2/2) + y - z)/(2*Sqrt[2*Pi]), y < 0 && z > 0}}, 0]

In[4]:= SliceContourPlot3D[f, {{"XStackedPlanes", {0}}, {"YStackedPlanes", {0}}, {"ZStackedPlanes", {0}}}, {x, -2, 2}, {y, -2, 2}, {z, 0, 2}, Contours -> 5, ColorFunction -> (ColorData["SunsetColors"][1 - #]&)]

Out[4]= [image]
```

A product of bivariate and univariate distributions:

```wl
In[5]:=
\[ScriptCapitalD] = ProductDistribution[BinormalDistribution[1 / 2], ExponentialDistribution[3]];
f = PDF[\[ScriptCapitalD], {x, y, z}]

Out[5]= Piecewise[{{(Sqrt[3]*E^((2/3)*(-x^2 + x*y - y^2) - 3*z))/Pi, z >= 0}}, 0]

In[6]:= SliceContourPlot3D[f, {x == y, x == -y, z == 0}, {x, -2, 2}, {y, -2, 2}, {z, 0, 1}, ColorFunction -> (ColorData["SunsetColors"][1 - #]&)]

Out[6]= [image]
```

---

Plot the pdf of a ``CopulaDistribution`` :

```wl
In[1]:=
\[ScriptCapitalD] = CopulaDistribution[{"Frank", 1}, {GammaDistribution[3, 2 / 3], ExponentialDistribution[2], NormalDistribution[]}];
f = PDF[\[ScriptCapitalD], {x, y, z}]

Out[1]= Piecewise[{{(27*E^(-((3*x)/2) - 2*y - z^2/2)*x^2)/(8*Sqrt[2*Pi]), y >= 0 && x > 0}}, 0]

In[2]:= SliceContourPlot3D[f, {y == 0, z == 0, {"YStackedPlanes", 5}}, {x, 0, 6}, {y, 0, 1.1}, {z, -3, 3}, Contours -> 7, PlotRange -> {0.1, 0.4}]

Out[2]= [image]
```

---

Visualize the ``PDF`` of a kernel density estimate of some trivariate data:

```wl
In[1]:=
data = RandomVariate[NormalDistribution[], {10 ^ 4, 3}];
f = PDF[SmoothKernelDistribution[data], {x, y, z}];

In[2]:= SliceContourPlot3D[f, "CenterPlanes", {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, Contours -> 7, PlotRange -> {0.01, 0.1}]

Out[2]= [image]
```

#### Potential and Wave Functions (4)

Plot the phase using color on the isosurface of a quadrupole potential:

```wl
In[1]:= f = (((x y) Exp[I ((6π/5) - π Sqrt[x^2 + y^2 + z^2])]) (-1 + 2 I + (3 + I/Sqrt[x^2 + y^2 + z^2]))/(x^2 + y^2 + z^2) Sqrt[x^2 + y^2 + z^2]);

In[2]:= SliceContourPlot3D[Arg[f], Abs[f] == (Abs[f] /. {x -> 0.2, y -> 0.1, z -> 0.1}), {x, -.25, .25}, {y, -.25, .25}, {z, -.25, .25}, Contours -> {0}]

Out[2]= [image]
```

Alternatively, show the $17\leq | f| \leq 21$ on several planes :

```wl
In[3]:= SliceContourPlot3D[Abs[f], {"ZStackedPlanes", 20}, {x, -.25, .25}, {y, -.25, .25}, {z, -.25, .25}, Contours -> {17, 21}, ContourShading -> Red, ClippingStyle -> None, PlotRange -> {All, All, All, {17, 21}}, BoundaryStyle -> None]

Out[3]= [image]
```

---

Plot spherical waves $\cos \left(\omega  \left\| p-p_i\right\| \right)$ from three sources $p_i$ in space:

```wl
In[1]:= f = Sum[Cos[10 Norm[{x, y, z} - {Sin[θ], Cos[θ], 0}]], {θ, 0, 2 π - (2 π/3), (2 π/3)}]

Out[1]= Cos[10 Sqrt[Abs[x]^2 + Abs[-1 + y]^2 + Abs[z]^2]] + Cos[10 Sqrt[Abs[-(Sqrt[3]/2) + x]^2 + Abs[(1/2) + y]^2 + Abs[z]^2]] + Cos[10 Sqrt[Abs[(Sqrt[3]/2) + x]^2 + Abs[(1/2) + y]^2 + Abs[z]^2]]

In[2]:=
SliceContourPlot3D[f, "CenterPlanes", 
	{x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> 3, PlotTheme -> "Minimal"]

Out[2]= [image]
```

---

Plot hydrogen orbital densities for quantum numbers $n$, $m$, $l$ :

```wl
In[1]:= a0 = Quantity["BohrRadius"] / Quantity["Meters"]

Out[1]= 5.291772109029999813118170167`9.519481150304392*^-11

In[2]:= ψ[{n_, l_, m_}, {r_, θ_, ϕ_}] := With[{ρ = 2r / (n a0)}, Sqrt[((2/n a0))^3((n - l - 1)!/2n(n + l)!)]Exp[-ρ / 2]ρ^lLaguerreL[n - l - 1, 2l + 1, ρ]SphericalHarmonicY[l, m, θ, ϕ]]
```

Plot $\psi _{2,1,0}(x,y,z)$ :

```wl
In[3]:= SliceContourPlot3D[(Abs@ψ[{2, 1, 0}, {Sqrt[x^2 + y^2 + z^2], ArcTan[z, Sqrt[x^2 + y^2]], ArcTan[x, y]}])^2, "CenterCutSphere", {x, -5 a0, 5 a0}, {y, -5 a0, 5 a0}, {z, -5 a0, 5 a0}, Contours -> 5, PlotLegends -> Automatic]

Out[3]= [image]
```

Plot $\psi _{n,m,l}(r,\theta ,\phi )$ :

```wl
In[4]:= Grid@(Flatten /@ Table[SliceContourPlot3D[(Abs@ψ[{n, l, m}, {Sqrt[x^2 + y^2 + z^2], ArcTan[z, Sqrt[x^2 + y^2]], ArcTan[x, y]}])^2, "CenterCutSphere", {x, -5 a0, 5 a0}, {y, -5 a0, 5 a0}, {z, -5 a0, 5 a0}, Contours -> 5, PlotLabel -> {n, l, m}, Axes -> None, Boxed -> False, ImageSize -> Tiny], {n, 1, 3}, {l, 0, n - 1}, {m, -l, l}])

Out[4]= [image]
```

---

An electrostatic potential built from a collection of point charges $q_i$ at positions $p_i$ :

```wl
In[1]:= ElectroStaticPotential[ql_, pl_, r_]  := Sum[ (ql[[i]]/Norm[r - pl[[i]]]), {i, Length[ql]}]

In[2]:= ElectroStaticPotential[{Subscript[q, 1], Subscript[q, 2]}, {{Subscript[x, 1], Subscript[y, 1], Subscript[z, 1]}, {Subscript[x, 2], Subscript[y, 2], Subscript[z, 2]}}, {x, y, z}]//TraditionalForm

Out[2]//TraditionalForm=
$$\frac{q_1}{\sqrt{\left| x-x_1\right| {}^2+\left| y-y_1\right| {}^2+\left| z-z_1\right| {}^2}}+\frac{q_2}{\sqrt{\left| x-x_2\right| {}^2+\left|
y-y_2\right| {}^2+\left| z-z_2\right| {}^2}}$$
```

Two charges $q_1=1$ and $q_2=-1$ :

```wl
In[3]:= p1 = SliceContourPlot3D[Evaluate[Clip@ElectroStaticPotential[{1, -1}, {{-1, -1, 0}, {1, 1, 0}}, {x, y, z}]], "ZStackedPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, ColorFunction -> "Rainbow", PlotLegends -> Automatic, PlotPoints -> 50]

Out[3]= [image]
```

Plot iso charge surfaces:

```wl
In[4]:= p2 = ContourPlot3D[Evaluate[ElectroStaticPotential[{1, -1}, {{-1, -1, 0}, {1, 1, 0}}, {x, y, z}]], {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> {-0.3, 0, 0.3}, Mesh -> None, ContourStyle -> Opacity[0.8]]

Out[4]= [image]
```

Show them together:

```wl
In[5]:= Show[p1, p2]

Out[5]= [image]
```

#### Partial Differential Equations (3)

Visualize a nonlinear sine-Gordon equation in two spatial dimensions with periodic boundary conditions with time represented along the ``z`` axis :

```wl
In[1]:=
L = 4;
usol = NDSolveValue[{D[u[t, x, y], t, t] == D[u[t, x, y], x, x] + D[u[t, x, y], y, y] + Sin[u[t, x, y]], u[t, -L, y] == u[t, L, y], u[t, x, -L] == u[t, x, L], u[0, x, y] == Exp[-(x ^ 2 + y ^ 2)], Derivative[1, 0, 0][u][0, x, y] == 0}, u, {t, 0, L / 2}, {x, -L, L}, {y, -L, L}]

Out[1]= InterpolatingFunction[{{0., 2.}, {…, -4., 4., …}, {…, -4., 4., …}}, <>]
```

The solution evolves in time along the ``z`` axis :

```wl
In[2]:= SliceContourPlot3D[usol[t, x, y], "CenterCutSphere", {x, -L, L}, {y, -L, L}, {t, 0, L / 2}, AxesLabel -> Automatic, PlotLegends -> Automatic]

Out[2]= [image]
```

---

Visualize Wolfram's nonlinear wave equation in two spatial dimensions with time represented along the ``z`` axis:

```wl
In[1]:= usol = NDSolveValue[{D[u[t, x, y], t, t] == D[u[t, x, y], x, x] + D[u[t, x, y], y, y] / 2 + (1 - u[t, x, y] ^ 2)(1 + 2u[t, x, y]), u[0, x, y] == E^-(x^2 + y^2), u[t, -5, y] == u[t, 5, y], u[t, x, -5] == u[t, x, 5], u^(1, 0, 0)[0, x, y] == 0}, u, {t, 0, 4}, {x, -5, 5}, {y, -5, 5}]

Out[1]= InterpolatingFunction[«5»]

In[2]:= SliceContourPlot3D[usol[t, x, y], "CenterCutSphere", {x, -5, 5}, {y, -5, 5}, {t, 1, 4}, AxesLabel -> Automatic, ColorFunction -> "BrightBands", PlotLegends -> Automatic]

Out[2]= [image]
```

---

Visualize solutions to 3D partial differential equations. In this case, a Poisson equation over a ``Ball`` and Dirichlet boundary conditions :

```wl
In[1]:= usol = NDSolveValue[{Subsuperscript[∇, {x, y, z}, 2]u[x, y, z] == 1, DirichletCondition[u[x, y, z] == x y z, True]}, u, {x, y, z}∈Ball[]]

Out[1]= InterpolatingFunction[{{-1., 1.}, {-1., 1.}, {-1., 1.}}, <>]

In[2]:= SliceContourPlot3D[usol[x, y, z], "XStackedPlanes", {x, y, z}∈Ball[]]

Out[2]= [image]
```

### Properties & Relations (5)

Use ``SliceDensityPlot3D`` for continuous densities on surfaces:

```wl
In[1]:= {SliceDensityPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}], SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]}

Out[1]= [image]
```

---

Use ``ContourPlot3D`` for constant value surfaces:

```wl
In[1]:= {ContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}], SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Contours -> 3]}

Out[1]= [image]
```

---

Use ``DensityPlot3D`` for full volume visualization of the function values:

```wl
In[1]:= {DensityPlot3D[x y z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}], SliceContourPlot3D[x y z, "BackPlanes", {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]}

Out[1]= [image]
```

---

Use ``ListSliceContourPlot3D`` for data:

```wl
In[1]:= data = Table[Sin[x] + y ^ 2 - z ^ 3, {z, -1, 1, 0.1}, {y, -1, 1, 0.1}, {x, -1, 1, 0.1}];

In[2]:= {ListSliceContourPlot3D[data, "BackPlanes"], SliceContourPlot3D[Sin[x] + y ^ 2 - z ^ 3, "BackPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]}

Out[2]= [image]
```

---

Use ``ContourPlot`` for contour plots in 2D :

```wl
In[1]:= {ContourPlot[x ^ 2 + y ^ 2, {x, -1, 1}, {y, -1, 1}], SliceContourPlot3D[x ^ 2 + y ^ 2, "BackPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]}

Out[1]= [image]
```

### Possible Issues (1)

Slice surfaces with a constant value may appear noisy:

```wl
In[1]:= SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterSphere", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[1]= [image]
```

The function $x^2+y^2+z^2$ is constant on the chosen slice surface :

```wl
In[2]:= ContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2 == 1, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[2]= [image]
```

Choosing a different slice surface gives a reasonable picture of the function:

```wl
In[3]:= SliceContourPlot3D[x ^ 2 + y ^ 2 + z ^ 2, "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[3]= [image]
```

## See Also

* [`ListSliceContourPlot3D`](https://reference.wolfram.com/language/ref/ListSliceContourPlot3D.en.md)
* [`SliceDensityPlot3D`](https://reference.wolfram.com/language/ref/SliceDensityPlot3D.en.md)
* [`ContourPlot`](https://reference.wolfram.com/language/ref/ContourPlot.en.md)
* [`ContourPlot3D`](https://reference.wolfram.com/language/ref/ContourPlot3D.en.md)

## Related Guides

* [Function Visualization](https://reference.wolfram.com/language/guide/FunctionVisualization.en.md)

## History

* [Introduced in 2015 (10.2)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn102.en.md) \| [Updated in 2022 (13.1)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn131.en.md)