---
title: "ListVectorDisplacementPlot3D"
language: "en"
type: "Symbol"
summary: "ListVectorDisplacementPlot3D[{{{vx11, vy11, vz11}, ..., {vx 1 n, vy 1 n, vz 1 n}}, ..., {{vx m 1, vy m 1, vz m 1}, ..., {vxmn, vymn, vzmn}}}] generates a displacement plot from an array of vector displacements {vxij, vyij, vzij}. ListVectorDisplacementPlot3D[{{{x1, y1, z1}, {vx1, vy1, vz1}}, ..., {{xn, yn, zn}, {vxn, vyn, vzn}}}] generates a displacement plot from displacements {vxi, vyi, vzi} at point {xi, yi, zi}. ListVectorDisplacementPlot3D[{{{{vx11, vy11, vz11}, s11}, ..., {{vx 1 n, vy 1 n, vz 1 n}, s 1 n}}, ..., {{{vx m 1, vy m 1, vz m 1}, s m 1}, ..., {{vxmn, vymn, vzmn}, smn}}}] uses the scalar values sij to color the displaced region. ListVectorDisplacementPlot3D[{{{x1, y1, z1}, {{vx1, vy1, vz1}, s1}}, ..., {{xn, yn, zn}, {{vxn, vyn, vzn}, sn}}}] uses the scalar values si at point {xi, yi, zi} to color the displaced region. ListVectorDisplacementPlot3D[..., reg] plots the displacement over the region reg."
keywords: 
- displacement plot
- stress plot
- strain plot
- deformation plot
- vector plot
- structural mechanics plot
- solid mechanics plot
canonical_url: "https://reference.wolfram.com/language/ref/ListVectorDisplacementPlot3D.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Vector Visualization"
    link: "https://reference.wolfram.com/language/guide/VectorVisualization.en.md"
related_functions: 
  - 
    title: "VectorDisplacementPlot3D"
    link: "https://reference.wolfram.com/language/ref/VectorDisplacementPlot3D.en.md"
  - 
    title: "ListVectorDisplacementPlot"
    link: "https://reference.wolfram.com/language/ref/ListVectorDisplacementPlot.en.md"
  - 
    title: "VectorDisplacementPlot"
    link: "https://reference.wolfram.com/language/ref/VectorDisplacementPlot.en.md"
  - 
    title: "ListVectorDensityPlot"
    link: "https://reference.wolfram.com/language/ref/ListVectorDensityPlot.en.md"
  - 
    title: "VectorDensityPlot"
    link: "https://reference.wolfram.com/language/ref/VectorDensityPlot.en.md"
  - 
    title: "ListStreamDensityPlot"
    link: "https://reference.wolfram.com/language/ref/ListStreamDensityPlot.en.md"
  - 
    title: "StreamDensityPlot"
    link: "https://reference.wolfram.com/language/ref/StreamDensityPlot.en.md"
  - 
    title: "StreamPlot3D"
    link: "https://reference.wolfram.com/language/ref/StreamPlot3D.en.md"
  - 
    title: "DensityPlot3D"
    link: "https://reference.wolfram.com/language/ref/DensityPlot3D.en.md"
---
# ListVectorDisplacementPlot3D

ListVectorDisplacementPlot3D[{{{vx11, vy11, vz11}, …, {vx1n, vy1n, vz1n}}, …, {{vxm1, vym1, vzm1}, …, {vxmn, vymn, vzmn}}}] generates a displacement plot from an array of vector displacements {vxij, vyij, vzij}.

ListVectorDisplacementPlot3D[{{{x1, y1, z1}, {vx1, vy1, vz1}}, …, {{xn, yn, zn}, {vxn, vyn, vzn}}}] generates a displacement plot from displacements {vxi, vyi, vzi} at point {xi, yi, zi}.

ListVectorDisplacementPlot3D[{{{{vx11, vy11, vz11}, s11}, …, {{vx1n, vy1n, vz1n}, s1n}}, …, {{{vxm1, vym1, vzm1}, sm1}, …, {{vxmn, vymn, vzmn}, smn}}}] uses the scalar values sij to color the displaced region.

ListVectorDisplacementPlot3D[{{{x1, y1, z1}, {{vx1, vy1, vz1}, s1}}, …, {{xn, yn, zn}, {{vxn, vyn, vzn}, sn}}}] uses the scalar values si at point {xi, yi, zi} to color the displaced region.

ListVectorDisplacementPlot3D[…, reg] plots the displacement over the region reg.

## Details and Options

* ``ListVectorDisplacementPlot3D`` generates a displacement plot using the vector field data over a region. By default, the size of the displacement is automatically scaled so that both small and large displacements remain visible. The displaced region is by default colored according to the magnitude of the displacement.

* If no scalar field values are given, they are taken to be the norm of the vector field.

* ``ListVectorDisplacementPlot3D`` by default interpolates the data given and plots vectors for the vector field at a regular grid of positions.

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

|                             |                   |                                                       |
| --------------------------- | ----------------- | ----------------------------------------------------- |
| Axes                        | True              | whether to show axes                                  |
| BoundaryStyle               | None              | how to draw RegionFunction boundaries                 |
| BoxRatios                   | Automatic         | effective 3D box ratios for simulated lighting        |
| ClippingStyle               | Automatic         | how to display arrows outside the vector range        |
| ColorFunction               | Automatic         | how to color background densities                     |
| ColorFunctionScaling        | True              | whether to scale arguments to ColorFunction           |
| DataRange                   | Automatic         | the range of x, y and z values to assume for data     |
| Mesh                        | None              | how many mesh lines to draw in the background         |
| MeshFunctions               | {#5&}             | how to determine the placement of mesh lines          |
| MeshStyle                   | Automatic         | the style of mesh lines                               |
| Method                      | Automatic         | methods to use for the plot                           |
| PerformanceGoal             | \$PerformanceGoal | aspects of performance to try to optimize             |
| PlotLegends                 | None              | legends for color gradients                           |
| PlotRange                   | {Full, Full}      | range of x, y, z values to include                    |
| PlotRangePadding            | Automatic         | how much to pad the range of values                   |
| PlotStyle                   | Automatic         | how to style the deformed region                      |
| PlotTheme                   | \$PlotTheme       | overall theme for the plot                            |
| RegionBoundaryStyle         | Automatic         | how to style plot region boundaries                   |
| RegionFunction              | (True&)           | determine what region to include                      |
| VectorColorFunction         | Automatic         | how to color vectors                                  |
| VectorColorFunctionScaling  | True              | whether to scale the arguments to VectorColorFunction |
| VectorMarkers               | Automatic         | shape to use for vectors                              |
| VectorPoints                | None              | the number or placement of vectors to plot            |
| VectorRange                 | Automatic         | range of vector lengths to show                       |
| VectorScaling               | Automatic         | how to scale the sizes of arrows                      |
| VectorSizes                 | Automatic         | sizes of displayed arrows                             |
| VectorStyle                 | Automatic         | how to draw vectors                                   |

* The arguments supplied to functions in ``MeshFunctions``, ``RegionFunction``, ``ColorFunction`` and ``VectorColorFunction`` are ``x``, ``y``, ``z``, `` vx``, ``vy``, ``vz``, ``s``.

* The default setting ``MeshFunctions -> {#7&}`` draws mesh lines for the scalar field ``s``.

* By default, the displacement plot shows a representation of the original region and the displaced region.

* ``RegionBoundaryStyle`` and ``RegionFillingStyle`` can be used to change the style of the original region.

* Additional settings for ``VectorPoints`` to show displacement arrows include:

|            |                                  |
| ---------- | -------------------------------- |
| Automatic  | automatically chosen points      |
| All        | use the original data points     |
| "Boundary" | points along the boundary of reg |

* By default, displacement arrows connect locations in the original region with the corresponding displaced locations.

* ``VectorSizes -> Full`` shows the full displacement rather than a scaled representation.

### 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 show axes                                                               |
| Axes                       | False             | 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              | None              | how to draw RegionFunction boundaries                                              |
| Boxed                      | True              | whether to draw the bounding box                                                   |
| BoxRatios                  | Automatic         | effective 3D box ratios for simulated lighting                                     |
| BoxStyle                   | {}                | style specifications for the box                                                   |
| ClippingStyle              | Automatic         | how to display arrows outside the vector range                                     |
| ClipPlanes                 | None              | clipping planes                                                                    |
| ClipPlanesStyle            | Automatic         | style specifications for clipping planes                                           |
| ColorFunction              | Automatic         | how to color background densities                                                  |
| 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                                            |
| DataRange                  | Automatic         | the range of x, y and z values to assume for data                                  |
| Epilog                     | {}                | 2D graphics primitives to be rendered after the main plot                          |
| FaceGrids                  | None              | grid lines to draw on the bounding box                                             |
| FaceGridsStyle             | {}                | style specifications for face grids                                                |
| FormatType                 | TraditionalForm   | default format type for text                                                       |
| ImageMargins               | 0.                | the margins to leave around the graphic                                            |
| ImagePadding               | All               | what extra padding to allow for labels, etc.                                       |
| ImageSize                  | Automatic         | absolute size at which to render the graphic                                       |
| LabelStyle                 | {}                | style specifications for labels                                                    |
| Lighting                   | Automatic         | simulated light sources to use                                                     |
| Mesh                       | None              | how many mesh lines to draw in the background                                      |
| MeshFunctions              | {#5&}             | how to determine the placement of mesh lines                                       |
| MeshStyle                  | Automatic         | the style of mesh lines                                                            |
| Method                     | Automatic         | methods to use for the plot                                                        |
| PerformanceGoal            | \$PerformanceGoal | aspects of performance to try to optimize                                          |
| PlotLabel                  | None              | a label for the plot                                                               |
| PlotLegends                | None              | legends for color gradients                                                        |
| PlotRange                  | {Full, Full}      | range of x, y, z values to include                                                 |
| PlotRangePadding           | Automatic         | how much to pad the range of values                                                |
| PlotRegion                 | Automatic         | final display region to be filled                                                  |
| PlotStyle                  | Automatic         | how to style the deformed 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                         |
| RegionBoundaryStyle        | Automatic         | how to style plot region boundaries                                                |
| RegionFunction             | (True&)           | determine what region to include                                                   |
| RotationAction             | "Fit"             | how to render after interactive rotation                                           |
| SphericalRegion            | Automatic         | whether to make the circumscribing sphere fit in the final display area            |
| Ticks                      | Automatic         | specification for ticks                                                            |
| TicksStyle                 | {}                | style specification for ticks                                                      |
| TouchscreenAutoZoom        | False             | whether to zoom to fullscreen when activated on a touchscreen                      |
| VectorColorFunction        | Automatic         | how to color vectors                                                               |
| VectorColorFunctionScaling | True              | whether to scale the arguments to VectorColorFunction                              |
| VectorMarkers              | Automatic         | shape to use for vectors                                                           |
| VectorPoints               | None              | the number or placement of vectors to plot                                         |
| VectorRange                | Automatic         | range of vector lengths to show                                                    |
| VectorScaling              | Automatic         | how to scale the sizes of arrows                                                   |
| VectorSizes                | Automatic         | sizes of displayed arrows                                                          |
| VectorStyle                | Automatic         | how to draw vectors                                                                |
| ViewAngle                  | Automatic         | angle of the field of view                                                         |
| ViewCenter                 | Automatic         | point to display at the center                                                     |
| ViewMatrix                 | Automatic         | explicit transformation matrix                                                     |
| ViewPoint                  | {1.3, -2.4, 2.}   | viewing position                                                                   |
| ViewProjection             | Automatic         | projection method for rendering objects distant from the viewer                    |
| ViewRange                  | All               | range of viewing distances to include                                              |
| ViewVector                 | Automatic         | position and direction of a simulated camera                                       |
| ViewVertical               | {0, 0, 1}         | direction to make vertical                                                         |

## Examples (72)

### Basic Examples (4)

Plot a displacement field colored by its norm interpolated from a specified set of vectors:

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

Out[1]= [image]
```

---

Plot the vector field from data specifying coordinates and vectors. The reference region is the convex hull of the coordinates:

```wl
In[1]:= data = Table[{x, y, z} = RandomReal[{-5, 5}, 3];{{x, y, z}, {z, y, -x}}, {50}];

In[2]:= ListVectorDisplacementPlot3D[data]

Out[2]= [image]
```

---

Specify a scalar field to color the deformed region:

```wl
In[1]:= data = Table[{x, y, z} = RandomReal[{-5, 5}, 3];{{x, y, z}, {{z, y, -x}, x y z}}, {50}];

In[2]:= ListVectorDisplacementPlot3D[data]

Out[2]= [image]
```

---

Specify the reference region:

```wl
In[1]:= data = Table[{x, y, z} = RandomReal[{-5, 5}, 3];{{x, y, z}, {z, y, -x}}, {50}];

In[2]:= ListVectorDisplacementPlot3D[data, Cuboid[{-5, -5, -5}, {5, 5, 5}]]

Out[2]= [image]
```

### Scope (15)

#### Sampling (8)

Visualize a scaled displacement field by comparing a reference and a deformed region:

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

Out[1]= [image]
```

---

Specify the coordinates and the vector field:

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

Out[1]= [image]
```

---

Specify the coordinates, the vector field and a scalar field:

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

Out[1]= [image]
```

---

Generate random points in a vector field:

```wl
In[1]:= data = Table[{x, y, z} = RandomReal[{-5, 5}, 3];{{x, y, z}, {Sin[x], Cos[y], Sin[z]}}, {50}];
```

By default, the reference region is the convex hull of the coordinates:

```wl
In[2]:= ListVectorDisplacementPlot3D[data]

Out[2]= [image]
```

Vectors are drawn from points in the reference region to corresponding points in the (scaled) deformed region:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, VectorPoints -> Automatic]

Out[3]= [image]
```

Restrict vectors to points on the boundary:

```wl
In[4]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary"]

Out[4]= [image]
```

Specify other vectors:

```wl
In[5]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Hexagonal"]

Out[5]= [image]
```

---

Displacements can be drawn to scale:

```wl
In[1]:= ListVectorDisplacementPlot3D[Table[{{x, y, z}, (RotationMatrix[π / 2, {1, 1, 1}] - IdentityMatrix[3]).{x, y, z}}, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}], VectorSizes -> Full]

Out[1]= [image]
```

---

Specify the region:

```wl
In[1]:= ListVectorDisplacementPlot3D[Table[{{x, y, z}, {x - y, y z, z}}, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}], Ball[{0, 0, 0}, 5]]

Out[1]= [image]
```

---

Specify the region with a ``RegionFunction`` :

```wl
In[1]:= ListVectorDisplacementPlot3D[Table[{{x, y, z}, {x - y, y z, z}}, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}], RegionFunction -> Function[{x, y, z}, x y z ≤ 2]]

Out[1]= [image]
```

---

The domain may be a curve:

```wl
In[1]:= data = Table[{{x, y, z}, {x - y, y z, z}}, {x, -5, 5}, {y, -5, 5}, {z, -5, 5}];

In[2]:= ListVectorDisplacementPlot3D[data, HilbertCurve[2, 3]]

Out[2]= [image]
```

The domain may be an ``ImplicitRegion`` :

```wl
In[3]:= ℛ = ImplicitRegion[x^4 + y^4 + z^4 ≤ 16, {x, y, z}];

In[4]:= ListVectorDisplacementPlot3D[data, ℛ]

Out[4]= [image]
```

The domain may be a ``ParametricRegion`` :

```wl
In[5]:= ℛ = ParametricRegion[{{s, (1 + t) s ^ 2 - t, t^2}, -1 ≤ s ≤ 1 && 0 ≤ t ≤ 1}, {s, t}];

In[6]:= ListVectorDisplacementPlot3D[data, ℛ]

Out[6]= [image]
```

The domain may be a ``MeshRegion`` :

```wl
In[7]:= ℛ = MeshRegion[{{0, 0, 0}, {0, 0, 5}, {0, -5, 0}, {5, 0, 0}, {0, 5, 0}}, {Triangle[{1, 2, 3}], Triangle[{1, 2, 4}], Triangle[{1, 2, 5}]}];

In[8]:= ListVectorDisplacementPlot3D[data, ℛ]

Out[8]= [image]
```

The domain may be a ``BoundaryMeshRegion`` :

```wl
In[9]:= ℛ = BoundaryMeshRegion[{{0, 0, 0}, {5, 0, 0}, {0, 5, 0}, {0, 0, 5}}, Polygon[{{1, 2, 3}, {1, 2, 4}, {2, 3, 4}, {1, 3, 4}}]];

In[10]:= ListVectorDisplacementPlot3D[data, ℛ]

Out[10]= [image]
```

#### Presentation (7)

Specify the ``ColorFunction`` for the deformed region:

```wl
In[1]:= ListVectorDisplacementPlot3D[Table[{{x, y, z}, {x, -y, -Sin[z]}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}], ColorFunction -> "Rainbow"]

Out[1]= [image]
```

---

Specify the ``VectorColorFunction`` independently of the ``ColorFunction`` :

```wl
In[1]:= ListVectorDisplacementPlot3D[Table[{{x, y, z}, {x, -y, -Sin[z]}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}], VectorPoints -> "Boundary", VectorColorFunction -> "DarkRainbow"]

Out[1]= [image]
```

---

Use a single color for the arrows:

```wl
In[1]:= ListVectorDisplacementPlot3D[Table[{{x, y, z}, {x, -y, -Sin[z]}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}], VectorPoints -> "Boundary", VectorColorFunction -> None]

Out[1]= [image]
```

---

Include a legend for the norms of the displacements:

```wl
In[1]:= ListVectorDisplacementPlot3D[Table[{{x, y, z}, {x, -y, -Sin[z]}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}], PlotLegends -> Automatic]

Out[1]= [image]
```

---

Include a legend for the optional scalar field:

```wl
In[1]:= ListVectorDisplacementPlot3D[Table[{{x, y, z}, {{x, -y, -Sin[z]}, x y z}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}], PlotLegends -> Automatic]

Out[1]= [image]
```

---

Include a ``Mesh`` :

```wl
In[1]:= ListVectorDisplacementPlot3D[Table[{{x, y, z}, (RotationMatrix[π / 4, {0, 0, 1}] - IdentityMatrix[3]).{x, y, z}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}], Mesh -> 5]

Out[1]= [image]
```

---

Draw displacements to scale:

```wl
In[1]:= ListVectorDisplacementPlot3D[Table[{{x, y, z}, (RotationMatrix[π / 4, {0, 0, 1}] - IdentityMatrix[3]).{x, y, z}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}], Mesh -> 5, VectorSizes -> Full]

Out[1]= [image]
```

### Options (31)

#### BoxRatios (1)

By default, the aspect ratio is ``Automatic`` :

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

In[2]:= ListVectorDisplacementPlot3D[data]

Out[2]= [image]
```

Set the box ratios:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, BoxRatios -> {1, 1, 1}]

Out[3]= [image]
```

#### BoundaryStyle (1)

By default, the boundary style matches the interior colors in the deformed region:

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

In[2]:= ListVectorDisplacementPlot3D[data]

Out[2]= [image]
```

Specify the ``BoundaryStyle`` :

```wl
In[3]:= ListVectorDisplacementPlot3D[data, BoundaryStyle -> Directive[Red, Thick]]

Out[3]= [image]
```

``BoundaryStyle`` applies to regions cut by ``RegionFunction`` :

```wl
In[4]:= ListVectorDisplacementPlot3D[data, BoundaryStyle -> Directive[Red, Thick], RegionFunction -> Function[{x, y, z, vx, vy, vz, n}, x^2 + z^2 ≥ 1]]

Out[4]= [image]
```

#### ColorFunction (4)

By default, the deformed region is colored by the norm of the field:

```wl
In[1]:= data = Table[{{x, y, z}, {1 - x, y, z}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}];

In[2]:= ListVectorDisplacementPlot3D[data, Ball[]]

Out[2]= [image]
```

---

Specify a scalar field for the colors:

```wl
In[1]:= data = Table[{{x, y, z}, {{1 - x, y, z}, x y z}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}];

In[2]:= ListVectorDisplacementPlot3D[data, Ball[]]

Out[2]= [image]
```

---

Use a named color gradient:

```wl
In[1]:= data = Table[{{x, y, z}, {{1 - x, y, z}, x y z}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}];

In[2]:= ListVectorDisplacementPlot3D[data, Ball[], ColorFunction -> "Rainbow"]

Out[2]= [image]
```

---

Specify a custom ``ColorFunction`` :

```wl
In[1]:= data = Table[{{x, y, z}, {{1 - x, y, z}, x y z}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}];

In[2]:= ListVectorDisplacementPlot3D[data, Ball[], ColorFunction -> Function[{x, y, z, vx, vy, vz, n}, Hue[vy, n, 1]]]

Out[2]= [image]
```

#### ColorFunctionScaling (2)

Use the natural range of norm values:

```wl
In[1]:= data = Table[{{x, y, z}, {1 - x, y, z}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}];

In[2]:= ListVectorDisplacementPlot3D[data, Ball[], ColorFunctionScaling -> False]

Out[2]= [image]
```

---

Control the scaling of the individual arguments of the ``ColorFunction`` :

```wl
In[1]:= data = Table[{{x, y, z}, {1 - x, y, z}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}];

In[2]:= ListVectorDisplacementPlot3D[data, Ball[], ColorFunction -> Function[{x, y, z, vx, vy, vz, n}, Hue[vx vy vz, n, 1]], ColorFunctionScaling -> {True, True, True, False, False, False, True}]

Out[2]= [image]
```

#### DataRange (1)

By default, the reference region is taken to be the index range of the data array:

```wl
In[1]:= data = Table[{1 - x, y, z}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}];

In[2]:= ListVectorDisplacementPlot3D[data]

Out[2]= [image]
```

Specify the data range for the reference region:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, DataRange -> {{-1, 1}, {-1, 1}, {-1, 1}}]

Out[3]= [image]
```

#### Mesh (1)

Specify a ``Mesh`` to visualize the displacements:

```wl
In[1]:= data = Table[{z, y, x}, {x, 1, 10}, {y, 1, 10}, {z, 1, 10}];

In[2]:= ListVectorDisplacementPlot3D[data, Mesh -> 5]

Out[2]= [image]
```

Show the initial and final sampling mesh:

```wl
In[3]:= {ListVectorDisplacementPlot3D[data, Mesh -> Full], ListVectorDisplacementPlot3D[data, Mesh -> All]}

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

Specify 10 mesh lines in the $x$ direction, 5 in the $y$ direction and 3 in the $z$ direction:

```wl
In[4]:= ListVectorDisplacementPlot3D[data, Mesh -> {10, 5, 3}]

Out[4]= [image]
```

Use mesh lines at specific values:

```wl
In[5]:= ListVectorDisplacementPlot3D[data, Mesh -> {{5, 7, 8}, {2, 3}, {4}}]

Out[5]= [image]
```

Highlight specific mesh lines:

```wl
In[6]:= ListVectorDisplacementPlot3D[data, Mesh -> {{{2, Red}, {4, Blue}}, {5, 6, 7}, {{5, Green}}}]

Out[6]= [image]
```

Mesh lines are suppressed in the reference region if the boundary and filling of the reference region are removed:

```wl
In[7]:= ListVectorDisplacementPlot3D[data, Mesh -> 5, RegionBoundaryStyle -> None, RegionFillingStyle -> None]

Out[7]= [image]
```

#### MeshFunctions (1)

By default, the mesh lines are parallel to the $x y$, $x z$ and $y z$ planes in the reference region:

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

In[2]:= ListVectorDisplacementPlot3D[data, Ball[], Mesh -> 6]

Out[2]= [image]
```

Use circular mesh lines in the reference region:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, Ball[], Mesh -> 5, MeshFunctions -> {#1^2 + #2^2&, #1^2 + #3^2&, #2^2 + #3^2&}]

Out[3]= [image]
```

#### MeshStyle (1)

Style the mesh lines:

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

In[2]:= ListVectorDisplacementPlot3D[data, Ball[], Mesh -> 6, MeshStyle -> Red]

Out[2]= [image]
```

Style the mesh lines differently in different directions:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, Ball[], Mesh -> 6, MeshStyle -> {Red, Green, Blue}]

Out[3]= [image]
```

#### PlotLegends (3)

Include a legend to show the color range of vector norms:

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

In[2]:= ListVectorDisplacementPlot3D[data, PlotLegends -> Automatic]

Out[2]= [image]
```

---

Include a legend to show the color range of an optional scalar field:

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

In[2]:= ListVectorDisplacementPlot3D[data, PlotLegends -> Automatic]

Out[2]= [image]
```

---

Control the placement of the legend:

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

In[2]:= ListVectorDisplacementPlot3D[data, PlotLegends -> Placed[Automatic, Below]]

Out[2]= [image]
```

#### PlotPoints (1)

Use more points to get smoother regions:

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

In[2]:= ListVectorDisplacementPlot3D[data, RegionUnion[Ball[], Cylinder[{{0, 0, -2}, {0, 0, -1}}, 1]], PlotPoints -> 50]

Out[2]= [image]
```

#### PlotRange (1)

The full ``PlotRange`` is used by default:

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

In[2]:= ListVectorDisplacementPlot3D[data]

Out[2]= [image]
```

Specify an explicit limit that is shared by the $x$, $y$ and $z$ directions:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, PlotRange -> 3]

Out[3]= [image]
```

Specify different plot ranges in the $x$, $y$ and $z$ directions:

```wl
In[4]:= ListVectorDisplacementPlot3D[data, PlotRange -> {{-3, 3}, {-4, 4}, {-4, 4}}]

Out[4]= [image]
```

#### PlotStyle (1)

Remove the filling for the deformed region:

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

In[2]:= ListVectorDisplacementPlot3D[data, PlotStyle -> None]

Out[2]= [image]
```

Apply a ``Texture`` to the deformed region:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, PlotStyle -> Texture[[image]]]

Out[3]= [image]
```

``ColorFunction`` has precedence over ``PlotStyle`` :

```wl
In[4]:= ListVectorDisplacementPlot3D[data, ColorFunction -> None, PlotStyle -> Red]

Out[4]= [image]
```

#### RegionBoundaryStyle (1)

Specify the boundary style of the reference region:

```wl
In[1]:= data = Table[{{x, y, z}, {x y, z, x}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}];

In[2]:= ListVectorDisplacementPlot3D[data, Cylinder[], RegionBoundaryStyle -> Directive[Red, Thick]]

Out[2]= [image]
```

Remove the boundary of the reference region:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, Cylinder[], RegionBoundaryStyle -> None]

Out[3]= [image]
```

#### RegionFillingStyle (1)

Specify the filling of the reference region:

```wl
In[1]:= data = Table[{{x, y, z}, {x y, z, x}}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}];

In[2]:= ListVectorDisplacementPlot3D[data, Cylinder[], RegionFillingStyle -> Red]

Out[2]= [image]
```

Remove the filling for the reference region:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, Cylinder[], RegionFillingStyle -> None]

Out[3]= [image]
```

#### RegionFunction (1)

Use a ``RegionFunction`` to specify the reference region:

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

In[2]:= ListVectorDisplacementPlot3D[data, RegionFunction -> Function[{x, y, z, vx, vy, vz, n}, 1 ≤ x^2 + 2y^2 ≤ 4]]

Out[2]= [image]
```

#### VectorAspectRatio (1)

The default aspect ratio for a vector marker is 1/4:

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

In[2]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary"]

Out[2]= [image]
```

Specify the relative width of a vector marker:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary", VectorAspectRatio -> 1 / 8]

Out[3]= [image]
```

#### VectorColorFunction (1)

By default, if ``VectorColorFunction`` is ``Automatic``, then the ``VectorColorFunction`` matches the ``ColorFunction`` :

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

In[2]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary", ColorFunction -> GrayLevel]

Out[2]= [image]
```

Specify a ``VectorColorFunction`` that is different from the ``ColorFunction`` :

```wl
In[3]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary", ColorFunction -> GrayLevel, VectorColorFunction -> "Rainbow"]

Out[3]= [image]
```

Use no ``VectorColorFunction`` :

```wl
In[4]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary", VectorColorFunction -> None]

Out[4]= [image]
```

#### VectorColorFunctionScaling (1)

Use the natural range of norm values for vector colors:

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

In[2]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary", ColorFunction -> GrayLevel, VectorColorFunction -> "Rainbow", VectorColorFunctionScaling -> False]

Out[2]= [image]
```

#### VectorMarkers (1)

By default, vectors are drawn from points in the reference region to corresponding points in the deformed region:

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

In[2]:= ListVectorDisplacementPlot3D[data, VectorPoints -> Automatic]

Out[2]= [image]
```

Use a named appearance to draw the vectors:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary", VectorMarkers -> "Tube"]

Out[3]= [image]
```

Center the markers at the sampled points:

```wl
In[4]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary", VectorMarkers -> Placed["Arrow", "Center"]]

Out[4]= [image]
```

#### VectorPoints (2)

No vectors are shown by default:

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

In[2]:= ListVectorDisplacementPlot3D[data]

Out[2]= [image]
```

Show vectors sampled from the entire original region:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, VectorPoints -> Automatic]

Out[3]= [image]
```

Sample vectors from the boundary of the region:

```wl
In[4]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary"]

Out[4]= [image]
```

Use symbolic names to specify the density of vectors:

```wl
In[5]:=
{ListVectorDisplacementPlot3D[data, VectorPoints -> "Fine"], 
	ListVectorDisplacementPlot3D[data, VectorPoints -> "Coarse"]}

Out[5]= [image]
```

Use symbolic names to specify the arrangement of vectors:

```wl
In[6]:=
{ListVectorDisplacementPlot3D[data, VectorPoints -> "Hexagonal"], 
	ListVectorDisplacementPlot3D[data, VectorPoints -> "FaceCenteredCubic"], 
	ListVectorDisplacementPlot3D[data, VectorPoints -> "Regular"]}

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

Specify the number of vectors in the $x$, $y$ and $z$ directions:

```wl
In[7]:= ListVectorDisplacementPlot3D[data, VectorPoints -> 6]

Out[7]= [image]
```

Specify a different number of vectors in the $x$, $y$ and $z$ directions:

```wl
In[8]:= ListVectorDisplacementPlot3D[data, VectorPoints -> {6, 8, 3}]

Out[8]= [image]
```

Give specific locations for vectors:

```wl
In[9]:= points = {{3, 3, 3}, {-3, 3, 3}, {-3, -3, 3}, {3, -3, 3}, {3, 3, -3}, {-3, 3, -3}, {-3, -3, -3}, {3, -3, -3}};

In[10]:= ListVectorDisplacementPlot3D[data, VectorPoints -> points]

Out[10]= [image]
```

---

Along a curve, vectors are equally spaced by default:

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

In[2]:= ListVectorDisplacementPlot3D[data, HilbertCurve[2, 3], VectorPoints -> Automatic]

Out[2]= [image]
```

#### VectorRange (1)

Specify the range of vector norms:

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

In[2]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary", VectorRange -> {2, 3}]

Out[2]= [image]
```

Style the clipped vectors:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary", VectorRange -> {2, 3}, ClippingStyle -> Black]

Out[3]= [image]
```

#### VectorScaling (1)

By default, vectors extend from points in the reference region to corresponding points in the deformed region:

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

In[2]:= ListVectorDisplacementPlot3D[data, Cuboid[], VectorPoints -> "Boundary"]

Out[2]= [image]
```

Set all vectors to have the same size:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, Cuboid[], VectorPoints -> "Boundary", VectorScaling -> None]

Out[3]= [image]
```

#### VectorSizes (1)

By default, vectors extend from points in the reference region to corresponding points in the deformed region:

```wl
In[1]:= data = Table[{{x, y, z}, (RotationMatrix[π / 4, {0, 0, 1}] - IdentityMatrix[3]).{x, y, z}}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}];

In[2]:= ListVectorDisplacementPlot3D[data, Cuboid[{-2, -2, -2}, {2, 2, 2}], VectorPoints -> "Boundary"]

Out[2]= [image]
```

Suppress scaling of the displacement vectors so that a rotation of 45° looks appropriate:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, Cuboid[{-2, -2, -2}, {2, 2, 2}], VectorPoints -> "Boundary", VectorSizes -> Full]

Out[3]= [image]
```

Specify the displacement size relative to the default scaled displacement:

```wl
In[4]:= ListVectorDisplacementPlot3D[data, Cuboid[{-2, -2, -2}, {2, 2, 2}], VectorPoints -> "Boundary", VectorSizes -> 2]

Out[4]= [image]
```

Suppress scaling of the displacement vectors even if no vectors are displayed:

```wl
In[5]:= ListVectorDisplacementPlot3D[data, Cuboid[{-2, -2, -2}, {2, 2, 2}], VectorSizes -> Full]

Out[5]= [image]
```

#### VectorStyle (1)

``VectorColorFunction`` has precedence over ``VectorStyle`` :

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

In[2]:= ListVectorDisplacementPlot3D[data, Cone[], VectorPoints -> "Boundary", VectorColorFunction -> None, VectorStyle -> Red]

Out[2]= [image]
```

### Applications (14)

#### Basic Applications (13)

A constant displacement field moves each point in the reference region by the same amount:

```wl
In[1]:= data = Table[{{x, y, z}, {3, 2, 1}}, {x, 0, 1, 0.2}, {y, 0, 1, 0.2}, {z, 0, 1, 0.2}];

In[2]:= ListVectorDisplacementPlot3D[data]

Out[2]= [image]
```

---

Note that the displacements are automatically scaled so that very small and very large displacements are both visible:

```wl
In[1]:=
dataSmall = Table[{{x, y, z}, {0.3, 0.2, 0.1}}, {x, 0, 1, 0.2}, {y, 0, 1, 0.2}, {z, 0, 1, 0.2}];
dataLarge = Table[{{x, y, z}, {300, 200, 100}}, {x, 0, 1, 0.2}, {y, 0, 1, 0.2}, {z, 0, 1, 0.2}];

In[2]:= {ListVectorDisplacementPlot3D[dataSmall], ListVectorDisplacementPlot3D[dataLarge]}

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

---

Use ``VectorSizes -> Full`` to display the actual sizes of displacements:

```wl
In[1]:= data = Table[{{x, y, z}, {3, 2, 1}}, {x, 0, 1, 0.2}, {y, 0, 1, 0.2}, {z, 0, 1, 0.2}];

In[2]:= ListVectorDisplacementPlot3D[data, VectorSizes -> Full]

Out[2]= [image]
```

---

Color is used to indicate the magnitude of the displacements:

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

In[2]:= ListVectorDisplacementPlot3D[data, PlotLegends -> Automatic]

Out[2]= [image]
```

---

Color the region by a different scalar function:

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

In[2]:= ListVectorDisplacementPlot3D[data, PlotLegends -> Automatic]

Out[2]= [image]
```

---

Use arrows to indicate initial and final locations for a sample points:

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

In[2]:= ListVectorDisplacementPlot3D[data, VectorPoints -> "Boundary"]

Out[2]= [image]
```

---

Visualize a dilation in the $x$ direction:

```wl
In[1]:=
data = Table[{{x, y, z}, (⁠|   |   |   |
| - | - | - |
| 2 | 0 | 0 |
| 0 | 0 | 0 |
| 0 | 0 | 0 |⁠).{x, y, z}}, {x, -1, 1, 0.2}, {y, -1, 1, 0.2}, {z, -1, 1, 0.2}];

In[2]:= ListVectorDisplacementPlot3D[data, VectorSizes -> Full]

Out[2]= [image]
```

---

Visualize a contraction in the $x$ direction:

```wl
In[1]:=
data = Table[{{x, y, z}, (⁠|        |   |   |
| ------ | - | - |
| -1 / 2 | 0 | 0 |
| 0      | 0 | 0 |
| 0      | 0 | 0 |⁠).{x, y, z}}, {x, -1, 1, 0.2}, {y, -1, 1, 0.2}, {z, -1, 1, 0.2}];

In[2]:= ListVectorDisplacementPlot3D[data, VectorSizes -> Full]

Out[2]= [image]
```

---

Visualize dilations in the $x$ and $y$ directions and a contraction in the $z$ direction:

```wl
In[1]:=
data = Table[{{x, y, z}, (⁠|   |   |        |
| - | - | ------ |
| 1 | 0 | 0      |
| 0 | 2 | 0      |
| 0 | 0 | -1 / 2 |⁠).{x, y, z}}, {x, -1, 1, 0.2}, {y, -1, 1, 0.2}, {z, -1, 1, 0.2}];

In[2]:= ListVectorDisplacementPlot3D[data, VectorSizes -> Full]

Out[2]= [image]
```

---

Visualize a shear in the $x$ direction applied to the faces $y=\pm 1$ :

```wl
In[1]:=
data = Table[{{x, y, z}, (⁠|   |   |   |
| - | - | - |
| 0 | 1 | 0 |
| 0 | 0 | 0 |
| 0 | 0 | 0 |⁠).{x, y, z}}, {x, -1, 1, 0.2}, {y, -1, 1, 0.2}, {z, -1, 1, 0.2}];

In[2]:= ListVectorDisplacementPlot3D[data, VectorSizes -> Full]

Out[2]= [image]
```

---

Visualize a shear in the $x$ direction applied to the faces $z=\pm 1$ :

```wl
In[1]:=
data = Table[{{x, y, z}, (⁠|   |   |   |
| - | - | - |
| 0 | 0 | 1 |
| 0 | 0 | 0 |
| 0 | 0 | 0 |⁠).{x, y, z}}, {x, -1, 1, 0.2}, {y, -1, 1, 0.2}, {z, -1, 1, 0.2}];

In[2]:= ListVectorDisplacementPlot3D[data, VectorSizes -> Full]

Out[2]= [image]
```

---

Visualize a combined shear:

```wl
In[1]:=
data = Table[{{x, y, z}, (⁠|   |   |   |
| - | - | - |
| 0 | 1 | 2 |
| 0 | 0 | 3 |
| 0 | 0 | 0 |⁠).{x, y, z}}, {x, -1, 1, 0.2}, {y, -1, 1, 0.2}, {z, -1, 1, 0.2}];

In[2]:= ListVectorDisplacementPlot3D[data, VectorSizes -> Full]

Out[2]= [image]
```

---

Visualize a rotation about the $z$ axis:

```wl
In[1]:= data = Table[{{x, y, z}, (RotationMatrix[(π/6), {0, 0, 1}] - IdentityMatrix[3]).{x, y, z}}, {x, -1, 1, 0.2}, {y, -1, 1, 0.2}, {z, -1, 1, 0.2}];

In[2]:= ListVectorDisplacementPlot3D[data, VectorSizes -> Full]

Out[2]= [image]
```

#### Solid Mechanics (1)

The $x=0$ face of the displayed region is fixed (no displacement) and a uniform load of 10 kPa is applied to the $x=4$ face in the positive $x$ direction:

```wl
In[1]:=
Ω = RegionDifference[Cuboid[{0, 0, 0}, {4, 4, 4}], Cuboid[{2, 0, 2}, {4, 2, 4}]];
Graphics3D[{Ω, Black, Table[If[y == 0 && z == 4, Nothing, Arrow[Tube[{{4, y, z}, {5, y, z}}]]], {y, 0, 4, 2}, {z, 0, 4, 2}]}, ImageSize -> Small, Axes -> True, AxesLabel -> {"x", "y", "z"}]

Out[1]= [image]
```

Obtain data from a numerical solver of the form {location vector, displacement vector} assuming that the region is linearly elastic:

```wl
In[2]:= data = IconizedObject[«PDE solution data»];
```

Visualize the deformed region. Since the displacements are exaggerated in the plot, use a legend to indicate the actual sizes of the displacements:

```wl
In[3]:= ListVectorDisplacementPlot3D[data, Ω, PlotLegends -> Automatic, ColorFunction -> "Rainbow"]

Out[3]= [image]
```

### Properties & Relations (8)

Use ``ListVectorPlot`` for plotting data:

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

In[2]:= ListVectorPlot[data]

Out[2]= [image]
```

---

Use ``StreamPlot`` to plot with streamlines instead of vectors :

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

Out[1]= [image]
```

---

Use ``VectorDensityPlot`` to add a density plot of the scalar field:

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

Out[1]= [image]
```

---

Use ``ListVectorDensityPlot`` for plotting data with a density plot of the scalar field:

```wl
In[1]:= data = Table[{{x, y} = RandomReal[{-1.5, 1.5}, {2}], {{y, x - x ^ 3}, Abs[x + y]}}, {300}];

In[2]:= ListVectorDensityPlot[data]

Out[2]= [image]
```

---

Use ``LineIntegralConvolutionPlot`` to plot the line integral convolution of a vector field:

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

Out[1]= [image]
```

---

Use ``VectorPlot3D`` and ``StreamPlot3D`` to visualize 3D vector fields:

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

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

---

Plot vectors on surfaces with ``SliceVectorPlot3D`` :

```wl
In[1]:= SliceVectorPlot3D[{-y, x, z}, Sphere[], {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[1]= [image]
```

---

Plot complex functions as a vector field:

```wl
In[1]:= ComplexVectorPlot[z + 1 / z, {z, 2}]

Out[1]= [image]
```

## See Also

* [`VectorDisplacementPlot3D`](https://reference.wolfram.com/language/ref/VectorDisplacementPlot3D.en.md)
* [`ListVectorDisplacementPlot`](https://reference.wolfram.com/language/ref/ListVectorDisplacementPlot.en.md)
* [`VectorDisplacementPlot`](https://reference.wolfram.com/language/ref/VectorDisplacementPlot.en.md)
* [`ListVectorDensityPlot`](https://reference.wolfram.com/language/ref/ListVectorDensityPlot.en.md)
* [`VectorDensityPlot`](https://reference.wolfram.com/language/ref/VectorDensityPlot.en.md)
* [`ListStreamDensityPlot`](https://reference.wolfram.com/language/ref/ListStreamDensityPlot.en.md)
* [`StreamDensityPlot`](https://reference.wolfram.com/language/ref/StreamDensityPlot.en.md)
* [`StreamPlot3D`](https://reference.wolfram.com/language/ref/StreamPlot3D.en.md)
* [`DensityPlot3D`](https://reference.wolfram.com/language/ref/DensityPlot3D.en.md)

## Related Guides

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

## History

* [Introduced in 2021 (13.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn130.en.md)