---
title: "RegionPlot3D"
language: "en"
type: "Symbol"
summary: "RegionPlot3D[pred, {x, xmin, xmax}, {y, ymin, ymax}, {z, zmin, zmax}] makes a plot showing the three-dimensional region in which pred is True. RegionPlot3D[{pred1, pred2, ...}, ...] plots several regions corresponding to the predi."
keywords: 
- region plot3
- region plot 3D
- plot region
- plot volume
- plot inequalities
- plot constraints
- plot geometry
- visualize constraints
- visualize volumes
- visualize regions
- visualize geometry
- constructive solid geometry
- csg
- implicit regions
- r-sets
- VOXEL_PROJ
- slice
canonical_url: "https://reference.wolfram.com/language/ref/RegionPlot3D.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Function Visualization"
    link: "https://reference.wolfram.com/language/guide/FunctionVisualization.en.md"
related_functions: 
  - 
    title: "ContourPlot3D"
    link: "https://reference.wolfram.com/language/ref/ContourPlot3D.en.md"
  - 
    title: "RegionPlot"
    link: "https://reference.wolfram.com/language/ref/RegionPlot.en.md"
  - 
    title: "ParametricPlot3D"
    link: "https://reference.wolfram.com/language/ref/ParametricPlot3D.en.md"
  - 
    title: "ListSurfacePlot3D"
    link: "https://reference.wolfram.com/language/ref/ListSurfacePlot3D.en.md"
  - 
    title: "RegionFunction"
    link: "https://reference.wolfram.com/language/ref/RegionFunction.en.md"
  - 
    title: "Reduce"
    link: "https://reference.wolfram.com/language/ref/Reduce.en.md"
  - 
    title: "FindInstance"
    link: "https://reference.wolfram.com/language/ref/FindInstance.en.md"
  - 
    title: "Boole"
    link: "https://reference.wolfram.com/language/ref/Boole.en.md"
---
# RegionPlot3D

RegionPlot3D[pred, {x, xmin, xmax}, {y, ymin, ymax}, {z, zmin, zmax}] makes a plot showing the three-dimensional region in which pred is True. 

RegionPlot3D[{pred1, pred2, …}, …] plots several regions corresponding to the predi.

## Details and Options

* The predicate ``pred`` can be any logical combination of inequalities.

[image]

* The region plotted by ``RegionPlot3D`` can contain disconnected parts.

* ``RegionPlot3D`` treats the variables ``x``, ``y`` and ``z`` as local, effectively using ``Block``.

* ``RegionPlot3D`` has attribute ``HoldAll`` and evaluates ``pred`` after assigning numerical values to ``x``, ``y`` and ``z``. In some cases, it may be more efficient to use ``Evaluate`` to evaluate ``pred`` symbolically first.

* ``RegionPlot3D`` 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 surfaces                                            |
| ColorFunctionScaling       | True              | whether to scale arguments to ColorFunction                      |
| EvaluationMonitor          | None              | expression to evaluate at every function evaluation              |
| MaxRecursion               | Automatic         | the maximum number of recursive subdivisions allowed             |
| Mesh                       | Automatic         | how many mesh lines in each direction to draw                    |
| MeshFunctions              | {#1&, #2&, #3&}   | how to determine the placement of mesh lines                     |
| MeshShading                | None              | how to shade regions between mesh lines                          |
| MeshStyle                  | Automatic         | the style for mesh lines                                         |
| Method                     | Automatic         | the method to use for refining surfaces                          |
| NormalsFunction            | Automatic         | how to determine effective surface normals                       |
| PerformanceGoal            | \$PerformanceGoal | aspects of performance to try to optimize                        |
| PlotLegends                | None              | legends for surfaces                                             |
| PlotPoints                 | Automatic         | the initial number of sample points in each direction            |
| PlotRange                  | Full              | the range of values to include in the plot                       |
| PlotStyle                  | Automatic         | graphics directives for the style of the surface of each region  |
| PlotTheme                  | \$PlotTheme       | overall theme for the plot                                       |
| ScalingFunctions           | None              | how to scale individual coordinates                              |
| TextureCoordinateFunction  | Automatic         | how to determine texture coordinates                             |
| TextureCoordinateScaling   | True              | whether to scale arguments to TextureCoordinateFunction          |
| WorkingPrecision           | MachinePrecision  | the precision used in internal computations                      |

* ``RegionPlot3D`` initially evaluates ``pred`` at a 3D grid of equally spaced sample points specified by ``PlotPoints``. Then it uses an adaptive algorithm to subdivide at most ``MaxRecursion`` times, attempting to find the boundaries of all regions in which ``pred`` is ``True``.

* You should realize that since it uses only a finite number of sample points, it is possible for ``RegionPlot3D`` to miss regions in which ``pred`` is ``True``. To check your results, you should try increasing the settings for ``PlotPoints`` and ``MaxRecursion``.

* With the default setting ``PlotRange -> Full``, ``RegionPlot3D`` will explicitly include the full ranges ``xmin`` to ``xmax``, etc.

* With ``Mesh -> All``, ``RegionPlot3D`` will explicitly draw mesh lines to indicate the subdivisions it used to find each region.

* ``RegionPlot3D`` can in general only find regions of positive measure; it cannot find regions that are just lines or points.

* The arguments supplied to functions in ``MeshFunctions`` are ``x``, ``y``, and ``z``. Functions in ``ColorFunction`` and ``TextureCoordinateFunction`` are by default supplied with scaled versions of these arguments.

* ``RegionPlot3D`` returns ``Graphics3D[GraphicsComplex[data]]``.

* 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                    |

### 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 surfaces                                                              |
| ColorFunctionScaling      | True              | whether to scale arguments to ColorFunction                                        |
| ContentSelectable         | Automatic         | whether to allow contents to be selected                                           |
| 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                          |
| EvaluationMonitor         | None              | expression to evaluate at every function evaluation                                |
| 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                                                     |
| MaxRecursion              | Automatic         | the maximum number of recursive subdivisions allowed                               |
| Mesh                      | Automatic         | how many mesh lines in each direction to draw                                      |
| MeshFunctions             | {#1&, #2&, #3&}   | how to determine the placement of mesh lines                                       |
| MeshShading               | None              | how to shade regions between mesh lines                                            |
| MeshStyle                 | Automatic         | the style for mesh lines                                                           |
| Method                    | Automatic         | the method to use for refining surfaces                                            |
| NormalsFunction           | Automatic         | how to determine effective surface normals                                         |
| PerformanceGoal           | \$PerformanceGoal | aspects of performance to try to optimize                                          |
| PlotLabel                 | None              | a label for the plot                                                               |
| PlotLegends               | None              | legends for surfaces                                                               |
| PlotPoints                | Automatic         | the initial number of sample points in each direction                              |
| PlotRange                 | Full              | the range of values to include in the plot                                         |
| PlotRangePadding          | Automatic         | how much to pad the range of values                                                |
| PlotRegion                | Automatic         | final display region to be filled                                                  |
| PlotStyle                 | Automatic         | graphics directives for the style of the surface of each region                    |
| 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                         |
| 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                                                         |
| WorkingPrecision          | MachinePrecision  | the precision used in internal computations                                        |

---

## Examples (111)

### Basic Examples (4)

Plot a 3D region:

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

Out[1]= [image]
```

---

Plot multiple regions:

```wl
In[1]:= RegionPlot3D[{x + y + z < -2, x + y + z > 2}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Plot 3D regions defined by logical combinations of inequalities:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 + z ^ 2 < 1 && x ^ 2 + y ^ 2 < z ^ 2, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotPoints -> 35, PlotRange -> All]

Out[1]= [image]
```

---

Use simple styling of region boundaries:

```wl
In[1]:= RegionPlot3D[x y z < 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, PlotStyle -> Directive[Yellow, Opacity[0.5]], Mesh -> None]

Out[1]= [image]
```

### Scope (12)

#### Sampling (3)

Areas where the function is not ``True`` are excluded:

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

Out[1]= [image]
```

---

Use logical combinations of regions:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 + z ^ 2 ≤ 4 && y ^ 2 + z ^ 2 ≤ 3, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Regions do not have to be connected:

```wl
In[1]:= RegionPlot3D[x y z ≥ 1, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

#### Presentation (9)

Provide an explicit ``PlotStyle`` for the region:

```wl
In[1]:= RegionPlot3D[(x ^ 2 + y ^ 2 + z ^ 2) - (x ^ 4 + y ^ 4 + z ^ 4) > 1 / 2, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotStyle -> Orange]

Out[1]= [image]
```

---

Specify styles for each region:

```wl
In[1]:= RegionPlot3D[{x ^ 2 + y ^ 2 ≤ 1, x ^ 2 + z ^ 2 ≤ 1, y ^ 2 + z ^ 2 ≤ 1}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotStyle -> {Red, Orange, Yellow}, Mesh -> None]

Out[1]= [image]
```

---

Add labels:

```wl
In[1]:= RegionPlot3D[z ^ 2 - 1 <= x ^ 2 + y ^ 2 ≤ z ^ 2 + 1, {x, -2.3, 2.3}, {y, -2.3, 2.3}, {z, -2, 2}, PlotLabel -> z ^ 2 - 1 <= x ^ 2 + y ^ 2 ≤ z ^ 2 + 1, PlotStyle -> Directive[Specularity[White, 10], Opacity[0.85], Purple], PlotPoints -> 20, AxesLabel -> Automatic, AxesEdge -> {{-1, 0}, {1, 0}, {-1, 0}}, Mesh -> False]

Out[1]= [image]
```

---

Use an overlay mesh:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 + z ^ 2 ≤ 4 && y ^ 2 + z ^ 2 ≤ 2, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Mesh -> 9, MeshFunctions -> {#2&, #3&}, MeshStyle -> Red]

Out[1]= [image]
```

---

Style the areas between mesh lines:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> 8, MeshFunctions -> {Function[{x, y, z}, Norm[{x, y, z}]]}, MeshShading -> {Directive[Yellow, Opacity[0.4]], FaceForm[Cyan, Red]}]

Out[1]= [image]
```

---

Color the region with an overlay density:

```wl
In[1]:= RegionPlot3D[x y z ≥ -8, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, ColorFunction -> Function[{x, y, z}, Hue[Rescale[x y z, {1, 5 ^ 3}]]], ColorFunctionScaling -> False, Mesh -> None]

Out[1]= [image]
```

---

Use a theme with simple ticks in a bright color scheme:

```wl
In[1]:= RegionPlot3D[z ^ 2 - 1 <= x ^ 2 + y ^ 2 ≤ z ^ 2 + 1, {x, -2.3, 2.3}, {y, -2.3, 2.3}, {z, -2, 2}, PlotTheme -> "Business"]

Out[1]= [image]
```

---

Use a monochrome theme:

```wl
In[1]:= RegionPlot3D[z ^ 2 - 1 <= x ^ 2 + y ^ 2 ≤ z ^ 2 + 1, {x, -2.3, 2.3}, {y, -2.3, 2.3}, {z, -2, 2}, PlotTheme -> "Monochrome"]

Out[1]= [image]
```

---

Apply a log scale to the ``z`` axis:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 < z^2, {x, -10, 10}, {y, -10, 10}, {z, 0, 10}, ScalingFunctions -> {None, None, "Log"}]

Out[1]= [image]
```

### Options (82)

#### Axes (3)

By default, ``Axes`` are drawn:

```wl
In[1]:= RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}]

Out[1]= [image]
```

---

Use ``Axes -> False`` to turn off axes:

```wl
In[1]:= RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, Axes -> False]

Out[1]= [image]
```

---

Turn each axis on individually:

```wl
In[1]:= {RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, Axes -> {True, False, False}], RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, Axes -> {False, True, False}], RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, Axes -> {False, False, True}]}

Out[1]= [image]
```

#### AxesLabel (4)

No axes labels are drawn by default:

```wl
In[1]:= RegionPlot3D[x y z < 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}]

Out[1]= [image]
```

---

Place a label on the $z$ axis:

```wl
In[1]:= RegionPlot3D[x y z < 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, AxesLabel -> z]

Out[1]= [image]
```

---

Specify axes labels:

```wl
In[1]:= RegionPlot3D[x y z < 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, AxesLabel -> {X, Y, Z}]

Out[1]= [image]
```

---

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

```wl
In[1]:= RegionPlot3D[x y z < 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, AxesLabel -> Automatic]

Out[1]= [image]
```

#### AxesOrigin (2)

The position of the axes is determined automatically:

```wl
In[1]:= RegionPlot3D[x y z < 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}]

Out[1]= [image]
```

---

Specify an explicit origin for the axes:

```wl
In[1]:= RegionPlot3D[x y z < 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, AxesOrigin -> {5, 5, 5}]

Out[1]= [image]
```

#### AxesStyle (3)

Change the style for the axes:

```wl
In[1]:= RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, AxesStyle -> Red]

Out[1]= [image]
```

---

Specify the style of each axis:

```wl
In[1]:= RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, AxesStyle -> {{Thick, Brown}, {Thick, Blue}, {Thick, Green}}]

Out[1]= [image]
```

---

Use different styles for the ticks and the axes:

```wl
In[1]:= RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, AxesStyle -> Green, TicksStyle -> Black]

Out[1]= [image]
```

#### BoundaryStyle (3)

Boundary lines are black by default:

```wl
In[1]:= RegionPlot3D[x y z ≥ 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> None]

Out[1]= [image]
```

---

Use ``None`` to not draw any boundary lines:

```wl
In[1]:= RegionPlot3D[x y z ≥ 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, BoundaryStyle -> None, Mesh -> None]

Out[1]= [image]
```

---

Use red boundary lines:

```wl
In[1]:= RegionPlot3D[x y z ≥ 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, BoundaryStyle -> Red, Mesh -> None]

Out[1]= [image]
```

#### BoxRatios (2)

Regions are shown in a cube by default:

```wl
In[1]:= RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}]

Out[1]= [image]
```

---

Use the natural scale of the region:

```wl
In[1]:= RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, BoxRatios -> Automatic]

Out[1]= [image]
```

#### ColorFunction (5)

Color regions by scaled $x$, $y$, and $z$ values:

```wl
In[1]:= Table[RegionPlot3D[x y z ≥ 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, ColorFunction -> Function[{x, y, z}, f], PlotLabel -> f, AxesEdge -> {{-1, 0}, {1, 0}, {-1, 0}}], {f, {Hue[x], Hue[y], Hue[z]}}]

Out[1]= [image]
```

---

Named color functions use the scaled $z$ direction:

```wl
In[1]:= RegionPlot3D[x y z ≥ 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, ColorFunction -> "DarkRainbow"]

Out[1]= [image]
```

---

Color regions according to a function of unscaled $x$, $y$, and $z$ values:

```wl
In[1]:= RegionPlot3D[x y z ≥ 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, ColorFunction -> Function[{x, y, z}, Hue[Rescale[x y z, {1, 5 ^ 3}]]], ColorFunctionScaling -> False]

Out[1]= [image]
```

---

``ColorFunction`` has higher priority than ``PlotStyle`` :

```wl
In[1]:= RegionPlot3D[x y z ≥ 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, ColorFunction -> "BlueGreenYellow", PlotStyle -> Red]

Out[1]= [image]
```

---

``ColorFunction`` has lower priority than ``MeshShading`` :

```wl
In[1]:= RegionPlot3D[x y z ≥ 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, ColorFunction -> "BlueGreenYellow", Mesh -> 8, MeshShading -> {{{Automatic, Black}, {Black, Automatic}}, {{Black, Automatic}, {Automatic, Black}}}]

Out[1]= [image]
```

#### ColorFunctionScaling (1)

Color regions according to a function of unscaled $x$, $y$, and $z$ values:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, ColorFunction -> Function[{x, y, z}, Hue[Rescale[Norm[{x, y, z}], {0, Norm[{5, 5, 5}]}]]], ColorFunctionScaling -> False]

Out[1]= [image]
```

#### ImageSize (7)

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

```wl
In[1]:= {RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, ImageSize -> Tiny], RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, ImageSize -> Small]}

Out[1]= [image]
```

---

Specify the width of the plot:

```wl
In[1]:= {RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, ImageSize -> 150], RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, AspectRatio -> 1.5, ImageSize -> 150]}

Out[1]= [image]
```

Specify the height of the plot:

```wl
In[2]:= {RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, ImageSize -> {Automatic, 150}], RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, AspectRatio -> 2, ImageSize -> {Automatic, 150}]}

Out[2]= [image]
```

---

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

```wl
In[1]:= {RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, ImageSize -> UpTo[200]], RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, AspectRatio -> 2, ImageSize -> UpTo[200]]}

Out[1]= [image]
```

---

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

```wl
In[1]:= RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, ImageSize -> {200, 250}, Background -> LightBlue]

Out[1]= [image]
```

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

```wl
In[2]:= RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, AspectRatio -> Full, ImageSize -> {200, 250}, Background -> LightBlue]

Out[2]= [image]
```

---

Use maximum sizes for the width and height:

```wl
In[1]:= {RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, ImageSize -> {UpTo[150], UpTo[100]}], RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, 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[RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, 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[RegionPlot3D[x ^ 2 + (2y) ^ 2 + (3z) ^ 2 ≤ 1, {x, -1, 1}, {y, -1 / 2, 1 / 2}, {z, -1 / 3, 1 / 3}, AspectRatio -> Full, ImageSize -> {Scaled[0.5], Scaled[0.5]}, Background -> LightBlue], {200, 200}]]

Out[1]= [image]
```

#### Mesh (7)

Show the sampling mesh:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> All]

Out[1]= [image]
```

---

Show no mesh:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> None]

Out[1]= [image]
```

---

Use 5 mesh lines in each direction:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> 5]

Out[1]= [image]
```

---

Use 3 mesh lines in the $x$ direction and 6 mesh lines in the $y$ direction:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> {3, 6}, MeshFunctions -> {#1&, #2&}]

Out[1]= [image]
```

---

Use mesh lines at specific values:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> {{-2, 2}, {0}, {-2, 0, 2}}]

Out[1]= [image]
```

---

Use different styles for different mesh lines:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> {{{-2, Red}, {2, Red}}, {{0, Thick}}, {{-2, Green}, {0, Green}, {2, Green}}}]

Out[1]= [image]
```

---

Mesh lines apply to the whole region, not to each component:

```wl
In[1]:= RegionPlot3D[x y z ≥ 5, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> 10]

Out[1]= [image]
```

#### MeshFunctions (2)

Mesh lines in the $x$, $y$, and $z$ directions:

```wl
In[1]:= Table[RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> 10, MeshFunctions -> {Function[{x, y, z}, Evaluate[f]]}, PlotLabel -> f], {f, {x, y, z}}]

Out[1]= {[image], [image], [image]}
```

---

Mesh lines at fixed radii from the origin:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> 10, MeshFunctions -> {Function[{x, y, z}, Norm[{x, y, z}]]}]

Out[1]= [image]
```

#### MeshShading (5)

Alternate red and blue sections:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, MeshFunctions -> {#1 - #2&}, MeshShading -> {Red, Blue}]

Out[1]= [image]
```

---

``MeshShading`` has higher priority than ``ContourStyle`` for styling:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, MeshFunctions -> {#1 - #2&}, MeshShading -> {None, Blue}]

Out[1]= [image]
```

---

Use the ``PlotStyle`` for some segments by setting ``MeshShading`` to ``Automatic`` :

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, MeshFunctions -> {#1 - #2&}, MeshShading -> {Red, Automatic}, PlotStyle -> Directive[Opacity[0.5], Yellow]]

Out[1]= [image]
```

---

``MeshShading`` can be used with ``ColorFunction`` :

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, MeshFunctions -> {#1 - #2&}, MeshShading -> {Black, Automatic}, ColorFunction -> Function[{x, y, z}, Hue[z]]]

Out[1]= [image]
```

---

Fill between regions defined by multiple mesh functions:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, MeshShading -> Table[RGBColor[r, g, b], {r, 0, 1, 1 / 5}, {g, 0, 1, 1 / 5}, {b, 0, 1, 1 / 5}], Mesh -> 5, Lighting -> "Neutral"]

Out[1]= [image]
```

#### MeshStyle (2)

Use a dashed mesh in the $x$ direction:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, 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]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> 5, MeshFunctions -> {#1&, #2&}, MeshStyle -> {Dashed, Blue}]

Out[1]= [image]
```

#### NormalsFunction (4)

Normals are automatically calculated:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 + z ^ 2 < 1, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Mesh -> None]

Out[1]= [image]
```

---

Use ``None`` to get flat shading for all the polygons:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 + z ^ 2 < 1, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, NormalsFunction -> None, Mesh -> None]

Out[1]= [image]
```

---

Vary the effective normals used on the surface:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 + z ^ 2 < 1, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Mesh -> None, NormalsFunction -> Function[{x, y, z}, RandomReal[{-1, 1}, {3}]]]

Out[1]= [image]
```

---

The ``NormalsFunction`` does not get applied to clipped regions:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 + z ^ 2 < 3 / 2, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, NormalsFunction -> Function[{x, y, z}, RandomReal[{-1, 1}, {3}]], Mesh -> None]

Out[1]= [image]
```

#### PerformanceGoal (2)

Generate a higher-quality plot:

```wl
In[1]:= Timing[RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, PerformanceGoal -> "Quality"]]

Out[1]= [image]
```

---

Emphasize performance, possibly at the cost of quality:

```wl
In[1]:= Timing[RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, PerformanceGoal -> "Speed"]]

Out[1]= {0.015025, [image]}
```

#### PlotLegends (3)

Identify regions with a legend:

```wl
In[1]:= RegionPlot3D[{x ^ 2 + y ^ 2 ≤ 1, x ^ 2 + z ^ 2 ≤ 1, y ^ 2 + z ^ 2 ≤ 1}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotLegends -> {"aaa", "bbb", "ccc"}]

Out[1]= [image]
```

---

Use legends for color gradients:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, ColorFunction -> "TemperatureMap", PlotLegends -> Automatic]

Out[1]= [image]
```

---

Use ``Placed`` to put legends above the plot:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, ColorFunction -> "AvocadoColors", PlotLegends -> Placed[Automatic, Above]]

Out[1]= [image]
```

#### PlotPoints (1)

Use more initial points to get a smoother region:

```wl
In[1]:= Table[RegionPlot3D[x ^ 2 + y ^ 2 + z ^ 2 ≤ 1 + Sin[5x]Sin[5y]Sin[5z] / 2, {x, -1.25, 1.25}, {y, -1.25, 1.25}, {z, -1.25, 1.25}, Mesh -> None, MaxRecursion -> 0, PlotPoints -> pp], {pp, {5, 10, 15, 25}}]

Out[1]= {[image], [image], [image], [image]}
```

#### PlotStyle (5)

Regions are shown as solids:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}]

Out[1]= [image]
```

---

Use ``None`` to show a wireframe of the bounding surfaces:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, PlotStyle -> None]

Out[1]= [image]
```

---

Use an orange surface:

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, PlotStyle -> Directive[Specularity[White, 40], Orange], Mesh -> None]

Out[1]= [image]
```

---

``ColorFunction`` has higher priority than ``PlotStyle`` :

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> None, PlotStyle -> Directive[Opacity[0.5], Red], ColorFunction -> Function[{x, y, z}, Hue[z]]]

Out[1]= [image]
```

---

``MeshShading`` has higher priority than ``PlotStyle`` :

```wl
In[1]:= RegionPlot3D[x y z ≥ -1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, Mesh -> 5, MeshFunctions -> {#3&}, PlotStyle -> Directive[Opacity[0.5], Yellow], MeshShading -> {Red, Automatic}]

Out[1]= [image]
```

#### PlotTheme (2)

Use a highly stylized theme:

```wl
In[1]:= RegionPlot3D[x y z < 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, PlotPoints -> 35, PlotTheme -> "Marketing"]

Out[1]= [image]
```

---

Remove the mesh lines:

```wl
In[1]:= RegionPlot3D[x y z < 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}, PlotPoints -> 35, PlotTheme -> "Marketing", Mesh -> None]

Out[1]= [image]
```

#### ScalingFunctions (5)

By default, plots have linear scales in all directions:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 < z^2, {x, -10, 10}, {y, -10, 10}, {z, 0, 10}]

Out[1]= [image]
```

---

Apply a log scale to the ``z`` axis:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 < z^2, {x, -10, 10}, {y, -10, 10}, {z, 0, 10}, ScalingFunctions -> {None, None, "Log"}]

Out[1]= [image]
```

---

Use a shifted log scale to show a function with negative values:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 < z^2, {x, -10, 10}, {y, -10, 10}, {z, -10, 10}, ScalingFunctions -> {None, None, "SignedLog"}]

Out[1]= [image]
```

---

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

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 < z^2, {x, -10, 10}, {y, -10, 10}, {z, 0, 10}, ScalingFunctions -> {None, None, "Reverse"}]

Out[1]= [image]
```

---

Use a scale defined by a function and its inverse:

```wl
In[1]:= RegionPlot3D[x ^ 2 + y ^ 2 < z^2, {x, -10, 10}, {y, -10, 10}, {z, 0, 10}, ScalingFunctions -> {None, None, {-Log[#]&, Exp[-#]&}}]

Out[1]= [image]
```

#### TextureCoordinateFunction (4)

Textures use scaled $x$ and $y$ coordinates by default:

```wl
In[1]:= RegionPlot3D[(x ^ 2 + y ^ 2 + z ^ 2) - (x ^ 4 + y ^ 4 + z ^ 4) > 1 / 2, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Mesh -> None, PlotStyle -> Texture[ExampleData[{"ColorTexture", "MultiSpiralsPattern"}]]]

Out[1]= [image]
```

---

Use the $x$ and $z$ coordinates:

```wl
In[1]:= RegionPlot3D[(x ^ 2 + y ^ 2 + z ^ 2) - (x ^ 4 + y ^ 4 + z ^ 4) > 1 / 2, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Mesh -> None, TextureCoordinateFunction -> ({#1, #3}&), PlotStyle -> Texture[ExampleData[{"ColorTexture", "MultiSpiralsPattern"}]]]

Out[1]= [image]
```

---

Use unscaled coordinates:

```wl
In[1]:= RegionPlot3D[(x ^ 2 + y ^ 2 + z ^ 2) - (x ^ 4 + y ^ 4 + z ^ 4) > 1 / 2, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Mesh -> None, TextureCoordinateScaling -> False, PlotStyle -> Texture[ExampleData[{"ColorTexture", "MultiSpiralsPattern"}]]]

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]:= RegionPlot3D[(x ^ 2 + y ^ 2 + z ^ 2) - (x ^ 4 + y ^ 4 + z ^ 4) > 1 / 2, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Mesh -> None, PlotStyle -> 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[RegionPlot3D[(x ^ 2 + y ^ 2 + z ^ 2) - (x ^ 4 + y ^ 4 + z ^ 4) > 1 / 2, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Mesh -> None, PlotStyle -> Texture[texture], TextureCoordinateScaling -> s, PlotLabel -> s], {s, {True, False}}]

Out[2]= {[image], [image]}
```

#### Ticks (6)

Ticks are placed automatically in each plot:

```wl
In[1]:= RegionPlot3D[Sin[x y] >= z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

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

```wl
In[1]:= RegionPlot3D[Sin[x y] >= z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> None]

Out[1]= [image]
```

---

Place tick marks at specific positions:

```wl
In[1]:= RegionPlot3D[Sin[x y] >= z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> {{-2, .5, 2}, {-2, 0, 2}, {-2, 1, 2}}]

Out[1]= [image]
```

---

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

```wl
In[1]:= RegionPlot3D[Sin[x y] >= z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> {{{-2, -a}, {.5, b}, {2, a}}, {{-2, -a}, {0, c}, {2, a}}, {{-2, -a}, {1, d}, {2, a}}}]

Out[1]= [image]
```

---

Specify tick marks with scaled lengths:

```wl
In[1]:= RegionPlot3D[Sin[x y] >= z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> {{{-2, -a, .01}, {.5, b, .01}, {2, a, .01}}, {{-2, -a, .35}, {0, c, .26}, {2, a, .18}}, {{-2, -a, .01}, {1, d, .12}, {2, a, .2}}}]

Out[1]= [image]
```

---

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

```wl
In[1]:= RegionPlot3D[Sin[x y] >= z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Ticks -> {{{-2, -a, .01, Directive[Thick, Red]}, {.5, b, .01, Directive[Thick, Red]}, {2, a, .01, Directive[Thick, Red]}}, {{-2, -a, .35, Directive[Blue]}, {0, c, .26, Directive[Blue]}, {2, a, .18, Directive[Blue]}}, {{-2, -a, .01, Directive[Thick, Green]}, {1, d, .12, Directive[Thick, Green]}, {2, a, .2, Directive[Thick, Darker@Green]}}}]

Out[1]= [image]
```

#### TicksStyle (3)

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

```wl
In[1]:= RegionPlot3D[Sin[x y] >= z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, AxesStyle -> Directive[Red, Bold]]

Out[1]= [image]
```

---

Specify overall tick style, including the tick labels:

```wl
In[1]:= RegionPlot3D[Sin[x y] >= z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, TicksStyle -> Directive[Red, Thick]]

Out[1]= [image]
```

---

Specify tick style for each of the axes:

```wl
In[1]:= RegionPlot3D[Sin[x y] >= z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, TicksStyle -> {Directive[Red, 16], Directive[Blue, 16], Directive[Black, 16]}]

Out[1]= [image]
```

### Applications (3)

Find the intersection of two half-spaces:

```wl
In[1]:= RegionPlot3D[x < 2y + z + 3 && y > x + 2z - 4, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Mesh -> None, PlotPoints -> 50]

Out[1]= [image]
```

---

Simple regions including a cube:

```wl
In[1]:= RegionPlot3D[-1 ≤ x ≤ 1 && -1 ≤ y ≤ 1 && -1 ≤ z ≤ 1, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Mesh -> None, PlotPoints -> 50]

Out[1]= [image]
```

Half of a cube shell:

```wl
In[2]:= RegionPlot3D[-1 ≤ x ≤ 1 && -1 ≤ y ≤ 1 && -1 ≤ z ≤ 1 && Not[-1 / 2 ≤ x ≤ 1 / 2 && -1 / 2 ≤ y ≤ 1 / 2 && -1 / 2 ≤ z ≤ 1 / 2] && y ≥ 0, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Mesh -> None, PlotPoints -> 50]

Out[2]= [image]
```

Ball:

```wl
In[3]:= RegionPlot3D[x ^ 2 + y ^ 2 + z ^ 2 ≤ 3, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Mesh -> None]

Out[3]= [image]
```

Half of a spherical shell:

```wl
In[4]:= RegionPlot3D[1 ≤ x ^ 2 + y ^ 2 + z ^ 2 ≤ 3 && y ≥ 0, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Mesh -> None, PlotPoints -> 50]

Out[4]= [image]
```

Ellipsoid:

```wl
In[5]:= RegionPlot3D[x ^ 2 + y ^ 2 + 1 / 2z ^ 2 ≤ 3, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, Mesh -> None, PlotPoints -> 35]

Out[5]= [image]
```

Half of an ellipsoidal shell:

```wl
In[6]:= RegionPlot3D[1 ≤ x ^ 2 + y ^ 2 + 1 / 2z ^ 2 ≤ 3 && y ≥ 0, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, Mesh -> None, PlotPoints -> 50]

Out[6]= [image]
```

Spherical wedge:

```wl
In[7]:= RegionPlot3D[x ^ 2 + y ^ 2 + z ^ 2 ≤ 3 && y ≥ 0 && y ≥ x + z, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Mesh -> None, PlotPoints -> 50]

Out[7]= [image]
```

---

Combine ``PolyhedronData`` regions with other inequalities:

```wl
In[1]:= dod = PolyhedronData["Dodecahedron", "RegionFunction"][x, y, z]

Out[1]= 5 (2 + Sqrt[5]) + Sqrt[10 (5 + Sqrt[5])] (2 x + z) ≥ 0 && Sqrt[10 (5 + Sqrt[5])] (2 x + z) ≤ 5 (2 + Sqrt[5]) && Sqrt[50 - 10 Sqrt[5]] x + Sqrt[10 (5 + Sqrt[5])] z ≤ 5 (2 + Sqrt[5] + (1 + Sqrt[5]) y) && Sqrt[2 (5 + Sqrt[5])] z ≤ 2 + Sqrt[5] && Sqrt[ ... t[5]) + Sqrt[50 - 10 Sqrt[5]] x + 5 (1 + Sqrt[5]) y + Sqrt[10 (5 + Sqrt[5])] z ≥ 0 && Sqrt[10 (5 + Sqrt[5])] z ≤ 2 Sqrt[5 (5 + 2 Sqrt[5])] x + 5 (2 + Sqrt[5] + 2 y) && 10 y + Sqrt[10 (5 + Sqrt[5])] z ≤ 5 (2 + Sqrt[5]) + 2 Sqrt[5 (5 + 2 Sqrt[5])] x

In[2]:= RegionPlot3D[Evaluate[N[dod && Abs[x y z] > 1 / 20]], {x, -1.5, 1.5}, {y, -1.5, 1.5}, {z, -1.5, 1.5}, Mesh -> None, PlotPoints -> 75]

Out[2]= [image]
```

### Properties & Relations (8)

Use ``RegionPlot`` for areas:

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

Out[1]= [image]
```

---

Use ``ContourPlot`` and ``ContourPlot3D`` for systems of equalities:

```wl
In[1]:= ContourPlot[Abs[Nest[(# ^ 2 + x + I y)&, x + I y, 8]] == 2, {x, -1.5, 0.5}, {y, -1.1, 1.1}]

Out[1]= [image]

In[2]:= ContourPlot3D[-(x ^ 4 + y ^ 4 + z ^ 4) + (x ^ 2 + y ^ 2 + z ^ 2) == 1 / 2, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Mesh -> None, ContourStyle -> Orange]

Out[2]= [image]
```

---

Use ``ComplexRegionPlot`` for regions in the complex plane:

```wl
In[1]:= ComplexRegionPlot[Re[z ^ 3] > Im[z ^ 3], {z, 2}]

Out[1]= [image]
```

---

Use ``RegionFunction`` to constrain other plots:

```wl
In[1]:= DensityPlot[Sin[x y], {x, -1.5, 0.5}, {y, -1.1, 1.1}, RegionFunction -> Function[{x, y, z}, Abs[Nest[(# ^ 2 + x + I y)&, x + I y, 8]] < 2]]

Out[1]= [image]

In[2]:= Plot3D[Sin[x y], {x, -1.5, 0.5}, {y, -1.1, 1.1}, RegionFunction -> Function[{x, y, z}, Abs[Nest[(# ^ 2 + x + I y)&, x + I y, 8]] < 2]]

Out[2]= [image]
```

---

Use ``ParametricPlot3D`` for parametric curves and surfaces:

```wl
In[1]:= ParametricPlot3D[{r Cos[t], r Sin[t], r t / 6}, {r, 1, 2}, {t, 0, 6Pi}, Mesh -> None]

Out[1]= [image]
```

---

Use ``Integrate`` or ``NIntegrate`` to integrate over regions:

```wl
In[1]:= Integrate[x ^ 2Boole[x y z < 1 && -5 < x < 5 && -5 < y < 5 && -5 < z < 5], {x, -∞, ∞}, {y, -∞, ∞}, {z, -∞, ∞} ]

Out[1]= (5239584 + 31250 Log[125] + 15625 Log[15625]/1250)

In[2]:= NIntegrate[x ^ 2Boole[x y z < 1 && -5 < x < 5 && -5 < y < 5 && -5 < z < 5], {x, -∞, ∞}, {y, -∞, ∞}, {z, -∞, ∞} ]

Out[2]= 4433.08
```

The integration region:

```wl
In[3]:= RegionPlot3D[x y z < 1, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}]

Out[3]= [image]
```

---

Use ``Maximize``, ``NMaximize``, or ``FindMaximum`` to optimize over regions:

```wl
In[1]:= Maximize[{x ^ 2 + y - z ^ 2, 1 ≤ x ^ 2 - y ^ 2 ≤ 4 && 1 ≤ x ^ 2 - z ^ 2 ≤ 4 && x y z ≤ 1 && x ≥ 0 && y ≥ 0 && z ≥ 0}, {x, y, z}]

Out[1]= {-Root[101 + 65*#1 + 14*#1^2 + #1^3 & , 1, 0], {x -> Root[{101 + 65*#1 + 14*#1^2 + #1^3 & , -17 - 8*#1 - #1^2 + #2^2 & }, {1, 2}], y -> -Root[{101 + 65*#1 + 14*#1^2 + #1^3 & , -17 - 8*#1 - #1^2 + #2^2 & }, {1, 2}]^2 + Root[{101 + 65*#1 + 14*#1^2 + #1^3 & , -17 - 8*#1 - #1^2 + #2^2 & , 4 - #2^2 + #3^2 & }, {1, 2, 2}]^2 - Root[101 + 65*#1 + 14*#1^2 + #1^3 & , 1, 0], z -> Root[{101 + 65*#1 + 14*#1^2 + #1^3 & , -17 - 8*#1 - #1^2 + #2^2 & , 4 - #2^2 + #3^2 & }, {1, 2, 2}]}}

In[2]:= NMaximize[{x ^ 2 + y - z ^ 2, 1 ≤ x ^ 2 - y ^ 2 ≤ 4 && 1 ≤ x ^ 2 - z ^ 2 ≤ 4 && x y z ≤ 1 && x ≥ 0 && y ≥ 0 && z ≥ 0}, {x, y, z}]

Out[2]= {5.75488, {x -> 2.0198, y -> 1.75488, z -> 0.282127}}

In[3]:= FindMaximum[{x ^ 2 + y - z ^ 2, 1 ≤ x ^ 2 - y ^ 2 ≤ 4 && 1 ≤ x ^ 2 - z ^ 2 ≤ 4 && x y z ≤ 1 && x ≥ 0 && y ≥ 0 && z ≥ 0}, {x, y, z}]

Out[3]= {5.75488, {x -> 2.0198, y -> 1.75488, z -> 0.282126}}
```

---

Use ``Reduce`` to get a cylindrical representation of the region:

```wl
In[1]:= Reduce[x ^ 2 + y ^ 2 < 4 && x ^ 2 + z ^ 2 < 4, {x, y, z}]

Out[1]= -2 < x < 2 && -Sqrt[4 - x^2] < y < Sqrt[4 - x^2] && -Sqrt[4 - x^2] < z < Sqrt[4 - x^2]
```

Use ``FindInstance`` to find specific samples in regions:

```wl
In[2]:= FindInstance[x ^ 2 + y ^ 2 < 4 && x ^ 2 + z ^ 2 < 4, {x, y, z}]

Out[2]= {{x -> 0, y -> 0, z -> 0}}
```

### Neat Examples (2)

The region between norm balls:

```wl
In[1]:= RegionPlot3D[1 ≤ Norm[{x, y, z}, 1] && Norm[{x, y, z}] ≤ 1, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, Mesh -> None, PlotStyle -> Directive[Opacity[0.5], Pink, Specularity[White, 20]], PlotPoints -> 60, NormalsFunction -> "Average"]

Out[1]= [image]
```

---

Plot a scalar field over a 3D region:

```wl
In[1]:= RegionPlot3D[y ^ 2 + z ^ 2 ≤ 3 && x ^ 2 + z ^ 2 ≤ 3, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Mesh -> None, ColorFunction -> Function[{x, y, z}, Hue@Rescale[x y z, {-2, 2}]], ColorFunctionScaling -> False, PlotPoints -> 50]

Out[1]= [image]
```

## See Also

* [`ContourPlot3D`](https://reference.wolfram.com/language/ref/ContourPlot3D.en.md)
* [`RegionPlot`](https://reference.wolfram.com/language/ref/RegionPlot.en.md)
* [`ParametricPlot3D`](https://reference.wolfram.com/language/ref/ParametricPlot3D.en.md)
* [`ListSurfacePlot3D`](https://reference.wolfram.com/language/ref/ListSurfacePlot3D.en.md)
* [`RegionFunction`](https://reference.wolfram.com/language/ref/RegionFunction.en.md)
* [`Reduce`](https://reference.wolfram.com/language/ref/Reduce.en.md)
* [`FindInstance`](https://reference.wolfram.com/language/ref/FindInstance.en.md)
* [`Boole`](https://reference.wolfram.com/language/ref/Boole.en.md)

## Related Guides

* [Function Visualization](https://reference.wolfram.com/language/guide/FunctionVisualization.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) ▪ [2014 (10.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn100.en.md) ▪ [2020 (12.1)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn121.en.md) ▪ [2022 (13.1)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn131.en.md)