1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
"""
.. _create_unstructured_example:
Creating an Unstructured Grid
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Create an irregular, unstructured grid from NumPy arrays.
This example uses :class:`pyvista.UnstructuredGrid`.
"""
from __future__ import annotations
import numpy as np
import pyvista as pv
from pyvista import CellType
# %%
# An unstructured grid can be created directly from NumPy arrays.
# This is useful when creating a grid from scratch or copying it from another
# format. See `vtkUnstructuredGrid <https://www.vtk.org/doc/nightly/html/classvtkUnstructuredGrid.html>`_
# for available cell types and their descriptions.
# Contains information on the points composing each cell.
# Each cell begins with the number of points in the cell and then the points
# composing the cell
cells = np.array([8, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11, 12, 13, 14, 15])
# cell type array. Contains the cell type of each cell
cell_type = np.array([CellType.HEXAHEDRON, CellType.HEXAHEDRON])
# in this example, each cell uses separate points
cell1 = np.array(
[
[0, 0, 0],
[1, 0, 0],
[1, 1, 0],
[0, 1, 0],
[0, 0, 1],
[1, 0, 1],
[1, 1, 1],
[0, 1, 1],
],
)
cell2 = np.array(
[
[0, 0, 2],
[1, 0, 2],
[1, 1, 2],
[0, 1, 2],
[0, 0, 3],
[1, 0, 3],
[1, 1, 3],
[0, 1, 3],
],
)
# points of the cell array
points = np.vstack((cell1, cell2)).astype(float)
# create the unstructured grid directly from the numpy arrays
grid = pv.UnstructuredGrid(cells, cell_type, points)
# For cells of fixed sizes (like the mentioned Hexahedra), it is also possible to use the
# simplified dictionary interface. This automatically calculates the cell array.
# Note that for mixing with additional cell types, just the appropriate key needs to be
# added to the dictionary.
cells_hex = np.arange(16).reshape([2, 8])
# = np.array([[0, 1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14, 15]])
grid = pv.UnstructuredGrid({CellType.HEXAHEDRON: cells_hex}, points)
# plot the grid (and suppress the camera position output)
_ = grid.plot(show_edges=True)
# %%
# UnstructuredGrid with Shared Points
# -----------------------------------
#
# The next example again creates an unstructured grid containing
# hexahedral cells, but using common points between the cells.
# these points will all be shared between the cells
points = np.array(
[
[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[0.5, 0.0, 0.0],
[1.0, 1.0, 0.0],
[1.0, 0.5, 0.0],
[0.0, 1.0, 0.0],
[0.5, 1.0, 0.0],
[0.0, 0.5, 0.0],
[0.5, 0.5, 0.0],
[1.0, 0.0, 0.5],
[1.0, 0.0, 1.0],
[0.0, 0.0, 0.5],
[0.0, 0.0, 1.0],
[0.5, 0.0, 0.5],
[0.5, 0.0, 1.0],
[1.0, 1.0, 0.5],
[1.0, 1.0, 1.0],
[1.0, 0.5, 0.5],
[1.0, 0.5, 1.0],
[0.0, 1.0, 0.5],
[0.0, 1.0, 1.0],
[0.5, 1.0, 0.5],
[0.5, 1.0, 1.0],
[0.0, 0.5, 0.5],
[0.0, 0.5, 1.0],
[0.5, 0.5, 0.5],
[0.5, 0.5, 1.0],
],
)
# Each cell in the cell array needs to include the size of the cell
# and the points belonging to the cell. In this example, there are 8
# hexahedral cells that have common points between them.
cells = np.array(
[
[8, 0, 2, 8, 7, 11, 13, 25, 23],
[8, 2, 1, 4, 8, 13, 9, 17, 25],
[8, 7, 8, 6, 5, 23, 25, 21, 19],
[8, 8, 4, 3, 6, 25, 17, 15, 21],
[8, 11, 13, 25, 23, 12, 14, 26, 24],
[8, 13, 9, 17, 25, 14, 10, 18, 26],
[8, 23, 25, 21, 19, 24, 26, 22, 20],
[8, 25, 17, 15, 21, 26, 18, 16, 22],
],
).ravel()
# each cell is a HEXAHEDRON
celltypes = np.full(8, CellType.HEXAHEDRON, dtype=np.uint8)
# %%
# Finally, create the unstructured grid and plot it
grid = pv.UnstructuredGrid(cells, celltypes, points)
# Alternate versions:
grid = pv.UnstructuredGrid({CellType.HEXAHEDRON: cells.reshape([-1, 9])[:, 1:]}, points)
grid = pv.UnstructuredGrid(
{CellType.HEXAHEDRON: np.delete(cells, np.arange(0, cells.size, 9))},
points,
)
# plot the grid (and suppress the camera position output)
_ = grid.plot(show_edges=True)
# %%
# Tetrahedral Grid
# ~~~~~~~~~~~~~~~~
# Here is how we can create an unstructured tetrahedral grid.
# There are 10 cells here, each cell is [4, INDEX0, INDEX1, INDEX2, INDEX3]
# where INDEX is one of the corners of the tetrahedron.
#
# Note that the array does not need to be shaped like this, we could have a
# flat array, but it's easier to make out the structure of the array this way.
cells = np.array(
[
[4, 6, 5, 8, 7],
[4, 7, 3, 8, 9],
[4, 7, 3, 1, 5],
[4, 9, 3, 1, 7],
[4, 2, 6, 5, 8],
[4, 2, 6, 0, 4],
[4, 6, 2, 0, 8],
[4, 5, 2, 8, 3],
[4, 5, 3, 8, 7],
[4, 2, 6, 4, 5],
],
)
celltypes = np.full(10, fill_value=CellType.TETRA, dtype=np.uint8)
# These are the 10 points. The number of cells does not need to match the
# number of points, they just happen to in this example
points = np.array(
[
[-0.0, 0.0, -0.5],
[0.0, 0.0, 0.5],
[-0.43, 0.0, -0.25],
[-0.43, 0.0, 0.25],
[-0.0, 0.43, -0.25],
[0.0, 0.43, 0.25],
[0.43, 0.0, -0.25],
[0.43, 0.0, 0.25],
[0.0, -0.43, -0.25],
[0.0, -0.43, 0.25],
],
)
# Create and plot the unstructured grid
grid = pv.UnstructuredGrid(cells, celltypes, points)
grid.plot(show_edges=True)
# %%
# For fun, let's separate all the cells and plot out the individual cells. Shift
# them a little bit from the center to create an "exploded view".
split_cells = grid.explode(0.5)
split_cells.plot(show_edges=True, ssao=True)
|
